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 #include <utility> 25 #include <vector> 26 27 #include <android/hardware_buffer.h> 28 #include <ui/ANativeObjectBase.h> 29 #include <ui/GraphicBufferMapper.h> 30 #include <ui/PixelFormat.h> 31 #include <ui/Rect.h> 32 #include <utils/Flattenable.h> 33 #include <utils/RefBase.h> 34 35 #include <nativebase/nativebase.h> 36 37 #include <hardware/gralloc.h> 38 39 namespace android { 40 41 class GraphicBufferMapper; 42 43 using GraphicBufferDeathCallback = std::function<void(void* /*context*/, uint64_t bufferId)>; 44 45 // =========================================================================== 46 // GraphicBuffer 47 // =========================================================================== 48 49 class GraphicBuffer 50 : public ANativeObjectBase<ANativeWindowBuffer, GraphicBuffer, RefBase>, 51 public Flattenable<GraphicBuffer> 52 { 53 friend class Flattenable<GraphicBuffer>; 54 public: 55 56 enum { 57 USAGE_SW_READ_NEVER = GRALLOC_USAGE_SW_READ_NEVER, 58 USAGE_SW_READ_RARELY = GRALLOC_USAGE_SW_READ_RARELY, 59 USAGE_SW_READ_OFTEN = GRALLOC_USAGE_SW_READ_OFTEN, 60 USAGE_SW_READ_MASK = GRALLOC_USAGE_SW_READ_MASK, 61 62 USAGE_SW_WRITE_NEVER = GRALLOC_USAGE_SW_WRITE_NEVER, 63 USAGE_SW_WRITE_RARELY = GRALLOC_USAGE_SW_WRITE_RARELY, 64 USAGE_SW_WRITE_OFTEN = GRALLOC_USAGE_SW_WRITE_OFTEN, 65 USAGE_SW_WRITE_MASK = GRALLOC_USAGE_SW_WRITE_MASK, 66 67 USAGE_SOFTWARE_MASK = USAGE_SW_READ_MASK|USAGE_SW_WRITE_MASK, 68 69 USAGE_PROTECTED = GRALLOC_USAGE_PROTECTED, 70 71 USAGE_HW_TEXTURE = GRALLOC_USAGE_HW_TEXTURE, 72 USAGE_HW_RENDER = GRALLOC_USAGE_HW_RENDER, 73 USAGE_HW_2D = GRALLOC_USAGE_HW_2D, 74 USAGE_HW_COMPOSER = GRALLOC_USAGE_HW_COMPOSER, 75 USAGE_HW_VIDEO_ENCODER = GRALLOC_USAGE_HW_VIDEO_ENCODER, 76 USAGE_HW_MASK = GRALLOC_USAGE_HW_MASK, 77 78 USAGE_CURSOR = GRALLOC_USAGE_CURSOR, 79 }; 80 81 static sp<GraphicBuffer> from(ANativeWindowBuffer *); 82 83 static GraphicBuffer* fromAHardwareBuffer(AHardwareBuffer*); 84 static GraphicBuffer const* fromAHardwareBuffer(AHardwareBuffer const*); 85 AHardwareBuffer* toAHardwareBuffer(); 86 AHardwareBuffer const* toAHardwareBuffer() const; 87 88 // Create a GraphicBuffer to be unflatten'ed into or be reallocated. 89 GraphicBuffer(); 90 91 // Create a GraphicBuffer by allocating and managing a buffer internally. 92 // This function is privileged. See reallocate for details. 93 GraphicBuffer(uint32_t inWidth, uint32_t inHeight, PixelFormat inFormat, 94 uint32_t inLayerCount, uint64_t inUsage, 95 std::string requestorName = "<Unknown>"); 96 97 // Create a GraphicBuffer from an existing handle. 98 enum HandleWrapMethod : uint8_t { 99 // Wrap and use the handle directly. It assumes the handle has been 100 // registered and never fails. The handle must have a longer lifetime 101 // than this wrapping GraphicBuffer. 102 // 103 // This can be used when, for example, you want to wrap a handle that 104 // is already managed by another GraphicBuffer. 105 WRAP_HANDLE, 106 107 // Take ownership of the handle and use it directly. It assumes the 108 // handle has been registered and never fails. 109 // 110 // This can be used to manage an already registered handle with 111 // GraphicBuffer. 112 TAKE_HANDLE, 113 114 // Take onwership of an unregistered handle and use it directly. It 115 // can fail when the buffer does not register. There is no ownership 116 // transfer on failures. 117 // 118 // This can be used to, for example, create a GraphicBuffer from a 119 // handle returned by Parcel::readNativeHandle. 120 TAKE_UNREGISTERED_HANDLE, 121 122 // Make a clone of the handle and use the cloned handle. It can fail 123 // when cloning fails or when the buffer does not register. There is 124 // never ownership transfer. 125 // 126 // This can be used to create a GraphicBuffer from a handle that 127 // cannot be used directly, such as one from hidl_handle. 128 CLONE_HANDLE, 129 }; 130 GraphicBuffer(const native_handle_t* inHandle, HandleWrapMethod method, uint32_t inWidth, 131 uint32_t inHeight, PixelFormat inFormat, uint32_t inLayerCount, uint64_t inUsage, 132 uint32_t inStride); 133 134 // These functions are deprecated because they only take 32 bits of usage GraphicBuffer(const native_handle_t * inHandle,HandleWrapMethod method,uint32_t inWidth,uint32_t inHeight,PixelFormat inFormat,uint32_t inLayerCount,uint32_t inUsage,uint32_t inStride)135 GraphicBuffer(const native_handle_t* inHandle, HandleWrapMethod method, uint32_t inWidth, 136 uint32_t inHeight, PixelFormat inFormat, uint32_t inLayerCount, uint32_t inUsage, 137 uint32_t inStride) 138 : GraphicBuffer(inHandle, method, inWidth, inHeight, inFormat, inLayerCount, 139 static_cast<uint64_t>(inUsage), inStride) {} 140 GraphicBuffer(uint32_t inWidth, uint32_t inHeight, PixelFormat inFormat, 141 uint32_t inLayerCount, uint32_t inUsage, uint32_t inStride, 142 native_handle_t* inHandle, bool keepOwnership); 143 GraphicBuffer(uint32_t inWidth, uint32_t inHeight, PixelFormat inFormat, 144 uint32_t inUsage, std::string requestorName = "<Unknown>"); 145 146 // return status 147 status_t initCheck() const; 148 getWidth()149 uint32_t getWidth() const { return static_cast<uint32_t>(width); } getHeight()150 uint32_t getHeight() const { return static_cast<uint32_t>(height); } getStride()151 uint32_t getStride() const { return static_cast<uint32_t>(stride); } getUsage()152 uint64_t getUsage() const { return usage; } getPixelFormat()153 PixelFormat getPixelFormat() const { return format; } getLayerCount()154 uint32_t getLayerCount() const { return static_cast<uint32_t>(layerCount); } getBounds()155 Rect getBounds() const { return Rect(width, height); } getId()156 uint64_t getId() const { return mId; } 157 getGenerationNumber()158 uint32_t getGenerationNumber() const { return mGenerationNumber; } setGenerationNumber(uint32_t generation)159 void setGenerationNumber(uint32_t generation) { 160 mGenerationNumber = generation; 161 } 162 163 // This function is privileged. It requires access to the allocator 164 // device or service, which usually involves adding suitable selinux 165 // rules. 166 status_t reallocate(uint32_t inWidth, uint32_t inHeight, 167 PixelFormat inFormat, uint32_t inLayerCount, uint64_t inUsage); 168 169 bool needsReallocation(uint32_t inWidth, uint32_t inHeight, 170 PixelFormat inFormat, uint32_t inLayerCount, uint64_t inUsage); 171 172 // For the following two lock functions, if bytesPerStride or bytesPerPixel 173 // are unknown or variable, -1 will be returned 174 status_t lock(uint32_t inUsage, void** vaddr, int32_t* outBytesPerPixel = nullptr, 175 int32_t* outBytesPerStride = nullptr); 176 status_t lock(uint32_t inUsage, const Rect& rect, void** vaddr, 177 int32_t* outBytesPerPixel = nullptr, int32_t* outBytesPerStride = nullptr); 178 // For HAL_PIXEL_FORMAT_YCbCr_420_888 179 status_t lockYCbCr(uint32_t inUsage, android_ycbcr *ycbcr); 180 status_t lockYCbCr(uint32_t inUsage, const Rect& rect, 181 android_ycbcr *ycbcr); 182 status_t unlock(); 183 // For the following three lockAsync functions, if bytesPerStride or bytesPerPixel 184 // are unknown or variable, -1 will be returned 185 status_t lockAsync(uint32_t inUsage, void** vaddr, int fenceFd, 186 int32_t* outBytesPerPixel = nullptr, int32_t* outBytesPerStride = nullptr); 187 status_t lockAsync(uint32_t inUsage, const Rect& rect, void** vaddr, int fenceFd, 188 int32_t* outBytesPerPixel = nullptr, int32_t* outBytesPerStride = nullptr); 189 status_t lockAsync(uint64_t inProducerUsage, uint64_t inConsumerUsage, const Rect& rect, 190 void** vaddr, int fenceFd, int32_t* outBytesPerPixel = nullptr, 191 int32_t* outBytesPerStride = nullptr); 192 status_t lockAsyncYCbCr(uint32_t inUsage, android_ycbcr *ycbcr, 193 int fenceFd); 194 status_t lockAsyncYCbCr(uint32_t inUsage, const Rect& rect, 195 android_ycbcr *ycbcr, int fenceFd); 196 status_t unlockAsync(int *fenceFd); 197 198 status_t isSupported(uint32_t inWidth, uint32_t inHeight, PixelFormat inFormat, 199 uint32_t inLayerCount, uint64_t inUsage, bool* outSupported) const; 200 201 ANativeWindowBuffer* getNativeBuffer() const; 202 203 // for debugging 204 static void dumpAllocationsToSystemLog(); 205 206 // Flattenable protocol 207 size_t getFlattenedSize() const; 208 size_t getFdCount() const; 209 status_t flatten(void*& buffer, size_t& size, int*& fds, size_t& count) const; 210 status_t unflatten(void const*& buffer, size_t& size, int const*& fds, size_t& count); 211 getBufferMapperVersion()212 GraphicBufferMapper::Version getBufferMapperVersion() const { 213 return mBufferMapper.getMapperVersion(); 214 } 215 216 void addDeathCallback(GraphicBufferDeathCallback deathCallback, void* context); 217 218 private: 219 ~GraphicBuffer(); 220 221 enum { 222 ownNone = 0, 223 ownHandle = 1, 224 ownData = 2, 225 }; 226 getBufferMapper()227 inline const GraphicBufferMapper& getBufferMapper() const { 228 return mBufferMapper; 229 } getBufferMapper()230 inline GraphicBufferMapper& getBufferMapper() { 231 return mBufferMapper; 232 } 233 uint8_t mOwner; 234 235 private: 236 friend class Surface; 237 friend class BpSurface; 238 friend class BnSurface; 239 friend class LightRefBase<GraphicBuffer>; 240 GraphicBuffer(const GraphicBuffer& rhs); 241 GraphicBuffer& operator = (const GraphicBuffer& rhs); 242 const GraphicBuffer& operator = (const GraphicBuffer& rhs) const; 243 244 status_t initWithSize(uint32_t inWidth, uint32_t inHeight, 245 PixelFormat inFormat, uint32_t inLayerCount, 246 uint64_t inUsage, std::string requestorName); 247 248 status_t initWithHandle(const native_handle_t* inHandle, HandleWrapMethod method, 249 uint32_t inWidth, uint32_t inHeight, PixelFormat inFormat, 250 uint32_t inLayerCount, uint64_t inUsage, uint32_t inStride); 251 252 void free_handle(); 253 254 GraphicBufferMapper& mBufferMapper; 255 ssize_t mInitCheck; 256 257 // numbers of fds/ints in native_handle_t to flatten 258 uint32_t mTransportNumFds; 259 uint32_t mTransportNumInts; 260 261 uint64_t mId; 262 263 // Unused, but removing this may break GSI. 264 int32_t mBufferId = -1; 265 266 // Stores the generation number of this buffer. If this number does not 267 // match the BufferQueue's internal generation number (set through 268 // IGBP::setGenerationNumber), attempts to attach the buffer will fail. 269 uint32_t mGenerationNumber; 270 271 // Send a callback when a GraphicBuffer dies. 272 // 273 // This is used for BufferStateLayer caching. GraphicBuffers are refcounted per process. When 274 // A GraphicBuffer doesn't have any more sp<> in a process, it is destroyed. This causes 275 // problems when trying to implicitcly cache across process boundaries. Ideally, both sides 276 // of the cache would hold onto wp<> references. When an app dropped its sp<>, the GraphicBuffer 277 // would be destroyed. Unfortunately, when SurfaceFlinger has only a wp<> reference to the 278 // GraphicBuffer, it immediately goes out of scope in the SurfaceFlinger process. SurfaceFlinger 279 // must hold onto a sp<> to the buffer. When the GraphicBuffer goes out of scope in the app's 280 // process, the client side cache will get this callback. It erases the buffer from its cache 281 // and informs SurfaceFlinger that it should drop its strong pointer reference to the buffer. 282 std::vector<std::pair<GraphicBufferDeathCallback, void* /*mDeathCallbackContext*/>> 283 mDeathCallbacks; 284 }; 285 286 }; // namespace android 287 288 #endif // ANDROID_GRAPHIC_BUFFER_H 289