Merge "libui: update for revised HIDL gralloc" into oc-dev (1d472756) · Commits · e / os / android_frameworks_native-old

include/ui/Gralloc2.h

0 → 100644

+132 −0

Original line number	Original line	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_GRALLOC2_H
			#define ANDROID_UI_GRALLOC2_H

			#include <string>

			#include <android/hardware/graphics/allocator/2.0/IAllocator.h>
			#include <android/hardware/graphics/mapper/2.0/IMapper.h>
			#include <system/window.h>
			#include <utils/StrongPointer.h>

			namespace android {

			namespace Gralloc2 {

			using hardware::graphics::allocator::V2_0::IAllocator;
			using hardware::graphics::common::V1_0::BufferUsage;
			using hardware::graphics::common::V1_0::PixelFormat;
			using hardware::graphics::mapper::V2_0::BufferDescriptor;
			using hardware::graphics::mapper::V2_0::Error;
			using hardware::graphics::mapper::V2_0::IMapper;
			using hardware::graphics::mapper::V2_0::YCbCrLayout;

			// A wrapper to IMapper
			class Mapper {
			public:
			Mapper();

			// this will be removed and Mapper will be always valid
			bool valid() const { return (mMapper != nullptr); }

			Error createDescriptor(
			const IMapper::BufferDescriptorInfo& descriptorInfo,
			BufferDescriptor* outDescriptor) const;

			// Import a buffer that is from another HAL, another process, or is
			// cloned.
			//
			// The returned handle must be freed with freeBuffer.
			Error importBuffer(const hardware::hidl_handle& rawHandle,
			buffer_handle_t* outBufferHandle) const;

			void freeBuffer(buffer_handle_t bufferHandle) const;

			// The ownership of acquireFence is always transferred to the callee, even
			// on errors.
			Error lock(buffer_handle_t bufferHandle, uint64_t usage,
			const IMapper::Rect& accessRegion,
			int acquireFence, void** outData) const;

			// The ownership of acquireFence is always transferred to the callee, even
			// on errors.
			Error lock(buffer_handle_t bufferHandle, uint64_t usage,
			const IMapper::Rect& accessRegion,
			int acquireFence, YCbCrLayout* outLayout) const;

			// unlock returns a fence sync object (or -1) and the fence sync object is
			// owned by the caller
			int unlock(buffer_handle_t bufferHandle) const;

			private:
			sp<IMapper> mMapper;
			};

			// A wrapper to IAllocator
			class Allocator {
			public:
			// An allocator relies on a mapper, and that mapper must be alive at all
			// time.
			Allocator(const Mapper& mapper);

			// this will be removed and Allocator will be always valid
			bool valid() const { return (mAllocator != nullptr); }

			std::string dumpDebugInfo() const;

			/*
			* The returned buffers are already imported and must not be imported
			* again. outBufferHandles must point to a space that can contain at
			* least "count" buffer_handle_t.
			*/
			Error allocate(BufferDescriptor descriptor, uint32_t count,
			uint32_t* outStride, buffer_handle_t* outBufferHandles) const;

			Error allocate(BufferDescriptor descriptor,
			uint32_t* outStride, buffer_handle_t* outBufferHandle) const
			{
			return allocate(descriptor, 1, outStride, outBufferHandle);
			}

			Error allocate(const IMapper::BufferDescriptorInfo& descriptorInfo, uint32_t count,
			uint32_t* outStride, buffer_handle_t* outBufferHandles) const
			{
			BufferDescriptor descriptor;
			Error error = mMapper.createDescriptor(descriptorInfo, &descriptor);
			if (error == Error::NONE) {
			error = allocate(descriptor, count, outStride, outBufferHandles);
			}
			return error;
			}

			Error allocate(const IMapper::BufferDescriptorInfo& descriptorInfo,
			uint32_t* outStride, buffer_handle_t* outBufferHandle) const
			{
			return allocate(descriptorInfo, 1, outStride, outBufferHandle);
			}

			private:
			const Mapper& mMapper;
			sp<IAllocator> mAllocator;
			};

			} // namespace Gralloc2

			} // namespace android

			#endif // ANDROID_UI_GRALLOC2_H

include/ui/GrallocAllocator.h

deleted100644 → 0

+0 −68

Original line number	Original line	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_GRALLOC_ALLOCATOR_H
	#define ANDROID_UI_GRALLOC_ALLOCATOR_H

	#include <string>

	#include <android/hardware/graphics/allocator/2.0/IAllocator.h>
	#include <utils/StrongPointer.h>

	namespace android {

	namespace Gralloc2 {

	using hardware::graphics::allocator::V2_0::Error;
	using hardware::graphics::allocator::V2_0::ProducerUsage;
	using hardware::graphics::allocator::V2_0::ConsumerUsage;
	using hardware::graphics::allocator::V2_0::BufferDescriptor;
	using hardware::graphics::allocator::V2_0::Buffer;
	using hardware::graphics::allocator::V2_0::IAllocator;
	using hardware::graphics::allocator::V2_0::IAllocatorClient;
	using hardware::graphics::common::V1_0::PixelFormat;

	// Allocator is a wrapper to IAllocator, a proxy to server-side allocator.
	class Allocator {
	public:
	Allocator();

	// this will be removed and Allocator will be always valid
	bool valid() const { return (mAllocator != nullptr); }

	std::string dumpDebugInfo() const;

	Error createBufferDescriptor(
	const IAllocatorClient::BufferDescriptorInfo& descriptorInfo,
	BufferDescriptor* outDescriptor) const;
	void destroyBufferDescriptor(BufferDescriptor descriptor) const;

	Error allocate(BufferDescriptor descriptor, Buffer* outBuffer) const;
	void free(Buffer buffer) const;

	Error exportHandle(BufferDescriptor descriptor, Buffer buffer,
	native_handle_t** outBufferHandle) const;

	private:
	sp<IAllocator> mAllocator;
	sp<IAllocatorClient> mClient;
	};

	} // namespace Gralloc2

	} // namespace android

	#endif // ANDROID_UI_GRALLOC_ALLOCATOR_H

