Merge "Remove DetachedBufferRPC and BufferChannel" (cc19dbb8) · Commits · e / os / platform_frameworks_native

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

+0 −33

Original line number	Diff line number	Diff line
		@@ -162,39 +162,6 @@ class BufferTraits {
		void operator=(const BufferTraits&) = delete;
		};

		struct DetachedBufferRPC {
		private:
		enum {
		kOpDetachedBufferBase = 1000,

		// Allocates a standalone DetachedBuffer not associated with any producer
		// consumer set.
		kOpCreate,

		// Imports the given channel handle to a DetachedBuffer, taking ownership.
		kOpImport,

		// Creates a DetachedBuffer client from an existing one. The new client will
		// share the same underlying gralloc buffer and ashmem region for metadata.
		kOpDuplicate,
		};

		// Aliases.
		using LocalChannelHandle = pdx::LocalChannelHandle;
		using LocalHandle = pdx::LocalHandle;
		using Void = pdx::rpc::Void;

		public:
		PDX_REMOTE_METHOD(Create, kOpCreate,
		void(uint32_t width, uint32_t height, uint32_t layer_count,
		uint32_t format, uint64_t usage,
		size_t user_metadata_size));
		PDX_REMOTE_METHOD(Import, kOpImport, BufferTraits<LocalHandle>(Void));
		PDX_REMOTE_METHOD(Duplicate, kOpDuplicate, LocalChannelHandle(Void));

		PDX_REMOTE_API(API, Create, Import, Duplicate);
		};

		} // namespace dvr
		} // namespace android

services/vr/bufferhubd/Android.bp

+0 −1

