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

get rid of ISurface 

ISurface was only used to get the IGraphicBufferProducer from
a Layer. It's now replaced by a BBinder subclass / IBinder and
is only used as a handle to the surface, to both refer to it
and manage its life-time.

Also cleaned-up a bit the ISurfaceComposer interface and
"create layer" code path.

Change-Id: I68d0e02d57b862cffb31d5168c3bc10cea0906eb
This commit is contained in:
Mathias Agopian 2013-03-12 17:11:48 -07:00
parent f44e9f91f3
commit 4d9b822e2c
17 changed files with 207 additions and 359 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

62
include/gui/ISurface.h
View File

@ -1,62 +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_GUI_ISURFACE_H
#define ANDROID_GUI_ISURFACE_H
#include <stdint.h>
#include <sys/types.h>
#include <utils/Errors.h>
#include <utils/RefBase.h>
#include <binder/IInterface.h>
#include <ui/PixelFormat.h>
namespace android {
class IGraphicBufferProducer;
class ISurface : public IInterface
{
protected:
enum {
GET_SURFACE_TEXTURE = IBinder::FIRST_CALL_TRANSACTION,
};
public:
DECLARE_META_INTERFACE(Surface);
virtual sp<IGraphicBufferProducer> getSurfaceTexture() const = 0;
};
// ----------------------------------------------------------------------------
class BnSurface : public BnInterface<ISurface>
{
public:
virtual status_t onTransact( uint32_t code,
const Parcel& data,
Parcel* reply,
uint32_t flags = 0);
};
// ----------------------------------------------------------------------------
}; // namespace android
#endif // ANDROID_GUI_ISURFACE_H

10
include/gui/ISurfaceComposerClient.h
View File

