diff options
Diffstat (limited to 'libs/surfaceflinger')
25 files changed, 278 insertions, 2553 deletions
diff --git a/libs/surfaceflinger/Android.mk b/libs/surfaceflinger/Android.mk index c4a70c8fbbfd..49da111aaa4f 100644 --- a/libs/surfaceflinger/Android.mk +++ b/libs/surfaceflinger/Android.mk @@ -6,12 +6,12 @@ LOCAL_SRC_FILES:= \ DisplayHardware/DisplayHardware.cpp \ DisplayHardware/DisplayHardwareBase.cpp \ BlurFilter.cpp.arm \ + Buffer.cpp \ BufferAllocator.cpp \ Layer.cpp \ LayerBase.cpp \ LayerBuffer.cpp \ LayerBlur.cpp \ - LayerBitmap.cpp \ LayerDim.cpp \ MessageQueue.cpp \ SurfaceFlinger.cpp \ diff --git a/libs/surfaceflinger/LayerBitmap.cpp b/libs/surfaceflinger/Buffer.cpp index dd61e1a3f111..4a7c55e56ae9 100644 --- a/libs/surfaceflinger/LayerBitmap.cpp +++ b/libs/surfaceflinger/Buffer.cpp @@ -27,8 +27,8 @@ #include <ui/Surface.h> #include <pixelflinger/pixelflinger.h> +#include "Buffer.h" #include "BufferAllocator.h" -#include "LayerBitmap.h" #include "SurfaceFlinger.h" @@ -38,15 +38,16 @@ namespace android { // Buffer and implementation of android_native_buffer_t // =========================================================================== +Buffer::Buffer() + : SurfaceBuffer(), mInitCheck(NO_ERROR), mVStride(0) +{ +} + Buffer::Buffer(uint32_t w, uint32_t h, PixelFormat format, uint32_t reqUsage, uint32_t flags) - : SurfaceBuffer(), mInitCheck(NO_INIT), mFlags(flags), - mVStride(0) + : SurfaceBuffer(), mInitCheck(NO_INIT), mVStride(0) { - this->format = format; - if (w>0 && h>0) { - mInitCheck = initSize(w, h, reqUsage); - } + mInitCheck = initSize(w, h, format, reqUsage, flags); } Buffer::~Buffer() @@ -66,7 +67,19 @@ android_native_buffer_t* Buffer::getNativeBuffer() const return static_cast<android_native_buffer_t*>(const_cast<Buffer*>(this)); } -status_t Buffer::initSize(uint32_t w, uint32_t h, uint32_t reqUsage) +status_t Buffer::reallocate(uint32_t w, uint32_t h, PixelFormat f, + uint32_t reqUsage, uint32_t flags) +{ + if (handle) { + BufferAllocator& allocator(BufferAllocator::get()); + allocator.free(handle); + handle = 0; + } + return initSize(w, h, f, reqUsage, flags); +} + +status_t Buffer::initSize(uint32_t w, uint32_t h, PixelFormat format, + uint32_t reqUsage, uint32_t flags) { status_t err = NO_ERROR; @@ -84,7 +97,7 @@ status_t Buffer::initSize(uint32_t w, uint32_t h, uint32_t reqUsage) * */ - if (mFlags & Buffer::SECURE) { + if (flags & Buffer::SECURE) { // secure buffer, don't store it into the GPU usage = BufferAllocator::USAGE_SW_READ_OFTEN | BufferAllocator::USAGE_SW_WRITE_OFTEN; @@ -95,10 +108,10 @@ status_t Buffer::initSize(uint32_t w, uint32_t h, uint32_t reqUsage) } err = allocator.alloc(w, h, format, usage, &handle, &stride); - if (err == NO_ERROR) { - width = w; - height = h; + this->width = w; + this->height = h; + this->format = format; mVStride = 0; } @@ -121,78 +134,6 @@ status_t Buffer::lock(GGLSurface* sur, uint32_t usage) return res; } -// =========================================================================== -// LayerBitmap -// =========================================================================== - -LayerBitmap::LayerBitmap() - : mInfo(0), mWidth(0), mHeight(0) -{ -} - -LayerBitmap::~LayerBitmap() -{ -} - -status_t LayerBitmap::init(surface_info_t* info, - uint32_t w, uint32_t h, PixelFormat format, uint32_t flags) -{ - if (info == NULL) - return BAD_VALUE; - - mFormat = format; - mFlags = flags; - mWidth = w; - mHeight = h; - - mInfo = info; - memset(info, 0, sizeof(surface_info_t)); - info->flags = surface_info_t::eNeedNewBuffer; - - // init the buffer, but don't trigger an allocation - mBuffer = new Buffer(0, 0, format, flags); - return NO_ERROR; -} - -status_t LayerBitmap::setSize(uint32_t w, uint32_t h) -{ - Mutex::Autolock _l(mLock); - if ((w != mWidth) || (h != mHeight)) { - mWidth = w; - mHeight = h; - // this will signal the client that it needs to asks us for a new buffer - mInfo->flags = surface_info_t::eNeedNewBuffer; - } - return NO_ERROR; -} - -sp<Buffer> LayerBitmap::allocate(uint32_t reqUsage) -{ - Mutex::Autolock _l(mLock); - surface_info_t* info = mInfo; - mBuffer.clear(); // free buffer before allocating a new one - sp<Buffer> buffer = new Buffer(mWidth, mHeight, mFormat, reqUsage, mFlags); - status_t err = buffer->initCheck(); - if (LIKELY(err == NO_ERROR)) { - info->flags = surface_info_t::eBufferDirty; - info->status = NO_ERROR; - } else { - memset(info, 0, sizeof(surface_info_t)); - info->status = NO_MEMORY; - } - mBuffer = buffer; - return buffer; -} - -status_t LayerBitmap::free() -{ - mBuffer.clear(); - mWidth = 0; - mHeight = 0; - return NO_ERROR; -} - - // --------------------------------------------------------------------------- }; // namespace android diff --git a/libs/surfaceflinger/LayerBitmap.h b/libs/surfaceflinger/Buffer.h index 87e8f42b145e..79f4eeb6a981 100644 --- a/libs/surfaceflinger/LayerBitmap.h +++ b/libs/surfaceflinger/Buffer.h @@ -30,7 +30,7 @@ #include <pixelflinger/pixelflinger.h> -#include <private/ui/SharedState.h> +#include <private/ui/SharedBufferStack.h> #include <private/ui/SurfaceBuffer.h> class copybit_image_t; @@ -38,10 +38,6 @@ struct android_native_buffer_t; namespace android { -// --------------------------------------------------------------------------- -class IMemory; -class LayerBitmap; - // =========================================================================== // Buffer // =========================================================================== @@ -56,6 +52,8 @@ public: SECURE = 0x00000004 }; + Buffer(); + // creates w * h buffer Buffer(uint32_t w, uint32_t h, PixelFormat format, uint32_t reqUsage, uint32_t flags = 0); @@ -74,6 +72,9 @@ public: android_native_buffer_t* getNativeBuffer() const; + status_t reallocate(uint32_t w, uint32_t h, PixelFormat f, + uint32_t reqUsage, uint32_t flags); + private: friend class LightRefBase<Buffer>; Buffer(const Buffer& rhs); @@ -81,52 +82,11 @@ private: Buffer& operator = (const Buffer& rhs); const Buffer& operator = (const Buffer& rhs) const; - status_t initSize(uint32_t w, uint32_t h, uint32_t reqUsage); - - ssize_t mInitCheck; - uint32_t mFlags; - uint32_t mVStride; -}; - -// =========================================================================== -// LayerBitmap -// =========================================================================== + status_t initSize(uint32_t w, uint32_t h, PixelFormat format, + uint32_t reqUsage, uint32_t flags); -class LayerBitmap -{ -public: - enum { - DONT_CLEAR = Buffer::DONT_CLEAR, - SECURE = Buffer::SECURE - }; - LayerBitmap(); - ~LayerBitmap(); - - status_t init(surface_info_t* info, - uint32_t w, uint32_t h, PixelFormat format, uint32_t flags = 0); - - status_t setSize(uint32_t w, uint32_t h); - - sp<Buffer> allocate(uint32_t reqUsage); - status_t free(); - - sp<const Buffer> getBuffer() const { return mBuffer; } - sp<Buffer> getBuffer() { return mBuffer; } - - uint32_t getWidth() const { return mWidth; } - uint32_t getHeight() const { return mHeight; } - PixelFormat getPixelFormat() const { return mBuffer->getPixelFormat(); } - Rect getBounds() const { return mBuffer->getBounds(); } - -private: - surface_info_t* mInfo; - sp<Buffer> mBuffer; - uint32_t mWidth; - uint32_t mHeight; - PixelFormat mFormat; - uint32_t mFlags; - // protects setSize() and allocate() - mutable Mutex mLock; + ssize_t mInitCheck; + uint32_t mVStride; }; }; // namespace android diff --git a/libs/surfaceflinger/BufferAllocator.cpp b/libs/surfaceflinger/BufferAllocator.cpp index cee8b643dde6..19867a519a79 100644 --- a/libs/surfaceflinger/BufferAllocator.cpp +++ b/libs/surfaceflinger/BufferAllocator.cpp @@ -71,14 +71,23 @@ void BufferAllocator::dump(String8& result) const result.append(buffer); } +static inline uint32_t clamp(uint32_t c) { + return c>0 ? c : 1; +} + status_t BufferAllocator::alloc(uint32_t w, uint32_t h, PixelFormat format, int usage, buffer_handle_t* handle, int32_t* stride) { Mutex::Autolock _l(mLock); - + + // make sure to not allocate a 0 x 0 buffer + w = clamp(w); + h = clamp(h); + // we have a h/w allocator and h/w buffer is requested status_t err = mAllocDev->alloc(mAllocDev, w, h, format, usage, handle, stride); + LOGW_IF(err, "alloc(%u, %u, %d, %08x, ...) failed %d (%s)", w, h, format, usage, err, strerror(-err)); diff --git a/libs/surfaceflinger/DisplayHardware/DisplayHardware.cpp b/libs/surfaceflinger/DisplayHardware/DisplayHardware.cpp index 3f607f6dbb1d..651e7cf16b71 100644 --- a/libs/surfaceflinger/DisplayHardware/DisplayHardware.cpp +++ b/libs/surfaceflinger/DisplayHardware/DisplayHardware.cpp @@ -46,22 +46,25 @@ using namespace android; static __attribute__((noinline)) void checkGLErrors() { - GLenum error = glGetError(); - if (error != GL_NO_ERROR) + do { + // there could be more than one error flag + GLenum error = glGetError(); + if (error == GL_NO_ERROR) + break; LOGE("GL error 0x%04x", int(error)); + } while(true); } static __attribute__((noinline)) void checkEGLErrors(const char* token) { EGLint error = eglGetError(); - // GLESonGL seems to be returning 0 when there is no errors? - if (error && error != EGL_SUCCESS) - LOGE("%s error 0x%04x (%s)", + if (error && error != EGL_SUCCESS) { + LOGE("%s: EGL error 0x%04x (%s)", token, int(error), EGLUtils::strerror(error)); + } } - /* * Initialize the display to the specified values. * @@ -158,7 +161,6 @@ void DisplayHardware::init(uint32_t dpy) */ surface = eglCreateWindowSurface(display, config, mNativeWindow.get(), NULL); - checkEGLErrors("eglCreateWindowSurface"); if (eglQuerySurface(display, surface, EGL_SWAP_BEHAVIOR, &dummy) == EGL_TRUE) { if (dummy == EGL_BUFFER_PRESERVED) { @@ -212,8 +214,6 @@ void DisplayHardware::init(uint32_t dpy) */ context = eglCreateContext(display, config, NULL, NULL); - //checkEGLErrors("eglCreateContext"); - /* * Gather OpenGL ES extensions diff --git a/libs/surfaceflinger/Layer.cpp b/libs/surfaceflinger/Layer.cpp index 6f92515c32cc..ecb6b326476c 100644 --- a/libs/surfaceflinger/Layer.cpp +++ b/libs/surfaceflinger/Layer.cpp @@ -28,9 +28,9 @@ #include <ui/PixelFormat.h> #include <ui/Surface.h> +#include "Buffer.h" #include "clz.h" #include "Layer.h" -#include "LayerBitmap.h" #include "SurfaceFlinger.h" #include "DisplayHardware/DisplayHardware.h" @@ -47,26 +47,29 @@ const char* const Layer::typeID = "Layer"; // --------------------------------------------------------------------------- -Layer::Layer(SurfaceFlinger* flinger, DisplayID display, const sp<Client>& c, int32_t i) - : LayerBaseClient(flinger, display, c, i), +Layer::Layer(SurfaceFlinger* flinger, DisplayID display, + const sp<Client>& c, int32_t i) + : LayerBaseClient(flinger, display, c, i), lcblk(NULL), mSecure(false), - mFrontBufferIndex(1), - mNeedsBlending(true), - mResizeTransactionDone(false) + mNeedsBlending(true) { // no OpenGL operation is possible here, since we might not be // in the OpenGL thread. + lcblk = new SharedBufferServer(c->ctrlblk, i, NUM_BUFFERS); + mFrontBufferIndex = lcblk->getFrontBuffer(); } Layer::~Layer() { destroy(); // the actual buffers will be destroyed here + delete lcblk; + } void Layer::destroy() { - for (int i=0 ; i<NUM_BUFFERS ; i++) { + for (size_t i=0 ; i<NUM_BUFFERS ; i++) { if (mTextures[i].name != -1U) { glDeleteTextures(1, &mTextures[i].name); mTextures[i].name = -1U; @@ -76,19 +79,11 @@ void Layer::destroy() eglDestroyImageKHR(dpy, mTextures[i].image); mTextures[i].image = EGL_NO_IMAGE_KHR; } - mBuffers[i].free(); + mBuffers[i].clear(); } mSurface.clear(); } -void Layer::initStates(uint32_t w, uint32_t h, uint32_t flags) -{ - LayerBase::initStates(w,h,flags); - - if (flags & ISurfaceComposer::eDestroyBackbuffer) - lcblk->flags |= eNoCopyBack; -} - sp<LayerBaseClient::Surface> Layer::createSurface() const { return mSurface; @@ -112,13 +107,14 @@ status_t Layer::setBuffers( uint32_t w, uint32_t h, if (flags & ISurfaceComposer::eSecure) bufferFlags |= Buffer::SECURE; + mFormat = format; + mWidth = w; + mHeight = h; mSecure = (bufferFlags & Buffer::SECURE) ? true : false; mNeedsBlending = (info.h_alpha - info.l_alpha) > 0; - for (int i=0 ; i<2 ; i++) { - err = mBuffers[i].init(lcblk->surface + i, w, h, format, bufferFlags); - if (err != NO_ERROR) { - return err; - } + mBufferFlags = bufferFlags; + for (size_t i=0 ; i<NUM_BUFFERS ; i++) { + mBuffers[i] = new Buffer(); } mSurface = new SurfaceLayer(mFlinger, clientIndex(), this); return NO_ERROR; @@ -126,7 +122,8 @@ status_t Layer::setBuffers( uint32_t w, uint32_t h, void Layer::reloadTexture(const Region& dirty) { - const sp<Buffer>& buffer(frontBuffer().getBuffer()); + Mutex::Autolock _l(mLock); + sp<Buffer> buffer(getFrontBuffer()); if (LIKELY(mFlags & DisplayHardware::DIRECT_TEXTURE)) { int index = mFrontBufferIndex; if (LIKELY(!mTextures[index].dirty)) { @@ -202,80 +199,64 @@ void Layer::onDraw(const Region& clip) const const int index = (mFlags & DisplayHardware::DIRECT_TEXTURE) ? mFrontBufferIndex : 0; GLuint textureName = mTextures[index].name; - if (UNLIKELY(textureName == -1LU)) { - LOGW("Layer %p doesn't have a texture", this); + //LOGW("Layer %p doesn't have a texture", this); // the texture has not been created yet, this Layer has // in fact never been drawn into. this happens frequently with // SurfaceView. clearWithOpenGL(clip); return; } + drawWithOpenGL(clip, mTextures[index]); } -sp<SurfaceBuffer> Layer::peekBuffer(int usage) +sp<SurfaceBuffer> Layer::requestBuffer(int index, int usage) { /* - * This is called from the client's Surface::lock(), after it locked - * the surface successfully. We're therefore guaranteed that the - * back-buffer is not in use by ourselves. - * Of course, we need to validate all this, which is not trivial. - * - * FIXME: A resize could happen at any time here. What to do about this? - * - resize() form post() - * - resize() from doTransaction() - * - * We'll probably need an internal lock for this. - * + * 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. * - * TODO: We need to make sure that post() doesn't swap - * the buffers under us. + * 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 + * from Surface::dequeue() */ + status_t err = lcblk->assertReallocate(index); + LOGE_IF(err, "assertReallocate(%d) failed (%s)", index, strerror(-err)); - // it's okay to read swapState for the purpose of figuring out the - // backbuffer index, which cannot change (since the app has locked it). - const uint32_t state = lcblk->swapState; - const int32_t backBufferIndex = layer_cblk_t::backBuffer(state); + Mutex::Autolock _l(mLock); + uint32_t w = mWidth; + uint32_t h = mHeight; - // get rid of the EGL image, since we shouldn't need it anymore - // (note that we're in a different thread than where it is being used) - if (mTextures[backBufferIndex].image != EGL_NO_IMAGE_KHR) { - EGLDisplay dpy(mFlinger->graphicPlane(0).getEGLDisplay()); - eglDestroyImageKHR(dpy, mTextures[backBufferIndex].image); - mTextures[backBufferIndex].image = EGL_NO_IMAGE_KHR; + sp<Buffer>& buffer(mBuffers[index]); + if (buffer->getStrongCount() == 1) { + err = buffer->reallocate(w, h, mFormat, usage, mBufferFlags); + } else { + // here we have to reallocate a new buffer because we could have a + // client in our process with a reference to it (eg: status bar), + // and we can't release the handle under its feet. + buffer.clear(); + buffer = new Buffer(w, h, mFormat, usage, mBufferFlags); + err = buffer->initCheck(); } - - LayerBitmap& layerBitmap(mBuffers[backBufferIndex]); - sp<SurfaceBuffer> buffer = layerBitmap.allocate(usage); - - LOGD_IF(DEBUG_RESIZE, - "Layer::getBuffer(this=%p), index=%d, (%d,%d), (%d,%d)", - this, backBufferIndex, - layerBitmap.getWidth(), - layerBitmap.getHeight(), - layerBitmap.getBuffer()->getWidth(), - layerBitmap.getBuffer()->getHeight()); - - if (UNLIKELY(buffer == 0)) { - // XXX: what to do, what to do? + + if (err || buffer->handle == 0) { + LOGE_IF(err || buffer->handle == 0, + "Layer::requestBuffer(this=%p), index=%d, w=%d, h=%d failed (%s)", + this, index, w, h, strerror(-err)); } else { - // texture is now dirty... - mTextures[backBufferIndex].dirty = true; - // ... so it the visible region (because we consider the surface's - // buffer size for visibility calculations) - forceVisibilityTransaction(); - mFlinger->setTransactionFlags(eTraversalNeeded); + LOGD_IF(DEBUG_RESIZE, + "Layer::requestBuffer(this=%p), index=%d, w=%d, h=%d", + this, index, w, h); } - return buffer; -} -void Layer::scheduleBroadcast() -{ - sp<Client> ourClient(client.promote()); - if (ourClient != 0) { - mFlinger->scheduleBroadcast(ourClient); + if (err == NO_ERROR && buffer->handle != 0) { + // texture is now dirty... + mTextures[index].dirty = true; } + return buffer; } uint32_t Layer::doTransaction(uint32_t flags) @@ -283,114 +264,48 @@ uint32_t Layer::doTransaction(uint32_t flags) const Layer::State& front(drawingState()); const Layer::State& temp(currentState()); - // the test front.{w|h} != temp.{w|h} is not enough because it is possible - // that the size changed back to its previous value before the buffer - // was resized (in the eLocked case below), in which case, we still - // need to execute the code below so the clients have a chance to be - // release. resize() deals with the fact that the size can be the same. - - /* - * Various states we could be in... - - resize = state & eResizeRequested; - if (backbufferChanged) { - if (resize == 0) { - // ERROR, the resized buffer doesn't have its resize flag set - } else if (resize == mask) { - // ERROR one of the buffer has already been resized - } else if (resize == mask ^ eResizeRequested) { - // ERROR, the resized buffer doesn't have its resize flag set - } else if (resize == eResizeRequested) { - // OK, Normal case, proceed with resize - } - } else { - if (resize == 0) { - // OK, nothing special, do nothing - } else if (resize == mask) { - // restarted transaction, do nothing - } else if (resize == mask ^ eResizeRequested) { - // restarted transaction, do nothing - } else if (resize == eResizeRequested) { - // OK, size reset to previous value, proceed with resize - } - } - */ - // Index of the back buffer const bool backbufferChanged = (front.w != temp.w) || (front.h != temp.h); - const uint32_t state = lcblk->swapState; - const int32_t clientBackBufferIndex = layer_cblk_t::backBuffer(state); - const uint32_t mask = clientBackBufferIndex ? eResizeBuffer1 : eResizeBuffer0; - uint32_t resizeFlags = state & eResizeRequested; - - if (UNLIKELY(backbufferChanged && (resizeFlags != eResizeRequested))) { - LOGE( "backbuffer size changed, but both resize flags are not set! " - "(layer=%p), state=%08x, requested (%dx%d), drawing (%d,%d), " - "index=%d, (%dx%d), (%dx%d)", - this, state, - int(temp.w), int(temp.h), - int(drawingState().w), int(drawingState().h), - int(clientBackBufferIndex), - int(mBuffers[0].getWidth()), int(mBuffers[0].getHeight()), - int(mBuffers[1].getWidth()), int(mBuffers[1].getHeight())); - // if we get there we're pretty screwed. the only reasonable - // thing to do is to pretend we should do the resize since - // backbufferChanged is set (this also will give a chance to - // client to get unblocked) - resizeFlags = eResizeRequested; - } - - if (resizeFlags == eResizeRequested) { - // NOTE: asserting that clientBackBufferIndex!=mFrontBufferIndex - // here, would be wrong and misleading because by this point - // mFrontBufferIndex has not been updated yet. + if (backbufferChanged) { + // the size changed, we need to ask our client to request a new buffer LOGD_IF(DEBUG_RESIZE, - "resize (layer=%p), state=%08x, " - "requested (%dx%d), " - "drawing (%d,%d), " - "index=%d, (%dx%d), (%dx%d)", - this, state, - int(temp.w), int(temp.h), + "resize (layer=%p), requested (%dx%d), " + "drawing (%d,%d), (%dx%d), (%dx%d)", + this, int(temp.w), int(temp.h), int(drawingState().w), int(drawingState().h), - int(clientBackBufferIndex), - int(mBuffers[0].getWidth()), int(mBuffers[0].getHeight()), - int(mBuffers[1].getWidth()), int(mBuffers[1].getHeight())); - - if (state & eLocked) { - // if the buffer is locked, we can't resize anything because - // - the backbuffer is currently in use by the user - // - the front buffer is being shown - // We just act as if the transaction didn't happen and we - // reschedule it later... - flags |= eRestartTransaction; - } else { - // This buffer needs to be resized - status_t err = - resize(clientBackBufferIndex, temp.w, temp.h, "transaction"); - if (err == NO_ERROR) { - const uint32_t mask = clientBackBufferIndex ? - eResizeBuffer1 : eResizeBuffer0; - android_atomic_and(~mask, &(lcblk->swapState)); - // since a buffer became available, we can let the client go... - scheduleBroadcast(); - mResizeTransactionDone = true; - - // we're being resized and there is a freeze display request, - // acquire a freeze lock, so that the screen stays put - // until we've redrawn at the new size; this is to avoid - // glitches upon orientation changes. - if (mFlinger->hasFreezeRequest()) { - // if the surface is hidden, don't try to acquire the - // freeze lock, since hidden surfaces may never redraw - if (!(front.flags & ISurfaceComposer::eLayerHidden)) { - mFreezeLock = mFlinger->getFreezeLock(); - } - } + int(mBuffers[0]->getWidth()), int(mBuffers[0]->getHeight()), + int(mBuffers[1]->getWidth()), int(mBuffers[1]->getHeight())); + + // record the new size, form this point on, when the client request a + // buffer, it'll get the new size. + setDrawingSize(temp.w, temp.h); + + // all buffers need reallocation + lcblk->reallocate(); + + // recompute the visible region + // FIXME: ideally we would do that only when we have received + // a buffer of the right size + flags |= Layer::eVisibleRegion; + this->contentDirty = true; + +#if 0 + // FIXME: handle freeze lock + // we're being resized and there is a freeze display request, + // acquire a freeze lock, so that the screen stays put + // until we've redrawn at the new size; this is to avoid + // glitches upon orientation changes. + if (mFlinger->hasFreezeRequest()) { + // if the surface is hidden, don't try to acquire the + // freeze lock, since hidden surfaces may never redraw + if (!(front.flags & ISurfaceComposer::eLayerHidden)) { + mFreezeLock = mFlinger->getFreezeLock(); } } +#endif } - + if (temp.sequence != front.sequence) { if (temp.flags & ISurfaceComposer::eLayerHidden || temp.alpha == 0) { // this surface is now hidden, so it shouldn't hold a freeze lock @@ -402,65 +317,10 @@ uint32_t Layer::doTransaction(uint32_t flags) return LayerBase::doTransaction(flags); } -status_t Layer::resize( - int32_t clientBackBufferIndex, - uint32_t width, uint32_t height, - const char* what) -{ - /* - * handle resize (backbuffer and frontbuffer reallocation) - * this is called from post() or from doTransaction() - */ - - const LayerBitmap& clientBackBuffer(mBuffers[clientBackBufferIndex]); - - // if the new (transaction) size is != from the the backbuffer - // then we need to reallocate the backbuffer - bool backbufferChanged = (clientBackBuffer.getWidth() != width) || - (clientBackBuffer.getHeight() != height); - - LOGD_IF(!backbufferChanged, - "(%s) eResizeRequested (layer=%p), but size not changed: " - "requested (%dx%d), drawing (%d,%d), current (%d,%d)," - "state=%08lx, index=%d, (%dx%d), (%dx%d)", - what, this, - int(width), int(height), - int(drawingState().w), int(drawingState().h), - int(currentState().w), int(currentState().h), - long(lcblk->swapState), - int(clientBackBufferIndex), - int(mBuffers[0].getWidth()), int(mBuffers[0].getHeight()), - int(mBuffers[1].getWidth()), int(mBuffers[1].getHeight())); - - // this can happen when changing the size back and forth quickly - status_t err = NO_ERROR; - if (backbufferChanged) { - - LOGD_IF(DEBUG_RESIZE, - "resize (layer=%p), requested (%dx%d), " - "index=%d, (%dx%d), (%dx%d)", - this, int(width), int(height), int(clientBackBufferIndex), - int(mBuffers[0].getWidth()), int(mBuffers[0].getHeight()), - int(mBuffers[1].getWidth()), int(mBuffers[1].getHeight())); - - err = mBuffers[clientBackBufferIndex].setSize(width, height); - if (UNLIKELY(err != NO_ERROR)) { - // This really should never happen - LOGE("resizing buffer %d to (%u,%u) failed [%08x] %s", - clientBackBufferIndex, width, height, err, strerror(err)); - // couldn't reallocate the surface - android_atomic_write(eInvalidSurface, &lcblk->swapState); - } - } - return err; -} - -void Layer::setSizeChanged(uint32_t w, uint32_t h) -{ - LOGD_IF(DEBUG_RESIZE, - "setSizeChanged w=%d, h=%d (old: w=%d, h=%d)", - w, h, mCurrentState.w, mCurrentState.h); - android_atomic_or(eResizeRequested, &(lcblk->swapState)); +void Layer::setDrawingSize(uint32_t w, uint32_t h) { + Mutex::Autolock _l(mLock); + mWidth = w; + mHeight = h; } // ---------------------------------------------------------------------------- @@ -469,139 +329,26 @@ void Layer::setSizeChanged(uint32_t w, uint32_t h) void Layer::lockPageFlip(bool& recomputeVisibleRegions) { - uint32_t state = android_atomic_or(eBusy, &(lcblk->swapState)); - // preemptively block the client, because he might set - // eFlipRequested at any time and want to use this buffer - // for the next frame. This will be unset below if it - // turns out we didn't need it. - - uint32_t mask = eInvalidSurface | eFlipRequested | eResizeRequested; - if (!(state & mask)) - return; - - if (UNLIKELY(state & eInvalidSurface)) { - // if eInvalidSurface is set, this means the surface - // became invalid during a transaction (NO_MEMORY for instance) - scheduleBroadcast(); + ssize_t buf = lcblk->retireAndLock(); + if (buf < NO_ERROR) { + //LOGW("nothing to retire (%s)", strerror(-buf)); + // NOTE: here the buffer is locked because we will used + // for composition later in the loop return; } - - if (UNLIKELY(state & eFlipRequested)) { - uint32_t oldState; - mPostedDirtyRegion = post(&oldState, recomputeVisibleRegions); - if (oldState & eNextFlipPending) { - // Process another round (we know at least a buffer - // is ready for that client). - mFlinger->signalEvent(); - } - } -} - -Region Layer::post(uint32_t* previousSate, bool& recomputeVisibleRegions) -{ - // atomically swap buffers and (re)set eFlipRequested - int32_t oldValue, newValue; - layer_cblk_t * const lcblk = this->lcblk; - do { - oldValue = lcblk->swapState; - // get the current value - - LOG_ASSERT(oldValue&eFlipRequested, - "eFlipRequested not set, yet we're flipping! (state=0x%08lx)", - long(oldValue)); - - newValue = (oldValue ^ eIndex); - // swap buffers - - newValue &= ~(eFlipRequested | eNextFlipPending); - // clear eFlipRequested and eNextFlipPending - - if (oldValue & eNextFlipPending) - newValue |= eFlipRequested; - // if eNextFlipPending is set (second buffer already has something - // in it) we need to reset eFlipRequested because the client - // might never do it - - } while(android_atomic_cmpxchg(oldValue, newValue, &(lcblk->swapState))); - *previousSate = oldValue; - const int32_t index = (newValue & eIndex) ^ 1; - mFrontBufferIndex = index; + // we retired a buffer, which becomes the new front buffer + mFrontBufferIndex = buf; - /* NOTE: it's safe to set this flag here because this is only touched - * from LayerBitmap::allocate(), which by construction cannot happen - * while we're in post(). - */ - lcblk->surface[index].flags &= ~surface_info_t::eBufferDirty; - - // ... post the new front-buffer - Region dirty(lcblk->region + index); - dirty.andSelf(frontBuffer().getBounds()); - - //LOGD("Did post oldValue=%08lx, newValue=%08lx, mFrontBufferIndex=%u\n", - // oldValue, newValue, mFrontBufferIndex); - //dirty.dump("dirty"); + // get the dirty region + sp<Buffer> newFrontBuffer(getBuffer(buf)); + const Region dirty(lcblk->getDirtyRegion(buf)); + mPostedDirtyRegion = dirty.intersect( newFrontBuffer->getBounds() ); - if (UNLIKELY(oldValue & eResizeRequested)) { - - LOGD_IF(DEBUG_RESIZE, - "post (layer=%p), state=%08x, " - "index=%d, (%dx%d), (%dx%d)", - this, newValue, - int(1-index), - int(mBuffers[0].getWidth()), int(mBuffers[0].getHeight()), - int(mBuffers[1].getWidth()), int(mBuffers[1].getHeight())); - - // here, we just posted the surface and we have resolved - // the front/back buffer indices. The client is blocked, so - // it cannot start using the new backbuffer. - - // If the backbuffer was resized in THIS round, we actually cannot - // resize the frontbuffer because it has *just* been drawn (and we - // would have nothing to draw). In this case we just skip the resize - // it'll happen after the next page flip or during the next - // transaction. - - const uint32_t mask = (1-index) ? eResizeBuffer1 : eResizeBuffer0; - if (mResizeTransactionDone && (newValue & mask)) { - // Resize the layer's second buffer only if the transaction - // happened. It may not have happened yet if eResizeRequested - // was set immediately after the "transactionRequested" test, - // in which case the drawing state's size would be wrong. - mFreezeLock.clear(); - const Layer::State& s(drawingState()); - if (resize(1-index, s.w, s.h, "post") == NO_ERROR) { - do { - oldValue = lcblk->swapState; - if ((oldValue & eResizeRequested) == eResizeRequested) { - // ugh, another resize was requested since we processed - // the first buffer, don't free the client, and let - // the next transaction handle everything. - break; - } - newValue = oldValue & ~mask; - } while(android_atomic_cmpxchg(oldValue, newValue, &(lcblk->swapState))); - } - mResizeTransactionDone = false; - recomputeVisibleRegions = true; - this->contentDirty = true; - } - } + // FIXME: signal an event if we have more buffers waiting + // mFlinger->signalEvent(); - reloadTexture(dirty); - - return dirty; -} - -Point Layer::getPhysicalSize() const -{ - sp<const Buffer> front(frontBuffer().getBuffer()); - Point size(front->getWidth(), front->getHeight()); - if ((size.x | size.y) == 0) { - // if we don't have a buffer yet, just use the state's size. - size = LayerBase::getPhysicalSize(); - } - return size; + reloadTexture( mPostedDirtyRegion ); } void Layer::unlockPageFlip( @@ -622,21 +369,15 @@ void Layer::unlockPageFlip( // is in screen space as well). dirtyRegion.andSelf(visibleRegionScreen); outDirtyRegion.orSelf(dirtyRegion); - - // client could be blocked, so signal them so they get a - // chance to reevaluate their condition. - scheduleBroadcast(); } } void Layer::finishPageFlip() { - if (LIKELY(!(lcblk->swapState & eInvalidSurface))) { - LOGE_IF(!(lcblk->swapState & eBusy), - "layer %p wasn't locked!", this); - android_atomic_and(~eBusy, &(lcblk->swapState)); - } - scheduleBroadcast(); + status_t err = lcblk->unlock( mFrontBufferIndex ); + LOGE_IF(err!=NO_ERROR, + "layer %p, buffer=%d wasn't locked!", + this, mFrontBufferIndex); } // --------------------------------------------------------------------------- @@ -651,12 +392,16 @@ Layer::SurfaceLayer::~SurfaceLayer() { } -sp<SurfaceBuffer> Layer::SurfaceLayer::getBuffer(int usage) +sp<SurfaceBuffer> Layer::SurfaceLayer::requestBuffer(int index, int usage) { - sp<SurfaceBuffer> buffer = 0; + sp<SurfaceBuffer> buffer; sp<Layer> owner(getOwner()); if (owner != 0) { - buffer = owner->peekBuffer(usage); + LOGE_IF(uint32_t(index)>=NUM_BUFFERS, + "getBuffer() index (%d) out of range", index); + if (uint32_t(index) < NUM_BUFFERS) { + buffer = owner->requestBuffer(index, usage); + } } return buffer; } diff --git a/libs/surfaceflinger/Layer.h b/libs/surfaceflinger/Layer.h index add5d5074741..3b4489e4dae2 100644 --- a/libs/surfaceflinger/Layer.h +++ b/libs/surfaceflinger/Layer.h @@ -21,10 +21,6 @@ #include <sys/types.h> #include <ui/PixelFormat.h> - -#include <private/ui/SharedState.h> -#include <private/ui/LayerState.h> - #include <pixelflinger/pixelflinger.h> #include <EGL/egl.h> @@ -32,7 +28,7 @@ #include <GLES/gl.h> #include <GLES/glext.h> -#include "LayerBitmap.h" +#include "Buffer.h" #include "LayerBase.h" #include "Transform.h" @@ -41,12 +37,12 @@ namespace android { // --------------------------------------------------------------------------- class Client; -class LayerBitmap; class FreezeLock; +class Buffer; // --------------------------------------------------------------------------- -const int NUM_BUFFERS = 2; +const size_t NUM_BUFFERS = 2; class Layer : public LayerBaseClient { @@ -56,23 +52,22 @@ public: virtual char const* getTypeID() const { return typeID; } virtual uint32_t getTypeInfo() const { return typeInfo; } + + SharedBufferServer* lcblk; + + Layer(SurfaceFlinger* flinger, DisplayID display, const sp<Client>& client, int32_t i); virtual ~Layer(); - inline PixelFormat pixelFormat() const { - return frontBuffer().getPixelFormat(); - } + status_t setBuffers(uint32_t w, uint32_t h, + PixelFormat format, uint32_t flags=0); - status_t setBuffers( uint32_t w, uint32_t h, - PixelFormat format, uint32_t flags=0); + void setDrawingSize(uint32_t w, uint32_t h); virtual void onDraw(const Region& clip) const; - virtual void initStates(uint32_t w, uint32_t h, uint32_t flags); - virtual void setSizeChanged(uint32_t w, uint32_t h); virtual uint32_t doTransaction(uint32_t transactionFlags); - virtual Point getPhysicalSize() const; virtual void lockPageFlip(bool& recomputeVisibleRegions); virtual void unlockPageFlip(const Transform& planeTransform, Region& outDirtyRegion); virtual void finishPageFlip(); @@ -80,42 +75,31 @@ public: virtual bool isSecure() const { return mSecure; } virtual sp<Surface> createSurface() const; virtual status_t ditch(); - - const LayerBitmap& getBuffer(int i) const { return mBuffers[i]; } - LayerBitmap& getBuffer(int i) { return mBuffers[i]; } - + // only for debugging - const sp<FreezeLock>& getFreezeLock() const { return mFreezeLock; } + inline sp<Buffer> getBuffer(int i) { return mBuffers[i]; } + // only for debugging + inline const sp<FreezeLock>& getFreezeLock() const { return mFreezeLock; } + // only for debugging + inline PixelFormat pixelFormat() const { return mFormat; } private: - inline const LayerBitmap& - frontBuffer() const { return getBuffer(mFrontBufferIndex); } - inline LayerBitmap& - frontBuffer() { return getBuffer(mFrontBufferIndex); } - inline const LayerBitmap& - backBuffer() const { return getBuffer(1-mFrontBufferIndex); } - inline LayerBitmap& - backBuffer() { return getBuffer(1-mFrontBufferIndex); } - + inline sp<Buffer> getFrontBuffer() { + return mBuffers[mFrontBufferIndex]; + } + void reloadTexture(const Region& dirty); - status_t resize(int32_t index, uint32_t w, uint32_t h, const char* what); - Region post(uint32_t* oldState, bool& recomputeVisibleRegions); - sp<SurfaceBuffer> peekBuffer(int usage); + sp<SurfaceBuffer> requestBuffer(int index, int usage); void destroy(); - void scheduleBroadcast(); - - class SurfaceLayer : public LayerBaseClient::Surface - { + class SurfaceLayer : public LayerBaseClient::Surface { public: - SurfaceLayer(const sp<SurfaceFlinger>& flinger, - SurfaceID id, const sp<Layer>& owner); - ~SurfaceLayer(); - + SurfaceLayer(const sp<SurfaceFlinger>& flinger, + SurfaceID id, const sp<Layer>& owner); + ~SurfaceLayer(); private: - virtual sp<SurfaceBuffer> getBuffer(int usage); - + virtual sp<SurfaceBuffer> requestBuffer(int index, int usage); sp<Layer> getOwner() const { return static_cast<Layer*>(Surface::getOwner().get()); } @@ -125,13 +109,20 @@ private: sp<Surface> mSurface; bool mSecure; - LayerBitmap mBuffers[NUM_BUFFERS]; - Texture mTextures[NUM_BUFFERS]; int32_t mFrontBufferIndex; bool mNeedsBlending; - bool mResizeTransactionDone; Region mPostedDirtyRegion; sp<FreezeLock> mFreezeLock; + PixelFormat mFormat; + uint32_t mBufferFlags; + + // protected by mLock + sp<Buffer> mBuffers[NUM_BUFFERS]; + Texture mTextures[NUM_BUFFERS]; + uint32_t mWidth; + uint32_t mHeight; + + mutable Mutex mLock; }; // --------------------------------------------------------------------------- diff --git a/libs/surfaceflinger/LayerBase.cpp b/libs/surfaceflinger/LayerBase.cpp index ec38fe9fd54f..62e41b0f17d8 100644 --- a/libs/surfaceflinger/LayerBase.cpp +++ b/libs/surfaceflinger/LayerBase.cpp @@ -30,7 +30,6 @@ #include "clz.h" #include "LayerBase.h" -#include "LayerBlur.h" #include "SurfaceFlinger.h" #include "DisplayHardware/DisplayHardware.h" @@ -127,9 +126,6 @@ uint32_t LayerBase::setTransactionFlags(uint32_t flags) { return android_atomic_or(flags, &mTransactionFlags); } -void LayerBase::setSizeChanged(uint32_t w, uint32_t h) { -} - bool LayerBase::setPosition(int32_t x, int32_t y) { if (mCurrentState.transform.tx() == x && mCurrentState.transform.ty() == y) return false; @@ -149,7 +145,6 @@ bool LayerBase::setLayer(uint32_t z) { bool LayerBase::setSize(uint32_t w, uint32_t h) { if (mCurrentState.w == w && mCurrentState.h == h) return false; - setSizeChanged(w, h); mCurrentState.w = w; mCurrentState.h = h; requestTransaction(); @@ -219,21 +214,14 @@ uint32_t LayerBase::doTransaction(uint32_t flags) return flags; } -Point LayerBase::getPhysicalSize() const -{ - const Layer::State& front(drawingState()); - return Point(front.w, front.h); -} - void LayerBase::validateVisibility(const Transform& planeTransform) { const Layer::State& s(drawingState()); const Transform tr(planeTransform * s.transform); const bool transformed = tr.transformed(); - const Point size(getPhysicalSize()); - uint32_t w = size.x; - uint32_t h = size.y; + uint32_t w = s.w; + uint32_t h = s.h; tr.transform(mVertices[0], 0, 0); tr.transform(mVertices[1], 0, h); tr.transform(mVertices[2], w, h); @@ -655,9 +643,7 @@ int32_t LayerBaseClient::sIdentity = 0; LayerBaseClient::LayerBaseClient(SurfaceFlinger* flinger, DisplayID display, const sp<Client>& client, int32_t i) : LayerBase(flinger, display), client(client), - lcblk( client!=0 ? &(client->ctrlblk->layers[i]) : 0 ), - mIndex(i), - mIdentity(uint32_t(android_atomic_inc(&sIdentity))) + mIndex(i), mIdentity(uint32_t(android_atomic_inc(&sIdentity))) { } @@ -666,11 +652,8 @@ void LayerBaseClient::onFirstRef() sp<Client> client(this->client.promote()); if (client != 0) { client->bindLayer(this, mIndex); - // Initialize this layer's control block - memset(this->lcblk, 0, sizeof(layer_cblk_t)); - this->lcblk->identity = mIdentity; - Region::writeEmpty(&(this->lcblk->region[0]), sizeof(flat_region_t)); - Region::writeEmpty(&(this->lcblk->region[1]), sizeof(flat_region_t)); + // Initialize this layer's identity + client->ctrlblk->setIdentity(mIndex, mIdentity); } } @@ -759,7 +742,7 @@ status_t LayerBaseClient::Surface::onTransact( return BnSurface::onTransact(code, data, reply, flags); } -sp<SurfaceBuffer> LayerBaseClient::Surface::getBuffer(int) +sp<SurfaceBuffer> LayerBaseClient::Surface::requestBuffer(int index, int usage) { return NULL; } diff --git a/libs/surfaceflinger/LayerBase.h b/libs/surfaceflinger/LayerBase.h index 2168de0e79f5..78bb4bf9faec 100644 --- a/libs/surfaceflinger/LayerBase.h +++ b/libs/surfaceflinger/LayerBase.h @@ -23,6 +23,7 @@ #include <EGL/egl.h> #include <EGL/eglext.h> +#include <private/ui/SharedBufferStack.h> #include <private/ui/LayerState.h> #include <utils/RefBase.h> @@ -137,11 +138,6 @@ public: virtual void initStates(uint32_t w, uint32_t h, uint32_t flags); /** - * setSizeChanged - called when the *current* state's size is changed. - */ - virtual void setSizeChanged(uint32_t w, uint32_t h); - - /** * doTransaction - process the transaction. This is a good place to figure * out which attributes of the surface have changed. */ @@ -161,13 +157,6 @@ public: virtual void setCoveredRegion(const Region& coveredRegion); /** - * getPhysicalSize - returns the physical size of the drawing state of - * the surface. If the surface is backed by a bitmap, this is the size of - * the bitmap (as opposed to the size of the drawing state). - */ - virtual Point getPhysicalSize() const; - - /** * validateVisibility - cache a bunch of things */ virtual void validateVisibility(const Transform& globalTransform); @@ -308,8 +297,8 @@ public: virtual ~LayerBaseClient(); virtual void onFirstRef(); - wp<Client> client; - layer_cblk_t* const lcblk; + wp<Client> client; +// SharedBufferServer* lcblk; inline uint32_t getIdentity() const { return mIdentity; } inline int32_t clientIndex() const { return mIndex; } @@ -336,7 +325,7 @@ public: sp<LayerBaseClient> getOwner() const; private: - virtual sp<SurfaceBuffer> getBuffer(int usage); + virtual sp<SurfaceBuffer> requestBuffer(int index, int usage); virtual status_t registerBuffers(const ISurface::BufferHeap& buffers); virtual void postBuffer(ssize_t offset); virtual void unregisterBuffers(); diff --git a/libs/surfaceflinger/LayerBuffer.cpp b/libs/surfaceflinger/LayerBuffer.cpp index 8a55a3f277e4..433b48e1001f 100644 --- a/libs/surfaceflinger/LayerBuffer.cpp +++ b/libs/surfaceflinger/LayerBuffer.cpp @@ -28,6 +28,7 @@ #include <hardware/copybit.h> +#include "Buffer.h" #include "BufferAllocator.h" #include "LayerBuffer.h" #include "SurfaceFlinger.h" @@ -58,7 +59,7 @@ LayerBuffer::~LayerBuffer() void LayerBuffer::onFirstRef() { LayerBaseClient::onFirstRef(); - mSurface = new SurfaceBuffer(mFlinger, clientIndex(), + mSurface = new SurfaceLayerBuffer(mFlinger, clientIndex(), const_cast<LayerBuffer *>(this)); } @@ -181,21 +182,21 @@ sp<LayerBuffer::Source> LayerBuffer::clearSource() { } // ============================================================================ -// LayerBuffer::SurfaceBuffer +// LayerBuffer::SurfaceLayerBuffer // ============================================================================ -LayerBuffer::SurfaceBuffer::SurfaceBuffer(const sp<SurfaceFlinger>& flinger, +LayerBuffer::SurfaceLayerBuffer::SurfaceLayerBuffer(const sp<SurfaceFlinger>& flinger, SurfaceID id, const sp<LayerBuffer>& owner) : LayerBaseClient::Surface(flinger, id, owner->getIdentity(), owner) { } -LayerBuffer::SurfaceBuffer::~SurfaceBuffer() +LayerBuffer::SurfaceLayerBuffer::~SurfaceLayerBuffer() { unregisterBuffers(); } -status_t LayerBuffer::SurfaceBuffer::registerBuffers( +status_t LayerBuffer::SurfaceLayerBuffer::registerBuffers( const ISurface::BufferHeap& buffers) { sp<LayerBuffer> owner(getOwner()); @@ -204,21 +205,21 @@ status_t LayerBuffer::SurfaceBuffer::registerBuffers( return NO_INIT; } -void LayerBuffer::SurfaceBuffer::postBuffer(ssize_t offset) +void LayerBuffer::SurfaceLayerBuffer::postBuffer(ssize_t offset) { sp<LayerBuffer> owner(getOwner()); if (owner != 0) owner->postBuffer(offset); } -void LayerBuffer::SurfaceBuffer::unregisterBuffers() +void LayerBuffer::SurfaceLayerBuffer::unregisterBuffers() { sp<LayerBuffer> owner(getOwner()); if (owner != 0) owner->unregisterBuffers(); } -sp<OverlayRef> LayerBuffer::SurfaceBuffer::createOverlay( +sp<OverlayRef> LayerBuffer::SurfaceLayerBuffer::createOverlay( uint32_t w, uint32_t h, int32_t format) { sp<OverlayRef> result; sp<LayerBuffer> owner(getOwner()); @@ -462,8 +463,8 @@ void LayerBuffer::BufferSource::onDraw(const Region& clip) const const int tmp_h = floorf(src_height * yscale); if (mTempBitmap==0 || - mTempBitmap->getWidth() < tmp_w || - mTempBitmap->getHeight() < tmp_h) { + mTempBitmap->getWidth() < size_t(tmp_w) || + mTempBitmap->getHeight() < size_t(tmp_h)) { mTempBitmap.clear(); mTempBitmap = new android::Buffer( tmp_w, tmp_h, src.img.format, diff --git a/libs/surfaceflinger/LayerBuffer.h b/libs/surfaceflinger/LayerBuffer.h index 80572193c1d9..e539f681133d 100644 --- a/libs/surfaceflinger/LayerBuffer.h +++ b/libs/surfaceflinger/LayerBuffer.h @@ -24,7 +24,6 @@ #include <private/ui/LayerState.h> #include "LayerBase.h" -#include "LayerBitmap.h" struct copybit_device_t; @@ -32,9 +31,12 @@ namespace android { // --------------------------------------------------------------------------- +class Buffer; class Region; class OverlayRef; +// --------------------------------------------------------------------------- + class LayerBuffer : public LayerBaseClient { class Source : public LightRefBase<Source> { @@ -179,12 +181,12 @@ private: }; - class SurfaceBuffer : public LayerBaseClient::Surface + class SurfaceLayerBuffer : public LayerBaseClient::Surface { public: - SurfaceBuffer(const sp<SurfaceFlinger>& flinger, + SurfaceLayerBuffer(const sp<SurfaceFlinger>& flinger, SurfaceID id, const sp<LayerBuffer>& owner); - virtual ~SurfaceBuffer(); + virtual ~SurfaceLayerBuffer(); virtual status_t registerBuffers(const ISurface::BufferHeap& buffers); virtual void postBuffer(ssize_t offset); diff --git a/libs/surfaceflinger/LayerDim.cpp b/libs/surfaceflinger/LayerDim.cpp index f613767de8d5..8ba0a9d0da46 100644 --- a/libs/surfaceflinger/LayerDim.cpp +++ b/libs/surfaceflinger/LayerDim.cpp @@ -21,6 +21,7 @@ #include <utils/Errors.h> #include <utils/Log.h> +#include "Buffer.h" #include "BufferAllocator.h" #include "LayerDim.h" #include "SurfaceFlinger.h" diff --git a/libs/surfaceflinger/LayerDim.h b/libs/surfaceflinger/LayerDim.h index 33bd49d54d32..d4672a1c44c5 100644 --- a/libs/surfaceflinger/LayerDim.h +++ b/libs/surfaceflinger/LayerDim.h @@ -24,12 +24,11 @@ #include <EGL/eglext.h> #include "LayerBase.h" -#include "LayerBitmap.h" - -namespace android { // --------------------------------------------------------------------------- +namespace android { + class LayerDim : public LayerBaseClient { static bool sUseTexture; diff --git a/libs/surfaceflinger/SurfaceFlinger.cpp b/libs/surfaceflinger/SurfaceFlinger.cpp index c78921a11575..b368db6e2e3b 100644 --- a/libs/surfaceflinger/SurfaceFlinger.cpp +++ b/libs/surfaceflinger/SurfaceFlinger.cpp @@ -44,12 +44,12 @@ #include <GLES/gl.h> #include "clz.h" +#include "Buffer.h" #include "BufferAllocator.h" #include "Layer.h" #include "LayerBlur.h" #include "LayerBuffer.h" #include "LayerDim.h" -#include "LayerBitmap.h" #include "SurfaceFlinger.h" #include "DisplayHardware/DisplayHardware.h" @@ -173,12 +173,12 @@ SurfaceFlinger::SurfaceFlinger() : BnSurfaceComposer(), Thread(false), mTransactionFlags(0), mTransactionCount(0), + mResizeTransationPending(false), mLayersRemoved(false), mBootTime(systemTime()), mHardwareTest("android.permission.HARDWARE_TEST"), mAccessSurfaceFlinger("android.permission.ACCESS_SURFACE_FLINGER"), mDump("android.permission.DUMP"), - mLastScheduledBroadcast(NULL), mVisibleRegionsDirty(false), mDeferReleaseConsole(false), mFreezeDisplay(false), @@ -497,13 +497,11 @@ bool SurfaceFlinger::threadLoop() // release the clients before we flip ('cause flip might block) unlockClients(); - executeScheduledBroadcasts(); postFramebuffer(); } else { // pretend we did the post unlockClients(); - executeScheduledBroadcasts(); usleep(16667); // 60 fps period } return true; @@ -773,7 +771,8 @@ void SurfaceFlinger::computeVisibleRegions( void SurfaceFlinger::commitTransaction() { mDrawingState = mCurrentState; - mTransactionCV.signal(); + mResizeTransationPending = false; + mTransactionCV.broadcast(); } void SurfaceFlinger::handlePageFlip() @@ -910,37 +909,6 @@ void SurfaceFlinger::unlockClients() } } -void SurfaceFlinger::scheduleBroadcast(const sp<Client>& client) -{ - if (mLastScheduledBroadcast != client) { - mLastScheduledBroadcast = client; - mScheduledBroadcasts.add(client); - } -} - -void SurfaceFlinger::executeScheduledBroadcasts() -{ - SortedVector< wp<Client> >& list(mScheduledBroadcasts); - size_t count = list.size(); - while (count--) { - sp<Client> client = list[count].promote(); - if (client != 0) { - per_client_cblk_t* const cblk = client->ctrlblk; - if (cblk->lock.tryLock() == NO_ERROR) { - cblk->cv.broadcast(); - list.removeAt(count); - cblk->lock.unlock(); - } else { - // schedule another round - LOGW("executeScheduledBroadcasts() skipped, " - "contention on the client. We'll try again later..."); - signalDelayedEvent(ms2ns(4)); - } - } - } - mLastScheduledBroadcast = 0; -} - void SurfaceFlinger::debugFlashRegions() { const DisplayHardware& hw(graphicPlane(0).displayHardware()); @@ -1129,18 +1097,10 @@ void SurfaceFlinger::free_resources_l() mLayersRemoved = false; // free resources associated with disconnected clients - SortedVector< wp<Client> >& scheduledBroadcasts(mScheduledBroadcasts); Vector< sp<Client> >& disconnectedClients(mDisconnectedClients); const size_t count = disconnectedClients.size(); for (size_t i=0 ; i<count ; i++) { sp<Client> client = disconnectedClients[i]; - // if this client is the scheduled broadcast list, - // remove it from there (and we don't need to signal it - // since it is dead). - int32_t index = scheduledBroadcasts.indexOf(client); - if (index >= 0) { - scheduledBroadcasts.removeItemsAt(index); - } mTokens.release(client->cid); } disconnectedClients.clear(); @@ -1173,6 +1133,13 @@ void SurfaceFlinger::closeGlobalTransaction() { if (android_atomic_dec(&mTransactionCount) == 1) { signalEvent(); + + // if there is a transaction with a resize, wait for it to + // take effect before returning. + Mutex::Autolock _l(mStateLock); + while (mResizeTransationPending) { + mTransactionCV.wait(mStateLock); + } } } @@ -1424,8 +1391,10 @@ status_t SurfaceFlinger::setClientState( } } if (what & eSizeChanged) { - if (layer->setSize(s.w, s.h)) + if (layer->setSize(s.w, s.h)) { flags |= eTraversalNeeded; + mResizeTransationPending = true; + } } if (what & eAlphaChanged) { if (layer->setAlpha(uint8_t(255.0f*s.alpha+0.5f))) @@ -1543,28 +1512,27 @@ status_t SurfaceFlinger::dump(int fd, const Vector<String16>& args) "id=0x%08x, client=0x%08x, identity=%u\n", lbc->clientIndex(), client.get() ? client->cid : 0, lbc->getIdentity()); + + result.append(buffer); + buffer[0] = 0; } - result.append(buffer); - buffer[0] = 0; /*** Layer ***/ sp<Layer> l = LayerBase::dynamicCast< Layer* >(layer.get()); if (l != 0) { - const LayerBitmap& buf0(l->getBuffer(0)); - const LayerBitmap& buf1(l->getBuffer(1)); + result.append( l->lcblk->dump(" ") ); + sp<const Buffer> buf0(l->getBuffer(0)); + sp<const Buffer> buf1(l->getBuffer(1)); snprintf(buffer, SIZE, " " "format=%2d, [%3ux%3u:%3u] [%3ux%3u:%3u]," - " freezeLock=%p, swapState=0x%08x\n", + " freezeLock=%p\n", l->pixelFormat(), - buf0.getWidth(), buf0.getHeight(), - buf0.getBuffer()->getStride(), - buf1.getWidth(), buf1.getHeight(), - buf1.getBuffer()->getStride(), - l->getFreezeLock().get(), - l->lcblk->swapState); + buf0->getWidth(), buf0->getHeight(), buf0->getStride(), + buf1->getWidth(), buf1->getHeight(), buf1->getStride(), + l->getFreezeLock().get()); + result.append(buffer); + buffer[0] = 0; } - result.append(buffer); - buffer[0] = 0; s.transparentRegion.dump(result, "transparentRegion"); layer->transparentRegionScreen.dump(result, "transparentRegionScreen"); layer->visibleRegionScreen.dump(result, "visibleRegionScreen"); @@ -1657,8 +1625,12 @@ status_t SurfaceFlinger::onTransact( const DisplayHardware& hw(graphicPlane(0).displayHardware()); mDirtyRegion.set(hw.bounds()); // careful that's not thread-safe signalEvent(); + return NO_ERROR; + } + case 1005:{ // force transaction + setTransactionFlags(eTransactionNeeded|eTraversalNeeded); + return NO_ERROR; } - return NO_ERROR; case 1007: // set mFreezeCount mFreezeCount = data.readInt32(); return NO_ERROR; @@ -1688,21 +1660,20 @@ Client::Client(ClientID clientID, const sp<SurfaceFlinger>& 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)); + const int cblksize = ((sizeof(SharedClient)+(pgsize-1))&~(pgsize-1)); mCblkHeap = new MemoryHeapBase(cblksize, 0, "SurfaceFlinger Client control-block"); - ctrlblk = static_cast<per_client_cblk_t *>(mCblkHeap->getBase()); + ctrlblk = static_cast<SharedClient *>(mCblkHeap->getBase()); if (ctrlblk) { // construct the shared structure in-place. - new(ctrlblk) per_client_cblk_t; + new(ctrlblk) SharedClient; } } Client::~Client() { if (ctrlblk) { - const int pgsize = getpagesize(); - ctrlblk->~per_client_cblk_t(); // destroy our shared-structure. + ctrlblk->~SharedClient(); // destroy our shared-structure. } } diff --git a/libs/surfaceflinger/SurfaceFlinger.h b/libs/surfaceflinger/SurfaceFlinger.h index 69e2f2ebf307..f207f8503f9a 100644 --- a/libs/surfaceflinger/SurfaceFlinger.h +++ b/libs/surfaceflinger/SurfaceFlinger.h @@ -34,7 +34,7 @@ #include <ui/ISurfaceComposer.h> #include <ui/ISurfaceFlingerClient.h> -#include <private/ui/SharedState.h> +#include <private/ui/SharedBufferStack.h> #include <private/ui/LayerState.h> #include "Barrier.h" @@ -87,7 +87,7 @@ public: } // pointer to this client's control block - per_client_cblk_t* ctrlblk; + SharedClient* ctrlblk; ClientID cid; @@ -268,8 +268,6 @@ private: bool lockPageFlip(const LayerVector& currentLayers); void unlockPageFlip(const LayerVector& currentLayers); void handleRepaint(); - void scheduleBroadcast(const sp<Client>& client); - void executeScheduledBroadcasts(); void postFramebuffer(); void composeSurfaces(const Region& dirty); void unlockClients(); @@ -313,6 +311,7 @@ private: volatile int32_t mTransactionFlags; volatile int32_t mTransactionCount; Condition mTransactionCV; + bool mResizeTransationPending; // protected by mStateLock (but we could use another lock) Tokenizer mTokens; @@ -337,8 +336,6 @@ private: Region mDirtyRegionRemovedLayer; Region mInvalidRegion; Region mWormholeRegion; - wp<Client> mLastScheduledBroadcast; - SortedVector< wp<Client> > mScheduledBroadcasts; bool mVisibleRegionsDirty; bool mDeferReleaseConsole; bool mFreezeDisplay; diff --git a/libs/surfaceflinger/purgatory/GPUHardware/GPUHardware.cpp b/libs/surfaceflinger/purgatory/GPUHardware/GPUHardware.cpp deleted file mode 100644 index 2de628b0f1df..000000000000 --- a/libs/surfaceflinger/purgatory/GPUHardware/GPUHardware.cpp +++ /dev/null @@ -1,585 +0,0 @@ -/* - * Copyright (C) 2008 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. - */ - -#define LOG_TAG "SurfaceFlinger" - -#include <stdlib.h> -#include <stdio.h> -#include <stdint.h> -#include <unistd.h> -#include <fcntl.h> -#include <errno.h> -#include <math.h> -#include <sys/types.h> -#include <sys/stat.h> -#include <sys/ioctl.h> - -#include <cutils/log.h> -#include <cutils/properties.h> - -#include <binder/IBinder.h> -#include <binder/MemoryDealer.h> -#include <binder/MemoryBase.h> -#include <binder/MemoryHeapPmem.h> -#include <binder/MemoryHeapBase.h> -#include <binder/IPCThreadState.h> -#include <utils/StopWatch.h> - -#include <ui/ISurfaceComposer.h> - -#include "VRamHeap.h" -#include "GPUHardware.h" - -#if HAVE_ANDROID_OS -#include <linux/android_pmem.h> -#endif - -#include "GPUHardware/GPUHardware.h" - - -/* - * Manage the GPU. This implementation is very specific to the G1. - * There are no abstraction here. - * - * All this code will soon go-away and be replaced by a new architecture - * for managing graphics accelerators. - * - * In the meantime, it is conceptually possible to instantiate a - * GPUHardwareInterface for another GPU (see GPUFactory at the bottom - * of this file); practically... doubtful. - * - */ - -namespace android { - -// --------------------------------------------------------------------------- - -class GPUClientHeap; -class GPUAreaHeap; - -class GPUHardware : public GPUHardwareInterface, public IBinder::DeathRecipient -{ -public: - static const int GPU_RESERVED_SIZE; - static const int GPUR_SIZE; - - GPUHardware(); - virtual ~GPUHardware(); - - virtual void revoke(int pid); - virtual sp<MemoryDealer> request(int pid); - virtual status_t request(int pid, - const sp<IGPUCallback>& callback, - ISurfaceComposer::gpu_info_t* gpu); - - virtual status_t friendlyRevoke(); - virtual void unconditionalRevoke(); - - virtual pid_t getOwner() const { return mOwner; } - - // used for debugging only... - virtual sp<SimpleBestFitAllocator> getAllocator() const; - -private: - - - enum { - NO_OWNER = -1, - }; - - struct GPUArea { - sp<GPUAreaHeap> heap; - sp<MemoryHeapPmem> clientHeap; - sp<IMemory> map(); - }; - - struct Client { - pid_t pid; - GPUArea smi; - GPUArea ebi; - GPUArea reg; - void createClientHeaps(); - void revokeAllHeaps(); - }; - - Client& getClientLocked(pid_t pid); - status_t requestLocked(int pid); - void releaseLocked(); - void takeBackGPULocked(); - void registerCallbackLocked(const sp<IGPUCallback>& callback, - Client& client); - - virtual void binderDied(const wp<IBinder>& who); - - mutable Mutex mLock; - sp<GPUAreaHeap> mSMIHeap; - sp<GPUAreaHeap> mEBIHeap; - sp<GPUAreaHeap> mREGHeap; - - KeyedVector<pid_t, Client> mClients; - DefaultKeyedVector< wp<IBinder>, pid_t > mRegisteredClients; - - pid_t mOwner; - - sp<MemoryDealer> mCurrentAllocator; - sp<IGPUCallback> mCallback; - - sp<SimpleBestFitAllocator> mAllocator; - - Condition mCondition; -}; - -// size reserved for GPU surfaces -// 1200 KB fits exactly: -// - two 320*480 16-bits double-buffered surfaces -// - one 320*480 32-bits double-buffered surface -// - one 320*240 16-bits double-buffered, 4x anti-aliased surface -const int GPUHardware::GPU_RESERVED_SIZE = 1200 * 1024; -const int GPUHardware::GPUR_SIZE = 1 * 1024 * 1024; - -// --------------------------------------------------------------------------- - -/* - * GPUHandle is a special IMemory given to the client. It represents their - * handle to the GPU. Once they give it up, they loose GPU access, or if - * they explicitly revoke their access through the binder code 1000. - * In both cases, this triggers a callback to revoke() - * first, and then actually powers down the chip. - * - * In the case of a misbehaving app, GPUHardware can ask for an immediate - * release of the GPU to the target process which should answer by calling - * code 1000 on GPUHandle. If it doesn't in a timely manner, the GPU will - * be revoked from under their feet. - * - * We should never hold a strong reference on GPUHandle. In practice this - * shouldn't be a big issue though because clients should use code 1000 and - * not rely on the dtor being called. - * - */ - -class GPUClientHeap : public MemoryHeapPmem -{ -public: - GPUClientHeap(const wp<GPUHardware>& gpu, - const sp<MemoryHeapBase>& heap) - : MemoryHeapPmem(heap), mGPU(gpu) { } -protected: - wp<GPUHardware> mGPU; -}; - -class GPUAreaHeap : public MemoryHeapBase -{ -public: - GPUAreaHeap(const wp<GPUHardware>& gpu, - const char* const vram, size_t size=0, size_t reserved=0) - : MemoryHeapBase(vram, size), mGPU(gpu) { - if (base() != MAP_FAILED) { - if (reserved == 0) - reserved = virtualSize(); - mAllocator = new SimpleBestFitAllocator(reserved); - } - } - virtual sp<MemoryHeapPmem> createClientHeap() { - sp<MemoryHeapBase> parentHeap(this); - return new GPUClientHeap(mGPU, parentHeap); - } - virtual const sp<SimpleBestFitAllocator>& getAllocator() const { - return mAllocator; - } -private: - sp<SimpleBestFitAllocator> mAllocator; -protected: - wp<GPUHardware> mGPU; -}; - -class GPURegisterHeap : public GPUAreaHeap -{ -public: - GPURegisterHeap(const sp<GPUHardware>& gpu) - : GPUAreaHeap(gpu, "/dev/hw3d", GPUHardware::GPUR_SIZE) { } - virtual sp<MemoryHeapPmem> createClientHeap() { - sp<MemoryHeapBase> parentHeap(this); - return new MemoryHeapRegs(mGPU, parentHeap); - } -private: - class MemoryHeapRegs : public GPUClientHeap { - public: - MemoryHeapRegs(const wp<GPUHardware>& gpu, - const sp<MemoryHeapBase>& heap) - : GPUClientHeap(gpu, heap) { } - sp<MemoryHeapPmem::MemoryPmem> createMemory(size_t offset, size_t size); - virtual void revoke(); - private: - class GPUHandle : public MemoryHeapPmem::MemoryPmem { - public: - GPUHandle(const sp<GPUHardware>& gpu, - const sp<MemoryHeapPmem>& heap) - : MemoryHeapPmem::MemoryPmem(heap), - mGPU(gpu), mOwner(gpu->getOwner()) { } - virtual ~GPUHandle(); - virtual sp<IMemoryHeap> getMemory( - ssize_t* offset, size_t* size) const; - virtual void revoke() { }; - virtual status_t onTransact( - uint32_t code, const Parcel& data, - Parcel* reply, uint32_t flags); - private: - void revokeNotification(); - wp<GPUHardware> mGPU; - pid_t mOwner; - }; - }; -}; - -GPURegisterHeap::MemoryHeapRegs::GPUHandle::~GPUHandle() { - //LOGD("GPUHandle %p released, revoking GPU", this); - revokeNotification(); -} -void GPURegisterHeap::MemoryHeapRegs::GPUHandle::revokeNotification() { - sp<GPUHardware> hw(mGPU.promote()); - if (hw != 0) { - hw->revoke(mOwner); - } -} -sp<IMemoryHeap> GPURegisterHeap::MemoryHeapRegs::GPUHandle::getMemory( - ssize_t* offset, size_t* size) const -{ - sp<MemoryHeapPmem> heap = getHeap(); - if (offset) *offset = 0; - if (size) *size = heap !=0 ? heap->virtualSize() : 0; - return heap; -} -status_t GPURegisterHeap::MemoryHeapRegs::GPUHandle::onTransact( - uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) -{ - status_t err = BnMemory::onTransact(code, data, reply, flags); - if (err == UNKNOWN_TRANSACTION && code == 1000) { - int callingPid = IPCThreadState::self()->getCallingPid(); - //LOGD("pid %d voluntarily revoking gpu", callingPid); - if (callingPid == mOwner) { - revokeNotification(); - // we've revoked the GPU, don't do it again later when we - // are destroyed. - mGPU.clear(); - } else { - LOGW("%d revoking someone else's gpu? (owner=%d)", - callingPid, mOwner); - } - err = NO_ERROR; - } - return err; -} - -// --------------------------------------------------------------------------- - - -sp<MemoryHeapPmem::MemoryPmem> GPURegisterHeap::MemoryHeapRegs::createMemory( - size_t offset, size_t size) -{ - sp<GPUHandle> memory; - sp<GPUHardware> gpu = mGPU.promote(); - if (heapID()>0 && gpu!=0) { -#if HAVE_ANDROID_OS - /* this is where the GPU is powered on and the registers are mapped - * in the client */ - //LOGD("ioctl(HW3D_GRANT_GPU)"); - int err = ioctl(heapID(), HW3D_GRANT_GPU, base()); - if (err) { - // it can happen if the master heap has been closed already - // in which case the GPU already is revoked (app crash for - // instance). - LOGW("HW3D_GRANT_GPU failed (%s), mFD=%d, base=%p", - strerror(errno), heapID(), base()); - } - memory = new GPUHandle(gpu, this); -#endif - } - return memory; -} - -void GPURegisterHeap::MemoryHeapRegs::revoke() -{ - MemoryHeapPmem::revoke(); -#if HAVE_ANDROID_OS - if (heapID() > 0) { - //LOGD("ioctl(HW3D_REVOKE_GPU)"); - int err = ioctl(heapID(), HW3D_REVOKE_GPU, base()); - LOGE_IF(err, "HW3D_REVOKE_GPU failed (%s), mFD=%d, base=%p", - strerror(errno), heapID(), base()); - } -#endif -} - -/*****************************************************************************/ - -GPUHardware::GPUHardware() - : mOwner(NO_OWNER) -{ -} - -GPUHardware::~GPUHardware() -{ -} - -status_t GPUHardware::requestLocked(int pid) -{ - const int self_pid = getpid(); - if (pid == self_pid) { - // can't use GPU from surfaceflinger's process - return PERMISSION_DENIED; - } - - if (mOwner != pid) { - if (mREGHeap != 0) { - if (mOwner != NO_OWNER) { - // someone already has the gpu. - takeBackGPULocked(); - releaseLocked(); - } - } else { - // first time, initialize the stuff. - if (mSMIHeap == 0) - mSMIHeap = new GPUAreaHeap(this, "/dev/pmem_gpu0"); - if (mEBIHeap == 0) - mEBIHeap = new GPUAreaHeap(this, - "/dev/pmem_gpu1", 0, GPU_RESERVED_SIZE); - mREGHeap = new GPURegisterHeap(this); - mAllocator = mEBIHeap->getAllocator(); - if (mAllocator == NULL) { - // something went terribly wrong. - mSMIHeap.clear(); - mEBIHeap.clear(); - mREGHeap.clear(); - return INVALID_OPERATION; - } - } - Client& client = getClientLocked(pid); - mCurrentAllocator = new MemoryDealer(client.ebi.clientHeap, mAllocator); - mOwner = pid; - } - return NO_ERROR; -} - -sp<MemoryDealer> GPUHardware::request(int pid) -{ - sp<MemoryDealer> dealer; - Mutex::Autolock _l(mLock); - Client* client; - LOGD("pid %d requesting gpu surface (current owner = %d)", pid, mOwner); - if (requestLocked(pid) == NO_ERROR) { - dealer = mCurrentAllocator; - LOGD_IF(dealer!=0, "gpu surface granted to pid %d", mOwner); - } - return dealer; -} - -status_t GPUHardware::request(int pid, const sp<IGPUCallback>& callback, - ISurfaceComposer::gpu_info_t* gpu) -{ - if (callback == 0) - return BAD_VALUE; - - sp<IMemory> gpuHandle; - LOGD("pid %d requesting gpu core (owner = %d)", pid, mOwner); - Mutex::Autolock _l(mLock); - status_t err = requestLocked(pid); - if (err == NO_ERROR) { - // it's guaranteed to be there, be construction - Client& client = mClients.editValueFor(pid); - registerCallbackLocked(callback, client); - gpu->count = 2; - gpu->regions[0].region = client.smi.map(); - gpu->regions[1].region = client.ebi.map(); - gpu->regs = client.reg.map(); - gpu->regions[0].reserved = 0; - gpu->regions[1].reserved = GPU_RESERVED_SIZE; - if (gpu->regs != 0) { - //LOGD("gpu core granted to pid %d, handle base=%p", - // mOwner, gpu->regs->pointer()); - } - mCallback = callback; - } else { - LOGW("couldn't grant gpu core to pid %d", pid); - } - return err; -} - -void GPUHardware::revoke(int pid) -{ - Mutex::Autolock _l(mLock); - if (mOwner > 0) { - if (pid != mOwner) { - LOGW("GPU owned by %d, revoke from %d", mOwner, pid); - return; - } - //LOGD("revoke pid=%d, owner=%d", pid, mOwner); - // mOwner could be <0 if the same process acquired the GPU - // several times without releasing it first. - mCondition.signal(); - releaseLocked(); - } -} - -status_t GPUHardware::friendlyRevoke() -{ - Mutex::Autolock _l(mLock); - //LOGD("friendlyRevoke owner=%d", mOwner); - takeBackGPULocked(); - releaseLocked(); - return NO_ERROR; -} - -void GPUHardware::takeBackGPULocked() -{ - sp<IGPUCallback> callback = mCallback; - mCallback.clear(); - if (callback != 0) { - callback->gpuLost(); // one-way - mCondition.waitRelative(mLock, ms2ns(250)); - } -} - -void GPUHardware::releaseLocked() -{ - //LOGD("revoking gpu from pid %d", mOwner); - if (mOwner != NO_OWNER) { - // this may fail because the client might have died, and have - // been removed from the list. - ssize_t index = mClients.indexOfKey(mOwner); - if (index >= 0) { - Client& client(mClients.editValueAt(index)); - client.revokeAllHeaps(); - } - mOwner = NO_OWNER; - mCurrentAllocator.clear(); - mCallback.clear(); - } -} - -GPUHardware::Client& GPUHardware::getClientLocked(pid_t pid) -{ - ssize_t index = mClients.indexOfKey(pid); - if (index < 0) { - Client client; - client.pid = pid; - client.smi.heap = mSMIHeap; - client.ebi.heap = mEBIHeap; - client.reg.heap = mREGHeap; - index = mClients.add(pid, client); - } - Client& client(mClients.editValueAt(index)); - client.createClientHeaps(); - return client; -} - -// ---------------------------------------------------------------------------- -// for debugging / testing ... - -sp<SimpleBestFitAllocator> GPUHardware::getAllocator() const { - Mutex::Autolock _l(mLock); - return mAllocator; -} - -void GPUHardware::unconditionalRevoke() -{ - Mutex::Autolock _l(mLock); - releaseLocked(); -} - -// --------------------------------------------------------------------------- - -sp<IMemory> GPUHardware::GPUArea::map() { - sp<IMemory> memory; - if (clientHeap != 0 && heap != 0) { - memory = clientHeap->mapMemory(0, heap->virtualSize()); - } - return memory; -} - -void GPUHardware::Client::createClientHeaps() -{ - if (smi.clientHeap == 0) - smi.clientHeap = smi.heap->createClientHeap(); - if (ebi.clientHeap == 0) - ebi.clientHeap = ebi.heap->createClientHeap(); - if (reg.clientHeap == 0) - reg.clientHeap = reg.heap->createClientHeap(); -} - -void GPUHardware::Client::revokeAllHeaps() -{ - if (smi.clientHeap != 0) - smi.clientHeap->revoke(); - if (ebi.clientHeap != 0) - ebi.clientHeap->revoke(); - if (reg.clientHeap != 0) - reg.clientHeap->revoke(); -} - -void GPUHardware::registerCallbackLocked(const sp<IGPUCallback>& callback, - Client& client) -{ - sp<IBinder> binder = callback->asBinder(); - if (mRegisteredClients.add(binder, client.pid) >= 0) { - binder->linkToDeath(this); - } -} - -void GPUHardware::binderDied(const wp<IBinder>& who) -{ - Mutex::Autolock _l(mLock); - pid_t pid = mRegisteredClients.valueFor(who); - if (pid != 0) { - ssize_t index = mClients.indexOfKey(pid); - if (index >= 0) { - //LOGD("*** removing client at %d", index); - Client& client(mClients.editValueAt(index)); - client.revokeAllHeaps(); // not really needed in theory - mClients.removeItemsAt(index); - if (mClients.size() == 0) { - //LOGD("*** was last client closing everything"); - mCallback.clear(); - mAllocator.clear(); - mCurrentAllocator.clear(); - mSMIHeap.clear(); - mREGHeap.clear(); - - // NOTE: we cannot clear the EBI heap because surfaceflinger - // itself may be using it, since this is where surfaces - // are allocated. if we're in the middle of compositing - // a surface (even if its process just died), we cannot - // rip the heap under our feet. - - mOwner = NO_OWNER; - } - } - } -} - -// --------------------------------------------------------------------------- - -sp<GPUHardwareInterface> GPUFactory::getGPU() -{ - sp<GPUHardwareInterface> gpu; - if (access("/dev/hw3d", F_OK) == 0) { - gpu = new GPUHardware(); - } - return gpu; -} - -// --------------------------------------------------------------------------- -}; // namespace android - diff --git a/libs/surfaceflinger/purgatory/GPUHardware/GPUHardware.h b/libs/surfaceflinger/purgatory/GPUHardware/GPUHardware.h deleted file mode 100644 index 335452808fee..000000000000 --- a/libs/surfaceflinger/purgatory/GPUHardware/GPUHardware.h +++ /dev/null @@ -1,63 +0,0 @@ -/* - * Copyright (C) 2008 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_GPU_HARDWARE_H -#define ANDROID_GPU_HARDWARE_H - -#include <stdint.h> -#include <sys/types.h> - -#include <utils/RefBase.h> -#include <utils/threads.h> -#include <utils/KeyedVector.h> - -#include <ui/ISurfaceComposer.h> - -namespace android { - -// --------------------------------------------------------------------------- - -class IGPUCallback; - -class GPUHardwareInterface : public virtual RefBase -{ -public: - virtual void revoke(int pid) = 0; - virtual sp<MemoryDealer> request(int pid) = 0; - virtual status_t request(int pid, const sp<IGPUCallback>& callback, - ISurfaceComposer::gpu_info_t* gpu) = 0; - - virtual status_t friendlyRevoke() = 0; - - // used for debugging only... - virtual sp<SimpleBestFitAllocator> getAllocator() const = 0; - virtual pid_t getOwner() const = 0; - virtual void unconditionalRevoke() = 0; -}; - -// --------------------------------------------------------------------------- - -class GPUFactory -{ -public: - // the gpu factory - static sp<GPUHardwareInterface> getGPU(); -}; - -// --------------------------------------------------------------------------- -}; // namespace android - -#endif // ANDROID_GPU_HARDWARE_H diff --git a/libs/surfaceflinger/purgatory/LayerOrientationAnim.cpp b/libs/surfaceflinger/purgatory/LayerOrientationAnim.cpp deleted file mode 100644 index 41c42d177573..000000000000 --- a/libs/surfaceflinger/purgatory/LayerOrientationAnim.cpp +++ /dev/null @@ -1,272 +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. - */ - -#define LOG_TAG "SurfaceFlinger" - -#include <stdlib.h> -#include <stdint.h> -#include <sys/types.h> - -#include <utils/Errors.h> -#include <utils/Log.h> -#include <utils/StopWatch.h> - -#include "BlurFilter.h" -#include "LayerBase.h" -#include "LayerOrientationAnim.h" -#include "SurfaceFlinger.h" -#include "DisplayHardware/DisplayHardware.h" -#include "OrientationAnimation.h" - -namespace android { -// --------------------------------------------------------------------------- - -const uint32_t LayerOrientationAnim::typeInfo = LayerBase::typeInfo | 0x80; -const char* const LayerOrientationAnim::typeID = "LayerOrientationAnim"; - -// --------------------------------------------------------------------------- - -// Animation... -const float DURATION = ms2ns(200); -const float BOUNCES_PER_SECOND = 0.5f; -//const float BOUNCES_AMPLITUDE = 1.0f/16.0f; -const float BOUNCES_AMPLITUDE = 0; -const float DIM_TARGET = 0.40f; -//#define INTERPOLATED_TIME(_t) ((_t)*(_t)) -#define INTERPOLATED_TIME(_t) (_t) - -// --------------------------------------------------------------------------- - -LayerOrientationAnim::LayerOrientationAnim( - SurfaceFlinger* flinger, DisplayID display, - OrientationAnimation* anim, - const sp<Buffer>& bitmapIn, - const sp<Buffer>& bitmapOut) - : LayerOrientationAnimBase(flinger, display), mAnim(anim), - mBitmapIn(bitmapIn), mBitmapOut(bitmapOut), - mTextureName(-1), mTextureNameIn(-1) -{ - // blur that texture. - mStartTime = systemTime(); - mFinishTime = 0; - mOrientationCompleted = false; - mFirstRedraw = false; - mLastNormalizedTime = 0; - mNeedsBlending = false; - mAlphaInLerp.set(1.0f, DIM_TARGET); - mAlphaOutLerp.set(0.5f, 1.0f); -} - -LayerOrientationAnim::~LayerOrientationAnim() -{ - if (mTextureName != -1U) { - glDeleteTextures(1, &mTextureName); - } - if (mTextureNameIn != -1U) { - glDeleteTextures(1, &mTextureNameIn); - } -} - -bool LayerOrientationAnim::needsBlending() const -{ - return mNeedsBlending; -} - -Point LayerOrientationAnim::getPhysicalSize() const -{ - const GraphicPlane& plane(graphicPlane(0)); - const DisplayHardware& hw(plane.displayHardware()); - return Point(hw.getWidth(), hw.getHeight()); -} - -void LayerOrientationAnim::validateVisibility(const Transform&) -{ - const Layer::State& s(drawingState()); - const Transform tr(s.transform); - const Point size(getPhysicalSize()); - uint32_t w = size.x; - uint32_t h = size.y; - mTransformedBounds = tr.makeBounds(w, h); - mLeft = tr.tx(); - mTop = tr.ty(); - transparentRegionScreen.clear(); - mTransformed = true; -} - -void LayerOrientationAnim::onOrientationCompleted() -{ - mFinishTime = systemTime(); - mOrientationCompleted = true; - mFirstRedraw = true; - mNeedsBlending = true; - mFlinger->invalidateLayerVisibility(this); -} - -void LayerOrientationAnim::onDraw(const Region& clip) const -{ - const nsecs_t now = systemTime(); - float alphaIn, alphaOut; - - if (mOrientationCompleted) { - if (mFirstRedraw) { - mFirstRedraw = false; - - // make a copy of what's on screen - copybit_image_t image; - mBitmapOut->getBitmapSurface(&image); - const DisplayHardware& hw(graphicPlane(0).displayHardware()); - hw.copyBackToImage(image); - - // and erase the screen for this round - glDisable(GL_BLEND); - glDisable(GL_DITHER); - glDisable(GL_SCISSOR_TEST); - glClearColor(0,0,0,0); - glClear(GL_COLOR_BUFFER_BIT); - - // FIXME: code below is gross - mNeedsBlending = false; - LayerOrientationAnim* self(const_cast<LayerOrientationAnim*>(this)); - mFlinger->invalidateLayerVisibility(self); - } - - // make sure pick-up where we left off - const float duration = DURATION * mLastNormalizedTime; - const float normalizedTime = (float(now - mFinishTime) / duration); - if (normalizedTime <= 1.0f) { - const float interpolatedTime = INTERPOLATED_TIME(normalizedTime); - alphaIn = mAlphaInLerp.getOut(); - alphaOut = mAlphaOutLerp(interpolatedTime); - } else { - mAnim->onAnimationFinished(); - alphaIn = mAlphaInLerp.getOut(); - alphaOut = mAlphaOutLerp.getOut(); - } - } else { - const float normalizedTime = float(now - mStartTime) / DURATION; - if (normalizedTime <= 1.0f) { - mLastNormalizedTime = normalizedTime; - const float interpolatedTime = INTERPOLATED_TIME(normalizedTime); - alphaIn = mAlphaInLerp(interpolatedTime); - alphaOut = 0.0f; - } else { - mLastNormalizedTime = 1.0f; - const float to_seconds = DURATION / seconds(1); - alphaIn = mAlphaInLerp.getOut(); - if (BOUNCES_AMPLITUDE > 0.0f) { - const float phi = BOUNCES_PER_SECOND * - (((normalizedTime - 1.0f) * to_seconds)*M_PI*2); - if (alphaIn > 1.0f) alphaIn = 1.0f; - else if (alphaIn < 0.0f) alphaIn = 0.0f; - alphaIn += BOUNCES_AMPLITUDE * (1.0f - cosf(phi)); - } - alphaOut = 0.0f; - } - mAlphaOutLerp.setIn(alphaIn); - } - drawScaled(1.0f, alphaIn, alphaOut); -} - -void LayerOrientationAnim::drawScaled(float scale, float alphaIn, float alphaOut) const -{ - copybit_image_t dst; - const GraphicPlane& plane(graphicPlane(0)); - const DisplayHardware& hw(plane.displayHardware()); - //hw.getDisplaySurface(&dst); - - // clear screen - // TODO: with update on demand, we may be able - // to not erase the screen at all during the animation - if (!mOrientationCompleted) { - if (scale==1.0f && (alphaIn>=1.0f || alphaOut>=1.0f)) { - // we don't need to erase the screen in that case - } else { - glDisable(GL_BLEND); - glDisable(GL_DITHER); - glDisable(GL_SCISSOR_TEST); - glClearColor(0,0,0,0); - glClear(GL_COLOR_BUFFER_BIT); - } - } - - copybit_image_t src; - mBitmapIn->getBitmapSurface(&src); - - copybit_image_t srcOut; - mBitmapOut->getBitmapSurface(&srcOut); - - const int w = dst.w*scale; - const int h = dst.h*scale; - const int xc = uint32_t(dst.w-w)/2; - const int yc = uint32_t(dst.h-h)/2; - const copybit_rect_t drect = { xc, yc, xc+w, yc+h }; - const copybit_rect_t srect = { 0, 0, src.w, src.h }; - const Region reg(Rect( drect.l, drect.t, drect.r, drect.b )); - - GGLSurface t; - t.version = sizeof(GGLSurface); - t.width = src.w; - t.height = src.h; - t.stride = src.w; - t.vstride= src.h; - t.format = src.format; - t.data = (GGLubyte*)(intptr_t(src.base) + src.offset); - - Transform tr; - tr.set(scale,0,0,scale); - tr.set(xc, yc); - - // FIXME: we should not access mVertices and mDrawingState like that, - // but since we control the animation, we know it's going to work okay. - // eventually we'd need a more formal way of doing things like this. - LayerOrientationAnim& self(const_cast<LayerOrientationAnim&>(*this)); - tr.transform(self.mVertices[0], 0, 0); - tr.transform(self.mVertices[1], 0, src.h); - tr.transform(self.mVertices[2], src.w, src.h); - tr.transform(self.mVertices[3], src.w, 0); - if (!(mFlags & DisplayHardware::SLOW_CONFIG)) { - // Too slow to do this in software - self.mDrawingState.flags |= ISurfaceComposer::eLayerFilter; - } - - if (alphaIn > 0.0f) { - t.data = (GGLubyte*)(intptr_t(src.base) + src.offset); - if (UNLIKELY(mTextureNameIn == -1LU)) { - mTextureNameIn = createTexture(); - GLuint w=0, h=0; - const Region dirty(Rect(t.width, t.height)); - loadTexture(dirty, mTextureNameIn, t, w, h); - } - self.mDrawingState.alpha = int(alphaIn*255); - drawWithOpenGL(reg, mTextureNameIn, t); - } - - if (alphaOut > 0.0f) { - t.data = (GGLubyte*)(intptr_t(srcOut.base) + srcOut.offset); - if (UNLIKELY(mTextureName == -1LU)) { - mTextureName = createTexture(); - GLuint w=0, h=0; - const Region dirty(Rect(t.width, t.height)); - loadTexture(dirty, mTextureName, t, w, h); - } - self.mDrawingState.alpha = int(alphaOut*255); - drawWithOpenGL(reg, mTextureName, t); - } -} - -// --------------------------------------------------------------------------- - -}; // namespace android diff --git a/libs/surfaceflinger/purgatory/LayerOrientationAnim.h b/libs/surfaceflinger/purgatory/LayerOrientationAnim.h deleted file mode 100644 index a1a2654ef4da..000000000000 --- a/libs/surfaceflinger/purgatory/LayerOrientationAnim.h +++ /dev/null @@ -1,112 +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_LAYER_ORIENTATION_ANIM_H -#define ANDROID_LAYER_ORIENTATION_ANIM_H - -#include <stdint.h> -#include <sys/types.h> -#include <utils/threads.h> -#include <binder/Parcel.h> - -#include "LayerBase.h" -#include "LayerBitmap.h" - -namespace android { - -// --------------------------------------------------------------------------- -class OrientationAnimation; - - -class LayerOrientationAnimBase : public LayerBase -{ -public: - LayerOrientationAnimBase(SurfaceFlinger* flinger, DisplayID display) - : LayerBase(flinger, display) { - } - virtual void onOrientationCompleted() = 0; -}; - -// --------------------------------------------------------------------------- - -class LayerOrientationAnim : public LayerOrientationAnimBase -{ -public: - static const uint32_t typeInfo; - static const char* const typeID; - virtual char const* getTypeID() const { return typeID; } - virtual uint32_t getTypeInfo() const { return typeInfo; } - - LayerOrientationAnim(SurfaceFlinger* flinger, DisplayID display, - OrientationAnimation* anim, - const sp<Buffer>& bitmapIn, - const sp<Buffer>& bitmapOut); - virtual ~LayerOrientationAnim(); - - void onOrientationCompleted(); - - virtual void onDraw(const Region& clip) const; - virtual Point getPhysicalSize() const; - virtual void validateVisibility(const Transform& globalTransform); - virtual bool needsBlending() const; - virtual bool isSecure() const { return false; } -private: - void drawScaled(float scale, float alphaIn, float alphaOut) const; - - class Lerp { - float in; - float outMinusIn; - public: - Lerp() : in(0), outMinusIn(0) { } - Lerp(float in, float out) : in(in), outMinusIn(out-in) { } - float getIn() const { return in; }; - float getOut() const { return in + outMinusIn; } - void set(float in, float out) { - this->in = in; - this->outMinusIn = out-in; - } - void setIn(float in) { - this->in = in; - } - void setOut(float out) { - this->outMinusIn = out - this->in; - } - float operator()(float t) const { - return outMinusIn*t + in; - } - }; - - OrientationAnimation* mAnim; - sp<Buffer> mBitmapIn; - sp<Buffer> mBitmapOut; - nsecs_t mStartTime; - nsecs_t mFinishTime; - bool mOrientationCompleted; - mutable bool mFirstRedraw; - mutable float mLastNormalizedTime; - mutable GLuint mTextureName; - mutable GLuint mTextureNameIn; - mutable bool mNeedsBlending; - - mutable Lerp mAlphaInLerp; - mutable Lerp mAlphaOutLerp; -}; - -// --------------------------------------------------------------------------- - -}; // namespace android - -#endif // ANDROID_LAYER_ORIENTATION_ANIM_H diff --git a/libs/surfaceflinger/purgatory/LayerOrientationAnimRotate.cpp b/libs/surfaceflinger/purgatory/LayerOrientationAnimRotate.cpp deleted file mode 100644 index dc6b632a694d..000000000000 --- a/libs/surfaceflinger/purgatory/LayerOrientationAnimRotate.cpp +++ /dev/null @@ -1,269 +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. - */ - -#define LOG_TAG "SurfaceFlinger" - -#include <stdlib.h> -#include <stdint.h> -#include <sys/types.h> - -#include <utils/Errors.h> -#include <utils/Log.h> - -#include "LayerBase.h" -#include "LayerOrientationAnim.h" -#include "LayerOrientationAnimRotate.h" -#include "SurfaceFlinger.h" -#include "DisplayHardware/DisplayHardware.h" -#include "OrientationAnimation.h" - -namespace android { -// --------------------------------------------------------------------------- - -const uint32_t LayerOrientationAnimRotate::typeInfo = LayerBase::typeInfo | 0x100; -const char* const LayerOrientationAnimRotate::typeID = "LayerOrientationAnimRotate"; - -// --------------------------------------------------------------------------- - -const float ROTATION = M_PI * 0.5f; -const float ROTATION_FACTOR = 1.0f; // 1.0 or 2.0 -const float DURATION = ms2ns(200); -const float BOUNCES_PER_SECOND = 0.8; -const float BOUNCES_AMPLITUDE = (5.0f/180.f) * M_PI; - -LayerOrientationAnimRotate::LayerOrientationAnimRotate( - SurfaceFlinger* flinger, DisplayID display, - OrientationAnimation* anim, - const sp<Buffer>& bitmapIn, - const sp<Buffer>& bitmapOut) - : LayerOrientationAnimBase(flinger, display), mAnim(anim), - mBitmapIn(bitmapIn), mBitmapOut(bitmapOut), - mTextureName(-1), mTextureNameIn(-1) -{ - mStartTime = systemTime(); - mFinishTime = 0; - mOrientationCompleted = false; - mFirstRedraw = false; - mLastNormalizedTime = 0; - mLastAngle = 0; - mLastScale = 0; - mNeedsBlending = false; - const GraphicPlane& plane(graphicPlane(0)); - mOriginalTargetOrientation = plane.getOrientation(); -} - -LayerOrientationAnimRotate::~LayerOrientationAnimRotate() -{ - if (mTextureName != -1U) { - glDeleteTextures(1, &mTextureName); - } - if (mTextureNameIn != -1U) { - glDeleteTextures(1, &mTextureNameIn); - } -} - -bool LayerOrientationAnimRotate::needsBlending() const -{ - return mNeedsBlending; -} - -Point LayerOrientationAnimRotate::getPhysicalSize() const -{ - const GraphicPlane& plane(graphicPlane(0)); - const DisplayHardware& hw(plane.displayHardware()); - return Point(hw.getWidth(), hw.getHeight()); -} - -void LayerOrientationAnimRotate::validateVisibility(const Transform&) -{ - const Layer::State& s(drawingState()); - const Transform tr(s.transform); - const Point size(getPhysicalSize()); - uint32_t w = size.x; - uint32_t h = size.y; - mTransformedBounds = tr.makeBounds(w, h); - mLeft = tr.tx(); - mTop = tr.ty(); - transparentRegionScreen.clear(); - mTransformed = true; -} - -void LayerOrientationAnimRotate::onOrientationCompleted() -{ - mFinishTime = systemTime(); - mOrientationCompleted = true; - mFirstRedraw = true; - mNeedsBlending = true; - mFlinger->invalidateLayerVisibility(this); -} - -void LayerOrientationAnimRotate::onDraw(const Region& clip) const -{ - // Animation... - - const nsecs_t now = systemTime(); - float angle, scale, alpha; - - if (mOrientationCompleted) { - if (mFirstRedraw) { - // make a copy of what's on screen - copybit_image_t image; - mBitmapIn->getBitmapSurface(&image); - const DisplayHardware& hw(graphicPlane(0).displayHardware()); - hw.copyBackToImage(image); - - // FIXME: code below is gross - mFirstRedraw = false; - mNeedsBlending = false; - LayerOrientationAnimRotate* self(const_cast<LayerOrientationAnimRotate*>(this)); - mFlinger->invalidateLayerVisibility(self); - } - - // make sure pick-up where we left off - const float duration = DURATION * mLastNormalizedTime; - const float normalizedTime = (float(now - mFinishTime) / duration); - if (normalizedTime <= 1.0f) { - const float squaredTime = normalizedTime*normalizedTime; - angle = (ROTATION*ROTATION_FACTOR - mLastAngle)*squaredTime + mLastAngle; - scale = (1.0f - mLastScale)*squaredTime + mLastScale; - alpha = normalizedTime; - } else { - mAnim->onAnimationFinished(); - angle = ROTATION; - alpha = 1.0f; - scale = 1.0f; - } - } else { - // FIXME: works only for portrait framebuffers - const Point size(getPhysicalSize()); - const float TARGET_SCALE = size.x * (1.0f / size.y); - const float normalizedTime = float(now - mStartTime) / DURATION; - if (normalizedTime <= 1.0f) { - mLastNormalizedTime = normalizedTime; - const float squaredTime = normalizedTime*normalizedTime; - angle = ROTATION * squaredTime; - scale = (TARGET_SCALE - 1.0f)*squaredTime + 1.0f; - alpha = 0; - } else { - mLastNormalizedTime = 1.0f; - angle = ROTATION; - if (BOUNCES_AMPLITUDE) { - const float to_seconds = DURATION / seconds(1); - const float phi = BOUNCES_PER_SECOND * - (((normalizedTime - 1.0f) * to_seconds)*M_PI*2); - angle += BOUNCES_AMPLITUDE * sinf(phi); - } - scale = TARGET_SCALE; - alpha = 0; - } - mLastAngle = angle; - mLastScale = scale; - } - drawScaled(angle, scale, alpha); -} - -void LayerOrientationAnimRotate::drawScaled(float f, float s, float alpha) const -{ - copybit_image_t dst; - const GraphicPlane& plane(graphicPlane(0)); - const DisplayHardware& hw(plane.displayHardware()); - //hw.getDisplaySurface(&dst); - - // clear screen - // TODO: with update on demand, we may be able - // to not erase the screen at all during the animation - glDisable(GL_BLEND); - glDisable(GL_DITHER); - glDisable(GL_SCISSOR_TEST); - glClearColor(0,0,0,0); - glClear(GL_COLOR_BUFFER_BIT); - - const int w = dst.w; - const int h = dst.h; - - copybit_image_t src; - mBitmapIn->getBitmapSurface(&src); - const copybit_rect_t srect = { 0, 0, src.w, src.h }; - - - GGLSurface t; - t.version = sizeof(GGLSurface); - t.width = src.w; - t.height = src.h; - t.stride = src.w; - t.vstride= src.h; - t.format = src.format; - t.data = (GGLubyte*)(intptr_t(src.base) + src.offset); - - if (!mOriginalTargetOrientation) { - f = -f; - } - - Transform tr; - tr.set(f, w*0.5f, h*0.5f); - tr.scale(s, w*0.5f, h*0.5f); - - // FIXME: we should not access mVertices and mDrawingState like that, - // but since we control the animation, we know it's going to work okay. - // eventually we'd need a more formal way of doing things like this. - LayerOrientationAnimRotate& self(const_cast<LayerOrientationAnimRotate&>(*this)); - tr.transform(self.mVertices[0], 0, 0); - tr.transform(self.mVertices[1], 0, src.h); - tr.transform(self.mVertices[2], src.w, src.h); - tr.transform(self.mVertices[3], src.w, 0); - - if (!(mFlags & DisplayHardware::SLOW_CONFIG)) { - // Too slow to do this in software - self.mDrawingState.flags |= ISurfaceComposer::eLayerFilter; - } - - if (UNLIKELY(mTextureName == -1LU)) { - mTextureName = createTexture(); - GLuint w=0, h=0; - const Region dirty(Rect(t.width, t.height)); - loadTexture(dirty, mTextureName, t, w, h); - } - self.mDrawingState.alpha = 255; //-int(alpha*255); - const Region clip(Rect( srect.l, srect.t, srect.r, srect.b )); - drawWithOpenGL(clip, mTextureName, t); - - if (alpha > 0) { - const float sign = (!mOriginalTargetOrientation) ? 1.0f : -1.0f; - tr.set(f + sign*(M_PI * 0.5f * ROTATION_FACTOR), w*0.5f, h*0.5f); - tr.scale(s, w*0.5f, h*0.5f); - tr.transform(self.mVertices[0], 0, 0); - tr.transform(self.mVertices[1], 0, src.h); - tr.transform(self.mVertices[2], src.w, src.h); - tr.transform(self.mVertices[3], src.w, 0); - - copybit_image_t src; - mBitmapIn->getBitmapSurface(&src); - t.data = (GGLubyte*)(intptr_t(src.base) + src.offset); - if (UNLIKELY(mTextureNameIn == -1LU)) { - mTextureNameIn = createTexture(); - GLuint w=0, h=0; - const Region dirty(Rect(t.width, t.height)); - loadTexture(dirty, mTextureNameIn, t, w, h); - } - self.mDrawingState.alpha = int(alpha*255); - const Region clip(Rect( srect.l, srect.t, srect.r, srect.b )); - drawWithOpenGL(clip, mTextureNameIn, t); - } -} - -// --------------------------------------------------------------------------- - -}; // namespace android diff --git a/libs/surfaceflinger/purgatory/LayerOrientationAnimRotate.h b/libs/surfaceflinger/purgatory/LayerOrientationAnimRotate.h deleted file mode 100644 index a88eec06a88e..000000000000 --- a/libs/surfaceflinger/purgatory/LayerOrientationAnimRotate.h +++ /dev/null @@ -1,77 +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_LAYER_ORIENTATION_ANIM_ROTATE_H -#define ANDROID_LAYER_ORIENTATION_ANIM_ROTATE_H - -#include <stdint.h> -#include <sys/types.h> -#include <utils/threads.h> -#include <binder/Parcel.h> - -#include "LayerBase.h" -#include "LayerBitmap.h" - -namespace android { - -// --------------------------------------------------------------------------- -class OrientationAnimation; - -class LayerOrientationAnimRotate : public LayerOrientationAnimBase -{ -public: - static const uint32_t typeInfo; - static const char* const typeID; - virtual char const* getTypeID() const { return typeID; } - virtual uint32_t getTypeInfo() const { return typeInfo; } - - LayerOrientationAnimRotate(SurfaceFlinger* flinger, DisplayID display, - OrientationAnimation* anim, - const sp<Buffer>& bitmapIn, - const sp<Buffer>& bitmapOut); - virtual ~LayerOrientationAnimRotate(); - - void onOrientationCompleted(); - - virtual void onDraw(const Region& clip) const; - virtual Point getPhysicalSize() const; - virtual void validateVisibility(const Transform& globalTransform); - virtual bool needsBlending() const; - virtual bool isSecure() const { return false; } -private: - void drawScaled(float angle, float scale, float alpha) const; - - OrientationAnimation* mAnim; - sp<Buffer> mBitmapIn; - sp<Buffer> mBitmapOut; - nsecs_t mStartTime; - nsecs_t mFinishTime; - bool mOrientationCompleted; - int mOriginalTargetOrientation; - mutable bool mFirstRedraw; - mutable float mLastNormalizedTime; - mutable float mLastAngle; - mutable float mLastScale; - mutable GLuint mTextureName; - mutable GLuint mTextureNameIn; - mutable bool mNeedsBlending; -}; - -// --------------------------------------------------------------------------- - -}; // namespace android - -#endif // ANDROID_LAYER_ORIENTATION_ANIM_ROTATE_H diff --git a/libs/surfaceflinger/purgatory/OrientationAnimation.cpp b/libs/surfaceflinger/purgatory/OrientationAnimation.cpp deleted file mode 100644 index a6c9c28d0ba8..000000000000 --- a/libs/surfaceflinger/purgatory/OrientationAnimation.cpp +++ /dev/null @@ -1,150 +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 <stdint.h> -#include <sys/types.h> -#include <limits.h> - -#include "LayerOrientationAnim.h" -#include "LayerOrientationAnimRotate.h" -#include "OrientationAnimation.h" -#include "SurfaceFlinger.h" - -#include "DisplayHardware/DisplayHardware.h" - -namespace android { - -// --------------------------------------------------------------------------- - -OrientationAnimation::OrientationAnimation(const sp<SurfaceFlinger>& flinger) - : mFlinger(flinger), mLayerOrientationAnim(NULL), mState(DONE) -{ -} - -OrientationAnimation::~OrientationAnimation() -{ -} - -void OrientationAnimation::onOrientationChanged(uint32_t type) -{ - if (mState == DONE) { - mType = type; - if (!(type & ISurfaceComposer::eOrientationAnimationDisable)) { - mState = PREPARE; - } - } -} - -void OrientationAnimation::onAnimationFinished() -{ - if (mState != DONE) - mState = FINISH; -} - -bool OrientationAnimation::run_impl() -{ - bool skip_frame; - switch (mState) { - default: - case DONE: - skip_frame = done(); - break; - case PREPARE: - skip_frame = prepare(); - break; - case PHASE1: - skip_frame = phase1(); - break; - case PHASE2: - skip_frame = phase2(); - break; - case FINISH: - skip_frame = finished(); - break; - } - return skip_frame; -} - -bool OrientationAnimation::done() -{ - return done_impl(); -} - -bool OrientationAnimation::prepare() -{ - mState = PHASE1; - - const GraphicPlane& plane(mFlinger->graphicPlane(0)); - const DisplayHardware& hw(plane.displayHardware()); - const uint32_t w = hw.getWidth(); - const uint32_t h = hw.getHeight(); - - sp<Buffer> bitmap = new Buffer(w, h, hw.getFormat()); - sp<Buffer> bitmapIn = new Buffer(w, h, hw.getFormat()); - - copybit_image_t front; - bitmap->getBitmapSurface(&front); - hw.copyFrontToImage(front); // FIXME: we need an extension to do this - - sp<LayerOrientationAnimBase> l; - - if (mType & 0x80) { - l = new LayerOrientationAnimRotate( - mFlinger.get(), 0, this, bitmap, bitmapIn); - } else { - l = new LayerOrientationAnim( - mFlinger.get(), 0, this, bitmap, bitmapIn); - } - - l->initStates(w, h, 0); - l->setLayer(INT_MAX-1); - mFlinger->addLayer(l); - mLayerOrientationAnim = l; - return true; -} - -bool OrientationAnimation::phase1() -{ - if (mFlinger->isFrozen() == false) { - // start phase 2 - mState = PHASE2; - mLayerOrientationAnim->onOrientationCompleted(); - mLayerOrientationAnim->invalidate(); - return true; - - } - mLayerOrientationAnim->invalidate(); - return false; -} - -bool OrientationAnimation::phase2() -{ - // do the 2nd phase of the animation - mLayerOrientationAnim->invalidate(); - return false; -} - -bool OrientationAnimation::finished() -{ - mState = DONE; - mFlinger->removeLayer(mLayerOrientationAnim); - mLayerOrientationAnim.clear(); - return true; -} - -// --------------------------------------------------------------------------- - -}; // namespace android diff --git a/libs/surfaceflinger/purgatory/OrientationAnimation.h b/libs/surfaceflinger/purgatory/OrientationAnimation.h deleted file mode 100644 index 8ba66210e873..000000000000 --- a/libs/surfaceflinger/purgatory/OrientationAnimation.h +++ /dev/null @@ -1,84 +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_ORIENTATION_ANIMATION_H -#define ANDROID_ORIENTATION_ANIMATION_H - -#include <stdint.h> -#include <sys/types.h> - -#include "SurfaceFlinger.h" - -namespace android { - -// --------------------------------------------------------------------------- - -class SurfaceFlinger; -class MemoryDealer; -class LayerOrientationAnim; - -class OrientationAnimation -{ -public: - OrientationAnimation(const sp<SurfaceFlinger>& flinger); - virtual ~OrientationAnimation(); - - void onOrientationChanged(uint32_t type); - void onAnimationFinished(); - inline bool run() { - if (LIKELY(mState == DONE)) - return done_impl(); - return run_impl(); - } - -private: - enum { - DONE = 0, - PREPARE, - PHASE1, - PHASE2, - FINISH - }; - - bool run_impl(); - inline bool done_impl() { - if (mFlinger->isFrozen()) { - // we are not allowed to draw, but pause a bit to make sure - // apps don't end up using the whole CPU, if they depend on - // surfaceflinger for synchronization. - usleep(8333); // 8.3ms ~ 120fps - return true; - } - return false; - } - - bool done(); - bool prepare(); - bool phase1(); - bool phase2(); - bool finished(); - - sp<SurfaceFlinger> mFlinger; - sp< LayerOrientationAnimBase > mLayerOrientationAnim; - int mState; - uint32_t mType; -}; - -// --------------------------------------------------------------------------- - -}; // namespace android - -#endif // ANDROID_ORIENTATION_ANIMATION_H diff --git a/libs/surfaceflinger/purgatory/VRamHeap.cpp b/libs/surfaceflinger/purgatory/VRamHeap.cpp deleted file mode 100644 index f3ed790181eb..000000000000 --- a/libs/surfaceflinger/purgatory/VRamHeap.cpp +++ /dev/null @@ -1,174 +0,0 @@ -/* - * Copyright (C) 2008 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 <stdlib.h> -#include <stdio.h> -#include <stdint.h> -#include <unistd.h> -#include <fcntl.h> -#include <errno.h> -#include <math.h> -#include <sys/types.h> -#include <sys/stat.h> -#include <sys/ioctl.h> - -#include <cutils/log.h> -#include <cutils/properties.h> - -#include <utils/MemoryDealer.h> -#include <utils/MemoryBase.h> -#include <utils/MemoryHeapPmem.h> -#include <utils/MemoryHeapBase.h> - -#include "GPUHardware/GPUHardware.h" -#include "SurfaceFlinger.h" -#include "VRamHeap.h" - -#if HAVE_ANDROID_OS -#include <linux/android_pmem.h> -#endif - - -namespace android { - -// --------------------------------------------------------------------------- - -/* - * Amount of memory we reserve for surface, per client in PMEM - * (PMEM is used for 2D acceleration) - * 8 MB of address space per client should be enough. - */ -static const int PMEM_SIZE = int(8 * 1024 * 1024); - -int SurfaceHeapManager::global_pmem_heap = 0; - -// --------------------------------------------------------------------------- - -SurfaceHeapManager::SurfaceHeapManager(const sp<SurfaceFlinger>& flinger, - size_t clientHeapSize) - : mFlinger(flinger), mClientHeapSize(clientHeapSize) -{ - SurfaceHeapManager::global_pmem_heap = 1; -} - -SurfaceHeapManager::~SurfaceHeapManager() -{ -} - -void SurfaceHeapManager::onFirstRef() -{ - if (global_pmem_heap) { - const char* device = "/dev/pmem"; - mPMemHeap = new PMemHeap(device, PMEM_SIZE); - if (mPMemHeap->base() == MAP_FAILED) { - mPMemHeap.clear(); - global_pmem_heap = 0; - } - } -} - -sp<MemoryDealer> SurfaceHeapManager::createHeap( - uint32_t flags, - pid_t client_pid, - const sp<MemoryDealer>& defaultAllocator) -{ - sp<MemoryDealer> dealer; - - if (flags & ISurfaceComposer::eGPU) { - // don't grant GPU memory if GPU is disabled - char value[PROPERTY_VALUE_MAX]; - property_get("debug.egl.hw", value, "1"); - if (atoi(value) == 0) { - flags &= ~ISurfaceComposer::eGPU; - } - } - - if (flags & ISurfaceComposer::eGPU) { - // FIXME: this is msm7201A specific, where gpu surfaces may not be secure - if (!(flags & ISurfaceComposer::eSecure)) { - // if GPU doesn't work, we try eHardware - flags |= ISurfaceComposer::eHardware; - // asked for GPU memory, try that first - dealer = mFlinger->getGPU()->request(client_pid); - } - } - - if (dealer == NULL) { - if (defaultAllocator != NULL) - // if a default allocator is given, use that - dealer = defaultAllocator; - } - - if (dealer == NULL) { - // always try h/w accelerated memory first - if (global_pmem_heap) { - const sp<PMemHeap>& heap(mPMemHeap); - if (dealer == NULL && heap != NULL) { - dealer = new MemoryDealer( - heap->createClientHeap(), - heap->getAllocator()); - } - } - } - - if (dealer == NULL) { - // return the ashmem allocator (software rendering) - dealer = new MemoryDealer(mClientHeapSize, 0, "SFNativeHeap"); - } - return dealer; -} - -sp<SimpleBestFitAllocator> SurfaceHeapManager::getAllocator(int type) const -{ - Mutex::Autolock _l(mLock); - sp<SimpleBestFitAllocator> allocator; - - // this is only used for debugging - switch (type) { - case NATIVE_MEMORY_TYPE_PMEM: - if (mPMemHeap != 0) { - allocator = mPMemHeap->getAllocator(); - } - break; - } - return allocator; -} - -// --------------------------------------------------------------------------- - -PMemHeap::PMemHeap(const char* const device, size_t size, size_t reserved) - : MemoryHeapBase(device, size) -{ - //LOGD("%s, %p, mFD=%d", __PRETTY_FUNCTION__, this, heapID()); - if (base() != MAP_FAILED) { - //LOGD("%s, %u bytes", device, virtualSize()); - if (reserved == 0) - reserved = virtualSize(); - mAllocator = new SimpleBestFitAllocator(reserved); - } -} - -PMemHeap::~PMemHeap() { - //LOGD("%s, %p, mFD=%d", __PRETTY_FUNCTION__, this, heapID()); -} - -sp<MemoryHeapPmem> PMemHeap::createClientHeap() { - sp<MemoryHeapBase> parentHeap(this); - return new MemoryHeapPmem(parentHeap); -} - -// --------------------------------------------------------------------------- -}; // namespace android diff --git a/libs/surfaceflinger/purgatory/VRamHeap.h b/libs/surfaceflinger/purgatory/VRamHeap.h deleted file mode 100644 index 91401679cb2c..000000000000 --- a/libs/surfaceflinger/purgatory/VRamHeap.h +++ /dev/null @@ -1,78 +0,0 @@ -/* - * Copyright (C) 2008 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_VRAM_HEAP_H -#define ANDROID_VRAM_HEAP_H - -#include <stdint.h> -#include <sys/types.h> -#include <utils/MemoryDealer.h> - -namespace android { - -// --------------------------------------------------------------------------- - -class PMemHeap; -class MemoryHeapPmem; -class SurfaceFlinger; - -// --------------------------------------------------------------------------- - -class SurfaceHeapManager : public RefBase -{ -public: - SurfaceHeapManager(const sp<SurfaceFlinger>& flinger, size_t clientHeapSize); - virtual ~SurfaceHeapManager(); - virtual void onFirstRef(); - /* use ISurfaceComposer flags eGPU|eHArdware|eSecure */ - sp<MemoryDealer> createHeap(uint32_t flags=0, pid_t client_pid = 0, - const sp<MemoryDealer>& defaultAllocator = 0); - - // used for debugging only... - sp<SimpleBestFitAllocator> getAllocator(int type) const; - -private: - sp<PMemHeap> getHeap(int type) const; - - sp<SurfaceFlinger> mFlinger; - mutable Mutex mLock; - size_t mClientHeapSize; - sp<PMemHeap> mPMemHeap; - static int global_pmem_heap; -}; - -// --------------------------------------------------------------------------- - -class PMemHeap : public MemoryHeapBase -{ -public: - PMemHeap(const char* const vram, - size_t size=0, size_t reserved=0); - virtual ~PMemHeap(); - - virtual const sp<SimpleBestFitAllocator>& getAllocator() const { - return mAllocator; - } - virtual sp<MemoryHeapPmem> createClientHeap(); - -private: - sp<SimpleBestFitAllocator> mAllocator; -}; - -// --------------------------------------------------------------------------- -}; // namespace android - -#endif // ANDROID_VRAM_HEAP_H |