diff options
Diffstat (limited to 'libshims/include/ui/GraphicBuffer.h')
| -rw-r--r-- | libshims/include/ui/GraphicBuffer.h | 144 |
1 files changed, 125 insertions, 19 deletions
diff --git a/libshims/include/ui/GraphicBuffer.h b/libshims/include/ui/GraphicBuffer.h index e1e6a64..cc38982 100644 --- a/libshims/include/ui/GraphicBuffer.h +++ b/libshims/include/ui/GraphicBuffer.h @@ -20,18 +20,21 @@ #include <stdint.h> #include <sys/types.h> +#include <string> + #include <ui/ANativeObjectBase.h> #include <ui/PixelFormat.h> #include <ui/Rect.h> #include <utils/Flattenable.h> #include <utils/RefBase.h> -#include <hardware/gralloc.h> +#include <nativebase/nativebase.h> -struct ANativeWindowBuffer; +#include <hardware/gralloc.h> namespace android { +class DetachedBufferHandle; class GraphicBufferMapper; // =========================================================================== @@ -39,7 +42,7 @@ class GraphicBufferMapper; // =========================================================================== class GraphicBuffer - : public ANativeObjectBase< ANativeWindowBuffer, GraphicBuffer, RefBase >, + : public ANativeObjectBase<ANativeWindowBuffer, GraphicBuffer, RefBase>, public Flattenable<GraphicBuffer> { friend class Flattenable<GraphicBuffer>; @@ -66,21 +69,72 @@ public: USAGE_HW_COMPOSER = GRALLOC_USAGE_HW_COMPOSER, USAGE_HW_VIDEO_ENCODER = GRALLOC_USAGE_HW_VIDEO_ENCODER, USAGE_HW_MASK = GRALLOC_USAGE_HW_MASK, + + USAGE_CURSOR = GRALLOC_USAGE_CURSOR, }; + static sp<GraphicBuffer> from(ANativeWindowBuffer *); + + + // Create a GraphicBuffer to be unflatten'ed into or be reallocated. GraphicBuffer(); - // creates w * h buffer + // Create a GraphicBuffer by allocating and managing a buffer internally. + // This function is privileged. See reallocate for details. GraphicBuffer(uint32_t inWidth, uint32_t inHeight, PixelFormat inFormat, - uint32_t inUsage); - - // create a buffer from an existing handle + uint32_t inLayerCount, uint64_t inUsage, + std::string requestorName = "<Unknown>"); + + // Create a GraphicBuffer from an existing handle. + enum HandleWrapMethod : uint8_t { + // Wrap and use the handle directly. It assumes the handle has been + // registered and never fails. The handle must have a longer lifetime + // than this wrapping GraphicBuffer. + // + // This can be used when, for example, you want to wrap a handle that + // is already managed by another GraphicBuffer. + WRAP_HANDLE, + + // Take ownership of the handle and use it directly. It assumes the + // handle has been registered and never fails. + // + // This can be used to manage an already registered handle with + // GraphicBuffer. + TAKE_HANDLE, + + // Take onwership of an unregistered handle and use it directly. It + // can fail when the buffer does not register. There is no ownership + // transfer on failures. + // + // This can be used to, for example, create a GraphicBuffer from a + // handle returned by Parcel::readNativeHandle. + TAKE_UNREGISTERED_HANDLE, + + // Make a clone of the handle and use the cloned handle. It can fail + // when cloning fails or when the buffer does not register. There is + // never ownership transfer. + // + // This can be used to create a GraphicBuffer from a handle that + // cannot be used directly, such as one from hidl_handle. + CLONE_HANDLE, + }; + GraphicBuffer(const native_handle_t* handle, HandleWrapMethod method, + uint32_t width, uint32_t height, + PixelFormat format, uint32_t layerCount, + uint64_t usage, uint32_t stride); + + // These functions are deprecated because they only take 32 bits of usage + GraphicBuffer(const native_handle_t* handle, HandleWrapMethod method, + uint32_t width, uint32_t height, + PixelFormat format, uint32_t layerCount, + uint32_t usage, uint32_t stride) + : GraphicBuffer(handle, method, width, height, format, layerCount, + static_cast<uint64_t>(usage), stride) {} GraphicBuffer(uint32_t inWidth, uint32_t inHeight, PixelFormat inFormat, - uint32_t inUsage, uint32_t inStride, native_handle_t* inHandle, - bool keepOwnership); - - // create a buffer from an existing ANativeWindowBuffer - GraphicBuffer(ANativeWindowBuffer* buffer, bool keepOwnership); + uint32_t inLayerCount, uint32_t inUsage, uint32_t inStride, + native_handle_t* inHandle, bool keepOwnership); + GraphicBuffer(uint32_t inWidth, uint32_t inHeight, PixelFormat inFormat, + uint32_t inUsage, std::string requestorName = "<Unknown>"); // return status status_t initCheck() const; @@ -88,12 +142,25 @@ public: uint32_t getWidth() const { return static_cast<uint32_t>(width); } uint32_t getHeight() const { return static_cast<uint32_t>(height); } uint32_t getStride() const { return static_cast<uint32_t>(stride); } - uint32_t getUsage() const { return static_cast<uint32_t>(usage); } + uint64_t getUsage() const { return usage; } PixelFormat getPixelFormat() const { return format; } + uint32_t getLayerCount() const { return static_cast<uint32_t>(layerCount); } Rect getBounds() const { return Rect(width, height); } + uint64_t getId() const { return mId; } + + uint32_t getGenerationNumber() const { return mGenerationNumber; } + void setGenerationNumber(uint32_t generation) { + mGenerationNumber = generation; + } + // This function is privileged. It requires access to the allocator + // device or service, which usually involves adding suitable selinux + // rules. status_t reallocate(uint32_t inWidth, uint32_t inHeight, - PixelFormat inFormat, uint32_t inUsage); + PixelFormat inFormat, uint32_t inLayerCount, uint64_t inUsage); + + bool needsReallocation(uint32_t inWidth, uint32_t inHeight, + PixelFormat inFormat, uint32_t inLayerCount, uint64_t inUsage); status_t lock(uint32_t inUsage, void** vaddr); status_t lock(uint32_t inUsage, const Rect& rect, void** vaddr); @@ -102,6 +169,16 @@ public: status_t lockYCbCr(uint32_t inUsage, const Rect& rect, android_ycbcr *ycbcr); status_t unlock(); + status_t lockAsync(uint32_t inUsage, void** vaddr, int fenceFd); + status_t lockAsync(uint32_t inUsage, const Rect& rect, void** vaddr, + int fenceFd); + status_t lockAsync(uint64_t inProducerUsage, uint64_t inConsumerUsage, + const Rect& rect, void** vaddr, int fenceFd); + status_t lockAsyncYCbCr(uint32_t inUsage, android_ycbcr *ycbcr, + int fenceFd); + status_t lockAsyncYCbCr(uint32_t inUsage, const Rect& rect, + android_ycbcr *ycbcr, int fenceFd); + status_t unlockAsync(int *fenceFd); ANativeWindowBuffer* getNativeBuffer() const; @@ -114,6 +191,11 @@ public: status_t flatten(void*& buffer, size_t& size, int*& fds, size_t& count) const; status_t unflatten(void const*& buffer, size_t& size, int const*& fds, size_t& count); + // Sets and takes DetachedBuffer. Should only be called from BufferHub. + bool isDetachedBuffer() const; + status_t setDetachedBufferHandle(std::unique_ptr<DetachedBufferHandle> detachedBuffer); + std::unique_ptr<DetachedBufferHandle> takeDetachedBufferHandle(); + private: ~GraphicBuffer(); @@ -140,17 +222,41 @@ private: GraphicBuffer& operator = (const GraphicBuffer& rhs); const GraphicBuffer& operator = (const GraphicBuffer& rhs) const; - status_t initSize(uint32_t inWidth, uint32_t inHeight, PixelFormat inFormat, - uint32_t inUsage); + status_t initWithSize(uint32_t inWidth, uint32_t inHeight, + PixelFormat inFormat, uint32_t inLayerCount, + uint64_t inUsage, std::string requestorName); + + status_t initWithHandle(const native_handle_t* handle, + HandleWrapMethod method, uint32_t width, uint32_t height, + PixelFormat format, uint32_t layerCount, + uint64_t usage, uint32_t stride); void free_handle(); GraphicBufferMapper& mBufferMapper; ssize_t mInitCheck; - // If we're wrapping another buffer then this reference will make sure it - // doesn't get freed. - sp<ANativeWindowBuffer> mWrappedBuffer; + // numbers of fds/ints in native_handle_t to flatten + uint32_t mTransportNumFds; + uint32_t mTransportNumInts; + + uint64_t mId; + + // Stores the generation number of this buffer. If this number does not + // match the BufferQueue's internal generation number (set through + // IGBP::setGenerationNumber), attempts to attach the buffer will fail. + uint32_t mGenerationNumber; + + // Stores a BufferHub handle that can be used to re-attach this GraphicBuffer back into a + // BufferHub producer/consumer set. In terms of GraphicBuffer's relationship with BufferHub, + // there are three different modes: + // 1. Legacy mode: GraphicBuffer is not backed by BufferHub and mDetachedBufferHandle must be + // invalid. + // 2. Detached mode: GraphicBuffer is backed by BufferHub, but not part of a producer/consumer + // set. In this mode, mDetachedBufferHandle must be valid. + // 3. Attached mode: GraphicBuffer is backed by BufferHub and it's part of a producer/consumer + // set. In this mode, mDetachedBufferHandle must be invalid. + std::unique_ptr<DetachedBufferHandle> mDetachedBufferHandle; }; }; // namespace android |