Merge changes from topic \'gralloc1\' into nyc-mr1-dev (c152ef31) · Commits · e / os / android_frameworks_native-old

include/ui/Gralloc1.h

0 → 100644

+238 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright 2016 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		#ifndef ANDROID_UI_GRALLOC1_H
		#define ANDROID_UI_GRALLOC1_H

		#define GRALLOC1_LOG_TAG "Gralloc1"

		#include <ui/Gralloc1On0Adapter.h>

		#include <unordered_set>

		namespace std {
		template <>
		struct hash<gralloc1_capability_t> {
		size_t operator()(gralloc1_capability_t capability) const {
		return std::hash<int32_t>()(static_cast<int32_t>(capability));
		}
		};
		}

		namespace android {

		class Fence;
		class GraphicBuffer;

		namespace Gralloc1 {

		class Device;

		class Descriptor {
		public:
		Descriptor(Device& device, gralloc1_buffer_descriptor_t deviceId)
		: mShimDevice(device),
		mDeviceId(deviceId),
		mWidth(0),
		mHeight(0),
		mFormat(static_cast<android_pixel_format_t>(0)),
		mProducerUsage(GRALLOC1_PRODUCER_USAGE_NONE),
		mConsumerUsage(GRALLOC1_CONSUMER_USAGE_NONE) {}

		~Descriptor();

		gralloc1_buffer_descriptor_t getDeviceId() const { return mDeviceId; }

		gralloc1_error_t setDimensions(uint32_t width, uint32_t height);
		gralloc1_error_t setFormat(android_pixel_format_t format);
		gralloc1_error_t setProducerUsage(gralloc1_producer_usage_t usage);
		gralloc1_error_t setConsumerUsage(gralloc1_consumer_usage_t usage);

		private:
		Device& mShimDevice;
		const gralloc1_buffer_descriptor_t mDeviceId;

		uint32_t mWidth;
		uint32_t mHeight;
		android_pixel_format_t mFormat;
		gralloc1_producer_usage_t mProducerUsage;
		gralloc1_consumer_usage_t mConsumerUsage;

		}; // Descriptor

		class Device {
		friend class Gralloc1::Descriptor;

		public:
		Device(gralloc1_device_t* device);

		bool hasCapability(gralloc1_capability_t capability) const;

		std::string dump();

		std::shared_ptr<Descriptor> createDescriptor();

		gralloc1_error_t getStride(buffer_handle_t buffer, uint32_t* outStride);

		gralloc1_error_t allocate(
		const std::vector<std::shared_ptr<const Descriptor>>& descriptors,
		std::vector<buffer_handle_t>* outBuffers);
		gralloc1_error_t allocate(
		const std::shared_ptr<const Descriptor>& descriptor,
		gralloc1_backing_store_t id, buffer_handle_t* outBuffer);

		gralloc1_error_t retain(buffer_handle_t buffer);
		gralloc1_error_t retain(const GraphicBuffer* buffer);

		gralloc1_error_t release(buffer_handle_t buffer);

		gralloc1_error_t getNumFlexPlanes(buffer_handle_t buffer,
		uint32_t* outNumPlanes);

		gralloc1_error_t lock(buffer_handle_t buffer,
		gralloc1_producer_usage_t producerUsage,
		gralloc1_consumer_usage_t consumerUsage,
		const gralloc1_rect_t* accessRegion, void** outData,
		const sp<Fence>& acquireFence);
		gralloc1_error_t lockFlex(buffer_handle_t buffer,
		gralloc1_producer_usage_t producerUsage,
		gralloc1_consumer_usage_t consumerUsage,
		const gralloc1_rect_t* accessRegion,
		struct android_flex_layout* outData, const sp<Fence>& acquireFence);
		gralloc1_error_t lockYCbCr(buffer_handle_t buffer,
		gralloc1_producer_usage_t producerUsage,
		gralloc1_consumer_usage_t consumerUsage,
		const gralloc1_rect_t* accessRegion, struct android_ycbcr* outData,
		const sp<Fence>& acquireFence);

		gralloc1_error_t unlock(buffer_handle_t buffer, sp<Fence>* outFence);

		private:
		std::unordered_set<gralloc1_capability_t> loadCapabilities();

		bool loadFunctions();

		template <typename LockType, typename OutType>
		gralloc1_error_t lockHelper(LockType pfn, buffer_handle_t buffer,
		gralloc1_producer_usage_t producerUsage,
		gralloc1_consumer_usage_t consumerUsage,
		const gralloc1_rect_t* accessRegion, OutType* outData,
		const sp<Fence>& acquireFence) {
		int32_t intError = pfn(mDevice, buffer,
		static_cast<uint64_t>(producerUsage),
		static_cast<uint64_t>(consumerUsage), accessRegion, outData,
		acquireFence->dup());
		return static_cast<gralloc1_error_t>(intError);
		}

		gralloc1_device_t* const mDevice;

		const std::unordered_set<gralloc1_capability_t> mCapabilities;

		template <typename PFN, gralloc1_function_descriptor_t descriptor>
		struct FunctionLoader {
		FunctionLoader() : pfn(nullptr) {}

		bool load(gralloc1_device_t* device, bool errorIfNull) {
		gralloc1_function_pointer_t rawPointer =
		device->getFunction(device, descriptor);
		pfn = reinterpret_cast<PFN>(rawPointer);
		if (errorIfNull && !rawPointer) {
		ALOG(LOG_ERROR, GRALLOC1_LOG_TAG,
		"Failed to load function pointer %d", descriptor);
		}
		return rawPointer != nullptr;
		}

		template <typename ...Args>
		typename std::result_of<PFN(Args...)>::type operator()(Args... args) {
		return pfn(args...);
		}

		PFN pfn;
		};

		// Function pointers
		struct Functions {
		FunctionLoader<GRALLOC1_PFN_DUMP, GRALLOC1_FUNCTION_DUMP> dump;
		FunctionLoader<GRALLOC1_PFN_CREATE_DESCRIPTOR,
		GRALLOC1_FUNCTION_CREATE_DESCRIPTOR> createDescriptor;
		FunctionLoader<GRALLOC1_PFN_DESTROY_DESCRIPTOR,
		GRALLOC1_FUNCTION_DESTROY_DESCRIPTOR> destroyDescriptor;
		FunctionLoader<GRALLOC1_PFN_SET_CONSUMER_USAGE,
		GRALLOC1_FUNCTION_SET_CONSUMER_USAGE> setConsumerUsage;
		FunctionLoader<GRALLOC1_PFN_SET_DIMENSIONS,
		GRALLOC1_FUNCTION_SET_DIMENSIONS> setDimensions;
		FunctionLoader<GRALLOC1_PFN_SET_FORMAT,
		GRALLOC1_FUNCTION_SET_FORMAT> setFormat;
		FunctionLoader<GRALLOC1_PFN_SET_PRODUCER_USAGE,
		GRALLOC1_FUNCTION_SET_PRODUCER_USAGE> setProducerUsage;
		FunctionLoader<GRALLOC1_PFN_GET_BACKING_STORE,
		GRALLOC1_FUNCTION_GET_BACKING_STORE> getBackingStore;
		FunctionLoader<GRALLOC1_PFN_GET_CONSUMER_USAGE,
		GRALLOC1_FUNCTION_GET_CONSUMER_USAGE> getConsumerUsage;
		FunctionLoader<GRALLOC1_PFN_GET_DIMENSIONS,
		GRALLOC1_FUNCTION_GET_DIMENSIONS> getDimensions;
		FunctionLoader<GRALLOC1_PFN_GET_FORMAT,
		GRALLOC1_FUNCTION_GET_FORMAT> getFormat;
		FunctionLoader<GRALLOC1_PFN_GET_PRODUCER_USAGE,
		GRALLOC1_FUNCTION_GET_PRODUCER_USAGE> getProducerUsage;
		FunctionLoader<GRALLOC1_PFN_GET_STRIDE,
		GRALLOC1_FUNCTION_GET_STRIDE> getStride;
		FunctionLoader<GRALLOC1_PFN_ALLOCATE,
		GRALLOC1_FUNCTION_ALLOCATE> allocate;
		FunctionLoader<GRALLOC1_PFN_RETAIN,
		GRALLOC1_FUNCTION_RETAIN> retain;
		FunctionLoader<GRALLOC1_PFN_RELEASE,
		GRALLOC1_FUNCTION_RELEASE> release;
		FunctionLoader<GRALLOC1_PFN_GET_NUM_FLEX_PLANES,
		GRALLOC1_FUNCTION_GET_NUM_FLEX_PLANES> getNumFlexPlanes;
		FunctionLoader<GRALLOC1_PFN_LOCK,
		GRALLOC1_FUNCTION_LOCK> lock;
		FunctionLoader<GRALLOC1_PFN_LOCK_FLEX,
		GRALLOC1_FUNCTION_LOCK_FLEX> lockFlex;
		FunctionLoader<GRALLOC1_PFN_LOCK_YCBCR,
		GRALLOC1_FUNCTION_LOCK_YCBCR> lockYCbCr;
		FunctionLoader<GRALLOC1_PFN_UNLOCK,
		GRALLOC1_FUNCTION_UNLOCK> unlock;

		// Adapter-only functions
		FunctionLoader<GRALLOC1_PFN_RETAIN_GRAPHIC_BUFFER,
		GRALLOC1_FUNCTION_RETAIN_GRAPHIC_BUFFER> retainGraphicBuffer;
		FunctionLoader<GRALLOC1_PFN_ALLOCATE_WITH_ID,
		GRALLOC1_FUNCTION_ALLOCATE_WITH_ID> allocateWithId;
		} mFunctions;

		}; // class android::Gralloc1::Device

		class Loader
		{
		public:
		Loader();
		~Loader();

		std::unique_ptr<Device> getDevice();

		private:
		static std::unique_ptr<Gralloc1On0Adapter> mAdapter;
		std::unique_ptr<Device> mDevice;
		};

		} // namespace android::Gralloc1

		} // namespace android

		#endif