Original line number	Diff line number	Diff line
		@@ -28,7 +28,6 @@ sharedLibraries = [
		cc_library_static {
		name: "libbufferhubd",
		srcs: [
		"buffer_channel.cpp",
		"buffer_hub.cpp",
		"consumer_channel.cpp",
		"consumer_queue_channel.cpp",

services/vr/bufferhubd/buffer_channel.cpp

deleted100644 → 0

+0 −138

Original line number	Diff line number	Diff line
		#include <errno.h>
		#include <private/dvr/buffer_channel.h>
		#include <private/dvr/producer_channel.h>

		using android::pdx::BorrowedHandle;
		using android::pdx::ErrorStatus;
		using android::pdx::Message;
		using android::pdx::RemoteChannelHandle;
		using android::pdx::Status;
		using android::pdx::rpc::DispatchRemoteMethod;

		namespace android {
		namespace dvr {

		BufferChannel::BufferChannel(BufferHubService* service, int buffer_id,
		uint32_t width, uint32_t height,
		uint32_t layer_count, uint32_t format,
		uint64_t usage, size_t user_metadata_size)
		: BufferHubChannel(service, buffer_id, buffer_id, kDetachedBufferType) {
		buffer_node_ = std::make_shared<BufferNode>(
		width, height, layer_count, format, usage, user_metadata_size);
		if (!buffer_node_->IsValid()) {
		ALOGE("BufferChannel::BufferChannel: Failed to create BufferNode.");
		return;
		}
		client_state_mask_ = buffer_node_->AddNewActiveClientsBitToMask();
		}

		BufferChannel::BufferChannel(BufferHubService* service, int buffer_id,
		int channel_id,
		std::shared_ptr<BufferNode> buffer_node)
		: BufferHubChannel(service, buffer_id, channel_id, kDetachedBufferType),
		buffer_node_(buffer_node) {
		client_state_mask_ = buffer_node_->AddNewActiveClientsBitToMask();
		if (client_state_mask_ == 0U) {
		ALOGE("BufferChannel::BufferChannel: %s", strerror(errno));
		buffer_node_ = nullptr;
		}
		}

		BufferChannel::~BufferChannel() {
		ALOGD_IF(TRACE, "BufferChannel::~BufferChannel: channel_id=%d buffer_id=%d.",
		channel_id(), buffer_id());
		if (client_state_mask_ != 0U) {
		buffer_node_->RemoveClientsBitFromMask(client_state_mask_);
		}
		Hangup();
		}

		BufferHubChannel::BufferInfo BufferChannel::GetBufferInfo() const {
		return BufferInfo(
		buffer_id(), /consumer_count=/0, buffer_node_->buffer_desc().width,
		buffer_node_->buffer_desc().height, buffer_node_->buffer_desc().layers,
		buffer_node_->buffer_desc().format, buffer_node_->buffer_desc().usage,
		/state=/0, /signaled_mask=/0, /index=/0);
		}

		void BufferChannel::HandleImpulse(Message& /message/) {
		ATRACE_NAME("BufferChannel::HandleImpulse");
		}

		bool BufferChannel::HandleMessage(Message& message) {
		ATRACE_NAME("BufferChannel::HandleMessage");
		switch (message.GetOp()) {
		case DetachedBufferRPC::Import::Opcode:
		DispatchRemoteMethod<DetachedBufferRPC::Import>(
		*this, &BufferChannel::OnImport, message);
		return true;

		case DetachedBufferRPC::Duplicate::Opcode:
		DispatchRemoteMethod<DetachedBufferRPC::Duplicate>(
		*this, &BufferChannel::OnDuplicate, message);
		return true;

		default:
		return false;
		}
		}

		Status<BufferTraits<BorrowedHandle>> BufferChannel::OnImport(
		Message& /message/) {
		ATRACE_NAME("BufferChannel::OnImport");
		ALOGD_IF(TRACE, "BufferChannel::OnImport: buffer=%d.", buffer_id());

		BorrowedHandle ashmem_handle =
		BorrowedHandle(buffer_node_->metadata().ashmem_fd().get());

		// TODO(b/112057680) Move away from the GraphicBuffer-based IonBuffer.
		return BufferTraits<BorrowedHandle>{
		/buffer_handle=/buffer_node_->buffer_handle(),
		/metadata_handle=/ashmem_handle,
		/id=/buffer_id(),
		/client_state_mask=/client_state_mask_,
		/metadata_size=/buffer_node_->metadata().metadata_size(),
		/width=/buffer_node_->buffer_desc().width,
		/height=/buffer_node_->buffer_desc().height,
		/layer_count=/buffer_node_->buffer_desc().layers,
		/format=/buffer_node_->buffer_desc().format,
		/usage=/buffer_node_->buffer_desc().usage,
		/stride=/buffer_node_->buffer_desc().stride,
		/acquire_fence_fd=/BorrowedHandle{},
		/released_fence_fd=/BorrowedHandle{}};
		}

		Status<RemoteChannelHandle> BufferChannel::OnDuplicate(Message& message) {
		ATRACE_NAME("BufferChannel::OnDuplicate");
		ALOGD_IF(TRACE, "BufferChannel::OnDuplicate: buffer=%d.", buffer_id());

		int channel_id;
		auto status = message.PushChannel(0, nullptr, &channel_id);
		if (!status.ok()) {
		ALOGE("BufferChannel::OnDuplicate: Failed to push buffer channel: %s",
		status.GetErrorMessage().c_str());
		return ErrorStatus(ENOMEM);
		}

		auto channel = std::shared_ptr<BufferChannel>(
		new BufferChannel(service(), buffer_id(), channel_id, buffer_node_));
		if (!channel->IsValid()) {
		ALOGE("BufferChannel::OnDuplicate: Invalid buffer. %s", strerror(errno));
		return ErrorStatus(EINVAL);
		}

		const auto channel_status =
		service()->SetChannel(channel_id, std::move(channel));
		if (!channel_status) {
		// Technically, this should never fail, as we just pushed the channel. Note
		// that LOG_FATAL will be stripped out in non-debug build.
		LOG_FATAL(
		"BufferChannel::OnDuplicate: Failed to set new buffer channel: %s.",
		channel_status.GetErrorMessage().c_str());
		}

		return status;
		}

		} // namespace dvr
		} // namespace android

services/vr/bufferhubd/buffer_hub.cpp

+0 −43

Original line number	Diff line number	Diff line
		@@ -10,7 +10,6 @@
		#include <log/log.h>
		#include <pdx/default_transport/service_endpoint.h>
		#include <private/dvr/bufferhub_rpc.h>
		#include <private/dvr/buffer_channel.h>
		#include <private/dvr/buffer_hub.h>
		#include <private/dvr/consumer_channel.h>
		#include <private/dvr/producer_channel.h>
		@@ -242,11 +241,6 @@ pdx::Status<void> BufferHubService::HandleMessage(Message& message) {
		*this, &BufferHubService::OnCreateBuffer, message);
		return {};

		case DetachedBufferRPC::Create::Opcode:
		DispatchRemoteMethod<DetachedBufferRPC::Create>(
		*this, &BufferHubService::OnCreateDetachedBuffer, message);
		return {};

		case BufferHubRPC::CreateProducerQueue::Opcode:
		DispatchRemoteMethod<BufferHubRPC::CreateProducerQueue>(
		*this, &BufferHubService::OnCreateProducerQueue, message);
		@@ -288,43 +282,6 @@ Status<void> BufferHubService::OnCreateBuffer(Message& message, uint32_t width,
		}
		}

		pdx::Status<void> BufferHubService::OnCreateDetachedBuffer(
		pdx::Message& message, uint32_t width, uint32_t height,
		uint32_t layer_count, uint32_t format, uint64_t usage,
		size_t user_metadata_size) {
		// Use the producer channel id as the global buffer id.
		const int buffer_id = message.GetChannelId();
		ALOGD_IF(TRACE,
		"BufferHubService::OnCreateDetachedBuffer: buffer_id=%d width=%u "
		"height=%u layer_count=%u format=%u usage=%" PRIx64
		" user_metadata_size=%zu",
		buffer_id, width, height, layer_count, format, usage,
		user_metadata_size);

		// See if this channel is already attached to a buffer.
		if (const auto channel = message.GetChannel<BufferHubChannel>()) {
		ALOGE(
		"BufferHubService::OnCreateDetachedBuffer: Buffer already created: "
		"buffer=%d",
		buffer_id);
		return ErrorStatus(EALREADY);
		}

		std::unique_ptr<BufferChannel> channel =
		BufferChannel::Create(this, buffer_id, width, height, layer_count, format,
		usage, user_metadata_size);
		if (!channel) {
		ALOGE(
		"BufferHubService::OnCreateDetachedBuffer: Failed to allocate buffer, "
		"buffer=%d.",
		buffer_id);
		return ErrorStatus(ENOMEM);
		}

		message.SetChannel(std::move(channel));
		return {};
		}

		Status<QueueInfo> BufferHubService::OnCreateProducerQueue(
		pdx::Message& message, const ProducerQueueConfig& producer_config,
		const UsagePolicy& usage_policy) {

services/vr/bufferhubd/include/private/dvr/buffer_channel.h

deleted100644 → 0

+0 −61

Original line number	Diff line number	Diff line
		#ifndef ANDROID_DVR_BUFFERHUBD_BUFFER_CHANNEL_H_
		#define ANDROID_DVR_BUFFERHUBD_BUFFER_CHANNEL_H_

		#include <pdx/channel_handle.h>
		#include <pdx/file_handle.h>
		#include <private/dvr/buffer_hub.h>
		#include <private/dvr/buffer_hub_defs.h>
		#include <private/dvr/buffer_node.h>

		namespace android {
		namespace dvr {

		class BufferChannel : public BufferHubChannel {
		public:
		~BufferChannel() override;

		template <typename... Args>
		static std::unique_ptr<BufferChannel> Create(Args&&... args) {
		auto buffer = std::unique_ptr<BufferChannel>(
		new BufferChannel(std::forward<Args>(args)...));
		return buffer->IsValid() ? std::move(buffer) : nullptr;
		}

		// Returns whether the object holds a valid graphic buffer.
		bool IsValid() const {
		return buffer_node_ != nullptr && buffer_node_->IsValid();
		}

		// Captures buffer info for use by BufferHubService::DumpState().
		BufferInfo GetBufferInfo() const override;

		bool HandleMessage(pdx::Message& message) override;
		void HandleImpulse(pdx::Message& message) override;

		private:

		// Allocates a new detached buffer.
		BufferChannel(BufferHubService* service, int buffer_id, uint32_t width,
		uint32_t height, uint32_t layer_count, uint32_t format,
		uint64_t usage, size_t user_metadata_size);

		// Creates a detached buffer from an existing BufferNode. This method is used
		// in OnDuplicate method.
		BufferChannel(BufferHubService* service, int buffer_id, int channel_id,
		std::shared_ptr<BufferNode> buffer_node);

		pdx::Status<BufferTraits<pdx::BorrowedHandle>> OnImport(
		pdx::Message& message);
		pdx::Status<pdx::RemoteChannelHandle> OnDuplicate(pdx::Message& message);

		// The concrete implementation of the Buffer object.
		std::shared_ptr<BufferNode> buffer_node_ = nullptr;

		// The state bit of this buffer.
		uint32_t client_state_mask_ = 0U;
		};

		} // namespace dvr
		} // namespace android

		#endif // ANDROID_DVR_BUFFERHUBD_BUFFER_CHANNEL_H_