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_BUFFER_H
|
|
|
|
#define ANDROID_LAYER_BUFFER_H
|
|
|
|
|
|
|
|
#include <stdint.h>
|
|
|
|
#include <sys/types.h>
|
|
|
|
|
|
|
|
#include "LayerBase.h"
|
2010-05-11 03:06:11 +00:00
|
|
|
#include "TextureManager.h"
|
2009-03-04 03:31:44 +00:00
|
|
|
|
2009-06-24 04:11:43 +00:00
|
|
|
struct copybit_device_t;
|
|
|
|
|
2009-03-04 03:31:44 +00:00
|
|
|
namespace android {
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
|
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 Buffer;
|
2009-03-04 03:31:44 +00:00
|
|
|
class Region;
|
|
|
|
class OverlayRef;
|
|
|
|
|
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
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
|
2009-03-04 03:31:44 +00:00
|
|
|
class LayerBuffer : public LayerBaseClient
|
|
|
|
{
|
|
|
|
class Source : public LightRefBase<Source> {
|
|
|
|
public:
|
|
|
|
Source(LayerBuffer& layer);
|
|
|
|
virtual ~Source();
|
|
|
|
virtual void onDraw(const Region& clip) const;
|
|
|
|
virtual void onTransaction(uint32_t flags);
|
|
|
|
virtual void onVisibilityResolved(const Transform& planeTransform);
|
|
|
|
virtual void postBuffer(ssize_t offset);
|
|
|
|
virtual void unregisterBuffers();
|
2009-09-09 06:52:08 +00:00
|
|
|
virtual void destroy() { }
|
2009-03-04 03:31:44 +00:00
|
|
|
protected:
|
|
|
|
LayerBuffer& mLayer;
|
|
|
|
};
|
|
|
|
|
|
|
|
public:
|
|
|
|
LayerBuffer(SurfaceFlinger* flinger, DisplayID display,
|
2009-06-20 00:00:27 +00:00
|
|
|
const sp<Client>& client, int32_t i);
|
2009-03-04 03:31:44 +00:00
|
|
|
virtual ~LayerBuffer();
|
|
|
|
|
2009-04-18 02:36:26 +00:00
|
|
|
virtual void onFirstRef();
|
2009-03-04 03:31:44 +00:00
|
|
|
virtual bool needsBlending() const;
|
2010-04-21 00:55:49 +00:00
|
|
|
virtual const char* getTypeId() const { return "LayerBuffer"; }
|
2009-03-04 03:31:44 +00:00
|
|
|
|
2009-04-10 21:24:30 +00:00
|
|
|
virtual sp<LayerBaseClient::Surface> createSurface() const;
|
2009-04-18 02:36:26 +00:00
|
|
|
virtual status_t ditch();
|
2009-03-04 03:31:44 +00:00
|
|
|
virtual void onDraw(const Region& clip) const;
|
|
|
|
virtual uint32_t doTransaction(uint32_t flags);
|
|
|
|
virtual void unlockPageFlip(const Transform& planeTransform, Region& outDirtyRegion);
|
|
|
|
|
|
|
|
status_t registerBuffers(const ISurface::BufferHeap& buffers);
|
|
|
|
void postBuffer(ssize_t offset);
|
|
|
|
void unregisterBuffers();
|
2010-01-22 01:31:06 +00:00
|
|
|
sp<OverlayRef> createOverlay(uint32_t w, uint32_t h, int32_t format,
|
|
|
|
int32_t orientation);
|
2009-03-04 03:31:44 +00:00
|
|
|
|
|
|
|
sp<Source> getSource() const;
|
|
|
|
sp<Source> clearSource();
|
|
|
|
void setNeedsBlending(bool blending);
|
2009-09-09 06:52:08 +00:00
|
|
|
Rect getTransformedBounds() const {
|
2009-03-04 03:31:44 +00:00
|
|
|
return mTransformedBounds;
|
|
|
|
}
|
|
|
|
|
2009-09-09 06:52:08 +00:00
|
|
|
void serverDestroy();
|
|
|
|
|
2009-03-04 03:31:44 +00:00
|
|
|
private:
|
|
|
|
struct NativeBuffer {
|
|
|
|
copybit_image_t img;
|
|
|
|
copybit_rect_t crop;
|
|
|
|
};
|
|
|
|
|
2009-10-30 01:29:30 +00:00
|
|
|
static gralloc_module_t const* sGrallocModule;
|
|
|
|
static gralloc_module_t const* getGrallocModule() {
|
|
|
|
return sGrallocModule;
|
|
|
|
}
|
|
|
|
|
2009-03-04 03:31:44 +00:00
|
|
|
class Buffer : public LightRefBase<Buffer> {
|
|
|
|
public:
|
2010-03-08 19:14:20 +00:00
|
|
|
Buffer(const ISurface::BufferHeap& buffers,
|
|
|
|
ssize_t offset, size_t bufferSize);
|
2010-01-20 21:24:14 +00:00
|
|
|
inline bool supportsCopybit() const {
|
|
|
|
return mSupportsCopybit;
|
|
|
|
}
|
2009-03-04 03:31:44 +00:00
|
|
|
inline status_t getStatus() const {
|
|
|
|
return mBufferHeap.heap!=0 ? NO_ERROR : NO_INIT;
|
|
|
|
}
|
|
|
|
inline const NativeBuffer& getBuffer() const {
|
|
|
|
return mNativeBuffer;
|
|
|
|
}
|
|
|
|
protected:
|
|
|
|
friend class LightRefBase<Buffer>;
|
|
|
|
Buffer& operator = (const Buffer& rhs);
|
|
|
|
Buffer(const Buffer& rhs);
|
|
|
|
~Buffer();
|
|
|
|
private:
|
|
|
|
ISurface::BufferHeap mBufferHeap;
|
|
|
|
NativeBuffer mNativeBuffer;
|
2010-01-20 21:24:14 +00:00
|
|
|
bool mSupportsCopybit;
|
2009-03-04 03:31:44 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
class BufferSource : public Source {
|
|
|
|
public:
|
|
|
|
BufferSource(LayerBuffer& layer, const ISurface::BufferHeap& buffers);
|
|
|
|
virtual ~BufferSource();
|
|
|
|
|
|
|
|
status_t getStatus() const { return mStatus; }
|
|
|
|
sp<Buffer> getBuffer() const;
|
|
|
|
void setBuffer(const sp<Buffer>& buffer);
|
|
|
|
|
|
|
|
virtual void onDraw(const Region& clip) const;
|
|
|
|
virtual void postBuffer(ssize_t offset);
|
|
|
|
virtual void unregisterBuffers();
|
2009-09-09 06:52:08 +00:00
|
|
|
virtual void destroy() { }
|
2009-03-04 03:31:44 +00:00
|
|
|
private:
|
2009-12-09 22:32:56 +00:00
|
|
|
status_t initTempBuffer() const;
|
2010-01-20 21:56:07 +00:00
|
|
|
void clearTempBufferImage() const;
|
2009-09-09 03:02:47 +00:00
|
|
|
mutable Mutex mBufferSourceLock;
|
2009-06-24 01:08:22 +00:00
|
|
|
sp<Buffer> mBuffer;
|
|
|
|
status_t mStatus;
|
|
|
|
ISurface::BufferHeap mBufferHeap;
|
|
|
|
size_t mBufferSize;
|
2010-05-11 03:06:11 +00:00
|
|
|
mutable Texture mTexture;
|
2009-12-09 22:32:56 +00:00
|
|
|
mutable NativeBuffer mTempBuffer;
|
2010-05-11 03:06:11 +00:00
|
|
|
mutable TextureManager mTextureManager;
|
2009-03-04 03:31:44 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
class OverlaySource : public Source {
|
|
|
|
public:
|
|
|
|
OverlaySource(LayerBuffer& layer,
|
|
|
|
sp<OverlayRef>* overlayRef,
|
2010-01-22 01:31:06 +00:00
|
|
|
uint32_t w, uint32_t h, int32_t format, int32_t orientation);
|
2009-03-04 03:31:44 +00:00
|
|
|
virtual ~OverlaySource();
|
2009-07-21 04:18:04 +00:00
|
|
|
virtual void onDraw(const Region& clip) const;
|
2009-03-04 03:31:44 +00:00
|
|
|
virtual void onTransaction(uint32_t flags);
|
|
|
|
virtual void onVisibilityResolved(const Transform& planeTransform);
|
2009-09-09 06:52:08 +00:00
|
|
|
virtual void destroy();
|
2009-03-04 03:31:44 +00:00
|
|
|
private:
|
2009-09-09 06:52:08 +00:00
|
|
|
|
2009-03-04 03:31:44 +00:00
|
|
|
class OverlayChannel : public BnOverlay {
|
2009-09-09 06:52:08 +00:00
|
|
|
wp<LayerBuffer> mLayer;
|
2009-03-04 03:31:44 +00:00
|
|
|
virtual void destroy() {
|
2009-09-09 06:52:08 +00:00
|
|
|
sp<LayerBuffer> layer(mLayer.promote());
|
|
|
|
if (layer != 0) {
|
|
|
|
layer->serverDestroy();
|
2009-03-04 03:31:44 +00:00
|
|
|
}
|
|
|
|
}
|
2009-09-09 06:52:08 +00:00
|
|
|
public:
|
|
|
|
OverlayChannel(const sp<LayerBuffer>& layer)
|
|
|
|
: mLayer(layer) {
|
|
|
|
}
|
2009-03-04 03:31:44 +00:00
|
|
|
};
|
2009-09-09 03:02:47 +00:00
|
|
|
|
2009-03-04 03:31:44 +00:00
|
|
|
friend class OverlayChannel;
|
|
|
|
bool mVisibilityChanged;
|
|
|
|
|
|
|
|
overlay_t* mOverlay;
|
|
|
|
overlay_handle_t mOverlayHandle;
|
|
|
|
overlay_control_device_t* mOverlayDevice;
|
|
|
|
uint32_t mWidth;
|
|
|
|
uint32_t mHeight;
|
|
|
|
int32_t mFormat;
|
|
|
|
int32_t mWidthStride;
|
|
|
|
int32_t mHeightStride;
|
2010-01-22 01:31:06 +00:00
|
|
|
int32_t mOrientation;
|
2009-09-09 03:02:47 +00:00
|
|
|
mutable Mutex mOverlaySourceLock;
|
2009-07-21 23:17:59 +00:00
|
|
|
bool mInitialized;
|
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
|
|
|
class SurfaceLayerBuffer : public LayerBaseClient::Surface
|
2009-03-04 03:31:44 +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
|
|
|
SurfaceLayerBuffer(const sp<SurfaceFlinger>& flinger,
|
2009-04-18 02:36:26 +00:00
|
|
|
SurfaceID id, const sp<LayerBuffer>& owner);
|
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
|
|
|
virtual ~SurfaceLayerBuffer();
|
2009-04-10 21:24:30 +00:00
|
|
|
|
2009-03-04 03:31:44 +00:00
|
|
|
virtual status_t registerBuffers(const ISurface::BufferHeap& buffers);
|
|
|
|
virtual void postBuffer(ssize_t offset);
|
|
|
|
virtual void unregisterBuffers();
|
2009-04-10 21:24:30 +00:00
|
|
|
|
2009-03-04 03:31:44 +00:00
|
|
|
virtual sp<OverlayRef> createOverlay(
|
2010-01-22 01:31:06 +00:00
|
|
|
uint32_t w, uint32_t h, int32_t format, int32_t orientation);
|
2009-03-04 03:31:44 +00:00
|
|
|
private:
|
2009-04-10 21:24:30 +00:00
|
|
|
sp<LayerBuffer> getOwner() const {
|
|
|
|
return static_cast<LayerBuffer*>(Surface::getOwner().get());
|
2009-03-04 03:31:44 +00:00
|
|
|
}
|
|
|
|
};
|
2009-09-09 03:02:47 +00:00
|
|
|
|
2009-03-04 03:31:44 +00:00
|
|
|
mutable Mutex mLock;
|
|
|
|
sp<Source> mSource;
|
2009-04-18 02:36:26 +00:00
|
|
|
sp<Surface> mSurface;
|
2009-03-04 03:31:44 +00:00
|
|
|
bool mInvalidate;
|
|
|
|
bool mNeedsBlending;
|
2009-11-06 07:08:00 +00:00
|
|
|
copybit_device_t* mBlitEngine;
|
2009-03-04 03:31:44 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
|
|
|
|
}; // namespace android
|
|
|
|
|
|
|
|
#endif // ANDROID_LAYER_BUFFER_H
|