media.bufferpool@1.0 implementation (9fe0a3ab) · Commits · e / devices / smdk4412 / android_frameworks_av

media/libstagefright/codec2/Android.bp

+3 −0

Original line number	Diff line number	Diff line
		cc_library_shared {
		name: "libstagefright_codec2",
		vendor_available: true,
		vndk: {
		enabled: true,
		},

		tags: [
		"optional",

media/libstagefright/codec2/vndk/Android.bp

+4 −0

Original line number	Diff line number	Diff line
		@@ -54,3 +54,7 @@ cc_library_shared {
		"-std=c++14",
		],
		}

		subdirs = [
		"bufferpool",
		]

media/libstagefright/codec2/vndk/bufferpool/Accessor.cpp

0 → 100644

+100 −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.
		*/

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

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

		// 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);
		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<C2Allocator> &allocator, bool linear)
		: mImpl(new Impl(allocator, linear)) {}

		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) {
		if (mImpl) {
		return mImpl->connect(this, connection, pConnectionId, fmqDescPtr);
		}
		return ResultStatus::CRITICAL_ERROR;
		}

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

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

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

media/libstagefright/codec2/vndk/bufferpool/Accessor.h

0 → 100644

+144 −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 <hidl/MQDescriptor.h>
		#include <hidl/Status.h>
		#include <C2Buffer.h>
		#include <BufferPoolTypes.h>
		#include "BufferStatus.h"

		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 Connection;

		/**
		* 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.
		* @param linear whether the allocator is linear or not.
		*/
		Accessor(const std::shared_ptr<C2Allocator> &allocator, bool linear);

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

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

		/** Allocates a buffer form 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.
		*
		* @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);

		/**
		* 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);

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

		// FIXME: most likely delete, this is only for passthrough implementations
		// extern "C" IAccessor* HIDL_FETCH_IAccessor(const char* name);

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

		#endif // ANDROID_HARDWARE_MEDIA_BUFFERPOOL_V1_0_ACCESSOR_H

media/libstagefright/codec2/vndk/bufferpool/AccessorImpl.cpp

0 → 100644

+542 −0

File added.

Preview size limit exceeded, changes collapsed.