Merge "Deprecate producer/consumer usage: Step 2" into oc-dev (35c17092) · Commits · e / os / android_frameworks_native-old

libs/vr/libbufferhub/buffer_hub_client.cpp

+12 −6

Original line number	Diff line number	Diff line
		@@ -216,8 +216,9 @@ BufferProducer::BufferProducer(uint32_t width, uint32_t height, uint32_t format,
		event_fd(), width, height, format, producer_usage, consumer_usage,
		metadata_size, slice_count);

		// (b/37881101) Deprecate producer/consumer usage
		auto status = InvokeRemoteMethod<BufferHubRPC::CreateBuffer>(
		width, height, format, producer_usage, consumer_usage, metadata_size,
		width, height, format, (producer_usage \| consumer_usage), metadata_size,
		slice_count);
		if (!status) {
		ALOGE(
		@@ -257,9 +258,10 @@ BufferProducer::BufferProducer(const std::string& name, int user_id,
		event_fd(), name.c_str(), user_id, group_id, width, height, format,
		producer_usage, consumer_usage, meta_size_bytes, slice_count);

		// (b/37881101) Deprecate producer/consumer usage
		auto status = InvokeRemoteMethod<BufferHubRPC::CreatePersistentBuffer>(
		name, user_id, group_id, width, height, format, producer_usage,
		consumer_usage, meta_size_bytes, slice_count);
		name, user_id, group_id, width, height, format,
		(producer_usage \| consumer_usage), meta_size_bytes, slice_count);
		if (!status) {
		ALOGE(
		"BufferProducer::BufferProducer: Failed to create/get persistent "
		@@ -295,8 +297,10 @@ BufferProducer::BufferProducer(uint64_t producer_usage, uint64_t consumer_usage,
		const int format = HAL_PIXEL_FORMAT_BLOB;
		const size_t meta_size_bytes = 0;
		const size_t slice_count = 1;

		// (b/37881101) Deprecate producer/consumer usage
		auto status = InvokeRemoteMethod<BufferHubRPC::CreateBuffer>(
		width, height, format, producer_usage, consumer_usage, meta_size_bytes,
		width, height, format, (producer_usage \| consumer_usage), meta_size_bytes,
		slice_count);
		if (!status) {
		ALOGE("BufferProducer::BufferProducer: Failed to create blob: %s",
		@@ -333,9 +337,11 @@ BufferProducer::BufferProducer(const std::string& name, int user_id,
		const int format = HAL_PIXEL_FORMAT_BLOB;
		const size_t meta_size_bytes = 0;
		const size_t slice_count = 1;

		// (b/37881101) Deprecate producer/consumer usage
		auto status = InvokeRemoteMethod<BufferHubRPC::CreatePersistentBuffer>(
		name, user_id, group_id, width, height, format, producer_usage,
		consumer_usage, meta_size_bytes, slice_count);
		name, user_id, group_id, width, height, format,
		(producer_usage \| consumer_usage), meta_size_bytes, slice_count);
		if (!status) {
		ALOGE(
		"BufferProducer::BufferProducer: Failed to create persistent "

libs/vr/libbufferhub/include/private/dvr/bufferhub_rpc.h

+20 −31

Original line number	Diff line number	Diff line
		@@ -24,8 +24,7 @@ class NativeBufferHandle {
		width_(buffer.width()),
		height_(buffer.height()),
		format_(buffer.format()),
		producer_usage_(buffer.usage()),
		consumer_usage_(buffer.usage()) {
		usage_(buffer.usage()) {
		// Populate the fd and int vectors: native_handle->data[] is an array of fds
		// followed by an array of opaque ints.
		const int fd_count = buffer.handle()->numFds;
		@@ -48,11 +47,9 @@ class NativeBufferHandle {
		for (const auto& fd : fds_)
		fd_ints.push_back(fd.Get());

		// TODO(b/37881101) Get rid of producer/consumer usage.
		const int ret =
		buffer->Import(fd_ints.data(), fd_ints.size(), opaque_ints_.data(),
		opaque_ints_.size(), width_, height_, stride_, format_,
		(producer_usage_ \| consumer_usage_));
		const int ret = buffer->Import(fd_ints.data(), fd_ints.size(),
		opaque_ints_.data(), opaque_ints_.size(),
		width_, height_, stride_, format_, usage_);
		if (ret < 0)
		return ret;

		@@ -76,20 +73,18 @@ class NativeBufferHandle {
		uint32_t width_;
		uint32_t height_;
		uint32_t format_;
		uint64_t producer_usage_;
		uint64_t consumer_usage_;
		uint64_t usage_;
		std::vector<int> opaque_ints_;
		std::vector<FileHandleType> fds_;

		void Clear() {
		id_ = -1;
		stride_ = width_ = height_ = format_ = producer_usage_ = consumer_usage_ =
		0;
		stride_ = width_ = height_ = format_ = usage_ = 0;
		}

		PDX_SERIALIZABLE_MEMBERS(NativeBufferHandle<FileHandleType>, id_, stride_,
		width_, height_, format_, producer_usage_,
		consumer_usage_, opaque_ints_, fds_);
		width_, height_, format_, usage_, opaque_ints_,
		fds_);

		NativeBufferHandle(const NativeBufferHandle&) = delete;
		void operator=(const NativeBufferHandle&) = delete;
		@@ -140,20 +135,14 @@ struct QueueInfo {
		};

		struct UsagePolicy {
		uint64_t producer_set_mask;
		uint64_t producer_clear_mask;
		uint64_t producer_deny_set_mask;
		uint64_t producer_deny_clear_mask;
		uint64_t consumer_set_mask;
		uint64_t consumer_clear_mask;
		uint64_t consumer_deny_set_mask;
		uint64_t consumer_deny_clear_mask;
		uint64_t usage_set_mask;
		uint64_t usage_clear_mask;
		uint64_t usage_deny_set_mask;
		uint64_t usage_deny_clear_mask;

		private:
		PDX_SERIALIZABLE_MEMBERS(UsagePolicy, producer_set_mask, producer_clear_mask,
		producer_deny_set_mask, producer_deny_clear_mask,
		consumer_set_mask, consumer_clear_mask,
		consumer_deny_set_mask, consumer_deny_clear_mask);
		PDX_SERIALIZABLE_MEMBERS(UsagePolicy, usage_set_mask, usage_clear_mask,
		usage_deny_set_mask, usage_deny_clear_mask);
		};

		// BufferHub Service RPC interface. Defines the endpoints, op codes, and method
		@@ -203,13 +192,13 @@ struct BufferHubRPC {
		// Methods.
		PDX_REMOTE_METHOD(CreateBuffer, kOpCreateBuffer,
		void(uint32_t width, uint32_t height, uint32_t format,
		uint64_t producer_usage, uint64_t consumer_usage,
		size_t meta_size_bytes, size_t slice_count));
		uint64_t usage, size_t meta_size_bytes,
		size_t slice_count));
		PDX_REMOTE_METHOD(CreatePersistentBuffer, kOpCreatePersistentBuffer,
		void(const std::string& name, int user_id, int group_id,
		uint32_t width, uint32_t height, uint32_t format,
		uint64_t producer_usage, uint64_t consumer_usage,
		size_t meta_size_bytes, size_t slice_count));
		uint64_t usage, size_t meta_size_bytes,
		size_t slice_count));
		PDX_REMOTE_METHOD(GetPersistentBuffer, kOpGetPersistentBuffer,
		void(const std::string& name));
		PDX_REMOTE_METHOD(GetBuffer, kOpGetBuffer,
		@@ -241,8 +230,8 @@ struct BufferHubRPC {
		kOpProducerQueueAllocateBuffers,
		std::vector<std::pair<LocalChannelHandle, size_t>>(
		uint32_t width, uint32_t height, uint32_t format,
		uint64_t producer_usage, uint64_t consumer_usage,
		size_t slice_count, size_t buffer_count));
		uint64_t usage, size_t slice_count,
		size_t buffer_count));
		PDX_REMOTE_METHOD(ProducerQueueDetachBuffer, kOpProducerQueueDetachBuffer,
		void(size_t slot));
		PDX_REMOTE_METHOD(ConsumerQueueImportBuffers, kOpConsumerQueueImportBuffers,

libs/vr/libbufferhubqueue/buffer_hub_queue_client.cpp

+9 −27

Original line number	Diff line number	Diff line
		@@ -317,7 +317,7 @@ std::shared_ptr<BufferHubBuffer> BufferHubQueue::Dequeue(int timeout,
		}

		ProducerQueue::ProducerQueue(size_t meta_size)
		: ProducerQueue(meta_size, 0, 0, 0, 0, 0, 0, 0, 0) {}
		: ProducerQueue(meta_size, 0, 0, 0, 0) {}

		ProducerQueue::ProducerQueue(LocalChannelHandle handle)
		: BASE(std::move(handle)) {
		@@ -329,22 +329,14 @@ ProducerQueue::ProducerQueue(LocalChannelHandle handle)
		}
		}

		ProducerQueue::ProducerQueue(size_t meta_size, uint64_t producer_usage_set_mask,
		uint64_t producer_usage_clear_mask,
		uint64_t producer_usage_deny_set_mask,
		uint64_t producer_usage_deny_clear_mask,
		uint64_t consumer_usage_set_mask,
		uint64_t consumer_usage_clear_mask,
		uint64_t consumer_usage_deny_set_mask,
		uint64_t consumer_usage_deny_clear_mask)
		ProducerQueue::ProducerQueue(size_t meta_size, uint64_t usage_set_mask,
		uint64_t usage_clear_mask,
		uint64_t usage_deny_set_mask,
		uint64_t usage_deny_clear_mask)
		: BASE(BufferHubRPC::kClientPath) {
		auto status = InvokeRemoteMethod<BufferHubRPC::CreateProducerQueue>(
		meta_size,
		UsagePolicy{producer_usage_set_mask, producer_usage_clear_mask,
		producer_usage_deny_set_mask, producer_usage_deny_clear_mask,
		consumer_usage_set_mask, consumer_usage_clear_mask,
		consumer_usage_deny_set_mask,
		consumer_usage_deny_clear_mask});
		meta_size, UsagePolicy{usage_set_mask, usage_clear_mask,
		usage_deny_set_mask, usage_deny_clear_mask});
		if (!status) {
		ALOGE("ProducerQueue::ProducerQueue: Failed to create producer queue: %s",
		status.GetErrorMessage().c_str());
		@@ -356,16 +348,8 @@ ProducerQueue::ProducerQueue(size_t meta_size, uint64_t producer_usage_set_mask,
		}

		int ProducerQueue::AllocateBuffer(uint32_t width, uint32_t height,
		uint32_t format, uint32_t usage,
		uint32_t format, uint64_t usage,
		size_t slice_count, size_t* out_slot) {
		return AllocateBuffer(width, height, format, usage, usage, slice_count,
		out_slot);
		}

		int ProducerQueue::AllocateBuffer(uint32_t width, uint32_t height,
		uint32_t format, uint64_t producer_usage,
		uint64_t consumer_usage, size_t slice_count,
		size_t* out_slot) {
		if (out_slot == nullptr) {
		ALOGE("ProducerQueue::AllocateBuffer: Parameter out_slot cannot be null.");
		return -EINVAL;
		@@ -378,11 +362,9 @@ int ProducerQueue::AllocateBuffer(uint32_t width, uint32_t height,
		}

		const size_t kBufferCount = 1U;

		Status<std::vector<std::pair<LocalChannelHandle, size_t>>> status =
		InvokeRemoteMethod<BufferHubRPC::ProducerQueueAllocateBuffers>(
		width, height, format, producer_usage, consumer_usage, slice_count,
		kBufferCount);
		width, height, format, usage, slice_count, kBufferCount);
		if (!status) {
		ALOGE(
		"ProducerQueue::AllocateBuffer failed to create producer buffer "

libs/vr/libbufferhubqueue/include/private/dvr/buffer_hub_queue_client.h

+5 −28

Original line number	Diff line number	Diff line
		@@ -279,22 +279,7 @@ class ProducerQueue : public pdx::ClientBase<ProducerQueue, BufferHubQueue> {
		uint32_t usage_deny_set_mask,
		uint32_t usage_deny_clear_mask) {
		return BASE::Create(sizeof(Meta), usage_set_mask, usage_clear_mask,
		usage_deny_set_mask, usage_deny_clear_mask,
		usage_set_mask, usage_clear_mask, usage_deny_set_mask,
		usage_deny_clear_mask);
		}
		template <typename Meta>
		static std::unique_ptr<ProducerQueue> Create(
		uint64_t producer_usage_set_mask, uint64_t producer_usage_clear_mask,
		uint64_t producer_usage_deny_set_mask,
		uint64_t producer_usage_deny_clear_mask, uint64_t consumer_usage_set_mask,
		uint64_t consumer_usage_clear_mask, uint64_t consumer_usage_deny_set_mask,
		uint64_t consumer_usage_deny_clear_mask) {
		return BASE::Create(sizeof(Meta), producer_usage_set_mask,
		producer_usage_clear_mask, producer_usage_deny_set_mask,
		producer_usage_deny_clear_mask, consumer_usage_set_mask,
		consumer_usage_clear_mask, consumer_usage_deny_set_mask,
		consumer_usage_deny_clear_mask);
		usage_deny_set_mask, usage_deny_clear_mask);
		}

		// Import a \|ProducerQueue\| from a channel handle.
		@@ -317,10 +302,7 @@ class ProducerQueue : public pdx::ClientBase<ProducerQueue, BufferHubQueue> {
		// Returns Zero on success and negative error code when buffer allocation
		// fails.
		int AllocateBuffer(uint32_t width, uint32_t height, uint32_t format,
		uint32_t usage, size_t slice_count, size_t* out_slot);
		int AllocateBuffer(uint32_t width, uint32_t height, uint32_t format,
		uint64_t producer_usage, uint64_t consumer_usage,
		size_t slice_count, size_t* out_slot);
		uint64_t usage, size_t slice_count, size_t* out_slot);

		// Add a producer buffer to populate the queue. Once added, a producer buffer
		// is available to use (i.e. in \|Gain\|'ed mode).
		@@ -345,14 +327,9 @@ class ProducerQueue : public pdx::ClientBase<ProducerQueue, BufferHubQueue> {
		// arguments as the constructors.
		explicit ProducerQueue(size_t meta_size);
		ProducerQueue(LocalChannelHandle handle);
		ProducerQueue(size_t meta_size, uint64_t producer_usage_set_mask,
		uint64_t producer_usage_clear_mask,
		uint64_t producer_usage_deny_set_mask,
		uint64_t producer_usage_deny_clear_mask,
		uint64_t consumer_usage_set_mask,
		uint64_t consumer_usage_clear_mask,
		uint64_t consumer_usage_deny_set_mask,
		uint64_t consumer_usage_deny_clear_mask);
		ProducerQueue(size_t meta_size, uint64_t usage_set_mask,
		uint64_t usage_clear_mask, uint64_t usage_deny_set_mask,
		uint64_t usage_deny_clear_mask);

		int OnBufferReady(std::shared_ptr<BufferHubBuffer> buf,
		LocalHandle* release_fence) override;

libs/vr/libdisplay/display_manager_client_impl.cpp

+2 −3

Original line number	Diff line number	Diff line
		@@ -32,10 +32,9 @@ int DisplayManagerClient::GetSurfaceList(
		}

		std::unique_ptr<IonBuffer> DisplayManagerClient::SetupNamedBuffer(
		const std::string& name, size_t size, uint64_t producer_usage,
		uint64_t consumer_usage) {
		const std::string& name, size_t size, uint64_t usage) {
		auto status = InvokeRemoteMethod<DisplayManagerRPC::SetupNamedBuffer>(
		name, size, producer_usage, consumer_usage);
		name, size, usage);
		if (!status) {
		ALOGE(
		"DisplayManagerClient::SetupNamedBuffer: Failed to create the named "