@ -27,11 +27,11 @@
#include <ui/PixelFormat.h>
#include <gui/ISurface.h>
namespace android {
// ----------------------------------------------------------------------------
class IGraphicBufferProducer;
class ISurfaceComposerClient : public IInterface
{
public:
@ -55,9 +55,11 @@ public:
/*
* Requires ACCESS_SURFACE_FLINGER permission
*/
virtual sp<ISurface> createSurface(
virtual status_t createSurface(
const String8& name, uint32_t w, uint32_t h,
PixelFormat format, uint32_t flags) = 0;
PixelFormat format, uint32_t flags,
sp<IBinder>* handle,
sp<IGraphicBufferProducer>* gbp) = 0;
/*
* Requires ACCESS_SURFACE_FLINGER permission

10
include/gui/SurfaceControl.h
View File

@ -27,7 +27,6 @@
#include <ui/PixelFormat.h>
#include <ui/Region.h>
#include <gui/ISurface.h>
#include <gui/ISurfaceComposerClient.h>
namespace android {
@ -46,9 +45,11 @@ public:
static bool isValid(const sp<SurfaceControl>& surface) {
return (surface != 0) && surface->isValid();
}
bool isValid() {
return mSurface!=0 && mClient!=0;
return mHandle!=0 && mClient!=0;
}
static bool isSameSurface(
const sp<SurfaceControl>& lhs, const sp<SurfaceControl>& rhs);
@ -82,7 +83,8 @@ private:
SurfaceControl(
const sp<SurfaceComposerClient>& client,
const sp<ISurface>& surface);
const sp<IBinder>& handle,
const sp<IGraphicBufferProducer>& gbp);
~SurfaceControl();
@ -90,7 +92,7 @@ private:
void destroy();
sp<SurfaceComposerClient> mClient;
sp<IBinder> mSurface;
sp<IBinder> mHandle;
sp<IGraphicBufferProducer> mGraphicBufferProducer;
mutable Mutex mLock;
mutable sp<Surface> mSurfaceData;

1
include/private/gui/LayerState.h
View File

@ -24,7 +24,6 @@
#include <ui/Region.h>
#include <ui/Rect.h>
#include <gui/ISurface.h>
namespace android {

1
libs/gui/Android.mk
View File

@ -17,7 +17,6 @@ LOCAL_SRC_FILES:= \
IGraphicBufferProducer.cpp \
ISensorEventConnection.cpp \
ISensorServer.cpp \
ISurface.cpp \
ISurfaceComposer.cpp \
ISurfaceComposerClient.cpp \
LayerState.cpp \

66
libs/gui/ISurface.cpp
View File

@ -1,66 +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 "ISurface"
#include <stdio.h>
#include <stdint.h>
#include <sys/types.h>
#include <binder/Parcel.h>
#include <gui/ISurface.h>
#include <gui/IGraphicBufferProducer.h>
namespace android {
// ----------------------------------------------------------------------
class BpSurface : public BpInterface<ISurface>
{
public:
BpSurface(const sp<IBinder>& impl)
: BpInterface<ISurface>(impl)
{
}
virtual sp<IGraphicBufferProducer> getSurfaceTexture() const {
Parcel data, reply;
data.writeInterfaceToken(ISurface::getInterfaceDescriptor());
remote()->transact(GET_SURFACE_TEXTURE, data, &reply);
return interface_cast<IGraphicBufferProducer>(reply.readStrongBinder());
}
};
IMPLEMENT_META_INTERFACE(Surface, "android.ui.ISurface");
// ----------------------------------------------------------------------
status_t BnSurface::onTransact(
uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
{
switch(code) {
case GET_SURFACE_TEXTURE: {
CHECK_INTERFACE(ISurface, data, reply);
reply->writeStrongBinder( getSurfaceTexture()->asBinder() );
return NO_ERROR;
}
default:
return BBinder::onTransact(code, data, reply, flags);
}
}
}; // namespace android

31
libs/gui/ISurfaceComposerClient.cpp
View File

@ -29,7 +29,7 @@
#include <ui/Point.h>
#include <ui/Rect.h>
#include <gui/ISurface.h>
#include <gui/IGraphicBufferProducer.h>
#include <gui/ISurfaceComposerClient.h>
#include <private/gui/LayerState.h>
@ -46,16 +46,13 @@ class BpSurfaceComposerClient : public BpInterface<ISurfaceComposerClient>
{
public:
BpSurfaceComposerClient(const sp<IBinder>& impl)
: BpInterface<ISurfaceComposerClient>(impl)
{
: BpInterface<ISurfaceComposerClient>(impl) {
}
virtual sp<ISurface> createSurface( const String8& name,
uint32_t w,
uint32_t h,
PixelFormat format,
uint32_t flags)
{
virtual status_t createSurface(const String8& name, uint32_t w,
uint32_t h, PixelFormat format, uint32_t flags,
sp<IBinder>* handle,
sp<IGraphicBufferProducer>* gbp) {
Parcel data, reply;
data.writeInterfaceToken(ISurfaceComposerClient::getInterfaceDescriptor());
data.writeString8(name);
@ -64,11 +61,12 @@ public:
data.writeInt32(format);
data.writeInt32(flags);
remote()->transact(CREATE_SURFACE, data, &reply);
return interface_cast<ISurface>(reply.readStrongBinder());
*handle = reply.readStrongBinder();
*gbp = interface_cast<IGraphicBufferProducer>(reply.readStrongBinder());
return reply.readInt32();
}
virtual status_t destroySurface(const sp<IBinder>& handle)
{
virtual status_t destroySurface(const sp<IBinder>& handle) {
Parcel data, reply;
data.writeInterfaceToken(ISurfaceComposerClient::getInterfaceDescriptor());
data.writeStrongBinder(handle);
@ -92,8 +90,13 @@ status_t BnSurfaceComposerClient::onTransact(
uint32_t h = data.readInt32();
PixelFormat format = data.readInt32();
uint32_t flags = data.readInt32();
sp<ISurface> s = createSurface(name, w, h, format, flags);
reply->writeStrongBinder(s->asBinder());
sp<IBinder> handle;
sp<IGraphicBufferProducer> gbp;
status_t result = createSurface(name, w, h, format, flags,
&handle, &gbp);
reply->writeStrongBinder(handle);
reply->writeStrongBinder(gbp->asBinder());
reply->writeInt32(result);
return NO_ERROR;
} break;
case DESTROY_SURFACE: {

15
libs/gui/SurfaceComposerClient.cpp
View File

@ -32,7 +32,6 @@
#include <ui/DisplayInfo.h>
#include <gui/IGraphicBufferProducer.h>
#include <gui/ISurface.h>
#include <gui/ISurfaceComposer.h>
#include <gui/ISurfaceComposerClient.h>
#include <gui/SurfaceComposerClient.h>
@ -471,14 +470,18 @@ sp<SurfaceControl> SurfaceComposerClient::createSurface(
PixelFormat format,
uint32_t flags)
{
sp<SurfaceControl> result;
sp<SurfaceControl> sur;
if (mStatus == NO_ERROR) {
sp<ISurface> surface = mClient->createSurface(name, w, h, format, flags);
if (surface != 0) {
result = new SurfaceControl(this, surface);
sp<IBinder> handle;
sp<IGraphicBufferProducer> gbp;
status_t err = mClient->createSurface(name, w, h, format, flags,
&handle, &gbp);
ALOGE_IF(err, "SurfaceComposerClient::createSurface error %s", strerror(-err));
if (err == NO_ERROR) {
sur = new SurfaceControl(this, handle, gbp);
}
}
return result;
return sur;
}
sp<IBinder> SurfaceComposerClient::createDisplay(const String8& displayName,

44
libs/gui/SurfaceControl.cpp
View File

@ -34,7 +34,6 @@
#include <ui/GraphicBuffer.h>
#include <ui/Rect.h>
#include <gui/ISurface.h>
#include <gui/ISurfaceComposer.h>
#include <gui/Surface.h>
#include <gui/SurfaceComposerClient.h>
@ -48,13 +47,10 @@ namespace android {
SurfaceControl::SurfaceControl(
const sp<SurfaceComposerClient>& client,
const sp<ISurface>& surface)
: mClient(client)
const sp<IBinder>& handle,
const sp<IGraphicBufferProducer>& gbp)
: mClient(client), mHandle(handle), mGraphicBufferProducer(gbp)
{
if (surface != 0) {
mSurface = surface->asBinder();
mGraphicBufferProducer = surface->getSurfaceTexture();
}
}
SurfaceControl::~SurfaceControl()
@ -65,12 +61,12 @@ SurfaceControl::~SurfaceControl()
void SurfaceControl::destroy()
{
if (isValid()) {
mClient->destroySurface(mSurface);
mClient->destroySurface(mHandle);
}
// clear all references and trigger an IPC now, to make sure things
// happen without delay, since these resources are quite heavy.
mClient.clear();
mSurface.clear();
mHandle.clear();
mGraphicBufferProducer.clear();
IPCThreadState::self()->flushCommands();
}
@ -91,81 +87,81 @@ bool SurfaceControl::isSameSurface(
{
if (lhs == 0 || rhs == 0)
return false;
return lhs->mSurface == rhs->mSurface;
return lhs->mHandle == rhs->mHandle;
}
status_t SurfaceControl::setLayerStack(int32_t layerStack) {
status_t err = validate();
if (err < 0) return err;
const sp<SurfaceComposerClient>& client(mClient);
return client->setLayerStack(mSurface, layerStack);
return client->setLayerStack(mHandle, layerStack);
}
status_t SurfaceControl::setLayer(int32_t layer) {
status_t err = validate();
if (err < 0) return err;
const sp<SurfaceComposerClient>& client(mClient);
return client->setLayer(mSurface, layer);
return client->setLayer(mHandle, layer);
}
status_t SurfaceControl::setPosition(int32_t x, int32_t y) {
status_t err = validate();
if (err < 0) return err;
const sp<SurfaceComposerClient>& client(mClient);
return client->setPosition(mSurface, x, y);
return client->setPosition(mHandle, x, y);
}
status_t SurfaceControl::setSize(uint32_t w, uint32_t h) {
status_t err = validate();
if (err < 0) return err;
const sp<SurfaceComposerClient>& client(mClient);
return client->setSize(mSurface, w, h);
return client->setSize(mHandle, w, h);
}
status_t SurfaceControl::hide() {
status_t err = validate();
if (err < 0) return err;
const sp<SurfaceComposerClient>& client(mClient);
return client->hide(mSurface);
return client->hide(mHandle);
}
status_t SurfaceControl::show() {
status_t err = validate();
if (err < 0) return err;
const sp<SurfaceComposerClient>& client(mClient);
return client->show(mSurface);
return client->show(mHandle);
}
status_t SurfaceControl::setFlags(uint32_t flags, uint32_t mask) {
status_t err = validate();
if (err < 0) return err;
const sp<SurfaceComposerClient>& client(mClient);
return client->setFlags(mSurface, flags, mask);
return client->setFlags(mHandle, flags, mask);
}
status_t SurfaceControl::setTransparentRegionHint(const Region& transparent) {
status_t err = validate();
if (err < 0) return err;
const sp<SurfaceComposerClient>& client(mClient);
return client->setTransparentRegionHint(mSurface, transparent);
return client->setTransparentRegionHint(mHandle, transparent);
}
status_t SurfaceControl::setAlpha(float alpha) {
status_t err = validate();
if (err < 0) return err;
const sp<SurfaceComposerClient>& client(mClient);
return client->setAlpha(mSurface, alpha);
return client->setAlpha(mHandle, alpha);
}
status_t SurfaceControl::setMatrix(float dsdx, float dtdx, float dsdy, float dtdy) {
status_t err = validate();
if (err < 0) return err;
const sp<SurfaceComposerClient>& client(mClient);
return client->setMatrix(mSurface, dsdx, dtdx, dsdy, dtdy);
return client->setMatrix(mHandle, dsdx, dtdx, dsdy, dtdy);
}
status_t SurfaceControl::setCrop(const Rect& crop) {
status_t err = validate();
if (err < 0) return err;
const sp<SurfaceComposerClient>& client(mClient);
return client->setCrop(mSurface, crop);
return client->setCrop(mHandle, crop);
}
status_t SurfaceControl::validate() const
{
if (mSurface==0 || mClient==0) {
ALOGE("invalid ISurface (%p) or client (%p)",
mSurface.get(), mClient.get());
if (mHandle==0 || mClient==0) {
ALOGE("invalid handle (%p) or client (%p)",
mHandle.get(), mClient.get());
return NO_INIT;
}
return NO_ERROR;

29
services/surfaceflinger/Client.cpp
View File

@ -105,10 +105,11 @@ status_t Client::onTransact(
}
sp<ISurface> Client::createSurface(
status_t Client::createSurface(
const String8& name,
uint32_t w, uint32_t h, PixelFormat format,
uint32_t flags)
uint32_t w, uint32_t h, PixelFormat format, uint32_t flags,
sp<IBinder>* handle,
sp<IGraphicBufferProducer>* gbp)
{
/*
* createSurface must be called from the GL thread so that it can
@ -116,9 +117,11 @@ sp<ISurface> Client::createSurface(
*/
class MessageCreateLayer : public MessageBase {
sp<ISurface> result;
SurfaceFlinger* flinger;
Client* client;
sp<IBinder>* handle;
sp<IGraphicBufferProducer>* gbp;
status_t result;
const String8& name;
uint32_t w, h;
PixelFormat format;
@ -126,21 +129,23 @@ sp<ISurface> Client::createSurface(
public:
MessageCreateLayer(SurfaceFlinger* flinger,
const String8& name, Client* client,
uint32_t w, uint32_t h, PixelFormat format,
uint32_t flags)
: flinger(flinger), client(client), name(name),
w(w), h(h), format(format), flags(flags)
{
uint32_t w, uint32_t h, PixelFormat format, uint32_t flags,
sp<IBinder>* handle,
sp<IGraphicBufferProducer>* gbp)
: flinger(flinger), client(client),
handle(handle), gbp(gbp),
name(name), w(w), h(h), format(format), flags(flags) {
}
sp<ISurface> getResult() const { return result; }
status_t getResult() const { return result; }
virtual bool handler() {
result = flinger->createLayer(name, client, w, h, format, flags);
result = flinger->createLayer(name, client, w, h, format, flags,
handle, gbp);
return true;
}
};
sp<MessageBase> msg = new MessageCreateLayer(mFlinger.get(),
name, this, w, h, format, flags);
name, this, w, h, format, flags, handle, gbp);
mFlinger->postMessageSync(msg);
return static_cast<MessageCreateLayer*>( msg.get() )->getResult();
}

7
services/surfaceflinger/Client.h
View File

@ -52,10 +52,11 @@ public:
private:
// ISurfaceComposerClient interface
virtual sp<ISurface> createSurface(
virtual status_t createSurface(
const String8& name,
uint32_t w, uint32_t h,PixelFormat format,
uint32_t flags);
uint32_t w, uint32_t h,PixelFormat format, uint32_t flags,
sp<IBinder>* handle,
sp<IGraphicBufferProducer>* gbp);
virtual status_t destroySurface(const sp<IBinder>& handle);

139
services/surfaceflinger/Layer.cpp
View File

@ -52,7 +52,8 @@ namespace android {
int32_t Layer::sSequence = 1;
Layer::Layer(SurfaceFlinger* flinger, const sp<Client>& client)
Layer::Layer(SurfaceFlinger* flinger, const sp<Client>& client,
const String8& name, uint32_t w, uint32_t h, uint32_t flags)
: contentDirty(false),
sequence(uint32_t(android_atomic_inc(&sSequence))),
mFlinger(flinger),
@ -79,6 +80,29 @@ Layer::Layer(SurfaceFlinger* flinger, const sp<Client>& client)
{
mCurrentCrop.makeInvalid();
glGenTextures(1, &mTextureName);
uint32_t layerFlags = 0;
if (flags & ISurfaceComposerClient::eHidden)
layerFlags = layer_state_t::eLayerHidden;
if (flags & ISurfaceComposerClient::eNonPremultiplied)
mPremultipliedAlpha = false;
mName = name;
mCurrentState.active.w = w;
mCurrentState.active.h = h;
mCurrentState.active.crop.makeInvalid();
mCurrentState.z = 0;
mCurrentState.alpha = 0xFF;
mCurrentState.layerStack = 0;
mCurrentState.flags = layerFlags;
mCurrentState.sequence = 0;
mCurrentState.transform.set(0, 0);
mCurrentState.requested = mCurrentState.active;
// drawing state & current state are identical
mDrawingState = mCurrentState;
}
void Layer::onFirstRef()
@ -91,6 +115,7 @@ void Layer::onFirstRef()
mSurfaceFlingerConsumer->setConsumerUsageBits(getEffectiveUsage(0));
mSurfaceFlingerConsumer->setFrameAvailableListener(this);
mSurfaceFlingerConsumer->setSynchronousMode(true);
mSurfaceFlingerConsumer->setName(mName);
#ifdef TARGET_DISABLE_TRIPLE_BUFFERING
#warning "disabling triple buffering"
@ -103,8 +128,7 @@ void Layer::onFirstRef()
updateTransformHint(hw);
}
Layer::~Layer()
{
Layer::~Layer() {
sp<Client> c(mClientRef.promote());
if (c != 0) {
c->detachLayer(this);
@ -139,39 +163,10 @@ void Layer::onRemoved() {
// set-up
// ---------------------------------------------------------------------------
void Layer::setName(const String8& name) {
mName = name;
mSurfaceFlingerConsumer->setName(name);
}
String8 Layer::getName() const {
return mName;
}
void Layer::initStates(uint32_t w, uint32_t h, uint32_t flags)
{
uint32_t layerFlags = 0;
if (flags & ISurfaceComposerClient::eHidden)
layerFlags = layer_state_t::eLayerHidden;
if (flags & ISurfaceComposerClient::eNonPremultiplied)
mPremultipliedAlpha = false;
mCurrentState.active.w = w;
mCurrentState.active.h = h;
mCurrentState.active.crop.makeInvalid();
mCurrentState.z = 0;
mCurrentState.alpha = 0xFF;
mCurrentState.layerStack = 0;
mCurrentState.flags = layerFlags;
mCurrentState.sequence = 0;
mCurrentState.transform.set(0, 0);
mCurrentState.requested = mCurrentState.active;
// drawing state & current state are identical
mDrawingState = mCurrentState;
}
status_t Layer::setBuffers( uint32_t w, uint32_t h,
PixelFormat format, uint32_t flags)
{
@ -207,59 +202,47 @@ status_t Layer::setBuffers( uint32_t w, uint32_t h,
return NO_ERROR;
}
sp<ISurface> Layer::createSurface() {
/*
* This class provides an implementation of BnSurface (the "native" or
* "remote" side of the Binder IPC interface ISurface), and mixes in
* LayerCleaner to ensure that mFlinger->onLayerDestroyed() is called for
* this layer when the BSurface is destroyed.
*
* The idea is to provide a handle to the Layer through ISurface that
* is cleaned up automatically when the last reference to the ISurface
* goes away. (The references will be held on the "proxy" side, while
* the Layer exists on the "native" side.)
*
* The Layer has a reference to an instance of SurfaceFlinger's variant
* of GLConsumer, which holds a reference to the BufferQueue. The
* getSurfaceTexture() call returns a Binder interface reference for
* the producer interface of the buffer queue associated with the Layer.
*/
class BSurface : public BnSurface, public LayerCleaner {
wp<const Layer> mOwner;
virtual sp<IGraphicBufferProducer> getSurfaceTexture() const {
sp<IGraphicBufferProducer> res;
sp<const Layer> that( mOwner.promote() );
if (that != NULL) {
res = that->mSurfaceFlingerConsumer->getBufferQueue();
}
return res;
}
public:
BSurface(const sp<SurfaceFlinger>& flinger,
const sp<Layer>& layer)
: LayerCleaner(flinger, layer), mOwner(layer) { }
};
sp<ISurface> sur(new BSurface(mFlinger, this));
return sur;
}
wp<IBinder> Layer::getSurfaceTextureBinder() const {
return mSurfaceFlingerConsumer->getBufferQueue()->asBinder();
}
sp<ISurface> Layer::getSurface()
{
sp<ISurface> s;
sp<IBinder> Layer::getHandle() {
Mutex::Autolock _l(mLock);
LOG_ALWAYS_FATAL_IF(mHasSurface,
"Layer::getSurface() has already been called");
"Layer::getHandle() has already been called");
mHasSurface = true;
s = createSurface();
return s;
/*
* The layer handle is just a BBinder object passed to the client
* (remote process) -- we don't keep any reference on our side such that
* the dtor is called when the remote side let go of its reference.
*
* LayerCleaner ensures that mFlinger->onLayerDestroyed() is called for
* this layer when the handle is destroyed.
*/
class Handle : public BBinder, public LayerCleaner {
wp<const Layer> mOwner;
public:
Handle(const sp<SurfaceFlinger>& flinger, const sp<Layer>& layer)
: LayerCleaner(flinger, layer), mOwner(layer) {
}
};
return new Handle(mFlinger, this);
}
sp<BufferQueue> Layer::getBufferQueue() const {
return mSurfaceFlingerConsumer->getBufferQueue();
}
//virtual sp<IGraphicBufferProducer> getSurfaceTexture() const {
// sp<IGraphicBufferProducer> res;
// sp<const Layer> that( mOwner.promote() );
// if (that != NULL) {
// res = that->mSurfaceFlingerConsumer->getBufferQueue();
// }
// return res;
//}
// ---------------------------------------------------------------------------
// h/w composer set-up
// ---------------------------------------------------------------------------

29
services/surfaceflinger/Layer.h
View File

@ -124,16 +124,12 @@ public:
// -----------------------------------------------------------------------
Layer(SurfaceFlinger* flinger, const sp<Client>& client);
Layer(SurfaceFlinger* flinger, const sp<Client>& client,
const String8& name, uint32_t w, uint32_t h, uint32_t flags);
virtual ~Layer();
// the this layer's size and format
status_t setBuffers(uint32_t w, uint32_t h,
PixelFormat format, uint32_t flags=0);
// Creates an ISurface associated with this object. This may only be
// called once. to provide your own ISurface, override createSurface().
sp<ISurface> getSurface();
status_t setBuffers(uint32_t w, uint32_t h, PixelFormat format, uint32_t flags);
// modify current state
bool setPosition(float x, float y);
@ -154,18 +150,14 @@ public:
void computeGeometry(const sp<const DisplayDevice>& hw, LayerMesh* mesh) const;
Rect computeBounds() const;
sp<IBinder> getHandle();
sp<BufferQueue> getBufferQueue() const;
String8 getName() const;
// -----------------------------------------------------------------------
/*
* initStates - called just after construction
*/
virtual void initStates(uint32_t w, uint32_t h, uint32_t flags);
virtual const char* getTypeId() const { return "Layer"; }
virtual void setName(const String8& name);
String8 getName() const;
virtual void setGeometry(const sp<const DisplayDevice>& hw,
HWComposer::HWCLayerInterface& layer);
virtual void setPerFrameData(const sp<const DisplayDevice>& hw,
@ -277,8 +269,6 @@ public:
virtual void onRemoved();
virtual wp<IBinder> getSurfaceTextureBinder() const;
// Updates the transform hint in our SurfaceFlingerConsumer to match
// the current orientation of the display device.
virtual void updateTransformHint(const sp<const DisplayDevice>& hw) const;
@ -336,9 +326,6 @@ protected:
private:
// Creates an instance of ISurface for this Layer.
virtual sp<ISurface> createSurface();
// Interface implementation for SurfaceFlingerConsumer::FrameAvailableListener
virtual void onFrameAvailable();
@ -394,7 +381,7 @@ private:
// protected by mLock
mutable Mutex mLock;
// Set to true if an ISurface has been associated with this object.
// Set to true once we've returned this surface's handle
mutable bool mHasSurface;
const wp<Client> mClientRef;
};

18
services/surfaceflinger/LayerDim.cpp
View File

@ -33,8 +33,9 @@
namespace android {
// ---------------------------------------------------------------------------
LayerDim::LayerDim(SurfaceFlinger* flinger, const sp<Client>& client)
: Layer(flinger, client) {
LayerDim::LayerDim(SurfaceFlinger* flinger, const sp<Client>& client,
const String8& name, uint32_t w, uint32_t h, uint32_t flags)
: Layer(flinger, client, name, w, h, flags) {
}
LayerDim::~LayerDim() {
@ -69,19 +70,6 @@ void LayerDim::onDraw(const sp<const DisplayDevice>& hw, const Region& clip) con
}
}
sp<ISurface> LayerDim::createSurface()
{
class BSurface : public BnSurface, public LayerCleaner {
virtual sp<IGraphicBufferProducer> getSurfaceTexture() const { return 0; }
public:
BSurface(const sp<SurfaceFlinger>& flinger,
const sp<Layer>& layer)
: LayerCleaner(flinger, layer) { }
};
sp<ISurface> sur(new BSurface(mFlinger, this));
return sur;
}
bool LayerDim::isVisible() const {
const Layer::State& s(drawingState());
return !(s.flags & layer_state_t::eLayerHidden) && s.alpha;

4
services/surfaceflinger/LayerDim.h
View File

@ -32,7 +32,8 @@ namespace android {
class LayerDim : public Layer
{
public:
LayerDim(SurfaceFlinger* flinger, const sp<Client>& client);
LayerDim(SurfaceFlinger* flinger, const sp<Client>& client,
const String8& name, uint32_t w, uint32_t h, uint32_t flags);
virtual ~LayerDim();
virtual void onDraw(const sp<const DisplayDevice>& hw, const Region& clip) const;
@ -44,7 +45,6 @@ public:
virtual bool isFixedSize() const { return true; }
virtual bool isVisible() const;
virtual sp<ISurface> createSurface();
};
// ---------------------------------------------------------------------------

84
services/surfaceflinger/SurfaceFlinger.cpp
View File

@ -581,11 +581,10 @@ bool SurfaceFlinger::authenticateSurfaceTexture(
size_t count = currentLayers.size();
for (size_t i=0 ; i<count ; i++) {
const sp<Layer>& layer(currentLayers[i]);
// If this is an instance of Layer (as opposed to, say, LayerDim),
// we will get the consumer interface of SurfaceFlingerConsumer's
// Get the consumer interface of SurfaceFlingerConsumer's
// BufferQueue. If it's the same Binder object as the graphic
// buffer producer interface, return success.
wp<IBinder> lbcBinder = layer->getSurfaceTextureBinder();
sp<IBinder> lbcBinder = layer->getBufferQueue()->asBinder();
if (lbcBinder == surfaceTextureBinder) {
return true;
}
@ -601,7 +600,7 @@ bool SurfaceFlinger::authenticateSurfaceTexture(
size_t purgatorySize = mLayerPurgatory.size();
for (size_t i=0 ; i<purgatorySize ; i++) {
const sp<Layer>& layer(mLayerPurgatory.itemAt(i));
wp<IBinder> lbcBinder = layer->getSurfaceTextureBinder();
sp<IBinder> lbcBinder = layer->getBufferQueue()->asBinder();
if (lbcBinder == surfaceTextureBinder) {
return true;
}
@ -1720,7 +1719,7 @@ status_t SurfaceFlinger::purgatorizeLayer_l(const sp<Layer>& layer)
// it's possible that we don't find a layer, because it might
// have been destroyed already -- this is not technically an error
// from the user because there is a race between Client::destroySurface(),
// ~Client() and ~ISurface().
// ~Client() and ~LayerCleaner().
return (err == NAME_NOT_FOUND) ? status_t(NO_ERROR) : err;
}
@ -1924,48 +1923,49 @@ uint32_t SurfaceFlinger::setClientStateLocked(
return flags;
}
sp<ISurface> SurfaceFlinger::createLayer(
status_t SurfaceFlinger::createLayer(
const String8& name,
const sp<Client>& client,
uint32_t w, uint32_t h, PixelFormat format,
uint32_t flags)
uint32_t w, uint32_t h, PixelFormat format, uint32_t flags,
sp<IBinder>* handle, sp<IGraphicBufferProducer>* gbp)
{
sp<Layer> layer;
sp<ISurface> surfaceHandle;
//ALOGD("createLayer for (%d x %d), name=%s", w, h, name.string());
if (int32_t(w|h) < 0) {
ALOGE("createLayer() failed, w or h is negative (w=%d, h=%d)",
int(w), int(h));
return surfaceHandle;
return BAD_VALUE;
}
//ALOGD("createLayer for (%d x %d), name=%s", w, h, name.string());
status_t result = NO_ERROR;
sp<Layer> layer;
switch (flags & ISurfaceComposerClient::eFXSurfaceMask) {
case ISurfaceComposerClient::eFXSurfaceNormal:
layer = createNormalLayer(client, w, h, flags, format);
result = createNormalLayer(client,
name, w, h, flags, format,
handle, gbp, &layer);
break;
case ISurfaceComposerClient::eFXSurfaceDim:
layer = createDimLayer(client, w, h, flags);
result = createDimLayer(client,
name, w, h, flags,
handle, gbp, &layer);
break;
default:
result = BAD_VALUE;
break;
}
if (layer != 0) {
layer->initStates(w, h, flags);
layer->setName(name);
surfaceHandle = layer->getSurface();
if (surfaceHandle != 0) {
addClientLayer(client, surfaceHandle->asBinder(), layer);
}
if (result == NO_ERROR) {
addClientLayer(client, *handle, layer);
setTransactionFlags(eTransactionNeeded);
}
return surfaceHandle;
return result;
}
sp<Layer> SurfaceFlinger::createNormalLayer(
const sp<Client>& client,
uint32_t w, uint32_t h, uint32_t flags,
PixelFormat& format)
status_t SurfaceFlinger::createNormalLayer(const sp<Client>& client,
const String8& name, uint32_t w, uint32_t h, uint32_t flags, PixelFormat& format,
sp<IBinder>* handle, sp<IGraphicBufferProducer>* gbp, sp<Layer>* outLayer)
{
// initialize the surfaces
switch (format) {
@ -1987,21 +1987,25 @@ sp<Layer> SurfaceFlinger::createNormalLayer(
format = PIXEL_FORMAT_RGBA_8888;
#endif
sp<Layer> layer = new Layer(this, client);
status_t err = layer->setBuffers(w, h, format, flags);
if (CC_LIKELY(err != NO_ERROR)) {
ALOGE("createNormalLayer() failed (%s)", strerror(-err));
layer.clear();
*outLayer = new Layer(this, client, name, w, h, flags);
status_t err = (*outLayer)->setBuffers(w, h, format, flags);
if (err == NO_ERROR) {
*handle = (*outLayer)->getHandle();
*gbp = (*outLayer)->getBufferQueue();
}
return layer;
ALOGE_IF(err, "createNormalLayer() failed (%s)", strerror(-err));
return err;
}
sp<LayerDim> SurfaceFlinger::createDimLayer(
const sp<Client>& client,
uint32_t w, uint32_t h, uint32_t flags)
status_t SurfaceFlinger::createDimLayer(const sp<Client>& client,
const String8& name, uint32_t w, uint32_t h, uint32_t flags,
sp<IBinder>* handle, sp<IGraphicBufferProducer>* gbp, sp<Layer>* outLayer)
{
sp<LayerDim> layer = new LayerDim(this, client);
return layer;
*outLayer = new LayerDim(this, client, name, w, h, flags);
*handle = (*outLayer)->getHandle();
*gbp = (*outLayer)->getBufferQueue();
return NO_ERROR;
}
status_t SurfaceFlinger::onLayerRemoved(const sp<Client>& client, const sp<IBinder>& handle)
@ -2030,7 +2034,7 @@ status_t SurfaceFlinger::onLayerRemoved(const sp<Client>& client, const sp<IBind
status_t SurfaceFlinger::onLayerDestroyed(const wp<Layer>& layer)
{
// called by ~ISurface() when all references are gone
// called by ~LayerCleaner() when all references are gone
status_t err = NO_ERROR;
sp<Layer> l(layer.promote());
if (l != NULL) {

16
services/surfaceflinger/SurfaceFlinger.h
View File

@ -257,14 +257,18 @@ private:
/* ------------------------------------------------------------------------
* Layer management
*/
sp<ISurface> createLayer(const String8& name, const sp<Client>& client,
uint32_t w, uint32_t h, PixelFormat format, uint32_t flags);
status_t createLayer(const String8& name, const sp<Client>& client,
uint32_t w, uint32_t h, PixelFormat format, uint32_t flags,
sp<IBinder>* handle, sp<IGraphicBufferProducer>* gbp);
sp<Layer> createNormalLayer(const sp<Client>& client,
uint32_t w, uint32_t h, uint32_t flags, PixelFormat& format);
status_t createNormalLayer(const sp<Client>& client, const String8& name,
uint32_t w, uint32_t h, uint32_t flags, PixelFormat& format,
sp<IBinder>* outHandle, sp<IGraphicBufferProducer>* outGbp,
sp<Layer>* outLayer);
sp<LayerDim> createDimLayer(const sp<Client>& client,
uint32_t w, uint32_t h, uint32_t flags);
status_t createDimLayer(const sp<Client>& client, const String8& name,
uint32_t w, uint32_t h, uint32_t flags, sp<IBinder>* outHandle,
sp<IGraphicBufferProducer>* outGbp, sp<Layer>* outLayer);
// called in response to the window-manager calling
// ISurfaceComposerClient::destroySurface()