auto import from //branches/cupcake/...@125939
diff --git a/libs/surfaceflinger/BootAnimation.cpp b/libs/surfaceflinger/BootAnimation.cpp
index e9e34c3..d18f59a 100644
--- a/libs/surfaceflinger/BootAnimation.cpp
+++ b/libs/surfaceflinger/BootAnimation.cpp
@@ -36,8 +36,8 @@
#include <ui/ISurfaceFlingerClient.h>
#include <ui/EGLNativeWindowSurface.h>
-#include <graphics/SkBitmap.h>
-#include <graphics/SkImageDecoder.h>
+#include <core/SkBitmap.h>
+#include <images/SkImageDecoder.h>
#include <GLES/egl.h>
diff --git a/libs/surfaceflinger/DisplayHardware/DisplayHardware.cpp b/libs/surfaceflinger/DisplayHardware/DisplayHardware.cpp
index cd72179..19e32ec 100644
--- a/libs/surfaceflinger/DisplayHardware/DisplayHardware.cpp
+++ b/libs/surfaceflinger/DisplayHardware/DisplayHardware.cpp
@@ -250,7 +250,7 @@
mOverlayEngine = NULL;
if (hw_get_module(OVERLAY_HARDWARE_MODULE_ID, &module) == 0) {
- overlay_open(module, &mOverlayEngine);
+ overlay_control_open(module, &mOverlayEngine);
}
}
@@ -266,7 +266,7 @@
eglMakeCurrent(mDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
eglTerminate(mDisplay);
copybit_close(mBlitEngine);
- overlay_close(mOverlayEngine);
+ overlay_control_close(mOverlayEngine);
}
void DisplayHardware::releaseScreen() const
diff --git a/libs/surfaceflinger/DisplayHardware/DisplayHardware.h b/libs/surfaceflinger/DisplayHardware/DisplayHardware.h
index de4a2cc..df97b60 100644
--- a/libs/surfaceflinger/DisplayHardware/DisplayHardware.h
+++ b/libs/surfaceflinger/DisplayHardware/DisplayHardware.h
@@ -26,7 +26,7 @@
#include "DisplayHardware/DisplayHardwareBase.h"
-struct overlay_device_t;
+struct overlay_control_device_t;
struct copybit_device_t;
struct copybit_image_t;
struct copybit_t;
@@ -78,7 +78,7 @@
void getDisplaySurface(GGLSurface* fb) const;
EGLDisplay getEGLDisplay() const { return mDisplay; }
copybit_device_t* getBlitEngine() const { return mBlitEngine; }
- overlay_device_t* getOverlayEngine() const { return mOverlayEngine; }
+ overlay_control_device_t* getOverlayEngine() const { return mOverlayEngine; }
Rect bounds() const {
return Rect(mWidth, mHeight);
@@ -103,7 +103,7 @@
mutable Region mDirty;
sp<EGLDisplaySurface> mDisplaySurface;
copybit_device_t* mBlitEngine;
- overlay_device_t* mOverlayEngine;
+ overlay_control_device_t* mOverlayEngine;
};
}; // namespace android
diff --git a/libs/surfaceflinger/Layer.cpp b/libs/surfaceflinger/Layer.cpp
index 8ba0851..f65d669 100644
--- a/libs/surfaceflinger/Layer.cpp
+++ b/libs/surfaceflinger/Layer.cpp
@@ -316,7 +316,7 @@
if (err == NO_ERROR) {
const uint32_t mask = clientBackBufferIndex ? eResizeBuffer1 : eResizeBuffer0;
android_atomic_and(~mask, &(lcblk->swapState));
- // since a buffer became availlable, we can let the client go...
+ // since a buffer became available, we can let the client go...
mFlinger->scheduleBroadcast(client);
mResizeTransactionDone = true;
@@ -511,7 +511,7 @@
}
mResizeTransactionDone = false;
recomputeVisibleRegions = true;
- invalidate = true;
+ this->contentDirty = true;
}
}
diff --git a/libs/surfaceflinger/LayerBase.cpp b/libs/surfaceflinger/LayerBase.cpp
index af353e2..bdefba3 100644
--- a/libs/surfaceflinger/LayerBase.cpp
+++ b/libs/surfaceflinger/LayerBase.cpp
@@ -53,14 +53,15 @@
int32_t LayerBase::sIdentity = 0;
LayerBase::LayerBase(SurfaceFlinger* flinger, DisplayID display)
- : dpy(display), invalidate(false),
+ : dpy(display), contentDirty(false),
mFlinger(flinger),
mTransformed(false),
mOrientation(0),
mCanUseCopyBit(false),
mTransactionFlags(0),
mPremultipliedAlpha(true),
- mIdentity(uint32_t(android_atomic_inc(&sIdentity)))
+ mIdentity(uint32_t(android_atomic_inc(&sIdentity))),
+ mInvalidate(0)
{
const DisplayHardware& hw(flinger->graphicPlane(0).displayHardware());
mFlags = hw.getFlags();
@@ -205,7 +206,7 @@
if (temp.sequence != front.sequence) {
// invalidate and recompute the visible regions if needed
flags |= eVisibleRegion;
- this->invalidate = true;
+ this->contentDirty = true;
}
// Commit the transaction
@@ -299,12 +300,22 @@
void LayerBase::unlockPageFlip(
const Transform& planeTransform, Region& outDirtyRegion)
{
+ if ((android_atomic_and(~1, &mInvalidate)&1) == 1) {
+ outDirtyRegion.orSelf(visibleRegionScreen);
+ }
}
void LayerBase::finishPageFlip()
{
}
+void LayerBase::invalidate()
+{
+ if ((android_atomic_or(1, &mInvalidate)&1) == 0) {
+ mFlinger->signalEvent();
+ }
+}
+
void LayerBase::drawRegion(const Region& reg) const
{
Region::iterator iterator(reg);
diff --git a/libs/surfaceflinger/LayerBase.h b/libs/surfaceflinger/LayerBase.h
index b3f3771..5e14dc8 100644
--- a/libs/surfaceflinger/LayerBase.h
+++ b/libs/surfaceflinger/LayerBase.h
@@ -75,7 +75,7 @@
virtual ~LayerBase();
DisplayID dpy;
- mutable bool invalidate;
+ mutable bool contentDirty;
Region visibleRegionScreen;
Region transparentRegionScreen;
Region coveredRegionScreen;
@@ -112,18 +112,87 @@
Rect visibleBounds() const;
void drawRegion(const Region& reg) const;
+ void invalidate();
+
+ /**
+ * draw - performs some global clipping optimizations
+ * and calls onDraw().
+ * Typically this method is not overridden, instead implement onDraw()
+ * to perform the actual drawing.
+ */
virtual void draw(const Region& clip) const;
+
+ /**
+ * onDraw - draws the surface.
+ */
virtual void onDraw(const Region& clip) const = 0;
+
+ /**
+ * initStates - called just after construction
+ */
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.
+ */
virtual uint32_t doTransaction(uint32_t transactionFlags);
+
+ /**
+ * setVisibleRegion - called to set the new visible region. This gives
+ * a chance to update the new visible region or record the fact it changed.
+ */
virtual void setVisibleRegion(const Region& visibleRegion);
+
+ /**
+ * setCoveredRegion - called when the covered region changes. The covered
+ * region correspond to any area of the surface that is covered
+ * (transparently or not) by another surface.
+ */
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;
+
+ /**
+ * lockPageFlip - called each time the screen is redrawn and returns whether
+ * the visible regions need to be recomputed (this is a fairly heavy
+ * operation, so this should be set only if needed). Typically this is used
+ * to figure out if the content or size of a surface has changed.
+ */
virtual void lockPageFlip(bool& recomputeVisibleRegions);
+
+ /**
+ * unlockPageFlip - called each time the screen is redrawn. updates the
+ * final dirty region wrt the planeTransform.
+ * At this point, all visible regions, surface position and size, etc... are
+ * correct.
+ */
virtual void unlockPageFlip(const Transform& planeTransform, Region& outDirtyRegion);
+
+ /**
+ * finishPageFlip - called after all surfaces have drawn.
+ */
virtual void finishPageFlip();
+
+ /**
+ * needsBlending - true if this surface needs blending
+ */
virtual bool needsBlending() const { return false; }
+
+ /**
+ * isSecure - true if this surface is secure, that is if it prevents a
+ * screenshot to be taken,
+ */
virtual bool isSecure() const { return false; }
enum { // flags for doTransaction()
@@ -162,7 +231,6 @@
bool canUseCopybit() const;
-
SurfaceFlinger* mFlinger;
uint32_t mFlags;
@@ -184,7 +252,10 @@
bool mPremultipliedAlpha;
// only read
- const uint32_t mIdentity;
+ const uint32_t mIdentity;
+
+ // atomic
+ volatile int32_t mInvalidate;
private:
@@ -254,7 +325,7 @@
{ return INVALID_OPERATION; }
virtual void postBuffer(ssize_t offset) { }
virtual void unregisterBuffers() { };
- virtual sp<Overlay> createOverlay(
+ virtual sp<OverlayRef> createOverlay(
uint32_t w, uint32_t h, int32_t format) {
return NULL;
};
diff --git a/libs/surfaceflinger/LayerBlur.cpp b/libs/surfaceflinger/LayerBlur.cpp
index e3ae7fb..efadbcf 100644
--- a/libs/surfaceflinger/LayerBlur.cpp
+++ b/libs/surfaceflinger/LayerBlur.cpp
@@ -71,7 +71,7 @@
mRefreshCache = true;
mCacheDirty = true;
flags |= eVisibleRegion;
- this->invalidate = true;
+ this->contentDirty = true;
}
return LayerBase::doTransaction(flags);
}
diff --git a/libs/surfaceflinger/LayerBuffer.cpp b/libs/surfaceflinger/LayerBuffer.cpp
index 3861e68..700e4f5 100644
--- a/libs/surfaceflinger/LayerBuffer.cpp
+++ b/libs/surfaceflinger/LayerBuffer.cpp
@@ -46,7 +46,7 @@
LayerBuffer::LayerBuffer(SurfaceFlinger* flinger, DisplayID display,
Client* client, int32_t i)
: LayerBaseClient(flinger, display, client, i),
- mBuffer(0), mTextureName(-1U), mInvalidate(false), mNeedsBlending(false)
+ mNeedsBlending(false)
{
}
@@ -57,154 +57,6 @@
s->disown();
mClientSurface.clear();
}
-
- // this should always be called from the OpenGL thread
- if (mTextureName != -1U) {
- //glDeleteTextures(1, &mTextureName);
- deletedTextures.add(mTextureName);
- }
- // to help debugging we set those to zero
- mWidth = mHeight = 0;
-}
-
-bool LayerBuffer::needsBlending() const
-{
- Mutex::Autolock _l(mLock);
- return mNeedsBlending;
-}
-
-void LayerBuffer::onDraw(const Region& clip) const
-{
- sp<Buffer> buffer(getBuffer());
- if (UNLIKELY(buffer == 0)) {
- // nothing to do, we don't have a buffer
- clearWithOpenGL(clip);
- return;
- }
-
- status_t err = NO_ERROR;
- NativeBuffer src(buffer->getBuffer());
- const int can_use_copybit = canUseCopybit();
-
- if (can_use_copybit) {
- //StopWatch watch("MDP");
-
- const int src_width = src.crop.r - src.crop.l;
- const int src_height = src.crop.b - src.crop.t;
- int W = mTransformedBounds.width();
- int H = mTransformedBounds.height();
- if (getOrientation() & Transform::ROT_90) {
- int t(W); W=H; H=t;
- }
-
- /* With LayerBuffer, it is likely that we'll have to rescale the
- * surface, because this is often used for video playback or
- * camera-preview. Since we want these operation as fast as possible
- * we make sure we can use the 2D H/W even if it doesn't support
- * the requested scale factor, in which case we perform the scaling
- * in several passes. */
-
- copybit_device_t* copybit = mFlinger->getBlitEngine();
- const float min = copybit->get(copybit, COPYBIT_MINIFICATION_LIMIT);
- const float mag = copybit->get(copybit, COPYBIT_MAGNIFICATION_LIMIT);
-
- float xscale = 1.0f;
- if (src_width > W*min) xscale = 1.0f / min;
- else if (src_width*mag < W) xscale = mag;
-
- float yscale = 1.0f;
- if (src_height > H*min) yscale = 1.0f / min;
- else if (src_height*mag < H) yscale = mag;
-
- if (UNLIKELY(xscale!=1.0f || yscale!=1.0f)) {
- //LOGD("MDP scaling hack w=%d, h=%d, ww=%d, wh=%d, xs=%f, ys=%f",
- // src_width, src_height, W, H, xscale, yscale);
-
- if (UNLIKELY(mTemporaryDealer == 0)) {
- // allocate a memory-dealer for this the first time
- mTemporaryDealer = mFlinger->getSurfaceHeapManager()
- ->createHeap(ISurfaceComposer::eHardware);
- mTempBitmap.init(mTemporaryDealer);
- }
-
- const int tmp_w = floorf(src_width * xscale);
- const int tmp_h = floorf(src_height * yscale);
- err = mTempBitmap.setBits(tmp_w, tmp_h, 1, src.img.format);
-
- if (LIKELY(err == NO_ERROR)) {
- NativeBuffer tmp;
- mTempBitmap.getBitmapSurface(&tmp.img);
- tmp.crop.l = 0;
- tmp.crop.t = 0;
- tmp.crop.r = tmp.img.w;
- tmp.crop.b = tmp.img.h;
-
- region_iterator tmp_it(Region(Rect(tmp.crop.r, tmp.crop.b)));
- copybit->set_parameter(copybit, COPYBIT_TRANSFORM, 0);
- copybit->set_parameter(copybit, COPYBIT_PLANE_ALPHA, 0xFF);
- copybit->set_parameter(copybit, COPYBIT_DITHER, COPYBIT_DISABLE);
- err = copybit->stretch(copybit,
- &tmp.img, &src.img, &tmp.crop, &src.crop, &tmp_it);
- src = tmp;
- }
- }
-
- const DisplayHardware& hw(graphicPlane(0).displayHardware());
- copybit_image_t dst;
- hw.getDisplaySurface(&dst);
- const copybit_rect_t& drect
- = reinterpret_cast<const copybit_rect_t&>(mTransformedBounds);
- const State& s(drawingState());
- region_iterator it(clip);
- copybit->set_parameter(copybit, COPYBIT_TRANSFORM, getOrientation());
- copybit->set_parameter(copybit, COPYBIT_PLANE_ALPHA, s.alpha);
- copybit->set_parameter(copybit, COPYBIT_DITHER,
- s.flags & ISurfaceComposer::eLayerDither ?
- COPYBIT_ENABLE : COPYBIT_DISABLE);
- err = copybit->stretch(copybit,
- &dst, &src.img, &drect, &src.crop, &it);
- }
-
- if (!can_use_copybit || err) {
- if (UNLIKELY(mTextureName == -1LU)) {
- mTextureName = createTexture();
- }
- GLuint w = 0;
- GLuint h = 0;
- GGLSurface t;
- t.version = sizeof(GGLSurface);
- t.width = src.crop.r;
- t.height = src.crop.b;
- t.stride = src.img.w;
- t.vstride= src.img.h;
- t.format = src.img.format;
- t.data = (GGLubyte*)(intptr_t(src.img.base) + src.img.offset);
- const Region dirty(Rect(t.width, t.height));
- loadTexture(dirty, mTextureName, t, w, h);
- drawWithOpenGL(clip, mTextureName, t);
- }
-}
-
-void LayerBuffer::invalidateLocked()
-{
- mInvalidate = true;
- mFlinger->signalEvent();
-}
-
-void LayerBuffer::invalidate()
-{
- Mutex::Autolock _l(mLock);
- invalidateLocked();
-}
-
-void LayerBuffer::unlockPageFlip(const Transform& planeTransform,
- Region& outDirtyRegion)
-{
- Mutex::Autolock _l(mLock);
- if (mInvalidate) {
- mInvalidate = false;
- outDirtyRegion.orSelf(visibleRegionScreen);
- }
}
sp<LayerBuffer::SurfaceBuffer> LayerBuffer::getClientSurface() const
@@ -226,114 +78,106 @@
return s;
}
+bool LayerBuffer::needsBlending() const {
+ return mNeedsBlending;
+}
-status_t LayerBuffer::registerBuffers(int w, int h, int hstride, int vstride,
- PixelFormat format, const sp<IMemoryHeap>& memoryHeap)
-{
- if (memoryHeap == NULL) {
- // this is allowed, but in this case, it is illegal to receive
- // postBuffer(). The surface just erases the framebuffer with
- // fully transparent pixels.
- mHeap.clear();
- mWidth = w;
- mHeight = h;
- mNeedsBlending = false;
- return NO_ERROR;
- }
-
- status_t err = (memoryHeap->heapID() >= 0) ? NO_ERROR : NO_INIT;
- if (err != NO_ERROR)
- return err;
-
- // TODO: validate format/parameters
-
- Mutex::Autolock _l(mLock);
- mHeap = memoryHeap;
- mWidth = w;
- mHeight = h;
- mHStride = hstride;
- mVStride = vstride;
- mFormat = format;
- PixelFormatInfo info;
- getPixelFormatInfo(format, &info);
- mNeedsBlending = (info.h_alpha - info.l_alpha) > 0;
- return NO_ERROR;
+void LayerBuffer::setNeedsBlending(bool blending) {
+ mNeedsBlending = blending;
}
void LayerBuffer::postBuffer(ssize_t offset)
{
- sp<IMemoryHeap> heap;
- int w, h, hs, vs, f;
- { // scope for the lock
- Mutex::Autolock _l(mLock);
- w = mWidth;
- h = mHeight;
- hs= mHStride;
- vs= mVStride;
- f = mFormat;
- heap = mHeap;
- }
-
- sp<Buffer> buffer;
- if (heap != 0) {
- buffer = new Buffer(heap, offset, w, h, hs, vs, f);
- if (buffer->getStatus() != NO_ERROR)
- buffer.clear();
- setBuffer(buffer);
- invalidate();
- }
+ sp<Source> source(getSource());
+ if (source != 0)
+ source->postBuffer(offset);
}
void LayerBuffer::unregisterBuffers()
{
- Mutex::Autolock _l(mLock);
- mHeap.clear();
- mBuffer.clear();
- invalidateLocked();
+ sp<Source> source(getSource());
+ if (source != 0)
+ source->unregisterBuffers();
+ // XXX: clear mSource
}
-sp<Overlay> LayerBuffer::createOverlay(uint32_t w, uint32_t h, int32_t format)
+uint32_t LayerBuffer::doTransaction(uint32_t flags)
{
- sp<Overlay> result;
- Mutex::Autolock _l(mLock);
- if (mHeap != 0 || mBuffer != 0) {
- // we're a push surface. error.
- return result;
- }
-
- overlay_device_t* overlay_dev = mFlinger->getOverlayEngine();
- if (overlay_dev == NULL) {
- // overlays not supported
- return result;
- }
+ sp<Source> source(getSource());
+ if (source != 0)
+ source->onTransaction(flags);
+ return LayerBase::doTransaction(flags);
+}
- overlay_t* overlay = overlay_dev->createOverlay(overlay_dev, w, h, format);
- if (overlay == NULL) {
- // couldn't create the overlay (no memory? no more overlays?)
- return result;
+void LayerBuffer::unlockPageFlip(const Transform& planeTransform,
+ Region& outDirtyRegion)
+{
+ // this code-path must be as tight as possible, it's called each time
+ // the screen is composited.
+ sp<Source> source(getSource());
+ if (source != 0)
+ source->onVisibilityResolved(planeTransform);
+ LayerBase::unlockPageFlip(planeTransform, outDirtyRegion);
+}
+
+void LayerBuffer::onDraw(const Region& clip) const
+{
+ sp<Source> source(getSource());
+ if (LIKELY(source != 0)) {
+ source->onDraw(clip);
+ } else {
+ clearWithOpenGL(clip);
}
-
- /* TODO: implement the real stuff here */
-
+}
+
+/**
+ * This creates a "buffer" source for this surface
+ */
+status_t LayerBuffer::registerBuffers(int w, int h, int hstride, int vstride,
+ PixelFormat format, const sp<IMemoryHeap>& memoryHeap)
+{
+ Mutex::Autolock _l(mLock);
+ if (mSource != 0)
+ return INVALID_OPERATION;
+
+ sp<BufferSource> source = new BufferSource(*this, w, h,
+ hstride, vstride, format, memoryHeap);
+
+ status_t result = source->getStatus();
+ if (result == NO_ERROR) {
+ mSource = source;
+ }
+ return result;
+}
+
+/**
+ * This creates an "overlay" source for this surface
+ */
+sp<OverlayRef> LayerBuffer::createOverlay(uint32_t w, uint32_t h, int32_t f)
+{
+ sp<OverlayRef> result;
+ Mutex::Autolock _l(mLock);
+ if (mSource != 0)
+ return result;
+
+ sp<OverlaySource> source = new OverlaySource(*this, &result, w, h, f);
+ if (result != 0) {
+ mSource = source;
+ }
return result;
}
-sp<LayerBuffer::Buffer> LayerBuffer::getBuffer() const
-{
+sp<LayerBuffer::Source> LayerBuffer::getSource() const {
Mutex::Autolock _l(mLock);
- return mBuffer;
+ return mSource;
}
-void LayerBuffer::setBuffer(const sp<LayerBuffer::Buffer>& buffer)
-{
- Mutex::Autolock _l(mLock);
- mBuffer = buffer;
-}
-
-// ---------------------------------------------------------------------------
+// ============================================================================
+// LayerBuffer::SurfaceBuffer
+// ============================================================================
LayerBuffer::SurfaceBuffer::SurfaceBuffer(SurfaceID id, LayerBuffer* owner)
- : LayerBaseClient::Surface(id, owner->getIdentity()), mOwner(owner)
+: LayerBaseClient::Surface(id, owner->getIdentity()), mOwner(owner)
{
}
@@ -367,9 +211,9 @@
owner->unregisterBuffers();
}
-sp<Overlay> LayerBuffer::SurfaceBuffer::createOverlay(
+sp<OverlayRef> LayerBuffer::SurfaceBuffer::createOverlay(
uint32_t w, uint32_t h, int32_t format) {
- sp<Overlay> result;
+ sp<OverlayRef> result;
LayerBuffer* owner(getOwner());
if (owner)
result = owner->createOverlay(w, h, format);
@@ -382,12 +226,13 @@
mOwner = 0;
}
-
-// ---------------------------------------------------------------------------
+// ============================================================================
+// LayerBuffer::Buffer
+// ============================================================================
LayerBuffer::Buffer::Buffer(const sp<IMemoryHeap>& heap, ssize_t offset,
int w, int h, int hs, int vs, int f)
- : mCount(0), mHeap(heap)
+: mHeap(heap)
{
NativeBuffer& src(mNativeBuffer);
src.crop.l = 0;
@@ -408,5 +253,317 @@
{
}
+// ============================================================================
+// LayerBuffer::Source
+// LayerBuffer::BufferSource
+// LayerBuffer::OverlaySource
+// ============================================================================
+
+LayerBuffer::Source::Source(LayerBuffer& layer)
+ : mLayer(layer)
+{
+}
+LayerBuffer::Source::~Source() {
+}
+void LayerBuffer::Source::onDraw(const Region& clip) const {
+}
+void LayerBuffer::Source::onTransaction(uint32_t flags) {
+}
+void LayerBuffer::Source::onVisibilityResolved(
+ const Transform& planeTransform) {
+}
+void LayerBuffer::Source::postBuffer(ssize_t offset) {
+}
+void LayerBuffer::Source::unregisterBuffers() {
+}
+
+// ---------------------------------------------------------------------------
+
+LayerBuffer::BufferSource::BufferSource(LayerBuffer& layer,
+ int w, int h, int hstride, int vstride,
+ PixelFormat format, const sp<IMemoryHeap>& memoryHeap)
+ : Source(layer), mStatus(NO_ERROR), mTextureName(-1U)
+{
+ if (memoryHeap == NULL) {
+ // this is allowed, but in this case, it is illegal to receive
+ // postBuffer(). The surface just erases the framebuffer with
+ // fully transparent pixels.
+ mHeap.clear();
+ mWidth = w;
+ mHeight = h;
+ mLayer.setNeedsBlending(false);
+ return;
+ }
+
+ status_t err = (memoryHeap->heapID() >= 0) ? NO_ERROR : NO_INIT;
+ if (err != NO_ERROR) {
+ mStatus = err;
+ return;
+ }
+
+ // TODO: validate format/parameters
+ mHeap = memoryHeap;
+ mWidth = w;
+ mHeight = h;
+ mHStride = hstride;
+ mVStride = vstride;
+ mFormat = format;
+ PixelFormatInfo info;
+ getPixelFormatInfo(format, &info);
+ mLayer.setNeedsBlending((info.h_alpha - info.l_alpha) > 0);
+}
+
+LayerBuffer::BufferSource::~BufferSource()
+{
+ if (mTextureName != -1U) {
+ LayerBase::deletedTextures.add(mTextureName);
+ }
+}
+
+void LayerBuffer::BufferSource::postBuffer(ssize_t offset)
+{
+ sp<IMemoryHeap> heap;
+ int w, h, hs, vs, f;
+ { // scope for the lock
+ Mutex::Autolock _l(mLock);
+ w = mWidth;
+ h = mHeight;
+ hs= mHStride;
+ vs= mVStride;
+ f = mFormat;
+ heap = mHeap;
+ }
+
+ sp<Buffer> buffer;
+ if (heap != 0) {
+ buffer = new LayerBuffer::Buffer(heap, offset, w, h, hs, vs, f);
+ if (buffer->getStatus() != NO_ERROR)
+ buffer.clear();
+ setBuffer(buffer);
+ mLayer.invalidate();
+ }
+}
+
+void LayerBuffer::BufferSource::unregisterBuffers()
+{
+ Mutex::Autolock _l(mLock);
+ mHeap.clear();
+ mBuffer.clear();
+ mLayer.invalidate();
+}
+
+sp<LayerBuffer::Buffer> LayerBuffer::BufferSource::getBuffer() const
+{
+ Mutex::Autolock _l(mLock);
+ return mBuffer;
+}
+
+void LayerBuffer::BufferSource::setBuffer(const sp<LayerBuffer::Buffer>& buffer)
+{
+ Mutex::Autolock _l(mLock);
+ mBuffer = buffer;
+}
+
+void LayerBuffer::BufferSource::onDraw(const Region& clip) const
+{
+ sp<Buffer> buffer(getBuffer());
+ if (UNLIKELY(buffer == 0)) {
+ // nothing to do, we don't have a buffer
+ mLayer.clearWithOpenGL(clip);
+ return;
+ }
+
+ status_t err = NO_ERROR;
+ NativeBuffer src(buffer->getBuffer());
+ const Rect& transformedBounds = mLayer.getTransformedBounds();
+ const int can_use_copybit = mLayer.canUseCopybit();
+
+ if (can_use_copybit) {
+ const int src_width = src.crop.r - src.crop.l;
+ const int src_height = src.crop.b - src.crop.t;
+ int W = transformedBounds.width();
+ int H = transformedBounds.height();
+ if (mLayer.getOrientation() & Transform::ROT_90) {
+ int t(W); W=H; H=t;
+ }
+
+ /* With LayerBuffer, it is likely that we'll have to rescale the
+ * surface, because this is often used for video playback or
+ * camera-preview. Since we want these operation as fast as possible
+ * we make sure we can use the 2D H/W even if it doesn't support
+ * the requested scale factor, in which case we perform the scaling
+ * in several passes. */
+
+ copybit_device_t* copybit = mLayer.mFlinger->getBlitEngine();
+ const float min = copybit->get(copybit, COPYBIT_MINIFICATION_LIMIT);
+ const float mag = copybit->get(copybit, COPYBIT_MAGNIFICATION_LIMIT);
+
+ float xscale = 1.0f;
+ if (src_width > W*min) xscale = 1.0f / min;
+ else if (src_width*mag < W) xscale = mag;
+
+ float yscale = 1.0f;
+ if (src_height > H*min) yscale = 1.0f / min;
+ else if (src_height*mag < H) yscale = mag;
+
+ if (UNLIKELY(xscale!=1.0f || yscale!=1.0f)) {
+ if (UNLIKELY(mTemporaryDealer == 0)) {
+ // allocate a memory-dealer for this the first time
+ mTemporaryDealer = mLayer.mFlinger->getSurfaceHeapManager()
+ ->createHeap(ISurfaceComposer::eHardware);
+ mTempBitmap.init(mTemporaryDealer);
+ }
+
+ const int tmp_w = floorf(src_width * xscale);
+ const int tmp_h = floorf(src_height * yscale);
+ err = mTempBitmap.setBits(tmp_w, tmp_h, 1, src.img.format);
+
+ if (LIKELY(err == NO_ERROR)) {
+ NativeBuffer tmp;
+ mTempBitmap.getBitmapSurface(&tmp.img);
+ tmp.crop.l = 0;
+ tmp.crop.t = 0;
+ tmp.crop.r = tmp.img.w;
+ tmp.crop.b = tmp.img.h;
+
+ region_iterator tmp_it(Region(Rect(tmp.crop.r, tmp.crop.b)));
+ copybit->set_parameter(copybit, COPYBIT_TRANSFORM, 0);
+ copybit->set_parameter(copybit, COPYBIT_PLANE_ALPHA, 0xFF);
+ copybit->set_parameter(copybit, COPYBIT_DITHER, COPYBIT_DISABLE);
+ err = copybit->stretch(copybit,
+ &tmp.img, &src.img, &tmp.crop, &src.crop, &tmp_it);
+ src = tmp;
+ }
+ }
+
+ const DisplayHardware& hw(mLayer.graphicPlane(0).displayHardware());
+ copybit_image_t dst;
+ hw.getDisplaySurface(&dst);
+ const copybit_rect_t& drect
+ = reinterpret_cast<const copybit_rect_t&>(transformedBounds);
+ const State& s(mLayer.drawingState());
+ region_iterator it(clip);
+ copybit->set_parameter(copybit, COPYBIT_TRANSFORM, mLayer.getOrientation());
+ copybit->set_parameter(copybit, COPYBIT_PLANE_ALPHA, s.alpha);
+ copybit->set_parameter(copybit, COPYBIT_DITHER,
+ s.flags & ISurfaceComposer::eLayerDither ?
+ COPYBIT_ENABLE : COPYBIT_DISABLE);
+ err = copybit->stretch(copybit,
+ &dst, &src.img, &drect, &src.crop, &it);
+ }
+
+ if (!can_use_copybit || err) {
+ if (UNLIKELY(mTextureName == -1LU)) {
+ mTextureName = mLayer.createTexture();
+ }
+ GLuint w = 0;
+ GLuint h = 0;
+ GGLSurface t;
+ t.version = sizeof(GGLSurface);
+ t.width = src.crop.r;
+ t.height = src.crop.b;
+ t.stride = src.img.w;
+ t.vstride= src.img.h;
+ t.format = src.img.format;
+ t.data = (GGLubyte*)(intptr_t(src.img.base) + src.img.offset);
+ const Region dirty(Rect(t.width, t.height));
+ mLayer.loadTexture(dirty, mTextureName, t, w, h);
+ mLayer.drawWithOpenGL(clip, mTextureName, t);
+ }
+}
+
+// ---------------------------------------------------------------------------
+
+LayerBuffer::OverlaySource::OverlaySource(LayerBuffer& layer,
+ sp<OverlayRef>* overlayRef,
+ uint32_t w, uint32_t h, int32_t format)
+ : Source(layer), mVisibilityChanged(false), mOverlay(0), mOverlayHandle(0)
+{
+ overlay_control_device_t* overlay_dev = mLayer.mFlinger->getOverlayEngine();
+
+ if (overlay_dev == NULL) {
+ // overlays not supported
+ return;
+ }
+
+ overlay_t* overlay = overlay_dev->createOverlay(overlay_dev, w, h, format);
+ if (overlay == NULL) {
+ // couldn't create the overlay (no memory? no more overlays?)
+ return;
+ }
+
+ // enable dithering...
+ overlay_dev->setParameter(overlay_dev, overlay,
+ OVERLAY_DITHER, OVERLAY_ENABLE);
+
+ mOverlay = overlay;
+ mWidth = overlay->w;
+ mHeight = overlay->h;
+ mFormat = overlay->format;
+ mWidthStride = overlay->w_stride;
+ mHeightStride = overlay->h_stride;
+
+ mOverlayHandle = overlay->getHandleRef(overlay);
+
+ // NOTE: here it's okay to acquire a reference to "this"m as long as
+ // the reference is not released before we leave the ctor.
+ sp<OverlayChanel> chanel = new OverlayChanel(this);
+
+ *overlayRef = new OverlayRef(mOverlayHandle, chanel,
+ mWidth, mHeight, mFormat, mWidthStride, mHeightStride);
+}
+
+LayerBuffer::OverlaySource::~OverlaySource()
+{
+}
+
+void LayerBuffer::OverlaySource::onTransaction(uint32_t flags)
+{
+ const Layer::State& front(mLayer.drawingState());
+ const Layer::State& temp(mLayer.currentState());
+ if (temp.sequence != front.sequence) {
+ mVisibilityChanged = true;
+ }
+}
+
+void LayerBuffer::OverlaySource::onVisibilityResolved(
+ const Transform& planeTransform)
+{
+ // this code-path must be as tight as possible, it's called each time
+ // the screen is composited.
+ if (UNLIKELY(mOverlay != 0)) {
+ if (mVisibilityChanged) {
+ mVisibilityChanged = false;
+ const Rect& bounds = mLayer.getTransformedBounds();
+ int x = bounds.left;
+ int y = bounds.top;
+ int w = bounds.width();
+ int h = bounds.height();
+
+ // we need a lock here to protect "destroy"
+ Mutex::Autolock _l(mLock);
+ if (mOverlay) {
+ overlay_control_device_t* overlay_dev =
+ mLayer.mFlinger->getOverlayEngine();
+ overlay_dev->setPosition(overlay_dev, mOverlay, x,y,w,h);
+ overlay_dev->setParameter(overlay_dev, mOverlay,
+ OVERLAY_TRANSFORM, mLayer.getOrientation());
+ }
+ }
+ }
+}
+
+void LayerBuffer::OverlaySource::serverDestroy()
+{
+ // we need a lock here to protect "onVisibilityResolved"
+ Mutex::Autolock _l(mLock);
+ if (mOverlay) {
+ overlay_control_device_t* overlay_dev =
+ mLayer.mFlinger->getOverlayEngine();
+ overlay_dev->destroyOverlay(overlay_dev, mOverlay);
+ mOverlay = 0;
+ }
+}
+
// ---------------------------------------------------------------------------
}; // namespace android
diff --git a/libs/surfaceflinger/LayerBuffer.h b/libs/surfaceflinger/LayerBuffer.h
index 3e616f2..63ec2cf 100644
--- a/libs/surfaceflinger/LayerBuffer.h
+++ b/libs/surfaceflinger/LayerBuffer.h
@@ -33,10 +33,24 @@
class MemoryDealer;
class Region;
-class Overlay;
+class OverlayRef;
class LayerBuffer : public LayerBaseClient
{
+ class Source : public LightRefBase<Source> {
+ public:
+ Source(LayerBuffer& layer);
+ virtual ~Source();
+ virtual void onDraw(const Region& clip) const;
+ virtual void onTransaction(uint32_t flags);
+ virtual void onVisibilityResolved(const Transform& planeTransform);
+ virtual void postBuffer(ssize_t offset);
+ virtual void unregisterBuffers();
+ protected:
+ LayerBuffer& mLayer;
+ };
+
+
public:
static const uint32_t typeInfo;
static const char* const typeID;
@@ -51,39 +65,31 @@
virtual sp<LayerBaseClient::Surface> getSurface() const;
virtual void onDraw(const Region& clip) const;
+ virtual uint32_t doTransaction(uint32_t flags);
virtual void unlockPageFlip(const Transform& planeTransform, Region& outDirtyRegion);
status_t registerBuffers(int w, int h, int hstride, int vstride,
PixelFormat format, const sp<IMemoryHeap>& heap);
void postBuffer(ssize_t offset);
void unregisterBuffers();
- sp<Overlay> createOverlay(uint32_t w, uint32_t h, int32_t format);
- void invalidate();
- void invalidateLocked();
+ sp<OverlayRef> createOverlay(uint32_t w, uint32_t h, int32_t format);
+
+ sp<Source> getSource() const;
+ void setNeedsBlending(bool blending);
+ const Rect& getTransformedBounds() const {
+ return mTransformedBounds;
+ }
private:
-
- struct NativeBuffer
- {
+ struct NativeBuffer {
copybit_image_t img;
copybit_rect_t crop;
};
- class Buffer
- {
+ class Buffer : public LightRefBase<Buffer> {
public:
Buffer(const sp<IMemoryHeap>& heap, ssize_t offset,
int w, int h, int hs, int vs, int f);
- inline void incStrong(void*) const {
- android_atomic_inc(&mCount);
- }
- inline void decStrong(void*) const {
- int32_t c = android_atomic_dec(&mCount);
- //LOGE_IF(c<1, "Buffer::decStrong() called too many times");
- if (c == 1) {
- delete this;
- }
- }
inline status_t getStatus() const {
return mHeap!=0 ? NO_ERROR : NO_INIT;
}
@@ -91,15 +97,87 @@
return mNativeBuffer;
}
protected:
+ friend class LightRefBase<Buffer>;
Buffer& operator = (const Buffer& rhs);
Buffer(const Buffer& rhs);
~Buffer();
- mutable volatile int32_t mCount;
private:
sp<IMemoryHeap> mHeap;
NativeBuffer mNativeBuffer;
};
+ class BufferSource : public Source {
+ public:
+ BufferSource(LayerBuffer& layer,
+ int w, int h, int hstride, int vstride,
+ PixelFormat format, const sp<IMemoryHeap>& heap);
+ virtual ~BufferSource();
+
+ status_t getStatus() const { return mStatus; }
+ sp<Buffer> getBuffer() const;
+ void setBuffer(const sp<Buffer>& buffer);
+
+ virtual void onDraw(const Region& clip) const;
+ virtual void postBuffer(ssize_t offset);
+ virtual void unregisterBuffers();
+ private:
+ mutable Mutex mLock;
+ sp<IMemoryHeap> mHeap;
+ sp<Buffer> mBuffer;
+ status_t mStatus;
+ int mWidth;
+ int mHeight;
+ int mHStride;
+ int mVStride;
+ int mFormat;
+ mutable sp<MemoryDealer> mTemporaryDealer;
+ mutable LayerBitmap mTempBitmap;
+ mutable GLuint mTextureName;
+ };
+
+ class OverlaySource : public Source {
+ public:
+ OverlaySource(LayerBuffer& layer,
+ sp<OverlayRef>* overlayRef,
+ uint32_t w, uint32_t h, int32_t format);
+ virtual ~OverlaySource();
+ virtual void onTransaction(uint32_t flags);
+ virtual void onVisibilityResolved(const Transform& planeTransform);
+ private:
+ void serverDestroy();
+ class OverlayChanel : public BnOverlay {
+ mutable Mutex mLock;
+ sp<OverlaySource> mSource;
+ virtual void destroy() {
+ sp<OverlaySource> source;
+ { // scope for the lock;
+ Mutex::Autolock _l(mLock);
+ source = mSource;
+ mSource.clear();
+ }
+ if (source != 0) {
+ source->serverDestroy();
+ }
+ }
+ public:
+ OverlayChanel(const sp<OverlaySource>& source)
+ : mSource(source) {
+ }
+ };
+ friend class OverlayChanel;
+ bool mVisibilityChanged;
+
+ overlay_t* mOverlay;
+ overlay_handle_t const *mOverlayHandle;
+ uint32_t mWidth;
+ uint32_t mHeight;
+ int32_t mFormat;
+ int32_t mWidthStride;
+ int32_t mHeightStride;
+ mutable Mutex mLock;
+ };
+
+
class SurfaceBuffer : public LayerBaseClient::Surface
{
public:
@@ -109,7 +187,7 @@
PixelFormat format, const sp<IMemoryHeap>& heap);
virtual void postBuffer(ssize_t offset);
virtual void unregisterBuffers();
- virtual sp<Overlay> createOverlay(
+ virtual sp<OverlayRef> createOverlay(
uint32_t w, uint32_t h, int32_t format);
void disown();
private:
@@ -122,24 +200,14 @@
};
friend class SurfaceFlinger;
- sp<Buffer> getBuffer() const;
- void setBuffer(const sp<Buffer>& buffer);
sp<SurfaceBuffer> getClientSurface() const;
mutable Mutex mLock;
- sp<IMemoryHeap> mHeap;
- sp<Buffer> mBuffer;
- int mWidth;
- int mHeight;
- int mHStride;
- int mVStride;
- int mFormat;
- mutable GLuint mTextureName;
+ sp<Source> mSource;
+
bool mInvalidate;
bool mNeedsBlending;
mutable wp<SurfaceBuffer> mClientSurface;
- mutable sp<MemoryDealer> mTemporaryDealer;
- mutable LayerBitmap mTempBitmap;
};
// ---------------------------------------------------------------------------
diff --git a/libs/surfaceflinger/LayerScreenshot.cpp b/libs/surfaceflinger/LayerScreenshot.cpp
index 9b82bad..3e7132b 100644
--- a/libs/surfaceflinger/LayerScreenshot.cpp
+++ b/libs/surfaceflinger/LayerScreenshot.cpp
@@ -23,7 +23,7 @@
#include <utils/Errors.h>
#include <utils/Log.h>
-#include <graphics/SkBitmap.h>
+#include <core/SkBitmap.h>
#include <ui/EGLDisplaySurface.h>
diff --git a/libs/surfaceflinger/SurfaceFlinger.cpp b/libs/surfaceflinger/SurfaceFlinger.cpp
index e8de21a..4c719e8 100644
--- a/libs/surfaceflinger/SurfaceFlinger.cpp
+++ b/libs/surfaceflinger/SurfaceFlinger.cpp
@@ -231,7 +231,7 @@
return graphicPlane(0).displayHardware().getBlitEngine();
}
-overlay_device_t* SurfaceFlinger::getOverlayEngine() const
+overlay_control_device_t* SurfaceFlinger::getOverlayEngine() const
{
return graphicPlane(0).displayHardware().getOverlayEngine();
}
@@ -773,12 +773,12 @@
coveredRegion.andSelf(aboveCoveredLayers);
// compute this layer's dirty region
- if (layer->invalidate) {
+ if (layer->contentDirty) {
// we need to invalidate the whole region
dirty = visibleRegion;
// as well, as the old visible region
dirty.orSelf(layer->visibleRegionScreen);
- layer->invalidate = false;
+ layer->contentDirty = false;
} else {
// compute the exposed region
// dirty = what's visible now - what's wasn't covered before
@@ -1456,7 +1456,7 @@
"alpha=0x%02x, flags=0x%08x, tr=[%.2f, %.2f][%.2f, %.2f]\n",
layer->getTypeID(), layer,
s.z, layer->tx(), layer->ty(), s.w, s.h,
- layer->needsBlending(), layer->invalidate,
+ layer->needsBlending(), layer->contentDirty,
s.alpha, s.flags,
s.transform[0], s.transform[1],
s.transform[2], s.transform[3]);
@@ -1474,22 +1474,6 @@
}
result.append(buffer);
buffer[0] = 0;
- /*** LayerBuffer ***/
- LayerBuffer* const lbuf =
- LayerBase::dynamicCast<LayerBuffer*>((LayerBase*)layer);
- if (lbuf) {
- sp<LayerBuffer::Buffer> lbb(lbuf->getBuffer());
- if (lbb != 0) {
- const LayerBuffer::NativeBuffer& nbuf(lbb->getBuffer());
- snprintf(buffer, SIZE,
- " "
- "mBuffer={w=%u, h=%u, f=%d, offset=%u, base=%p, fd=%d }\n",
- nbuf.img.w, nbuf.img.h, nbuf.img.format, nbuf.img.offset,
- nbuf.img.base, nbuf.img.fd);
- }
- }
- result.append(buffer);
- buffer[0] = 0;
/*** Layer ***/
Layer* const l = LayerBase::dynamicCast<Layer*>((LayerBase*)layer);
if (l) {
diff --git a/libs/surfaceflinger/SurfaceFlinger.h b/libs/surfaceflinger/SurfaceFlinger.h
index 92021d0..a242f1a 100644
--- a/libs/surfaceflinger/SurfaceFlinger.h
+++ b/libs/surfaceflinger/SurfaceFlinger.h
@@ -180,7 +180,7 @@
}
copybit_device_t* getBlitEngine() const;
- overlay_device_t* getOverlayEngine() const;
+ overlay_control_device_t* getOverlayEngine() const;
private:
friend class BClient;
@@ -382,24 +382,16 @@
// ---------------------------------------------------------------------------
-class FreezeLock {
+class FreezeLock : public LightRefBase<FreezeLock> {
SurfaceFlinger* mFlinger;
- mutable volatile int32_t mCount;
public:
FreezeLock(SurfaceFlinger* flinger)
- : mFlinger(flinger), mCount(0) {
+ : mFlinger(flinger) {
mFlinger->incFreezeCount();
}
~FreezeLock() {
mFlinger->decFreezeCount();
}
- inline void incStrong(void*) const {
- android_atomic_inc(&mCount);
- }
- inline void decStrong(void*) const {
- if (android_atomic_dec(&mCount) == 1)
- delete this;
- }
};
// ---------------------------------------------------------------------------
diff --git a/libs/surfaceflinger/Transform.h b/libs/surfaceflinger/Transform.h
index 2f617c4..0b4835e 100644
--- a/libs/surfaceflinger/Transform.h
+++ b/libs/surfaceflinger/Transform.h
@@ -25,7 +25,7 @@
#include <GLES/gl.h>
-#include <corecg/SkMatrix.h>
+#include <core/SkMatrix.h>
namespace android {