ADHOC/replicant-frameworks_native
3
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
34cd567e40
replicant-frameworks_native/libs/surfaceflinger/Layer.h

132 lines
4.1 KiB
C
Raw Normal View History

auto import from //depot/cupcake/@135843
2009-03-04 03:31:44 +00:00
/*
* Copyright (C) 2007 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ANDROID_LAYER_H
#define ANDROID_LAYER_H
#include <stdint.h>
#include <sys/types.h>
fix [2167050] glTexImage2D code path buggy in SurfaceFlinger When EGLImage extension is not available, SurfaceFlinger will fallback to using glTexImage2D and glTexSubImage2D instead, which requires 50% more memory and an extra copy. However this code path has never been exercised and had some bugs which this patch fix. Mainly the scale factor wasn't computed right when falling back on glDrawElements. We also fallback to this mode of operation if a buffer doesn't have the adequate usage bits for EGLImage usage. This changes only code that is currently not executed. Some refactoring was needed to keep the change clean. This doesn't change anything functionaly.
2009-10-06 00:07:12 +00:00
#include <ui/GraphicBuffer.h>
auto import from //depot/cupcake/@135843
2009-03-04 03:31:44 +00:00
#include <ui/PixelFormat.h>
#include <pixelflinger/pixelflinger.h>
Integrate from //sandbox/mathias/donut/...@145728 SurfaceFlinger rework for new EGL driver model support.
2009-04-10 21:24:30 +00:00
#include <EGL/egl.h>
#include <EGL/eglext.h>
#include <GLES/gl.h>
#include <GLES/glext.h>
auto import from //depot/cupcake/@135843
2009-03-04 03:31:44 +00:00
#include "LayerBase.h"
#include "Transform.h"
namespace android {
// ---------------------------------------------------------------------------
class Client;
class FreezeLock;
// ---------------------------------------------------------------------------
fix [2068105] implement queueBuffer/lockBuffer/dequeueBuffer properly Rewrote SurfaceFlinger's buffer management from the ground-up. The design now support an arbitrary number of buffers per surface, however the current implementation is limited to four. Currently only 2 buffers are used in practice. The main new feature is to be able to dequeue all buffers at once (very important when there are only two). A client can dequeue all buffers until there are none available, it can lock all buffers except the last one that is used for composition. The client will block then, until a new buffer is enqueued. The current implementation requires that buffers are locked in the same order they are dequeued and enqueued in the same order they are locked. Only one buffer can be locked at a time. eg. Allowed sequence: DQ, DQ, LOCK, Q, LOCK, Q eg. Forbidden sequence: DQ, DQ, LOCK, LOCK, Q, Q
2009-09-07 23:32:45 +00:00
const size_t NUM_BUFFERS = 2;
Integrate from //sandbox/mathias/donut/...@145728 SurfaceFlinger rework for new EGL driver model support.
2009-04-10 21:24:30 +00:00
auto import from //depot/cupcake/@135843
2009-03-04 03:31:44 +00:00
class Layer : public LayerBaseClient
{
public:
static const uint32_t typeInfo;
static const char* const typeID;
virtual char const* getTypeID() const { return typeID; }
virtual uint32_t getTypeInfo() const { return typeInfo; }
fix [2068105] implement queueBuffer/lockBuffer/dequeueBuffer properly Rewrote SurfaceFlinger's buffer management from the ground-up. The design now support an arbitrary number of buffers per surface, however the current implementation is limited to four. Currently only 2 buffers are used in practice. The main new feature is to be able to dequeue all buffers at once (very important when there are only two). A client can dequeue all buffers until there are none available, it can lock all buffers except the last one that is used for composition. The client will block then, until a new buffer is enqueued. The current implementation requires that buffers are locked in the same order they are dequeued and enqueued in the same order they are locked. Only one buffer can be locked at a time. eg. Allowed sequence: DQ, DQ, LOCK, Q, LOCK, Q eg. Forbidden sequence: DQ, DQ, LOCK, LOCK, Q, Q
2009-09-07 23:32:45 +00:00
auto import from //depot/cupcake/@135843
2009-03-04 03:31:44 +00:00
Layer(SurfaceFlinger* flinger, DisplayID display,
fix a memory corruption where a SF Client could be used after it's been destroyed
2009-06-20 00:00:27 +00:00
const sp<Client>& client, int32_t i);
auto import from //depot/cupcake/@135843
2009-03-04 03:31:44 +00:00
virtual ~Layer();
fix [2068105] implement queueBuffer/lockBuffer/dequeueBuffer properly Rewrote SurfaceFlinger's buffer management from the ground-up. The design now support an arbitrary number of buffers per surface, however the current implementation is limited to four. Currently only 2 buffers are used in practice. The main new feature is to be able to dequeue all buffers at once (very important when there are only two). A client can dequeue all buffers until there are none available, it can lock all buffers except the last one that is used for composition. The client will block then, until a new buffer is enqueued. The current implementation requires that buffers are locked in the same order they are dequeued and enqueued in the same order they are locked. Only one buffer can be locked at a time. eg. Allowed sequence: DQ, DQ, LOCK, Q, LOCK, Q eg. Forbidden sequence: DQ, DQ, LOCK, LOCK, Q, Q
2009-09-07 23:32:45 +00:00
status_t setBuffers(uint32_t w, uint32_t h,
PixelFormat format, uint32_t flags=0);
auto import from //depot/cupcake/@135843
2009-03-04 03:31:44 +00:00
fix [2068105] implement queueBuffer/lockBuffer/dequeueBuffer properly Rewrote SurfaceFlinger's buffer management from the ground-up. The design now support an arbitrary number of buffers per surface, however the current implementation is limited to four. Currently only 2 buffers are used in practice. The main new feature is to be able to dequeue all buffers at once (very important when there are only two). A client can dequeue all buffers until there are none available, it can lock all buffers except the last one that is used for composition. The client will block then, until a new buffer is enqueued. The current implementation requires that buffers are locked in the same order they are dequeued and enqueued in the same order they are locked. Only one buffer can be locked at a time. eg. Allowed sequence: DQ, DQ, LOCK, Q, LOCK, Q eg. Forbidden sequence: DQ, DQ, LOCK, LOCK, Q, Q
2009-09-07 23:32:45 +00:00
void setDrawingSize(uint32_t w, uint32_t h);
auto import from //depot/cupcake/@135843
2009-03-04 03:31:44 +00:00
virtual void onDraw(const Region& clip) const;
virtual uint32_t doTransaction(uint32_t transactionFlags);
virtual void lockPageFlip(bool& recomputeVisibleRegions);
virtual void unlockPageFlip(const Transform& planeTransform, Region& outDirtyRegion);
virtual void finishPageFlip();
virtual bool needsBlending() const { return mNeedsBlending; }
turn dithering off if it's not needed
2009-09-24 02:16:27 +00:00
virtual bool needsDithering() const { return mNeedsDithering; }
auto import from //depot/cupcake/@135843
2009-03-04 03:31:44 +00:00
virtual bool isSecure() const { return mSecure; }
Integrate from //sandbox/mathias/donut/...@145728 SurfaceFlinger rework for new EGL driver model support.
2009-04-10 21:24:30 +00:00
virtual sp<Surface> createSurface() const;
more Surface lifetime management Surfaces are now destroyed once all references from the clients are gone, but they go through a partial destruction as soon as the window manager requests it. This last part is still buggy. see comments in SurfaceFlinger::destroySurface()
2009-04-18 02:36:26 +00:00
virtual status_t ditch();
fix [2068105] implement queueBuffer/lockBuffer/dequeueBuffer properly Rewrote SurfaceFlinger's buffer management from the ground-up. The design now support an arbitrary number of buffers per surface, however the current implementation is limited to four. Currently only 2 buffers are used in practice. The main new feature is to be able to dequeue all buffers at once (very important when there are only two). A client can dequeue all buffers until there are none available, it can lock all buffers except the last one that is used for composition. The client will block then, until a new buffer is enqueued. The current implementation requires that buffers are locked in the same order they are dequeued and enqueued in the same order they are locked. Only one buffer can be locked at a time. eg. Allowed sequence: DQ, DQ, LOCK, Q, LOCK, Q eg. Forbidden sequence: DQ, DQ, LOCK, LOCK, Q, Q
2009-09-07 23:32:45 +00:00
auto import from //depot/cupcake/@135843
2009-03-04 03:31:44 +00:00
// only for debugging
fix [2167050] glTexImage2D code path buggy in SurfaceFlinger When EGLImage extension is not available, SurfaceFlinger will fallback to using glTexImage2D and glTexSubImage2D instead, which requires 50% more memory and an extra copy. However this code path has never been exercised and had some bugs which this patch fix. Mainly the scale factor wasn't computed right when falling back on glDrawElements. We also fallback to this mode of operation if a buffer doesn't have the adequate usage bits for EGLImage usage. This changes only code that is currently not executed. Some refactoring was needed to keep the change clean. This doesn't change anything functionaly.
2009-10-06 00:07:12 +00:00
inline sp<GraphicBuffer> getBuffer(int i) { return mBuffers[i]; }
fix [2068105] implement queueBuffer/lockBuffer/dequeueBuffer properly Rewrote SurfaceFlinger's buffer management from the ground-up. The design now support an arbitrary number of buffers per surface, however the current implementation is limited to four. Currently only 2 buffers are used in practice. The main new feature is to be able to dequeue all buffers at once (very important when there are only two). A client can dequeue all buffers until there are none available, it can lock all buffers except the last one that is used for composition. The client will block then, until a new buffer is enqueued. The current implementation requires that buffers are locked in the same order they are dequeued and enqueued in the same order they are locked. Only one buffer can be locked at a time. eg. Allowed sequence: DQ, DQ, LOCK, Q, LOCK, Q eg. Forbidden sequence: DQ, DQ, LOCK, LOCK, Q, Q
2009-09-07 23:32:45 +00:00
// only for debugging
inline const sp<FreezeLock>& getFreezeLock() const { return mFreezeLock; }
// only for debugging
inline PixelFormat pixelFormat() const { return mFormat; }
auto import from //depot/cupcake/@135843
2009-03-04 03:31:44 +00:00
private:
fix [2152536] ANR in browser A window is created and the browser is about to render into it the very first time, at that point it does an IPC to SF to request a new buffer. Meanwhile, the window manager removes that window from the list and the shared memory block it uses is marked as invalid. However, at that point, another window is created and is given the same index (that just go freed), but a different identity and resets the "invalid" bit in the shared block. When we go back to the buffer allocation code, we're stuck because the surface we're allocating for is gone and we don't detect it's invalid because the invalid bit has been reset. It is not sufficient to check for the invalid bit, I should also check that identities match.
2009-10-07 02:00:57 +00:00
inline sp<GraphicBuffer> getFrontBufferLocked() {
fix [2068105] implement queueBuffer/lockBuffer/dequeueBuffer properly Rewrote SurfaceFlinger's buffer management from the ground-up. The design now support an arbitrary number of buffers per surface, however the current implementation is limited to four. Currently only 2 buffers are used in practice. The main new feature is to be able to dequeue all buffers at once (very important when there are only two). A client can dequeue all buffers until there are none available, it can lock all buffers except the last one that is used for composition. The client will block then, until a new buffer is enqueued. The current implementation requires that buffers are locked in the same order they are dequeued and enqueued in the same order they are locked. Only one buffer can be locked at a time. eg. Allowed sequence: DQ, DQ, LOCK, Q, LOCK, Q eg. Forbidden sequence: DQ, DQ, LOCK, LOCK, Q, Q
2009-09-07 23:32:45 +00:00
return mBuffers[mFrontBufferIndex];
}
auto import from //depot/cupcake/@135843
2009-03-04 03:31:44 +00:00
void reloadTexture(const Region& dirty);
fix [2167050] glTexImage2D code path buggy in SurfaceFlinger When EGLImage extension is not available, SurfaceFlinger will fallback to using glTexImage2D and glTexSubImage2D instead, which requires 50% more memory and an extra copy. However this code path has never been exercised and had some bugs which this patch fix. Mainly the scale factor wasn't computed right when falling back on glDrawElements. We also fallback to this mode of operation if a buffer doesn't have the adequate usage bits for EGLImage usage. This changes only code that is currently not executed. Some refactoring was needed to keep the change clean. This doesn't change anything functionaly.
2009-10-06 00:07:12 +00:00
uint32_t getEffectiveUsage(uint32_t usage) const;
sp<GraphicBuffer> requestBuffer(int index, int usage);
Surfaces are now destroyed properly in SurfaceFlinger. First, the window manager tells us when a surface is no longer needed. At this point, several things happen: - the surface is removed from the active/visible list - it is added to a purgatory list, where it waits for all clients to release their reference - it destroys all data/state that can be spared Later, when all clients are done, the remains of the Surface are disposed off: it is removed from the purgatory and destroyed. In particular its gralloc buffers are destroyed at that point (when we're sure nobody is using them anymore).
2009-04-22 22:23:34 +00:00
void destroy();
fix [2068105] implement queueBuffer/lockBuffer/dequeueBuffer properly Rewrote SurfaceFlinger's buffer management from the ground-up. The design now support an arbitrary number of buffers per surface, however the current implementation is limited to four. Currently only 2 buffers are used in practice. The main new feature is to be able to dequeue all buffers at once (very important when there are only two). A client can dequeue all buffers until there are none available, it can lock all buffers except the last one that is used for composition. The client will block then, until a new buffer is enqueued. The current implementation requires that buffers are locked in the same order they are dequeued and enqueued in the same order they are locked. Only one buffer can be locked at a time. eg. Allowed sequence: DQ, DQ, LOCK, Q, LOCK, Q eg. Forbidden sequence: DQ, DQ, LOCK, LOCK, Q, Q
2009-09-07 23:32:45 +00:00
class SurfaceLayer : public LayerBaseClient::Surface {
Integrate from //sandbox/mathias/donut/...@145728 SurfaceFlinger rework for new EGL driver model support.
2009-04-10 21:24:30 +00:00
public:
fix [2068105] implement queueBuffer/lockBuffer/dequeueBuffer properly Rewrote SurfaceFlinger's buffer management from the ground-up. The design now support an arbitrary number of buffers per surface, however the current implementation is limited to four. Currently only 2 buffers are used in practice. The main new feature is to be able to dequeue all buffers at once (very important when there are only two). A client can dequeue all buffers until there are none available, it can lock all buffers except the last one that is used for composition. The client will block then, until a new buffer is enqueued. The current implementation requires that buffers are locked in the same order they are dequeued and enqueued in the same order they are locked. Only one buffer can be locked at a time. eg. Allowed sequence: DQ, DQ, LOCK, Q, LOCK, Q eg. Forbidden sequence: DQ, DQ, LOCK, LOCK, Q, Q
2009-09-07 23:32:45 +00:00
SurfaceLayer(const sp<SurfaceFlinger>& flinger,
SurfaceID id, const sp<Layer>& owner);
~SurfaceLayer();
Integrate from //sandbox/mathias/donut/...@145728 SurfaceFlinger rework for new EGL driver model support.
2009-04-10 21:24:30 +00:00
private:
fix [2167050] glTexImage2D code path buggy in SurfaceFlinger When EGLImage extension is not available, SurfaceFlinger will fallback to using glTexImage2D and glTexSubImage2D instead, which requires 50% more memory and an extra copy. However this code path has never been exercised and had some bugs which this patch fix. Mainly the scale factor wasn't computed right when falling back on glDrawElements. We also fallback to this mode of operation if a buffer doesn't have the adequate usage bits for EGLImage usage. This changes only code that is currently not executed. Some refactoring was needed to keep the change clean. This doesn't change anything functionaly.
2009-10-06 00:07:12 +00:00
virtual sp<GraphicBuffer> requestBuffer(int index, int usage);
Integrate from //sandbox/mathias/donut/...@145728 SurfaceFlinger rework for new EGL driver model support.
2009-04-10 21:24:30 +00:00
sp<Layer> getOwner() const {
return static_cast<Layer*>(Surface::getOwner().get());
}
};
friend class SurfaceLayer;
auto import from //depot/cupcake/@135843
2009-03-04 03:31:44 +00:00
sp<Surface> mSurface;
bool mSecure;
fix [2168528] enable glTexImage2D code path in SF for software-only buffers
2009-10-06 01:20:39 +00:00
bool mNoEGLImageForSwBuffers;
auto import from //depot/cupcake/@135843
2009-03-04 03:31:44 +00:00
int32_t mFrontBufferIndex;
bool mNeedsBlending;
turn dithering off if it's not needed
2009-09-24 02:16:27 +00:00
bool mNeedsDithering;
auto import from //depot/cupcake/@135843
2009-03-04 03:31:44 +00:00
Region mPostedDirtyRegion;
sp<FreezeLock> mFreezeLock;
fix [2068105] implement queueBuffer/lockBuffer/dequeueBuffer properly Rewrote SurfaceFlinger's buffer management from the ground-up. The design now support an arbitrary number of buffers per surface, however the current implementation is limited to four. Currently only 2 buffers are used in practice. The main new feature is to be able to dequeue all buffers at once (very important when there are only two). A client can dequeue all buffers until there are none available, it can lock all buffers except the last one that is used for composition. The client will block then, until a new buffer is enqueued. The current implementation requires that buffers are locked in the same order they are dequeued and enqueued in the same order they are locked. Only one buffer can be locked at a time. eg. Allowed sequence: DQ, DQ, LOCK, Q, LOCK, Q eg. Forbidden sequence: DQ, DQ, LOCK, LOCK, Q, Q
2009-09-07 23:32:45 +00:00
PixelFormat mFormat;
// protected by mLock
fix [2167050] glTexImage2D code path buggy in SurfaceFlinger When EGLImage extension is not available, SurfaceFlinger will fallback to using glTexImage2D and glTexSubImage2D instead, which requires 50% more memory and an extra copy. However this code path has never been exercised and had some bugs which this patch fix. Mainly the scale factor wasn't computed right when falling back on glDrawElements. We also fallback to this mode of operation if a buffer doesn't have the adequate usage bits for EGLImage usage. This changes only code that is currently not executed. Some refactoring was needed to keep the change clean. This doesn't change anything functionaly.
2009-10-06 00:07:12 +00:00
sp<GraphicBuffer> mBuffers[NUM_BUFFERS];
fix [2068105] implement queueBuffer/lockBuffer/dequeueBuffer properly Rewrote SurfaceFlinger's buffer management from the ground-up. The design now support an arbitrary number of buffers per surface, however the current implementation is limited to four. Currently only 2 buffers are used in practice. The main new feature is to be able to dequeue all buffers at once (very important when there are only two). A client can dequeue all buffers until there are none available, it can lock all buffers except the last one that is used for composition. The client will block then, until a new buffer is enqueued. The current implementation requires that buffers are locked in the same order they are dequeued and enqueued in the same order they are locked. Only one buffer can be locked at a time. eg. Allowed sequence: DQ, DQ, LOCK, Q, LOCK, Q eg. Forbidden sequence: DQ, DQ, LOCK, LOCK, Q, Q
2009-09-07 23:32:45 +00:00
Texture mTextures[NUM_BUFFERS];
uint32_t mWidth;
uint32_t mHeight;
mutable Mutex mLock;
auto import from //depot/cupcake/@135843
2009-03-04 03:31:44 +00:00
};
// ---------------------------------------------------------------------------
}; // namespace android
#endif // ANDROID_LAYER_H
Reference in New Issue Copy Permalink