Move bufferpool@1.0 to frameworks (d79b6dac) · Commits · e / os / android_frameworks_av

media/bufferpool/1.0/Accessor.cpp

0 → 100644

+201 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2018 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.
		*/
		#define LOG_TAG "BufferPoolConnection"

		#include "Accessor.h"
		#include "AccessorImpl.h"
		#include "Connection.h"

		namespace android {
		namespace hardware {
		namespace media {
		namespace bufferpool {
		namespace V1_0 {
		namespace implementation {

		void ConnectionDeathRecipient::add(
		int64_t connectionId,
		const sp<Accessor> &accessor) {
		std::lock_guard<std::mutex> lock(mLock);
		if (mAccessors.find(connectionId) == mAccessors.end()) {
		mAccessors.insert(std::make_pair(connectionId, accessor));
		}
		}

		void ConnectionDeathRecipient::remove(int64_t connectionId) {
		std::lock_guard<std::mutex> lock(mLock);
		mAccessors.erase(connectionId);
		auto it = mConnectionToCookie.find(connectionId);
		if (it != mConnectionToCookie.end()) {
		uint64_t cookie = it->second;
		mConnectionToCookie.erase(it);
		auto cit = mCookieToConnections.find(cookie);
		if (cit != mCookieToConnections.end()) {
		cit->second.erase(connectionId);
		if (cit->second.size() == 0) {
		mCookieToConnections.erase(cit);
		}
		}
		}
		}

		void ConnectionDeathRecipient::addCookieToConnection(
		uint64_t cookie,
		int64_t connectionId) {
		std::lock_guard<std::mutex> lock(mLock);
		if (mAccessors.find(connectionId) == mAccessors.end()) {
		return;
		}
		mConnectionToCookie.insert(std::make_pair(connectionId, cookie));
		auto it = mCookieToConnections.find(cookie);
		if (it != mCookieToConnections.end()) {
		it->second.insert(connectionId);
		} else {
		mCookieToConnections.insert(std::make_pair(
		cookie, std::set<int64_t>{connectionId}));
		}
		}

		void ConnectionDeathRecipient::serviceDied(
		uint64_t cookie,
		const wp<::android::hidl::base::V1_0::IBase>& /* who */
		) {
		std::map<int64_t, const wp<Accessor>> connectionsToClose;
		{
		std::lock_guard<std::mutex> lock(mLock);

		auto it = mCookieToConnections.find(cookie);
		if (it != mCookieToConnections.end()) {
		for (auto conIt = it->second.begin(); conIt != it->second.end(); ++conIt) {
		auto accessorIt = mAccessors.find(*conIt);
		if (accessorIt != mAccessors.end()) {
		connectionsToClose.insert(std::make_pair(*conIt, accessorIt->second));
		mAccessors.erase(accessorIt);
		}
		mConnectionToCookie.erase(*conIt);
		}
		mCookieToConnections.erase(it);
		}
		}

		if (connectionsToClose.size() > 0) {
		sp<Accessor> accessor;
		for (auto it = connectionsToClose.begin(); it != connectionsToClose.end(); ++it) {
		accessor = it->second.promote();

		if (accessor) {
		accessor->close(it->first);
		ALOGD("connection %lld closed on death", (long long)it->first);
		}
		}
		}
		}

		namespace {
		static sp<ConnectionDeathRecipient> sConnectionDeathRecipient =
		new ConnectionDeathRecipient();
		}

		sp<ConnectionDeathRecipient> Accessor::getConnectionDeathRecipient() {
		return sConnectionDeathRecipient;
		}

		// Methods from ::android::hardware::media::bufferpool::V1_0::IAccessor follow.
		Return<void> Accessor::connect(connect_cb _hidl_cb) {
		sp<Connection> connection;
		ConnectionId connectionId;
		const QueueDescriptor* fmqDesc;

		ResultStatus status = connect(&connection, &connectionId, &fmqDesc, false);
		if (status == ResultStatus::OK) {
		_hidl_cb(status, connection, connectionId, *fmqDesc);
		} else {
		_hidl_cb(status, nullptr, -1LL,
		android::hardware::MQDescriptorSync<BufferStatusMessage>(
		std::vector<android::hardware::GrantorDescriptor>(),
		nullptr /* nhandle /, 0 / size */));
		}
		return Void();
		}

		Accessor::Accessor(const std::shared_ptr<BufferPoolAllocator> &allocator)
		: mImpl(new Impl(allocator)) {}

		Accessor::~Accessor() {
		}

		bool Accessor::isValid() {
		return (bool)mImpl;
		}

		ResultStatus Accessor::allocate(
		ConnectionId connectionId,
		const std::vector<uint8_t> &params,
		BufferId bufferId, const native_handle_t* handle) {
		if (mImpl) {
		return mImpl->allocate(connectionId, params, bufferId, handle);
		}
		return ResultStatus::CRITICAL_ERROR;
		}

		ResultStatus Accessor::fetch(
		ConnectionId connectionId, TransactionId transactionId,
		BufferId bufferId, const native_handle_t** handle) {
		if (mImpl) {
		return mImpl->fetch(connectionId, transactionId, bufferId, handle);
		}
		return ResultStatus::CRITICAL_ERROR;
		}

		ResultStatus Accessor::connect(
		sp<Connection> connection, ConnectionId pConnectionId,
		const QueueDescriptor** fmqDescPtr, bool local) {
		if (mImpl) {
		ResultStatus status = mImpl->connect(this, connection, pConnectionId, fmqDescPtr);
		if (!local && status == ResultStatus::OK) {
		sp<Accessor> accessor(this);
		sConnectionDeathRecipient->add(*pConnectionId, accessor);
		}
		return status;
		}
		return ResultStatus::CRITICAL_ERROR;
		}

		ResultStatus Accessor::close(ConnectionId connectionId) {
		if (mImpl) {
		ResultStatus status = mImpl->close(connectionId);
		sConnectionDeathRecipient->remove(connectionId);
		return status;
		}
		return ResultStatus::CRITICAL_ERROR;
		}

		void Accessor::cleanUp(bool clearCache) {
		if (mImpl) {
		mImpl->cleanUp(clearCache);
		}
		}

		//IAccessor* HIDL_FETCH_IAccessor(const char* /* name */) {
		// return new Accessor();
		//}

		} // namespace implementation
		} // namespace V1_0
		} // namespace bufferpool
		} // namespace media
		} // namespace hardware
		} // namespace android

