1/*
2 * Copyright (C) 2007 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#ifndef ANDROID_LAYER_BUFFER_H
18#define ANDROID_LAYER_BUFFER_H
19
20#include <stdint.h>
21#include <sys/types.h>
22
23#include <utils/IMemory.h>
24#include <private/ui/LayerState.h>
25#include <EGL/eglnatives.h>
26
27#include "LayerBase.h"
28#include "LayerBitmap.h"
29
30namespace android {
31
32// ---------------------------------------------------------------------------
33
34class MemoryDealer;
35class Region;
36class OverlayRef;
37
38class LayerBuffer : public LayerBaseClient
39{
40    class Source : public LightRefBase<Source> {
41    public:
42        Source(LayerBuffer& layer);
43        virtual ~Source();
44        virtual void onDraw(const Region& clip) const;
45        virtual void onTransaction(uint32_t flags);
46        virtual void onVisibilityResolved(const Transform& planeTransform);
47        virtual void postBuffer(ssize_t offset);
48        virtual void unregisterBuffers();
49        virtual bool transformed() const;
50    protected:
51        LayerBuffer& mLayer;
52    };
53
54
55public:
56    static const uint32_t typeInfo;
57    static const char* const typeID;
58    virtual char const* getTypeID() const { return typeID; }
59    virtual uint32_t getTypeInfo() const { return typeInfo; }
60
61            LayerBuffer(SurfaceFlinger* flinger, DisplayID display,
62                        Client* client, int32_t i);
63        virtual ~LayerBuffer();
64
65    virtual bool needsBlending() const;
66
67    virtual sp<LayerBaseClient::Surface> getSurface() const;
68    virtual void onDraw(const Region& clip) const;
69    virtual uint32_t doTransaction(uint32_t flags);
70    virtual void unlockPageFlip(const Transform& planeTransform, Region& outDirtyRegion);
71    virtual bool transformed() const;
72
73    status_t registerBuffers(const ISurface::BufferHeap& buffers);
74    void postBuffer(ssize_t offset);
75    void unregisterBuffers();
76    sp<OverlayRef> createOverlay(uint32_t w, uint32_t h, int32_t format);
77
78    sp<Source> getSource() const;
79    sp<Source> clearSource();
80    void setNeedsBlending(bool blending);
81    const Rect& getTransformedBounds() const {
82        return mTransformedBounds;
83    }
84
85private:
86    struct NativeBuffer {
87        copybit_image_t   img;
88        copybit_rect_t    crop;
89    };
90
91    class Buffer : public LightRefBase<Buffer> {
92    public:
93        Buffer(const ISurface::BufferHeap& buffers, ssize_t offset);
94        inline status_t getStatus() const {
95            return mBufferHeap.heap!=0 ? NO_ERROR : NO_INIT;
96        }
97        inline const NativeBuffer& getBuffer() const {
98            return mNativeBuffer;
99        }
100    protected:
101        friend class LightRefBase<Buffer>;
102        Buffer& operator = (const Buffer& rhs);
103        Buffer(const Buffer& rhs);
104        ~Buffer();
105    private:
106        ISurface::BufferHeap    mBufferHeap;
107        NativeBuffer            mNativeBuffer;
108    };
109
110    class BufferSource : public Source {
111    public:
112        BufferSource(LayerBuffer& layer, const ISurface::BufferHeap& buffers);
113        virtual ~BufferSource();
114
115        status_t getStatus() const { return mStatus; }
116        sp<Buffer> getBuffer() const;
117        void setBuffer(const sp<Buffer>& buffer);
118
119        virtual void onDraw(const Region& clip) const;
120        virtual void postBuffer(ssize_t offset);
121        virtual void unregisterBuffers();
122        virtual bool transformed() const;
123    private:
124        mutable Mutex   mLock;
125        sp<Buffer>      mBuffer;
126        status_t        mStatus;
127        ISurface::BufferHeap mBufferHeap;
128        size_t          mBufferSize;
129        mutable sp<MemoryDealer> mTemporaryDealer;
130        mutable LayerBitmap mTempBitmap;
131        mutable GLuint  mTextureName;
132    };
133
134    class OverlaySource : public Source {
135    public:
136        OverlaySource(LayerBuffer& layer,
137                sp<OverlayRef>* overlayRef,
138                uint32_t w, uint32_t h, int32_t format);
139        virtual ~OverlaySource();
140        virtual void onTransaction(uint32_t flags);
141        virtual void onVisibilityResolved(const Transform& planeTransform);
142    private:
143        void serverDestroy();
144        void destroyOverlay();
145        class OverlayChannel : public BnOverlay {
146            mutable Mutex mLock;
147            sp<OverlaySource> mSource;
148            virtual void destroy() {
149                sp<OverlaySource> source;
150                { // scope for the lock;
151                    Mutex::Autolock _l(mLock);
152                    source = mSource;
153                    mSource.clear();
154                }
155                if (source != 0) {
156                    source->serverDestroy();
157                }
158            }
159        public:
160            OverlayChannel(const sp<OverlaySource>& source)
161                : mSource(source) {
162            }
163        };
164        friend class OverlayChannel;
165        bool mVisibilityChanged;
166
167        overlay_t* mOverlay;
168        overlay_handle_t mOverlayHandle;
169        overlay_control_device_t* mOverlayDevice;
170        uint32_t mWidth;
171        uint32_t mHeight;
172        int32_t mFormat;
173        int32_t mWidthStride;
174        int32_t mHeightStride;
175        mutable Mutex mLock;
176    };
177
178
179    class SurfaceBuffer : public LayerBaseClient::Surface
180    {
181    public:
182                SurfaceBuffer(SurfaceID id, LayerBuffer* owner);
183        virtual ~SurfaceBuffer();
184        virtual status_t onTransact(
185            uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags);
186        virtual status_t registerBuffers(const ISurface::BufferHeap& buffers);
187        virtual void postBuffer(ssize_t offset);
188        virtual void unregisterBuffers();
189        virtual sp<OverlayRef> createOverlay(
190                uint32_t w, uint32_t h, int32_t format);
191       void disown();
192    private:
193        LayerBuffer* getOwner() const {
194            Mutex::Autolock _l(mLock);
195            return mOwner;
196        }
197        mutable Mutex   mLock;
198        LayerBuffer*    mOwner;
199    };
200
201    friend class SurfaceFlinger;
202    sp<SurfaceBuffer>   getClientSurface() const;
203
204    mutable Mutex   mLock;
205    sp<Source>      mSource;
206
207    bool            mInvalidate;
208    bool            mNeedsBlending;
209    mutable wp<SurfaceBuffer> mClientSurface;
210};
211
212// ---------------------------------------------------------------------------
213
214}; // namespace android
215
216#endif // ANDROID_LAYER_BUFFER_H
217