include/ui/GrallocMapper.h

deleted100644 → 0

+0 −74

Original line number	Original line	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_GRALLOC_MAPPER_H
	#define ANDROID_UI_GRALLOC_MAPPER_H

	#include <android/hardware/graphics/mapper/2.0/IMapper.h>
	#include <system/window.h>

	namespace android {

	namespace Gralloc2 {

	using hardware::graphics::allocator::V2_0::Error;
	using hardware::graphics::allocator::V2_0::ProducerUsage;
	using hardware::graphics::allocator::V2_0::ConsumerUsage;
	using hardware::graphics::common::V1_0::PixelFormat;
	using hardware::graphics::mapper::V2_0::FlexLayout;
	using hardware::graphics::mapper::V2_0::BackingStore;
	using hardware::graphics::mapper::V2_0::IMapper;

	// Mapper is a wrapper to IMapper, a client-side graphics buffer mapper.
	class Mapper {
	public:
	Mapper();

	// this will be removed and Mapper will be always valid
	bool valid() const { return (mMapper != nullptr); }

	Error retain(buffer_handle_t handle) const;
	void release(buffer_handle_t handle) const;

	Error getDimensions(buffer_handle_t handle,
	uint32_t* outWidth, uint32_t* outHeight) const;
	Error getFormat(buffer_handle_t handle, int32_t* outFormat) const;
	Error getLayerCount(buffer_handle_t handle, uint32_t* outLayerCount) const;
	Error getProducerUsage(buffer_handle_t handle,
	uint64_t* outProducerUsage) const;
	Error getConsumerUsage(buffer_handle_t handle,
	uint64_t* outConsumerUsage) const;
	Error getBackingStore(buffer_handle_t handle,
	uint64_t* outBackingStore) const;
	Error getStride(buffer_handle_t handle, uint32_t* outStride) const;

	Error lock(buffer_handle_t handle, uint64_t producerUsage,
	uint64_t consumerUsage, const IMapper::Rect& accessRegion,
	int acquireFence, void** outData) const;
	Error lock(buffer_handle_t handle, uint64_t producerUsage,
	uint64_t consumerUsage, const IMapper::Rect& accessRegion,
	int acquireFence, FlexLayout* outLayout) const;
	int unlock(buffer_handle_t handle) const;

	private:
	sp<IMapper> mMapper;
	};

	} // namespace Gralloc2

	} // namespace android

	#endif // ANDROID_UI_GRALLOC_MAPPER_H

include/ui/GraphicBufferAllocator.h

+1 −1

Original line number	Original line	Diff line number	Diff line
	@@ -96,8 +96,8 @@ private:
	GraphicBufferAllocator();		GraphicBufferAllocator();
	~GraphicBufferAllocator();		~GraphicBufferAllocator();

	const std::unique_ptr<const Gralloc2::Allocator> mAllocator;
	GraphicBufferMapper& mMapper;		GraphicBufferMapper& mMapper;
			const std::unique_ptr<const Gralloc2::Allocator> mAllocator;

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

include/ui/GraphicBufferMapper.h

+7 −23

Original line number	Original line	Diff line number	Diff line
	@@ -47,31 +47,15 @@ class GraphicBufferMapper : public Singleton<GraphicBufferMapper>
	public:		public:
	static inline GraphicBufferMapper& get() { return getInstance(); }		static inline GraphicBufferMapper& get() { return getInstance(); }

	// This may NOT work on devices without a valid Gralloc2::Mapper.		// The imported outHandle must be freed with freeBuffer when no longer
	status_t registerBuffer(buffer_handle_t handle);		// needed. rawHandle is owned by the caller.
			status_t importBuffer(buffer_handle_t rawHandle,
			buffer_handle_t* outHandle);

	status_t registerBuffer(const GraphicBuffer* buffer);		// This is temporary and will be removed soon
			status_t importBuffer(const GraphicBuffer* buffer);

	status_t unregisterBuffer(buffer_handle_t handle);		status_t freeBuffer(buffer_handle_t handle);

	status_t getDimensions(buffer_handle_t handle,
	uint32_t* outWidth, uint32_t* outHeight) const;

	status_t getFormat(buffer_handle_t handle, int32_t* outFormat) const;

	status_t getLayerCount(buffer_handle_t handle,
	uint32_t* outLayerCount) const;

	status_t getProducerUsage(buffer_handle_t handle,
	uint64_t* outProducerUsage) const;

	status_t getConsumerUsage(buffer_handle_t handle,
	uint64_t* outConsumerUsage) const;

	status_t getBackingStore(buffer_handle_t handle,
	uint64_t* outBackingStore) const;

	status_t getStride(buffer_handle_t handle, uint32_t* outStride) const;

	status_t lock(buffer_handle_t handle,		status_t lock(buffer_handle_t handle,
	uint32_t usage, const Rect& bounds, void** vaddr);		uint32_t usage, const Rect& bounds, void** vaddr);