include/ui/Gralloc1On0Adapter.h

0 → 100644

+478 −0

File added.

Preview size limit exceeded, changes collapsed.

include/ui/GraphicBufferAllocator.h

+19 −19

Original line number	Diff line number	Diff line
		@@ -27,42 +27,41 @@
		#include <utils/threads.h>
		#include <utils/Singleton.h>

		#include <ui/Gralloc1.h>
		#include <ui/PixelFormat.h>

		#include <hardware/gralloc.h>


		namespace android {
		// ---------------------------------------------------------------------------

		class Gralloc1Loader;
		class String8;

		class GraphicBufferAllocator : public Singleton<GraphicBufferAllocator>
		{
		public:
		enum {
		USAGE_SW_READ_NEVER = GRALLOC_USAGE_SW_READ_NEVER,
		USAGE_SW_READ_RARELY = GRALLOC_USAGE_SW_READ_RARELY,
		USAGE_SW_READ_OFTEN = GRALLOC_USAGE_SW_READ_OFTEN,
		USAGE_SW_READ_MASK = GRALLOC_USAGE_SW_READ_MASK,
		USAGE_SW_READ_NEVER = GRALLOC1_CONSUMER_USAGE_CPU_READ_NEVER,
		USAGE_SW_READ_RARELY = GRALLOC1_CONSUMER_USAGE_CPU_READ,
		USAGE_SW_READ_OFTEN = GRALLOC1_CONSUMER_USAGE_CPU_READ_OFTEN,
		USAGE_SW_READ_MASK = GRALLOC1_CONSUMER_USAGE_CPU_READ_OFTEN,

		USAGE_SW_WRITE_NEVER = GRALLOC_USAGE_SW_WRITE_NEVER,
		USAGE_SW_WRITE_RARELY = GRALLOC_USAGE_SW_WRITE_RARELY,
		USAGE_SW_WRITE_OFTEN = GRALLOC_USAGE_SW_WRITE_OFTEN,
		USAGE_SW_WRITE_MASK = GRALLOC_USAGE_SW_WRITE_MASK,
		USAGE_SW_WRITE_NEVER = GRALLOC1_PRODUCER_USAGE_CPU_WRITE_NEVER,
		USAGE_SW_WRITE_RARELY = GRALLOC1_PRODUCER_USAGE_CPU_WRITE,
		USAGE_SW_WRITE_OFTEN = GRALLOC1_PRODUCER_USAGE_CPU_WRITE_OFTEN,
		USAGE_SW_WRITE_MASK = GRALLOC1_PRODUCER_USAGE_CPU_WRITE_OFTEN,

		USAGE_SOFTWARE_MASK = USAGE_SW_READ_MASK\|USAGE_SW_WRITE_MASK,

		USAGE_HW_TEXTURE = GRALLOC_USAGE_HW_TEXTURE,
		USAGE_HW_RENDER = GRALLOC_USAGE_HW_RENDER,
		USAGE_HW_2D = GRALLOC_USAGE_HW_2D,
		USAGE_HW_MASK = GRALLOC_USAGE_HW_MASK
		USAGE_HW_TEXTURE = GRALLOC1_CONSUMER_USAGE_GPU_TEXTURE,
		USAGE_HW_RENDER = GRALLOC1_PRODUCER_USAGE_GPU_RENDER_TARGET,
		USAGE_HW_2D = 0x00000400, // Deprecated
		USAGE_HW_MASK = 0x00071F00, // Deprecated
		};

		static inline GraphicBufferAllocator& get() { return getInstance(); }

		status_t alloc(uint32_t w, uint32_t h, PixelFormat format, uint32_t usage,
		buffer_handle_t* handle, uint32_t* stride);
		status_t allocate(uint32_t w, uint32_t h, PixelFormat format,
		uint32_t usage, buffer_handle_t* handle, uint32_t* stride,
		uint64_t graphicBufferId);

		status_t free(buffer_handle_t handle);

		@@ -86,7 +85,8 @@ private:
		GraphicBufferAllocator();
		~GraphicBufferAllocator();

		alloc_device_t *mAllocDev;
		std::unique_ptr<Gralloc1::Loader> mLoader;
		std::unique_ptr<Gralloc1::Device> mDevice;
		};

		// ---------------------------------------------------------------------------

include/ui/GraphicBufferMapper.h

+7 −9

Original line number	Diff line number	Diff line
		@@ -20,12 +20,9 @@
		#include <stdint.h>
		#include <sys/types.h>

		#include <utils/Singleton.h>

		#include <hardware/gralloc.h>
		#include <ui/Gralloc1.h>


		struct gralloc_module_t;
		#include <utils/Singleton.h>

		namespace android {

		@@ -39,6 +36,7 @@ public:
		static inline GraphicBufferMapper& get() { return getInstance(); }

		status_t registerBuffer(buffer_handle_t handle);
		status_t registerBuffer(const GraphicBuffer* buffer);

		status_t unregisterBuffer(buffer_handle_t handle);

		@@ -59,13 +57,13 @@ public:

		status_t unlockAsync(buffer_handle_t handle, int *fenceFd);

		// dumps information about the mapping of this handle
		void dump(buffer_handle_t handle);

		private:
		friend class Singleton<GraphicBufferMapper>;

		GraphicBufferMapper();
		gralloc_module_t const *mAllocMod;

		std::unique_ptr<Gralloc1::Loader> mLoader;
		std::unique_ptr<Gralloc1::Device> mDevice;
		};

		// ---------------------------------------------------------------------------

libs/ui/Android.mk

+3 −1

Original line number	Diff line number	Diff line
		@@ -17,7 +17,7 @@ include $(CLEAR_VARS)

		LOCAL_CLANG := true
		LOCAL_CPPFLAGS := -std=c++1y -Weverything -Werror
		LOCAL_SANITIZE := integer
		# LOCAL_SANITIZE := integer

		# The static constructors and destructors in this library have not been noted to
		# introduce significant overheads
		@@ -37,6 +37,8 @@ LOCAL_CPPFLAGS += -Wno-padded
		LOCAL_SRC_FILES := \
		Fence.cpp \
		FrameStats.cpp \
		Gralloc1.cpp \
		Gralloc1On0Adapter.cpp \
		GraphicBuffer.cpp \
		GraphicBufferAllocator.cpp \
		GraphicBufferMapper.cpp \