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 "LayerBase.h"
24#include "TextureManager.h"
25
26struct copybit_device_t;
27
28namespace android {
29
30// ---------------------------------------------------------------------------
31
32class Buffer;
33class Region;
34class OverlayRef;
35
36// ---------------------------------------------------------------------------
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 onvalidateVisibility(const Transform& globalTransform) { }
48        virtual void postBuffer(ssize_t offset);
49        virtual void unregisterBuffers();
50        virtual void destroy() { }
51        SurfaceFlinger* getFlinger() const { return mLayer.mFlinger.get(); }
52    protected:
53        LayerBuffer& mLayer;
54    };
55
56public:
57            LayerBuffer(SurfaceFlinger* flinger, DisplayID display,
58                    const sp<Client>& client);
59        virtual ~LayerBuffer();
60
61    virtual void onFirstRef();
62    virtual bool needsBlending() const;
63    virtual const char* getTypeId() const { return "LayerBuffer"; }
64
65    virtual sp<LayerBaseClient::Surface> createSurface() const;
66    virtual status_t ditch();
67    virtual void onDraw(const Region& clip) const;
68    virtual void drawForSreenShot() const;
69    virtual uint32_t doTransaction(uint32_t flags);
70    virtual void unlockPageFlip(const Transform& planeTransform, Region& outDirtyRegion);
71    virtual void validateVisibility(const Transform& globalTransform);
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            int32_t orientation);
78
79    sp<Source> getSource() const;
80    sp<Source> clearSource();
81    void setNeedsBlending(bool blending);
82    Rect getTransformedBounds() const {
83        return mTransformedBounds;
84    }
85
86    void serverDestroy();
87
88private:
89    struct NativeBuffer {
90        copybit_image_t   img;
91        copybit_rect_t    crop;
92    };
93
94    static gralloc_module_t const* sGrallocModule;
95    static gralloc_module_t const* getGrallocModule() {
96        return sGrallocModule;
97    }
98
99    class Buffer : public LightRefBase<Buffer> {
100    public:
101        Buffer(const ISurface::BufferHeap& buffers,
102                ssize_t offset, size_t bufferSize);
103        inline bool supportsCopybit() const {
104            return mSupportsCopybit;
105        }
106        inline status_t getStatus() const {
107            return mBufferHeap.heap!=0 ? NO_ERROR : NO_INIT;
108        }
109        inline const NativeBuffer& getBuffer() const {
110            return mNativeBuffer;
111        }
112    protected:
113        friend class LightRefBase<Buffer>;
114        Buffer& operator = (const Buffer& rhs);
115        Buffer(const Buffer& rhs);
116        ~Buffer();
117    private:
118        ISurface::BufferHeap    mBufferHeap;
119        NativeBuffer            mNativeBuffer;
120        bool                    mSupportsCopybit;
121    };
122
123    class BufferSource : public Source {
124    public:
125        BufferSource(LayerBuffer& layer, const ISurface::BufferHeap& buffers);
126        virtual ~BufferSource();
127
128        status_t getStatus() const { return mStatus; }
129        sp<Buffer> getBuffer() const;
130        void setBuffer(const sp<Buffer>& buffer);
131
132        virtual void onDraw(const Region& clip) const;
133        virtual void postBuffer(ssize_t offset);
134        virtual void unregisterBuffers();
135        virtual void destroy() { }
136    private:
137        status_t initTempBuffer() const;
138        void clearTempBufferImage() const;
139        mutable Mutex                   mBufferSourceLock;
140        sp<Buffer>                      mBuffer;
141        status_t                        mStatus;
142        ISurface::BufferHeap            mBufferHeap;
143        size_t                          mBufferSize;
144        mutable Texture                 mTexture;
145        mutable NativeBuffer            mTempBuffer;
146        mutable TextureManager          mTextureManager;
147    };
148
149    class OverlaySource : public Source {
150    public:
151        OverlaySource(LayerBuffer& layer,
152                sp<OverlayRef>* overlayRef,
153                uint32_t w, uint32_t h, int32_t format, int32_t orientation);
154        virtual ~OverlaySource();
155        virtual void onDraw(const Region& clip) const;
156        virtual void onTransaction(uint32_t flags);
157        virtual void onVisibilityResolved(const Transform& planeTransform);
158        virtual void onvalidateVisibility(const Transform& globalTransform);
159        virtual void destroy();
160    private:
161
162        class OverlayChannel : public BnOverlay {
163            wp<LayerBuffer> mLayer;
164            virtual void destroy() {
165                sp<LayerBuffer> layer(mLayer.promote());
166                if (layer != 0) {
167                    layer->serverDestroy();
168                }
169            }
170        public:
171            OverlayChannel(const sp<LayerBuffer>& layer)
172                : mLayer(layer) {
173            }
174        };
175
176        friend class OverlayChannel;
177        bool mVisibilityChanged;
178
179        overlay_t* mOverlay;
180        overlay_handle_t mOverlayHandle;
181        overlay_control_device_t* mOverlayDevice;
182        uint32_t mWidth;
183        uint32_t mHeight;
184        int32_t mFormat;
185        int32_t mWidthStride;
186        int32_t mHeightStride;
187        int32_t mOrientation;
188        mutable Mutex mOverlaySourceLock;
189        bool mInitialized;
190    };
191
192
193    class SurfaceLayerBuffer : public LayerBaseClient::Surface
194    {
195    public:
196        SurfaceLayerBuffer(const sp<SurfaceFlinger>& flinger,
197                        const sp<LayerBuffer>& owner);
198        virtual ~SurfaceLayerBuffer();
199
200        virtual status_t registerBuffers(const ISurface::BufferHeap& buffers);
201        virtual void postBuffer(ssize_t offset);
202        virtual void unregisterBuffers();
203
204        virtual sp<OverlayRef> createOverlay(
205                uint32_t w, uint32_t h, int32_t format, int32_t orientation);
206    private:
207        sp<LayerBuffer> getOwner() const {
208            return static_cast<LayerBuffer*>(Surface::getOwner().get());
209        }
210    };
211
212    mutable Mutex   mLock;
213    sp<Source>      mSource;
214    sp<Surface>     mSurface;
215    bool            mInvalidate;
216    bool            mNeedsBlending;
217    copybit_device_t* mBlitEngine;
218};
219
220// ---------------------------------------------------------------------------
221
222}; // namespace android
223
224#endif // ANDROID_LAYER_BUFFER_H
225