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

SurfaceFlinger cleanup

Browse Source 
mostly refactored SurfaceFlinger.h, but also removed dead code.
cleaned-up a few includes as well.

Change-Id: Ib15f4ffe567912b61ee98aa076c6a283b72811b5
This commit is contained in:
Mathias Agopian 2012-07-23 23:11:29 -07:00
parent 36b285eac9
commit 921e6ac4b7
14 changed files with 389 additions and 402 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
services/surfaceflinger/Client.cpp
View File

@ -22,6 +22,7 @@
#include <private/android_filesystem_config.h>
#include "Client.h"
#include "Layer.h"
#include "LayerBase.h"
#include "SurfaceFlinger.h"
@ -118,7 +119,7 @@ sp<ISurface> Client::createSurface(
* have access to the GL context.
*/
class MessageCreateSurface : public MessageBase {
class MessageCreateLayer : public MessageBase {
sp<ISurface> result;
SurfaceFlinger* flinger;
ISurfaceComposerClient::surface_data_t* params;
@ -129,7 +130,7 @@ sp<ISurface> Client::createSurface(
PixelFormat format;
uint32_t flags;
public:
MessageCreateSurface(SurfaceFlinger* flinger,
MessageCreateLayer(SurfaceFlinger* flinger,
ISurfaceComposerClient::surface_data_t* params,
const String8& name, Client* client,
DisplayID display, uint32_t w, uint32_t h, PixelFormat format,
@ -140,19 +141,19 @@ sp<ISurface> Client::createSurface(
}
sp<ISurface> getResult() const { return result; }
virtual bool handler() {
result = flinger->createSurface(params, name, client,
result = flinger->createLayer(params, name, client,
display, w, h, format, flags);
return true;
}
};
sp<MessageBase> msg = new MessageCreateSurface(mFlinger.get(),
sp<MessageBase> msg = new MessageCreateLayer(mFlinger.get(),
params, name, this, display, w, h, format, flags);
mFlinger->postMessageSync(msg);
return static_cast<MessageCreateSurface*>( msg.get() )->getResult();
return static_cast<MessageCreateLayer*>( msg.get() )->getResult();
}
status_t Client::destroySurface(SurfaceID sid) {
return mFlinger->removeSurface(this, sid);
return mFlinger->onLayerRemoved(this, sid);
}
// ---------------------------------------------------------------------------

3
services/surfaceflinger/DisplayHardware.cpp
View File

@ -40,6 +40,7 @@
#include "DisplayHardware.h"
#include "GLExtensions.h"
#include "SurfaceFlinger.h"
#include "LayerBase.h"
// ----------------------------------------------------------------------------
using namespace android;
@ -102,7 +103,7 @@ DisplayHardware::DisplayHardware(
int display,
const sp<SurfaceTextureClient>& surface,
EGLConfig config)
: DisplayHardwareBase(flinger, display),
: DisplayHardwareBase(display),
mFlinger(flinger),
mDisplayId(display),
mHwc(0),

16
services/surfaceflinger/DisplayHardware/DisplayHardwareBase.cpp
View File

@ -14,25 +14,15 @@
* limitations under the License.
*/
#include <errno.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <utils/Log.h>
#include <stdint.h>
#include <sys/types.h>
#include "DisplayHardware/DisplayHardwareBase.h"
#include "SurfaceFlinger.h"
// ----------------------------------------------------------------------------
namespace android {
DisplayHardwareBase::DisplayHardwareBase(const sp<SurfaceFlinger>& flinger,
uint32_t displayIndex)
{
DisplayHardwareBase::DisplayHardwareBase(uint32_t displayIndex) {
mScreenAcquired = true;
}

30
services/surfaceflinger/DisplayHardware/DisplayHardwareBase.h
View File

@ -18,25 +18,14 @@
#define ANDROID_DISPLAY_HARDWARE_BASE_H
#include <stdint.h>
#include <utils/RefBase.h>
#include <utils/StrongPointer.h>
#include <utils/threads.h>
namespace android {
class SurfaceFlinger;
class DisplayHardwareBase
{
class DisplayHardwareBase {
public:
DisplayHardwareBase(
const sp<SurfaceFlinger>& flinger,
uint32_t displayIndex);
DisplayHardwareBase(uint32_t displayIndex);
~DisplayHardwareBase();
void startSleepManagement() const;
// console management
void releaseScreen() const;
void acquireScreen() const;
@ -44,21 +33,8 @@ public:
bool canDraw() const;
private:
class DisplayEventThread : public Thread {
wp<SurfaceFlinger> mFlinger;
status_t waitForFbSleep();
status_t waitForFbWake();
public:
DisplayEventThread(const sp<SurfaceFlinger>& flinger);
virtual ~DisplayEventThread();
virtual bool threadLoop();
status_t initCheck() const;
};
sp<DisplayEventThread> mDisplayEventThread;
mutable int mScreenAcquired;
mutable int mScreenAcquired;
};
}; // namespace android

3
services/surfaceflinger/DisplayHardware/HWComposer.cpp
View File

@ -31,6 +31,8 @@
#include <utils/Trace.h>
#include <utils/Vector.h>
#include <ui/GraphicBuffer.h>
#include <hardware/hardware.h>
#include <hardware/hwcomposer.h>
@ -39,6 +41,7 @@
#include <EGL/egl.h>
#include "Layer.h" // needed only for debugging
#include "LayerBase.h"
#include "HWComposer.h"
#include "SurfaceFlinger.h"

8
services/surfaceflinger/DisplayHardware/HWComposer.h
View File

@ -24,7 +24,11 @@
#include <hardware/hwcomposer_defs.h>
#include <utils/Condition.h>
#include <utils/Mutex.h>
#include <utils/StrongPointer.h>
#include <utils/Thread.h>
#include <utils/Timers.h>
#include <utils/Vector.h>
extern "C" int clock_nanosleep(clockid_t clock_id, int flags,
@ -38,10 +42,10 @@ struct hwc_procs;
namespace android {
// ---------------------------------------------------------------------------
class GraphicBuffer;
class LayerBase;
class String8;
class SurfaceFlinger;
class LayerBase;
class GraphicBuffer;
class HWComposer
{

9
services/surfaceflinger/EventThread.cpp
View File

@ -24,6 +24,7 @@
#include <gui/DisplayEventReceiver.h>
#include <utils/Errors.h>
#include <utils/String8.h>
#include <utils/Trace.h>
#include "DisplayHardware.h"
@ -31,20 +32,16 @@
#include "SurfaceFlinger.h"
// ---------------------------------------------------------------------------
namespace android {
// ---------------------------------------------------------------------------
EventThread::EventThread(const sp<SurfaceFlinger>& flinger)
: mFlinger(flinger),
mHw(const_cast<DisplayHardware&>(flinger->getDefaultDisplayHardware())), // XXX: eventthread will need rework
: mHw(const_cast<DisplayHardware&>(flinger->getDefaultDisplayHardware())), // XXX: eventthread will need rework
mLastVSyncTimestamp(0),
mVSyncTimestamp(0),
mUseSoftwareVSync(false),
mDeliveredEvents(0),
mDebugVsyncEnabled(false)
{
mDebugVsyncEnabled(false) {
}
void EventThread::onFirstRef() {

4
services/surfaceflinger/EventThread.h
View File

@ -30,12 +30,11 @@
#include "DisplayHardware.h"
// ---------------------------------------------------------------------------
namespace android {
// ---------------------------------------------------------------------------
class SurfaceFlinger;
class String8;
// ---------------------------------------------------------------------------
@ -91,7 +90,6 @@ private:
void disableVSyncLocked();
// constants
sp<SurfaceFlinger> mFlinger;
DisplayHardware& mHw;
mutable Mutex mLock;

3
services/surfaceflinger/Layer.cpp
View File

@ -124,8 +124,7 @@ void Layer::onFirstRef()
Layer::~Layer()
{
mFlinger->postMessageAsync(
new SurfaceFlinger::MessageDestroyGLTexture(mTextureName) );
mFlinger->deleteTextureAsync(mTextureName);
}
void Layer::onFrameQueued() {

11
services/surfaceflinger/LayerBase.cpp
View File

@ -31,6 +31,7 @@
#include "clz.h"
#include "Client.h"
#include "LayerBase.h"
#include "Layer.h"
#include "SurfaceFlinger.h"
#include "DisplayHardware.h"
@ -438,6 +439,14 @@ void LayerBase::dumpStats(String8& result, char* scratch, size_t SIZE) const {
void LayerBase::clearStats() {
}
sp<LayerBaseClient> LayerBase::getLayerBaseClient() const {
return 0;
}
sp<Layer> LayerBase::getLayer() const {
return 0;
}
// ---------------------------------------------------------------------------
int32_t LayerBaseClient::sIdentity = 1;
@ -521,7 +530,7 @@ LayerBaseClient::LayerCleaner::LayerCleaner(const sp<SurfaceFlinger>& flinger,
LayerBaseClient::LayerCleaner::~LayerCleaner() {
// destroy client resources
mFlinger->destroySurface(mLayer);
mFlinger->onLayerDestroyed(mLayer);
}
// ---------------------------------------------------------------------------

4
services/surfaceflinger/LayerBase.h
View File

@ -125,8 +125,8 @@ public:
Rect computeBounds() const;
virtual sp<LayerBaseClient> getLayerBaseClient() const { return 0; }
virtual sp<Layer> getLayer() const { return 0; }
virtual sp<LayerBaseClient> getLayerBaseClient() const;
virtual sp<Layer> getLayer() const;
virtual const char* getTypeId() const { return "LayerBase"; }

7
services/surfaceflinger/LayerScreenshot.cpp
View File

@ -41,8 +41,7 @@ LayerScreenshot::LayerScreenshot(SurfaceFlinger* flinger, DisplayID display,
LayerScreenshot::~LayerScreenshot()
{
if (mTextureName) {
mFlinger->postMessageAsync(
new SurfaceFlinger::MessageDestroyGLTexture(mTextureName) );
mFlinger->deleteTextureAsync(mTextureName);
}
}
@ -85,8 +84,8 @@ void LayerScreenshot::initStates(uint32_t w, uint32_t h, uint32_t flags) {
uint32_t LayerScreenshot::doTransaction(uint32_t flags)
{
const Layer::State& draw(drawingState());
const Layer::State& curr(currentState());
const LayerBase::State& draw(drawingState());
const LayerBase::State& curr(currentState());
if (draw.flags & ISurfaceComposer::eLayerHidden) {
if (!(curr.flags & ISurfaceComposer::eLayerHidden)) {

139
services/surfaceflinger/SurfaceFlinger.cpp
View File

@ -16,17 +16,13 @@
#define ATRACE_TAG ATRACE_TAG_GRAPHICS
#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/types.h>
#include <errno.h>
#include <math.h>
#include <limits.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <EGL/egl.h>
#include <GLES/gl.h>
#include <cutils/log.h>
#include <cutils/properties.h>
@ -37,16 +33,19 @@
#include <binder/PermissionCache.h>
#include <gui/IDisplayEventConnection.h>
#include <gui/BitTube.h>
#include <gui/SurfaceTextureClient.h>
#include <ui/GraphicBufferAllocator.h>
#include <ui/PixelFormat.h>
#include <utils/String8.h>
#include <utils/String16.h>
#include <utils/StopWatch.h>
#include <utils/Trace.h>
#include <ui/GraphicBufferAllocator.h>
#include <ui/PixelFormat.h>
#include <GLES/gl.h>
#include <private/android_filesystem_config.h>
#include <private/gui/SharedBufferStack.h>
#include "clz.h"
#include "DdmConnection.h"
@ -62,10 +61,6 @@
#include "DisplayHardware/FramebufferSurface.h"
#include "DisplayHardware/HWComposer.h"
#include <private/android_filesystem_config.h>
#include <private/gui/SharedBufferStack.h>
#include <gui/BitTube.h>
#include <gui/SurfaceTextureClient.h>
#define EGL_VERSION_HW_ANDROID 0x3143
@ -100,11 +95,6 @@ SurfaceFlinger::SurfaceFlinger()
mLastTransactionTime(0),
mBootFinished(false),
mExternalDisplaySurface(EGL_NO_SURFACE)
{
init();
}
void SurfaceFlinger::init()
{
ALOGI("SurfaceFlinger is starting");
@ -192,7 +182,7 @@ void SurfaceFlinger::bootFinished()
const String16 name("window");
sp<IBinder> window(defaultServiceManager()->getService(name));
if (window != 0) {
window->linkToDeath(this);
window->linkToDeath(static_cast<IBinder::DeathRecipient*>(this));
}
// stop boot animation
@ -201,6 +191,21 @@ void SurfaceFlinger::bootFinished()
property_set("service.bootanim.exit", "1");
}
void SurfaceFlinger::deleteTextureAsync(GLuint texture) {
class MessageDestroyGLTexture : public MessageBase {
GLuint texture;
public:
MessageDestroyGLTexture(GLuint texture)
: texture(texture) {
}
virtual bool handler() {
glDeleteTextures(1, &texture);
return true;
}
};
postMessageAsync(new MessageDestroyGLTexture(texture));
}
status_t SurfaceFlinger::selectConfigForPixelFormat(
EGLDisplay dpy,
EGLint const* attrs,
@ -1250,30 +1255,15 @@ void SurfaceFlinger::drawWormhole() const
}
}
status_t SurfaceFlinger::addLayer(const sp<LayerBase>& layer)
{
Mutex::Autolock _l(mStateLock);
addLayer_l(layer);
setTransactionFlags(eTransactionNeeded|eTraversalNeeded);
return NO_ERROR;
}
status_t SurfaceFlinger::addLayer_l(const sp<LayerBase>& layer)
{
ssize_t i = mCurrentState.layersSortedByZ.add(layer);
return (i < 0) ? status_t(i) : status_t(NO_ERROR);
}
ssize_t SurfaceFlinger::addClientLayer(const sp<Client>& client,
const sp<LayerBaseClient>& lbc)
{
// attach this layer to the client
size_t name = client->attachLayer(lbc);
Mutex::Autolock _l(mStateLock);
// add this layer to the current state list
addLayer_l(lbc);
Mutex::Autolock _l(mStateLock);
mCurrentState.layersSortedByZ.add(lbc);
return ssize_t(name);
}
@ -1289,10 +1279,6 @@ status_t SurfaceFlinger::removeLayer(const sp<LayerBase>& layer)
status_t SurfaceFlinger::removeLayer_l(const sp<LayerBase>& layerBase)
{
sp<LayerBaseClient> lbc(layerBase->getLayerBaseClient());
if (lbc != 0) {
mLayerMap.removeItem( lbc->getSurfaceBinder() );
}
ssize_t index = mCurrentState.layersSortedByZ.remove(layerBase);
if (index >= 0) {
mLayersRemoved = true;
@ -1319,13 +1305,6 @@ status_t SurfaceFlinger::purgatorizeLayer_l(const sp<LayerBase>& layerBase)
return (err == NAME_NOT_FOUND) ? status_t(NO_ERROR) : err;
}
status_t SurfaceFlinger::invalidateLayerVisibility(const sp<LayerBase>& layer)
{
layer->forceVisibilityTransaction();
setTransactionFlags(eTraversalNeeded);
return NO_ERROR;
}
uint32_t SurfaceFlinger::peekTransactionFlags(uint32_t flags)
{
return android_atomic_release_load(&mTransactionFlags);
@ -1390,7 +1369,7 @@ void SurfaceFlinger::setTransactionState(const Vector<ComposerState>& state,
}
}
sp<ISurface> SurfaceFlinger::createSurface(
sp<ISurface> SurfaceFlinger::createLayer(
ISurfaceComposerClient::surface_data_t* params,
const String8& name,
const sp<Client>& client,
@ -1401,26 +1380,24 @@ sp<ISurface> SurfaceFlinger::createSurface(
sp<ISurface> surfaceHandle;
if (int32_t(w|h) < 0) {
ALOGE("createSurface() failed, w or h is negative (w=%d, h=%d)",
ALOGE("createLayer() failed, w or h is negative (w=%d, h=%d)",
int(w), int(h));
return surfaceHandle;
}
//ALOGD("createSurface for (%d x %d), name=%s", w, h, name.string());
sp<Layer> normalLayer;
//ALOGD("createLayer for (%d x %d), name=%s", w, h, name.string());
switch (flags & eFXSurfaceMask) {
case eFXSurfaceNormal:
normalLayer = createNormalSurface(client, d, w, h, flags, format);
layer = normalLayer;
layer = createNormalLayer(client, d, w, h, flags, format);
break;
case eFXSurfaceBlur:
// for now we treat Blur as Dim, until we can implement it
// efficiently.
case eFXSurfaceDim:
layer = createDimSurface(client, d, w, h, flags);
layer = createDimLayer(client, d, w, h, flags);
break;
case eFXSurfaceScreenshot:
layer = createScreenshotSurface(client, d, w, h, flags);
layer = createScreenshotLayer(client, d, w, h, flags);
break;
}
@ -1428,24 +1405,18 @@ sp<ISurface> SurfaceFlinger::createSurface(
layer->initStates(w, h, flags);
layer->setName(name);
ssize_t token = addClientLayer(client, layer);
surfaceHandle = layer->getSurface();
if (surfaceHandle != 0) {
params->token = token;
params->identity = layer->getIdentity();
if (normalLayer != 0) {
Mutex::Autolock _l(mStateLock);
mLayerMap.add(layer->getSurfaceBinder(), normalLayer);
}
}
setTransactionFlags(eTransactionNeeded);
}
return surfaceHandle;
}
sp<Layer> SurfaceFlinger::createNormalSurface(
sp<Layer> SurfaceFlinger::createNormalLayer(
const sp<Client>& client, DisplayID display,
uint32_t w, uint32_t h, uint32_t flags,
PixelFormat& format)
@ -1473,13 +1444,13 @@ sp<Layer> SurfaceFlinger::createNormalSurface(
sp<Layer> layer = new Layer(this, display, client);
status_t err = layer->setBuffers(w, h, format, flags);
if (CC_LIKELY(err != NO_ERROR)) {
ALOGE("createNormalSurfaceLocked() failed (%s)", strerror(-err));
ALOGE("createNormalLayer() failed (%s)", strerror(-err));
layer.clear();
}
return layer;
}
sp<LayerDim> SurfaceFlinger::createDimSurface(
sp<LayerDim> SurfaceFlinger::createDimLayer(
const sp<Client>& client, DisplayID display,
uint32_t w, uint32_t h, uint32_t flags)
{
@ -1487,7 +1458,7 @@ sp<LayerDim> SurfaceFlinger::createDimSurface(
return layer;
}
sp<LayerScreenshot> SurfaceFlinger::createScreenshotSurface(
sp<LayerScreenshot> SurfaceFlinger::createScreenshotLayer(
const sp<Client>& client, DisplayID display,
uint32_t w, uint32_t h, uint32_t flags)
{
@ -1495,7 +1466,7 @@ sp<LayerScreenshot> SurfaceFlinger::createScreenshotSurface(
return layer;
}
status_t SurfaceFlinger::removeSurface(const sp<Client>& client, SurfaceID sid)
status_t SurfaceFlinger::onLayerRemoved(const sp<Client>& client, SurfaceID sid)
{
/*
* called by the window manager, when a surface should be marked for
@ -1519,7 +1490,7 @@ status_t SurfaceFlinger::removeSurface(const sp<Client>& client, SurfaceID sid)
return err;
}
status_t SurfaceFlinger::destroySurface(const wp<LayerBaseClient>& layer)
status_t SurfaceFlinger::onLayerDestroyed(const wp<LayerBaseClient>& layer)
{
// called by ~ISurface() when all references are gone
status_t err = NO_ERROR;
@ -2731,12 +2702,30 @@ status_t SurfaceFlinger::captureScreen(DisplayID dpy,
// ---------------------------------------------------------------------------
sp<Layer> SurfaceFlinger::getLayer(const sp<ISurface>& sur) const
SurfaceFlinger::LayerVector::LayerVector() {
}
SurfaceFlinger::LayerVector::LayerVector(const LayerVector& rhs)
: SortedVector<sp<LayerBase> >(rhs) {
}
int SurfaceFlinger::LayerVector::do_compare(const void* lhs,
const void* rhs) const
{
sp<Layer> result;
Mutex::Autolock _l(mStateLock);
result = mLayerMap.valueFor( sur->asBinder() ).promote();
return result;
const sp<LayerBase>& l(*reinterpret_cast<const sp<LayerBase>*>(lhs));
const sp<LayerBase>& r(*reinterpret_cast<const sp<LayerBase>*>(rhs));
// sort layers by Z order
uint32_t lz = l->currentState().z;
uint32_t rz = r->currentState().z;
// then by sequence, so we get a stable ordering
return (lz != rz) ? (lz - rz) : (l->sequence - r->sequence);
}
// ---------------------------------------------------------------------------
SurfaceFlinger::State::State()
: orientation(ISurfaceComposer::eOrientationDefault),
orientationFlags(0) {
}
// ---------------------------------------------------------------------------

541
services/surfaceflinger/SurfaceFlinger.h
View File

@ -20,6 +20,9 @@
#include <stdint.h>
#include <sys/types.h>
#include <EGL/egl.h>
#include <GLES/gl.h>
#include <cutils/compiler.h>
#include <utils/Atomic.h>
@ -33,13 +36,14 @@
#include <binder/IMemory.h>
#include <ui/PixelFormat.h>
#include <gui/IGraphicBufferAlloc.h>
#include <gui/ISurfaceComposer.h>
#include <gui/ISurfaceComposerClient.h>
#include "Barrier.h"
#include "Layer.h"
#include <private/gui/LayerState.h>
#include "Barrier.h"
#include "MessageQueue.h"
namespace android {
@ -47,18 +51,20 @@ namespace android {
// ---------------------------------------------------------------------------
class Client;
class DisplayHardware;
class DisplayEventConnection;
class DisplayHardware;
class EventThread;
class Layer;
class LayerBase;
class LayerBaseClient;
class LayerDim;
class LayerScreenshot;
class SurfaceTextureClient;
struct surface_flinger_cblk_t;
// ---------------------------------------------------------------------------
class GraphicBufferAlloc : public BnGraphicBufferAlloc
{
class GraphicBufferAlloc : public BnGraphicBufferAlloc {
public:
GraphicBufferAlloc();
virtual ~GraphicBufferAlloc();
@ -69,102 +75,52 @@ public:
// ---------------------------------------------------------------------------
enum {
eTransactionNeeded = 0x01,
eTraversalNeeded = 0x02
eTransactionNeeded = 0x01, eTraversalNeeded = 0x02
};
class SurfaceFlinger :
public BinderService<SurfaceFlinger>,
public BnSurfaceComposer,
public IBinder::DeathRecipient,
protected Thread
class SurfaceFlinger : public BinderService<SurfaceFlinger>,
public BnSurfaceComposer,
private IBinder::DeathRecipient,
private Thread
{
public:
static char const* getServiceName() { return "SurfaceFlinger"; }
static char const* getServiceName() {
return "SurfaceFlinger";
}
SurfaceFlinger();
virtual ~SurfaceFlinger();
void init();
SurfaceFlinger();
virtual status_t onTransact(
uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags);
// post an asynchronous message to the main thread
status_t postMessageAsync(const sp<MessageBase>& msg, nsecs_t reltime = 0,
uint32_t flags = 0);
virtual status_t dump(int fd, const Vector<String16>& args);
// post a synchronous message to the main thread
status_t postMessageSync(const sp<MessageBase>& msg, nsecs_t reltime = 0,
uint32_t flags = 0);
// ISurfaceComposer interface
virtual sp<ISurfaceComposerClient> createConnection();
virtual sp<IGraphicBufferAlloc> createGraphicBufferAlloc();
virtual sp<IMemoryHeap> getCblk() const;
virtual void bootFinished();
virtual void setTransactionState(const Vector<ComposerState>& state,
int orientation, uint32_t flags);
virtual bool authenticateSurfaceTexture(const sp<ISurfaceTexture>& surface) const;
virtual sp<IDisplayEventConnection> createDisplayEventConnection();
// force full composition on all displays
void repaintEverything();
virtual status_t captureScreen(DisplayID dpy,
sp<IMemoryHeap>* heap,
uint32_t* width, uint32_t* height,
PixelFormat* format, uint32_t reqWidth, uint32_t reqHeight,
uint32_t minLayerZ, uint32_t maxLayerZ);
// renders content on given display to a texture. thread-safe version.
status_t renderScreenToTexture(DisplayID dpy, GLuint* textureName,
GLfloat* uOut, GLfloat* vOut);
virtual status_t turnElectronBeamOff(int32_t mode);
virtual status_t turnElectronBeamOn(int32_t mode);
// renders content on given display to a texture, w/o acquiring main lock
status_t renderScreenToTextureLocked(DisplayID dpy, GLuint* textureName,
GLfloat* uOut, GLfloat* vOut);
// called when screen needs to turn off
virtual void blank();
// called when screen is turning back on
virtual void unblank();
// returns the default Display
const DisplayHardware& getDefaultDisplayHardware() const {
return getDisplayHardware(0);
}
virtual void connectDisplay(const sp<ISurfaceTexture> display);
// called on the main thread by MessageQueue when an internal message
// is received
// TODO: this should be made accessible only to MessageQueue
void onMessageReceived(int32_t what);
// called on the main thread in response to screenReleased()
void onScreenReleased();
// called on the main thread in response to screenAcquired()
void onScreenAcquired();
status_t renderScreenToTexture(DisplayID dpy,
GLuint* textureName, GLfloat* uOut, GLfloat* vOut);
status_t renderScreenToTextureLocked(DisplayID dpy,
GLuint* textureName, GLfloat* uOut, GLfloat* vOut);
void onMessageReceived(int32_t what);
void handleMessageTransaction();
void handleMessageInvalidate();
void handleMessageRefresh();
status_t postMessageAsync(const sp<MessageBase>& msg,
nsecs_t reltime=0, uint32_t flags = 0);
status_t postMessageSync(const sp<MessageBase>& msg,
nsecs_t reltime=0, uint32_t flags = 0);
status_t removeLayer(const sp<LayerBase>& layer);
status_t addLayer(const sp<LayerBase>& layer);
status_t invalidateLayerVisibility(const sp<LayerBase>& layer);
void invalidateHwcGeometry();
sp<Layer> getLayer(const sp<ISurface>& sur) const;
GLuint getProtectedTexName() const { return mProtectedTexName; }
surface_flinger_cblk_t* getControlBlock() const;
class MessageDestroyGLTexture : public MessageBase {
GLuint texture;
public:
MessageDestroyGLTexture(GLuint texture) : texture(texture) { }
virtual bool handler() {
glDeleteTextures(1, &texture);
return true;
}
};
private:
// DeathRecipient interface
virtual void binderDied(const wp<IBinder>& who);
// utility function to delete a texture on the main thread
void deleteTextureAsync(GLuint texture);
private:
friend class Client;
@ -173,219 +129,284 @@ private:
friend class LayerBaseClient;
friend class Layer;
sp<ISurface> createSurface(
ISurfaceComposerClient::surface_data_t* params,
const String8& name,
const sp<Client>& client,
DisplayID display, uint32_t w, uint32_t h, PixelFormat format,
uint32_t flags);
// We're reference counted, never destroy SurfaceFlinger directly
virtual ~SurfaceFlinger();
sp<Layer> createNormalSurface(
const sp<Client>& client, DisplayID display,
uint32_t w, uint32_t h, uint32_t flags,
PixelFormat& format);
/* ------------------------------------------------------------------------
* Internal data structures
*/
sp<LayerDim> createDimSurface(
const sp<Client>& client, DisplayID display,
uint32_t w, uint32_t h, uint32_t flags);
sp<LayerScreenshot> createScreenshotSurface(
const sp<Client>& client, DisplayID display,
uint32_t w, uint32_t h, uint32_t flags);
status_t removeSurface(const sp<Client>& client, SurfaceID sid);
status_t destroySurface(const wp<LayerBaseClient>& layer);
uint32_t setClientStateLocked(const sp<Client>& client, const layer_state_t& s);
class LayerVector : public SortedVector< sp<LayerBase> > {
class LayerVector : public SortedVector<sp<LayerBase> > {
public:
LayerVector() { }
LayerVector(const LayerVector& rhs) : SortedVector< sp<LayerBase> >(rhs) { }
virtual int do_compare(const void* lhs, const void* rhs) const {
const sp<LayerBase>& l(*reinterpret_cast<const sp<LayerBase>*>(lhs));
const sp<LayerBase>& r(*reinterpret_cast<const sp<LayerBase>*>(rhs));
// sort layers by Z order
uint32_t lz = l->currentState().z;
uint32_t rz = r->currentState().z;
// then by sequence, so we get a stable ordering
return (lz != rz) ? (lz - rz) : (l->sequence - r->sequence);
}
LayerVector();
LayerVector(const LayerVector& rhs);
virtual int do_compare(const void* lhs, const void* rhs) const;
};
struct State {
State()
: orientation(ISurfaceComposer::eOrientationDefault),
orientationFlags(0) {
}
LayerVector layersSortedByZ;
uint8_t orientation;
uint8_t orientationFlags;
State();
LayerVector layersSortedByZ;
uint8_t orientation;
uint8_t orientationFlags;
};
virtual bool threadLoop();
virtual status_t readyToRun();
virtual void onFirstRef();
/* ------------------------------------------------------------------------
* IBinder interface
*/
virtual status_t onTransact(uint32_t code, const Parcel& data,
Parcel* reply, uint32_t flags);
virtual status_t dump(int fd, const Vector<String16>& args);
public: // hack to work around gcc 4.0.3 bug
/* ------------------------------------------------------------------------
* ISurfaceComposer interface
*/
virtual sp<ISurfaceComposerClient> createConnection();
virtual sp<IGraphicBufferAlloc> createGraphicBufferAlloc();
virtual sp<IMemoryHeap> getCblk() const;
virtual void bootFinished();
virtual void setTransactionState(const Vector<ComposerState>& state,
int orientation, uint32_t flags);
virtual bool authenticateSurfaceTexture(
const sp<ISurfaceTexture>& surface) const;
virtual sp<IDisplayEventConnection> createDisplayEventConnection();
virtual status_t captureScreen(DisplayID dpy, sp<IMemoryHeap>* heap,
uint32_t* width, uint32_t* height, PixelFormat* format,
uint32_t reqWidth, uint32_t reqHeight, uint32_t minLayerZ,
uint32_t maxLayerZ);
virtual status_t turnElectronBeamOff(int32_t mode);
virtual status_t turnElectronBeamOn(int32_t mode);
// called when screen needs to turn off
virtual void blank();
// called when screen is turning back on
virtual void unblank();
virtual void connectDisplay(const sp<ISurfaceTexture> display);
const DisplayHardware& getDisplayHardware(DisplayID dpy) const {
return *mDisplayHardwares[dpy];
}
const DisplayHardware& getDefaultDisplayHardware() const {
return getDisplayHardware(0);
}
/* ------------------------------------------------------------------------
* DeathRecipient interface
*/
virtual void binderDied(const wp<IBinder>& who);
void signalTransaction();
void signalLayerUpdate();
void signalRefresh();
void repaintEverything();
/* ------------------------------------------------------------------------
* Thread interface
*/
virtual bool threadLoop();
virtual status_t readyToRun();
virtual void onFirstRef();
private:
void waitForEvent();
Region handleTransaction(uint32_t transactionFlags);
Region handleTransactionLocked(uint32_t transactionFlags);
/* ------------------------------------------------------------------------
* Message handling
*/
void waitForEvent();
void signalTransaction();
void signalLayerUpdate();
void signalRefresh();
void computeVisibleRegions(
const LayerVector& currentLayers,
Region& dirtyRegion,
Region& wormholeRegion);
// called on the main thread in response to screenReleased()
void onScreenReleased();
// called on the main thread in response to screenAcquired()
void onScreenAcquired();
/* handlePageFilp: this is were we latch a new buffer
* if available and compute the dirty region.
* The return value is the dirty region expressed in the
* window manager's coordinate space (or the layer's state
* space, which is the same thing), in particular the dirty
* region is independent from a specific display's orientation.
*/
Region handlePageFlip();
void handleMessageTransaction();
void handleMessageInvalidate();
void handleMessageRefresh();
void handleRefresh();
void handleWorkList(const DisplayHardware& hw);
void handleRepaint(const DisplayHardware& hw);
void postFramebuffer();
void setupHardwareComposer(const DisplayHardware& hw);
void composeSurfaces(const DisplayHardware& hw, const Region& dirty);
Region handleTransaction(uint32_t transactionFlags);
Region handleTransactionLocked(uint32_t transactionFlags);
/* handlePageFilp: this is were we latch a new buffer
* if available and compute the dirty region.
* The return value is the dirty region expressed in the
* window manager's coordinate space (or the layer's state
* space, which is the same thing), in particular the dirty
* region is independent from a specific display's orientation.
*/
Region handlePageFlip();
void setInvalidateRegion(const Region& reg);
Region getAndClearInvalidateRegion();
void handleRefresh();
void handleWorkList(const DisplayHardware& hw);
void handleRepaint(const DisplayHardware& hw);
ssize_t addClientLayer(const sp<Client>& client,
const sp<LayerBaseClient>& lbc);
status_t addLayer_l(const sp<LayerBase>& layer);
status_t removeLayer_l(const sp<LayerBase>& layer);
status_t purgatorizeLayer_l(const sp<LayerBase>& layer);
/* ------------------------------------------------------------------------
* Transactions
*/
uint32_t getTransactionFlags(uint32_t flags);
uint32_t peekTransactionFlags(uint32_t flags);
uint32_t setTransactionFlags(uint32_t flags);
void commitTransaction();
uint32_t setClientStateLocked(const sp<Client>& client,
const layer_state_t& s);
uint32_t getTransactionFlags(uint32_t flags);
uint32_t peekTransactionFlags(uint32_t flags);
uint32_t setTransactionFlags(uint32_t flags);
void commitTransaction();
/* ------------------------------------------------------------------------
* Layer management
*/
sp<ISurface> createLayer(ISurfaceComposerClient::surface_data_t* params,
const String8& name, const sp<Client>& client, DisplayID display,
uint32_t w, uint32_t h, PixelFormat format, uint32_t flags);
sp<Layer> createNormalLayer(const sp<Client>& client, DisplayID display,
uint32_t w, uint32_t h, uint32_t flags, PixelFormat& format);
status_t captureScreenImplLocked(DisplayID dpy,
sp<IMemoryHeap>* heap,
uint32_t* width, uint32_t* height, PixelFormat* format,
uint32_t reqWidth, uint32_t reqHeight,
uint32_t minLayerZ, uint32_t maxLayerZ);
sp<LayerDim> createDimLayer(const sp<Client>& client, DisplayID display,
uint32_t w, uint32_t h, uint32_t flags);
status_t turnElectronBeamOffImplLocked(int32_t mode);
status_t turnElectronBeamOnImplLocked(int32_t mode);
status_t electronBeamOffAnimationImplLocked();
status_t electronBeamOnAnimationImplLocked();
sp<LayerScreenshot> createScreenshotLayer(const sp<Client>& client,
DisplayID display, uint32_t w, uint32_t h, uint32_t flags);
void debugFlashRegions(const DisplayHardware& hw);
void drawWormhole() const;
// called in response to the window-manager calling
// ISurfaceComposerClient::destroySurface()
// The specified layer is first placed in a purgatory list
// until all references from the client are released.
status_t onLayerRemoved(const sp<Client>& client, SurfaceID sid);
uint32_t getMaxTextureSize() const;
uint32_t getMaxViewportDims() const;
// called when all clients have released all their references to
// this layer meaning it is entirely safe to destroy all
// resources associated to this layer.
status_t onLayerDestroyed(const wp<LayerBaseClient>& layer);
static status_t selectConfigForPixelFormat(
EGLDisplay dpy,
EGLint const* attrs,
PixelFormat format,
EGLConfig* outConfig);
static EGLConfig selectEGLConfig(EGLDisplay disp, EGLint visualId);
static EGLContext createGLContext(EGLDisplay disp, EGLConfig config);
void initializeGL(EGLDisplay display, EGLSurface surface);
// remove a layer from SurfaceFlinger immediately
status_t removeLayer(const sp<LayerBase>& layer);
void startBootAnim();
// add a layer to SurfaceFlinger
ssize_t addClientLayer(const sp<Client>& client,
const sp<LayerBaseClient>& lbc);
void listLayersLocked(const Vector<String16>& args, size_t& index,
String8& result, char* buffer, size_t SIZE) const;
void dumpStatsLocked(const Vector<String16>& args, size_t& index,
String8& result, char* buffer, size_t SIZE) const;
void clearStatsLocked(const Vector<String16>& args, size_t& index,
String8& result, char* buffer, size_t SIZE) const;
void dumpAllLocked(String8& result, char* buffer, size_t SIZE) const;
status_t removeLayer_l(const sp<LayerBase>& layer);
status_t purgatorizeLayer_l(const sp<LayerBase>& layer);
mutable MessageQueue mEventQueue;
/* ------------------------------------------------------------------------
* Boot animation, on/off animations and screen capture
*/
// access must be protected by mStateLock
mutable Mutex mStateLock;
State mCurrentState;
volatile int32_t mTransactionFlags;
Condition mTransactionCV;
SortedVector< sp<LayerBase> > mLayerPurgatory;
bool mTransationPending;
Vector< sp<LayerBase> > mLayersPendingRemoval;
void startBootAnim();
// protected by mStateLock (but we could use another lock)
DisplayHardware* mDisplayHardwares[1];
bool mLayersRemoved;
DefaultKeyedVector< wp<IBinder>, wp<Layer> > mLayerMap;
status_t captureScreenImplLocked(DisplayID dpy, sp<IMemoryHeap>* heap,
uint32_t* width, uint32_t* height, PixelFormat* format,
uint32_t reqWidth, uint32_t reqHeight, uint32_t minLayerZ,
uint32_t maxLayerZ);
// access must be protected by mInvalidateLock
mutable Mutex mInvalidateLock;
Region mInvalidateRegion;
status_t turnElectronBeamOffImplLocked(int32_t mode);
status_t turnElectronBeamOnImplLocked(int32_t mode);
status_t electronBeamOffAnimationImplLocked();
status_t electronBeamOnAnimationImplLocked();
// constant members (no synchronization needed for access)
sp<IMemoryHeap> mServerHeap;
surface_flinger_cblk_t* mServerCblk;
GLuint mWormholeTexName;
GLuint mProtectedTexName;
nsecs_t mBootTime;
sp<EventThread> mEventThread;
GLint mMaxViewportDims[2];
GLint mMaxTextureSize;
EGLContext mEGLContext;
EGLConfig mEGLConfig;
/* ------------------------------------------------------------------------
* EGL
*/
static status_t selectConfigForPixelFormat(EGLDisplay dpy,
EGLint const* attrs, PixelFormat format, EGLConfig* outConfig);
static EGLConfig selectEGLConfig(EGLDisplay disp, EGLint visualId);
static EGLContext createGLContext(EGLDisplay disp, EGLConfig config);
void initializeGL(EGLDisplay display, EGLSurface surface);
uint32_t getMaxTextureSize() const;
uint32_t getMaxViewportDims() const;
/* ------------------------------------------------------------------------
* Display management
*/
const DisplayHardware& getDisplayHardware(DisplayID dpy) const {
return *mDisplayHardwares[dpy];
}
// Can only accessed from the main thread, these members
// don't need synchronization
State mDrawingState;
Region mDirtyRegion;
Region mDirtyRegionRemovedLayer;
Region mSwapRegion;
Region mWormholeRegion;
bool mVisibleRegionsDirty;
bool mHwWorkListDirty;
int32_t mElectronBeamAnimationMode;
/* ------------------------------------------------------------------------
* Compositing
*/
void invalidateHwcGeometry();
void computeVisibleRegions(const LayerVector& currentLayers,
Region& dirtyRegion, Region& wormholeRegion);
void postFramebuffer();
void setupHardwareComposer(const DisplayHardware& hw);
void composeSurfaces(const DisplayHardware& hw, const Region& dirty);
void setInvalidateRegion(const Region& reg);
Region getAndClearInvalidateRegion();
void drawWormhole() const;
GLuint getProtectedTexName() const {
return mProtectedTexName;
}
/* ------------------------------------------------------------------------
* Debugging & dumpsys
*/
void debugFlashRegions(const DisplayHardware& hw);
void listLayersLocked(const Vector<String16>& args, size_t& index,
String8& result, char* buffer, size_t SIZE) const;
void dumpStatsLocked(const Vector<String16>& args, size_t& index,
String8& result, char* buffer, size_t SIZE) const;
void clearStatsLocked(const Vector<String16>& args, size_t& index,
String8& result, char* buffer, size_t SIZE) const;
void dumpAllLocked(String8& result, char* buffer, size_t SIZE) const;
// don't use a lock for these, we don't care
int mDebugRegion;
int mDebugDDMS;
int mDebugDisableHWC;
int mDebugDisableTransformHint;
volatile nsecs_t mDebugInSwapBuffers;
nsecs_t mLastSwapBufferTime;
volatile nsecs_t mDebugInTransaction;
nsecs_t mLastTransactionTime;
bool mBootFinished;
/* ------------------------------------------------------------------------
* Attributes
*/
// these are thread safe
mutable Barrier mReadyToRunBarrier;
// access must be protected by mStateLock
mutable Mutex mStateLock;
State mCurrentState;
volatile int32_t mTransactionFlags;
Condition mTransactionCV;
SortedVector<sp<LayerBase> > mLayerPurgatory;
bool mTransationPending;
Vector<sp<LayerBase> > mLayersPendingRemoval;
// protected by mStateLock (but we could use another lock)
DisplayHardware* mDisplayHardwares[1];
bool mLayersRemoved;
// protected by mDestroyedLayerLock;
mutable Mutex mDestroyedLayerLock;
Vector<LayerBase const *> mDestroyedLayers;
// access must be protected by mInvalidateLock
mutable Mutex mInvalidateLock;
Region mInvalidateRegion;
// constant members (no synchronization needed for access)
sp<IMemoryHeap> mServerHeap;
surface_flinger_cblk_t* mServerCblk;
GLuint mWormholeTexName;
GLuint mProtectedTexName;
nsecs_t mBootTime;
sp<EventThread> mEventThread;
GLint mMaxViewportDims[2];
GLint mMaxTextureSize;
EGLContext mEGLContext;
EGLConfig mEGLConfig;
EGLSurface getExternalDisplaySurface() const;
sp<SurfaceTextureClient> mExternalDisplayNativeWindow;
EGLSurface mExternalDisplaySurface;
// Can only accessed from the main thread, these members
// don't need synchronization
State mDrawingState;
Region mDirtyRegion;
Region mDirtyRegionRemovedLayer;
Region mSwapRegion;
Region mWormholeRegion;
bool mVisibleRegionsDirty;
bool mHwWorkListDirty;
int32_t mElectronBeamAnimationMode;
// don't use a lock for these, we don't care
int mDebugRegion;
int mDebugDDMS;
int mDebugDisableHWC;
int mDebugDisableTransformHint;
volatile nsecs_t mDebugInSwapBuffers;
nsecs_t mLastSwapBufferTime;
volatile nsecs_t mDebugInTransaction;
nsecs_t mLastTransactionTime;
bool mBootFinished;
// these are thread safe
mutable MessageQueue mEventQueue;
mutable Barrier mReadyToRunBarrier;
// protected by mDestroyedLayerLock;
mutable Mutex mDestroyedLayerLock;
Vector<LayerBase const *> mDestroyedLayers;
/* ------------------------------------------------------------------------
* Feature prototyping
*/
EGLSurface getExternalDisplaySurface() const;
sp<SurfaceTextureClient> mExternalDisplayNativeWindow;
EGLSurface mExternalDisplaySurface;
public:
surface_flinger_cblk_t* getControlBlock() const;
};
// ---------------------------------------------------------------------------