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_GRAPHIC_BUFFER_H
18#define ANDROID_GRAPHIC_BUFFER_H
19
20#include <stdint.h>
21#include <sys/types.h>
22
23#include <string>
24
25#include <ui/ANativeObjectBase.h>
26#include <ui/PixelFormat.h>
27#include <ui/Rect.h>
28#include <utils/Flattenable.h>
29#include <utils/RefBase.h>
30
31#include <hardware/gralloc.h>
32
33struct ANativeWindowBuffer;
34
35namespace android {
36
37class GraphicBufferMapper;
38
39// ===========================================================================
40// GraphicBuffer
41// ===========================================================================
42
43class GraphicBuffer
44    : public ANativeObjectBase< ANativeWindowBuffer, GraphicBuffer, RefBase >,
45      public Flattenable<GraphicBuffer>
46{
47    friend class Flattenable<GraphicBuffer>;
48public:
49
50    enum {
51        USAGE_SW_READ_NEVER     = GRALLOC_USAGE_SW_READ_NEVER,
52        USAGE_SW_READ_RARELY    = GRALLOC_USAGE_SW_READ_RARELY,
53        USAGE_SW_READ_OFTEN     = GRALLOC_USAGE_SW_READ_OFTEN,
54        USAGE_SW_READ_MASK      = GRALLOC_USAGE_SW_READ_MASK,
55
56        USAGE_SW_WRITE_NEVER    = GRALLOC_USAGE_SW_WRITE_NEVER,
57        USAGE_SW_WRITE_RARELY   = GRALLOC_USAGE_SW_WRITE_RARELY,
58        USAGE_SW_WRITE_OFTEN    = GRALLOC_USAGE_SW_WRITE_OFTEN,
59        USAGE_SW_WRITE_MASK     = GRALLOC_USAGE_SW_WRITE_MASK,
60
61        USAGE_SOFTWARE_MASK     = USAGE_SW_READ_MASK|USAGE_SW_WRITE_MASK,
62
63        USAGE_PROTECTED         = GRALLOC_USAGE_PROTECTED,
64
65        USAGE_HW_TEXTURE        = GRALLOC_USAGE_HW_TEXTURE,
66        USAGE_HW_RENDER         = GRALLOC_USAGE_HW_RENDER,
67        USAGE_HW_2D             = GRALLOC_USAGE_HW_2D,
68        USAGE_HW_COMPOSER       = GRALLOC_USAGE_HW_COMPOSER,
69        USAGE_HW_VIDEO_ENCODER  = GRALLOC_USAGE_HW_VIDEO_ENCODER,
70        USAGE_HW_MASK           = GRALLOC_USAGE_HW_MASK,
71
72        USAGE_CURSOR            = GRALLOC_USAGE_CURSOR,
73    };
74
75    static sp<GraphicBuffer> from(ANativeWindowBuffer *);
76
77
78    // Create a GraphicBuffer to be unflatten'ed into or be reallocated.
79    GraphicBuffer();
80
81    // Create a GraphicBuffer by allocating and managing a buffer internally.
82    // This function is privileged.  See reallocate for details.
83    GraphicBuffer(uint32_t inWidth, uint32_t inHeight, PixelFormat inFormat,
84            uint32_t inLayerCount, uint64_t inUsage,
85            std::string requestorName = "<Unknown>");
86
87    // Create a GraphicBuffer from an existing handle.
88    enum HandleWrapMethod : uint8_t {
89        // Wrap and use the handle directly.  It assumes the handle has been
90        // registered and never fails.  The handle must have a longer lifetime
91        // than this wrapping GraphicBuffer.
92        //
93        // This can be used when, for example, you want to wrap a handle that
94        // is already managed by another GraphicBuffer.
95        WRAP_HANDLE,
96
97        // Take ownership of the handle and use it directly.  It assumes the
98        // handle has been registered and never fails.
99        //
100        // This can be used to manage an already registered handle with
101        // GraphicBuffer.
102        TAKE_HANDLE,
103
104        // Take onwership of an unregistered handle and use it directly.  It
105        // can fail when the buffer does not register.  There is no ownership
106        // transfer on failures.
107        //
108        // This can be used to, for example, create a GraphicBuffer from a
109        // handle returned by Parcel::readNativeHandle.
110        TAKE_UNREGISTERED_HANDLE,
111
112        // Make a clone of the handle and use the cloned handle.  It can fail
113        // when cloning fails or when the buffer does not register.  There is
114        // never ownership transfer.
115        //
116        // This can be used to create a GraphicBuffer from a handle that
117        // cannot be used directly, such as one from hidl_handle.
118        CLONE_HANDLE,
119    };
120    GraphicBuffer(const native_handle_t* handle, HandleWrapMethod method,
121            uint32_t width, uint32_t height,
122            PixelFormat format, uint32_t layerCount,
123            uint64_t usage, uint32_t stride);
124
125    // These functions are deprecated because they only take 32 bits of usage
126    GraphicBuffer(const native_handle_t* handle, HandleWrapMethod method,
127            uint32_t width, uint32_t height,
128            PixelFormat format, uint32_t layerCount,
129            uint32_t usage, uint32_t stride)
130        : GraphicBuffer(handle, method, width, height, format, layerCount,
131                static_cast<uint64_t>(usage), stride) {}
132    GraphicBuffer(uint32_t inWidth, uint32_t inHeight, PixelFormat inFormat,
133            uint32_t inLayerCount, uint32_t inUsage, uint32_t inStride,
134            native_handle_t* inHandle, bool keepOwnership);
135    GraphicBuffer(uint32_t inWidth, uint32_t inHeight, PixelFormat inFormat,
136            uint32_t inUsage, std::string requestorName = "<Unknown>");
137
138    // return status
139    status_t initCheck() const;
140
141    uint32_t getWidth() const           { return static_cast<uint32_t>(width); }
142    uint32_t getHeight() const          { return static_cast<uint32_t>(height); }
143    uint32_t getStride() const          { return static_cast<uint32_t>(stride); }
144    uint32_t getUsage() const           { return static_cast<uint32_t>(usage); }
145    PixelFormat getPixelFormat() const  { return format; }
146    uint32_t getLayerCount() const      { return static_cast<uint32_t>(layerCount); }
147    Rect getBounds() const              { return Rect(width, height); }
148    uint64_t getId() const              { return mId; }
149
150    uint32_t getGenerationNumber() const { return mGenerationNumber; }
151    void setGenerationNumber(uint32_t generation) {
152        mGenerationNumber = generation;
153    }
154
155    // This function is privileged.  It requires access to the allocator
156    // device or service, which usually involves adding suitable selinux
157    // rules.
158    status_t reallocate(uint32_t inWidth, uint32_t inHeight,
159            PixelFormat inFormat, uint32_t inLayerCount, uint64_t inUsage);
160
161    bool needsReallocation(uint32_t inWidth, uint32_t inHeight,
162            PixelFormat inFormat, uint32_t inLayerCount, uint64_t inUsage);
163
164    status_t lock(uint32_t inUsage, void** vaddr);
165    status_t lock(uint32_t inUsage, const Rect& rect, void** vaddr);
166    // For HAL_PIXEL_FORMAT_YCbCr_420_888
167    status_t lockYCbCr(uint32_t inUsage, android_ycbcr *ycbcr);
168    status_t lockYCbCr(uint32_t inUsage, const Rect& rect,
169            android_ycbcr *ycbcr);
170    status_t unlock();
171    status_t lockAsync(uint32_t inUsage, void** vaddr, int fenceFd);
172    status_t lockAsync(uint32_t inUsage, const Rect& rect, void** vaddr,
173            int fenceFd);
174    status_t lockAsync(uint64_t inProducerUsage, uint64_t inConsumerUsage,
175            const Rect& rect, void** vaddr, int fenceFd);
176    status_t lockAsyncYCbCr(uint32_t inUsage, android_ycbcr *ycbcr,
177            int fenceFd);
178    status_t lockAsyncYCbCr(uint32_t inUsage, const Rect& rect,
179            android_ycbcr *ycbcr, int fenceFd);
180    status_t unlockAsync(int *fenceFd);
181
182    ANativeWindowBuffer* getNativeBuffer() const;
183
184    // for debugging
185    static void dumpAllocationsToSystemLog();
186
187    // Flattenable protocol
188    size_t getFlattenedSize() const;
189    size_t getFdCount() const;
190    status_t flatten(void*& buffer, size_t& size, int*& fds, size_t& count) const;
191    status_t unflatten(void const*& buffer, size_t& size, int const*& fds, size_t& count);
192
193private:
194    ~GraphicBuffer();
195
196    enum {
197        ownNone   = 0,
198        ownHandle = 1,
199        ownData   = 2,
200    };
201
202    inline const GraphicBufferMapper& getBufferMapper() const {
203        return mBufferMapper;
204    }
205    inline GraphicBufferMapper& getBufferMapper() {
206        return mBufferMapper;
207    }
208    uint8_t mOwner;
209
210private:
211    friend class Surface;
212    friend class BpSurface;
213    friend class BnSurface;
214    friend class LightRefBase<GraphicBuffer>;
215    GraphicBuffer(const GraphicBuffer& rhs);
216    GraphicBuffer& operator = (const GraphicBuffer& rhs);
217    const GraphicBuffer& operator = (const GraphicBuffer& rhs) const;
218
219    status_t initWithSize(uint32_t inWidth, uint32_t inHeight,
220            PixelFormat inFormat, uint32_t inLayerCount,
221            uint64_t inUsage, std::string requestorName);
222
223    status_t initWithHandle(const native_handle_t* handle,
224            HandleWrapMethod method, uint32_t width, uint32_t height,
225            PixelFormat format, uint32_t layerCount,
226            uint64_t usage, uint32_t stride);
227
228    void free_handle();
229
230    GraphicBufferMapper& mBufferMapper;
231    ssize_t mInitCheck;
232
233    uint64_t mId;
234
235    // Stores the generation number of this buffer. If this number does not
236    // match the BufferQueue's internal generation number (set through
237    // IGBP::setGenerationNumber), attempts to attach the buffer will fail.
238    uint32_t mGenerationNumber;
239};
240
241}; // namespace android
242
243#endif // ANDROID_GRAPHIC_BUFFER_H
244