media/bufferpool/1.0/Accessor.h

0 → 100644

+188 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2018 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_HARDWARE_MEDIA_BUFFERPOOL_V1_0_ACCESSOR_H
		#define ANDROID_HARDWARE_MEDIA_BUFFERPOOL_V1_0_ACCESSOR_H

		#include <android/hardware/media/bufferpool/1.0/IAccessor.h>
		#include <bufferpool/BufferPoolTypes.h>
		#include <hidl/MQDescriptor.h>
		#include <hidl/Status.h>
		#include "BufferStatus.h"

		#include <set>

		namespace android {
		namespace hardware {
		namespace media {
		namespace bufferpool {
		namespace V1_0 {
		namespace implementation {

		using ::android::hardware::hidl_array;
		using ::android::hardware::hidl_memory;
		using ::android::hardware::hidl_string;
		using ::android::hardware::hidl_vec;
		using ::android::hardware::Return;
		using ::android::hardware::Void;
		using ::android::sp;

		struct Accessor;
		struct Connection;

		/**
		* Receives death notifications from remote connections.
		* On death notifications, the connections are closed and used resources
		* are released.
		*/
		struct ConnectionDeathRecipient : public hardware::hidl_death_recipient {
		/**
		* Registers a newly connected connection from remote processes.
		*/
		void add(int64_t connectionId, const sp<Accessor> &accessor);

		/**
		* Removes a connection.
		*/
		void remove(int64_t connectionId);

		void addCookieToConnection(uint64_t cookie, int64_t connectionId);

		virtual void serviceDied(
		uint64_t /* cookie */,
		const wp<::android::hidl::base::V1_0::IBase>& /* who */
		) override;

		private:
		std::mutex mLock;
		std::map<uint64_t, std::set<int64_t>> mCookieToConnections;
		std::map<int64_t, uint64_t> mConnectionToCookie;
		std::map<int64_t, const wp<Accessor>> mAccessors;
		};

		/**
		* A buffer pool accessor which enables a buffer pool to communicate with buffer
		* pool clients. 1:1 correspondense holds between a buffer pool and an accessor.
		*/
		struct Accessor : public IAccessor {
		// Methods from ::android::hardware::media::bufferpool::V1_0::IAccessor follow.
		Return<void> connect(connect_cb _hidl_cb) override;

		/**
		* Creates a buffer pool accessor which uses the specified allocator.
		*
		* @param allocator buffer allocator.
		*/
		explicit Accessor(const std::shared_ptr<BufferPoolAllocator> &allocator);

		/** Destructs a buffer pool accessor. */
		~Accessor();

		/** Returns whether the accessor is valid. */
		bool isValid();

		/** Allocates a buffer from a buffer pool.
		*
		* @param connectionId the connection id of the client.
		* @param params the allocation parameters.
		* @param bufferId the id of the allocated buffer.
		* @param handle the native handle of the allocated buffer.
		*
		* @return OK when a buffer is successfully allocated.
		* NO_MEMORY when there is no memory.
		* CRITICAL_ERROR otherwise.
		*/
		ResultStatus allocate(
		ConnectionId connectionId,
		const std::vector<uint8_t>& params,
		BufferId *bufferId,
		const native_handle_t** handle);

		/**
		* Fetches a buffer for the specified transaction.
		*
		* @param connectionId the id of receiving connection(client).
		* @param transactionId the id of the transfer transaction.
		* @param bufferId the id of the buffer to be fetched.
		* @param handle the native handle of the fetched buffer.
		*
		* @return OK when a buffer is successfully fetched.
		* NO_MEMORY when there is no memory.
		* CRITICAL_ERROR otherwise.
		*/
		ResultStatus fetch(
		ConnectionId connectionId,
		TransactionId transactionId,
		BufferId bufferId,
		const native_handle_t** handle);

		/**
		* Makes a connection to the buffer pool. The buffer pool client uses the
		* created connection in order to communicate with the buffer pool. An
		* FMQ for buffer status message is also created for the client.
		*
		* @param connection created connection
		* @param pConnectionId the id of the created connection
		* @param fmqDescPtr FMQ descriptor for shared buffer status message
		* queue between a buffer pool and the client.
		* @param local true when a connection request comes from local process,
		* false otherwise.
		*
		* @return OK when a connection is successfully made.
		* NO_MEMORY when there is no memory.
		* CRITICAL_ERROR otherwise.
		*/
		ResultStatus connect(
		sp<Connection> connection, ConnectionId pConnectionId,
		const QueueDescriptor** fmqDescPtr, bool local);

		/**
		* Closes the specified connection to the client.
		*
		* @param connectionId the id of the connection.
		*
		* @return OK when the connection is closed.
		* CRITICAL_ERROR otherwise.
		*/
		ResultStatus close(ConnectionId connectionId);

		/**
		* Processes pending buffer status messages and perfoms periodic cache
		* cleaning.
		*
		* @param clearCache if clearCache is true, it frees all buffers waiting
		* to be recycled.
		*/
		void cleanUp(bool clearCache);

		/**
		* Gets a hidl_death_recipient for remote connection death.
		*/
		static sp<ConnectionDeathRecipient> getConnectionDeathRecipient();

		private:
		class Impl;
		std::unique_ptr<Impl> mImpl;
		};

		} // namespace implementation
		} // namespace V1_0
		} // namespace bufferpool
		} // namespace media
		} // namespace hardware
		} // namespace android

		#endif // ANDROID_HARDWARE_MEDIA_BUFFERPOOL_V1_0_ACCESSOR_H