Merge "Move bufferpool@1.0 to frameworks" (dcfd26ee) · Commits · e / os / android_frameworks_av

media/bufferpool/1.0/Accessor.cpp

0 → 100644

+201 −0

Original line number	Original line	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	Original line	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

media/bufferpool/1.0/AccessorImpl.cpp

0 → 100644

+543 −0

File added.

Preview size limit exceeded, changes collapsed.

media/bufferpool/1.0/AccessorImpl.h

0 → 100644

+300 −0

Original line number	Original line	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_ACCESSORIMPL_H
			#define ANDROID_HARDWARE_MEDIA_BUFFERPOOL_V1_0_ACCESSORIMPL_H

			#include <map>
			#include <set>
			#include "Accessor.h"

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

			struct InternalBuffer;
			struct TransactionStatus;

			/**
			* An implementation of a buffer pool accessor(or a buffer pool implementation.) */
			class Accessor::Impl {
			public:
			Impl(const std::shared_ptr<BufferPoolAllocator> &allocator);

			~Impl();

			ResultStatus connect(
			const sp<Accessor> &accessor, sp<Connection> *connection,
			ConnectionId pConnectionId, const QueueDescriptor* fmqDescPtr);

			ResultStatus close(ConnectionId connectionId);

			ResultStatus allocate(ConnectionId connectionId,
			const std::vector<uint8_t>& params,
			BufferId *bufferId,
			const native_handle_t** handle);

			ResultStatus fetch(ConnectionId connectionId,
			TransactionId transactionId,
			BufferId bufferId,
			const native_handle_t** handle);

			void cleanUp(bool clearCache);

			private:
			// ConnectionId = pid : (timestamp_created + seqId)
			// in order to guarantee uniqueness for each connection
			static uint32_t sSeqId;
			static int32_t sPid;

			const std::shared_ptr<BufferPoolAllocator> mAllocator;

			/**
			* Buffer pool implementation.
			*
			* Handles buffer status messages. Handles buffer allocation/recycling.
			* Handles buffer transfer between buffer pool clients.
			*/
			struct BufferPool {
			private:
			std::mutex mMutex;
			int64_t mTimestampUs;
			int64_t mLastCleanUpUs;
			int64_t mLastLogUs;
			BufferId mSeq;
			BufferStatusObserver mObserver;

			std::map<ConnectionId, std::set<BufferId>> mUsingBuffers;
			std::map<BufferId, std::set<ConnectionId>> mUsingConnections;

			std::map<ConnectionId, std::set<TransactionId>> mPendingTransactions;
			// Transactions completed before TRANSFER_TO message arrival.
			// Fetch does not occur for the transactions.
			// Only transaction id is kept for the transactions in short duration.
			std::set<TransactionId> mCompletedTransactions;
			// Currently active(pending) transations' status & information.
			std::map<TransactionId, std::unique_ptr<TransactionStatus>>
			mTransactions;

			std::map<BufferId, std::unique_ptr<InternalBuffer>> mBuffers;
			std::set<BufferId> mFreeBuffers;

			/// Buffer pool statistics which tracks allocation and transfer statistics.
			struct Stats {
			/// Total size of allocations which are used or available to use.
			/// (bytes or pixels)
			size_t mSizeCached;
			/// # of cached buffers which are used or available to use.
			size_t mBuffersCached;
			/// Total size of allocations which are currently used. (bytes or pixels)
			size_t mSizeInUse;
			/// # of currently used buffers
			size_t mBuffersInUse;

			/// # of allocations called on bufferpool. (# of fetched from BlockPool)
			size_t mTotalAllocations;
			/// # of allocations that were served from the cache.
			/// (# of allocator alloc prevented)
			size_t mTotalRecycles;
			/// # of buffer transfers initiated.
			size_t mTotalTransfers;
			/// # of transfers that had to be fetched.
			size_t mTotalFetches;

			Stats()
			: mSizeCached(0), mBuffersCached(0), mSizeInUse(0), mBuffersInUse(0),
			mTotalAllocations(0), mTotalRecycles(0), mTotalTransfers(0), mTotalFetches(0) {}

			/// A new buffer is allocated on an allocation request.
			void onBufferAllocated(size_t allocSize) {
			mSizeCached += allocSize;
			mBuffersCached++;

			mSizeInUse += allocSize;
			mBuffersInUse++;

			mTotalAllocations++;
			}

			/// A buffer is evicted and destroyed.
			void onBufferEvicted(size_t allocSize) {
			mSizeCached -= allocSize;
			mBuffersCached--;
			}

			/// A buffer is recycled on an allocation request.
			void onBufferRecycled(size_t allocSize) {
			mSizeInUse += allocSize;
			mBuffersInUse++;

			mTotalAllocations++;
			mTotalRecycles++;
			}

			/// A buffer is available to be recycled.
			void onBufferUnused(size_t allocSize) {
			mSizeInUse -= allocSize;
			mBuffersInUse--;
			}

			/// A buffer transfer is initiated.
			void onBufferSent() {
			mTotalTransfers++;
			}

			/// A buffer fetch is invoked by a buffer transfer.
			void onBufferFetched() {
			mTotalFetches++;
			}
			} mStats;

			public:
			/** Creates a buffer pool. */
			BufferPool();

			/** Destroys a buffer pool. */
			~BufferPool();

			/**
			* Processes all pending buffer status messages, and returns the result.
			* Each status message is handled by methods with 'handle' prefix.
			*/
			void processStatusMessages();

			/**
			* Handles a buffer being owned by a connection.
			*
			* @param connectionId the id of the buffer owning connection.
			* @param bufferId the id of the buffer.
			*
			* @return {@code true} when the buffer is owned,
			* {@code false} otherwise.
			*/
			bool handleOwnBuffer(ConnectionId connectionId, BufferId bufferId);

			/**
			* Handles a buffer being released by a connection.
			*
			* @param connectionId the id of the buffer owning connection.
			* @param bufferId the id of the buffer.
			*
			* @return {@code true} when the buffer ownership is released,
			* {@code false} otherwise.
			*/
			bool handleReleaseBuffer(ConnectionId connectionId, BufferId bufferId);

			/**
			* Handles a transfer transaction start message from the sender.
			*
			* @param message a buffer status message for the transaction.
			*
			* @result {@code true} when transfer_to message is acknowledged,
			* {@code false} otherwise.
			*/
			bool handleTransferTo(const BufferStatusMessage &message);

			/**
			* Handles a transfer transaction being acked by the receiver.
			*
			* @param message a buffer status message for the transaction.
			*
			* @result {@code true} when transfer_from message is acknowledged,
			* {@code false} otherwise.
			*/
			bool handleTransferFrom(const BufferStatusMessage &message);

			/**
			* Handles a transfer transaction result message from the receiver.
			*
			* @param message a buffer status message for the transaction.
			*
			* @result {@code true} when the exisitng transaction is finished,
			* {@code false} otherwise.
			*/
			bool handleTransferResult(const BufferStatusMessage &message);

			/**
			* Handles a connection being closed, and returns the result. All the
			* buffers and transactions owned by the connection will be cleaned up.
			* The related FMQ will be cleaned up too.
			*
			* @param connectionId the id of the connection.
			*
			* @result {@code true} when the connection existed,
			* {@code false} otherwise.
			*/
			bool handleClose(ConnectionId connectionId);

			/**
			* Recycles a existing free buffer if it is possible.
			*
			* @param allocator the buffer allocator
			* @param params the allocation parameters.
			* @param pId the id of the recycled buffer.
			* @param handle the native handle of the recycled buffer.
			*
			* @return {@code true} when a buffer is recycled, {@code false}
			* otherwise.
			*/
			bool getFreeBuffer(
			const std::shared_ptr<BufferPoolAllocator> &allocator,
			const std::vector<uint8_t> &params,
			BufferId pId, const native_handle_t *handle);

			/**
			* Adds a newly allocated buffer to bufferpool.
			*
			* @param alloc the newly allocated buffer.
			* @param allocSize the size of the newly allocated buffer.
			* @param params the allocation parameters.
			* @param pId the buffer id for the newly allocated buffer.
			* @param handle the native handle for the newly allocated buffer.
			*
			* @return OK when an allocation is successfully allocated.
			* NO_MEMORY when there is no memory.
			* CRITICAL_ERROR otherwise.
			*/
			ResultStatus addNewBuffer(
			const std::shared_ptr<BufferPoolAllocation> &alloc,
			const size_t allocSize,
			const std::vector<uint8_t> &params,
			BufferId *pId,
			const native_handle_t **handle);

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

			friend class Accessor::Impl;
			} mBufferPool;
			};

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

			#endif // ANDROID_HARDWARE_MEDIA_BUFFERPOOL_V1_0_ACCESSORIMPL_H

media/bufferpool/1.0/Android.bp

0 → 100644

+29 −0

Original line number	Original line	Diff line number	Diff line
			cc_library {
			name: "libstagefright_bufferpool@1.0",
			vendor_available: true,
			srcs: [
			"Accessor.cpp",
			"AccessorImpl.cpp",
			"BufferPoolClient.cpp",
			"BufferStatus.cpp",
			"ClientManager.cpp",
			"Connection.cpp",
			],
			export_include_dirs: [
			"include",
			],
			shared_libs: [
			"libcutils",
			"libfmq",
			"libhidlbase",
			"libhwbinder",
			"libhidltransport",
			"liblog",
			"libutils",
			"android.hardware.media.bufferpool@1.0",
			],
			export_shared_lib_headers: [
			"libfmq",
			"android.hardware.media.bufferpool@1.0",
			],
			}