Merge "codec2 hal: AIDL type conversion, step 2" into main am: aaec79762d am:... (f5c33077) · Commits · e / os / android_frameworks_av

media/codec2/hal/aidl/Android.bp

0 → 100644

+149 −0

Original line number	Original line	Diff line number	Diff line
			package {
			default_applicable_licenses: ["frameworks_av_license"],
			}

			// DO NOT DEPEND ON THIS DIRECTLY
			// use libcodec2-aidl-client-defaults instead
			cc_library {
			name: "libcodec2_aidl_client",

			srcs: [
			"ParamTypes.cpp",
			],

			header_libs: [
			"libcodec2_hal_common",
			"libcodec2_internal", // private
			"libgui_headers",
			],

			shared_libs: [
			"android.hardware.media.bufferpool@2.0",
			"android.hardware.media.c2-V1-ndk",
			"libbinder_ndk",
			"libbase",
			"libcodec2",
			"libcodec2_vndk",
			"libcutils",
			"liblog",
			"libnativewindow",
			"libutils",
			],

			export_include_dirs: [
			"include",
			],

			export_shared_lib_headers: [
			"android.hardware.media.c2-V1-ndk",
			"libcodec2",
			],
			}

			// DO NOT DEPEND ON THIS DIRECTLY
			// use libcodec2-hidl-defaults instead
			//cc_library {
			// name: "libcodec2_hidl@1.0",
			// vendor_available: true,
			// min_sdk_version: "29",
			// apex_available: [
			// "//apex_available:platform",
			// "com.android.media.swcodec",
			// ],
			//
			// defaults: ["hidl_defaults"],
			//
			// srcs: [
			// "Component.cpp",
			// "ComponentInterface.cpp",
			// "ComponentStore.cpp",
			// "Configurable.cpp",
			// "InputBufferManager.cpp",
			// "InputSurface.cpp",
			// "InputSurfaceConnection.cpp",
			// "types.cpp",
			// ],
			//
			// header_libs: [
			// "libbinder_headers",
			// "libcodec2_hal_common",
			// "libcodec2_internal", // private
			// "libsystem_headers",
			// ],
			//
			// shared_libs: [
			// "android.hardware.graphics.bufferqueue@1.0",
			// "android.hardware.graphics.bufferqueue@2.0",
			// "android.hardware.graphics.common@1.0",
			// "android.hardware.media@1.0",
			// "android.hardware.media.bufferpool@2.0",
			// "android.hardware.media.c2@1.0",
			// "android.hardware.media.omx@1.0",
			// "libbase",
			// "libcodec2",
			// "libcodec2_vndk",
			// "libcodec2_hidl_plugin_stub",
			// "libcutils",
			// "libhidlbase",
			// "liblog",
			// "libstagefright_bufferpool@2.0.1",
			// "libstagefright_bufferqueue_helper_novndk",
			// "libui",
			// "libutils",
			// ],
			//
			// target: {
			// vendor: {
			// exclude_shared_libs: [
			// "libstagefright_bufferqueue_helper_novndk",
			// "libcodec2_hidl_plugin_stub",
			// ],
			// shared_libs: [
			// "libstagefright_bufferqueue_helper",
			// "libcodec2_hidl_plugin",
			// ],
			// },
			// apex: {
			// exclude_shared_libs: [
			// "libcodec2_hidl_plugin",
			// "libcodec2_hidl_plugin_stub",
			// ],
			// },
			// },
			//
			// export_include_dirs: [
			// "include",
			// ],
			//
			// export_shared_lib_headers: [
			// "android.hardware.media.c2@1.0",
			// "libcodec2",
			// "libcodec2_vndk",
			// "libhidlbase",
			// "libstagefright_bufferpool@2.0.1",
			// "libui",
			// ],
			//}
			//
			//// public dependency for Codec 2.0 HAL service implementations
			//cc_defaults {
			// name: "libcodec2-hidl-defaults@1.0",
			// defaults: ["libcodec2-impl-defaults"],
			//
			// shared_libs: [
			// "android.hardware.media.c2@1.0",
			// "libcodec2_hidl@1.0",
			// ],
			//}

			// public dependency for Codec 2.0 HAL client
			cc_defaults {
			name: "libcodec2-aidl-client-defaults",
			min_sdk_version: "34",
			defaults: ["libcodec2-impl-defaults"],

			shared_libs: [
			"android.hardware.media.c2-V1-ndk",
			"libcodec2_aidl_client",
			],
			}

media/codec2/hal/aidl/ParamTypes-specialization.h

0 → 100644

+72 −0

Original line number	Original line	Diff line number	Diff line
			/*
			* Copyright 2022 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 CODEC2_AIDL_UTILS_PARAM_TYPES_SPECIALIZATIONS_H
			#define CODEC2_AIDL_UTILS_PARAM_TYPES_SPECIALIZATIONS_H

			#include <aidl/android/hardware/media/c2/FieldId.h>
			#include <aidl/android/hardware/media/c2/FieldSupportedValues.h>
			#include <aidl/android/hardware/media/c2/Params.h>
			#include <aidl/android/hardware/media/c2/Status.h>
			#include <codec2/common/ParamTypes.h>

			namespace android {

			using ::aidl::android::hardware::media::c2::FieldId;
			using ::aidl::android::hardware::media::c2::FieldSupportedValues;
			using ::aidl::android::hardware::media::c2::Params;
			using ::aidl::android::hardware::media::c2::Status;

			// {offset, size} -> FieldId
			template<>
			void SetFieldId(FieldId *d, uint32_t offset, uint32_t size);

			// FieldId -> offset
			template<>
			uint32_t GetOffsetFromFieldId(const FieldId &s);

			// FieldId -> size
			template<>
			uint32_t GetSizeFromFieldId(const FieldId &s);

			template<>
			void SetStatus(Status *dst, c2_status_t src);

			template<>
			c2_status_t GetStatus(const Status &status);

			// C2FieldSupportedValues -> FieldSupportedValues
			template<>
			bool objcpy(FieldSupportedValues *d, const C2FieldSupportedValues &s);

			// FieldSupportedValues -> C2FieldSupportedValues
			template<>
			bool objcpy(C2FieldSupportedValues *d, const FieldSupportedValues &s);

			template<>
			struct _ParamsBlobHelper<Params> { typedef std::vector<uint8_t> BlobType; };

			template<>
			const std::vector<uint8_t> &GetBlob<Params>(const Params &params);

			template<>
			std::vector<uint8_t> GetBlob<Params>(Params params);

			} // namespace android



			#endif // CODEC2_AIDL_UTILS_PARAM_TYPES_SPECIALIZATIONS_H

media/codec2/hal/aidl/ParamTypes.cpp

+124 −1744

File changed.

Preview size limit exceeded, changes collapsed.

media/codec2/hal/aidl/include/codec2/aidl/ParamTypes.h

+39 −222

Original line number	Original line	Diff line number	Diff line
	@@ -14,57 +14,29 @@
	* limitations under the License.		* limitations under the License.
	*/		*/

	#ifndef CODEC2_HIDL_V1_0_UTILS_TYPES_H		#ifndef CODEC2_AIDL_UTILS_PARAM_TYPES_H
	#define CODEC2_HIDL_V1_0_UTILS_TYPES_H		#define CODEC2_AIDL_UTILS_PARAM_TYPES_H

	#include <bufferpool/ClientManager.h>		#include <aidl/android/hardware/media/c2/FieldSupportedValuesQuery.h>
	#include <android/hardware/media/bufferpool/2.0/IClientManager.h>		#include <aidl/android/hardware/media/c2/FieldSupportedValuesQueryResult.h>
	#include <android/hardware/media/bufferpool/2.0/types.h>		#include <aidl/android/hardware/media/c2/IComponentStore.h>
	#include <android/hardware/media/c2/1.0/IComponentStore.h>		#include <aidl/android/hardware/media/c2/ParamDescriptor.h>
	#include <android/hardware/media/c2/1.0/types.h>		#include <aidl/android/hardware/media/c2/SettingResult.h>
	#include <android/hidl/safe_union/1.0/types.h>		#include <aidl/android/hardware/media/c2/Status.h>
			#include <aidl/android/hardware/media/c2/StructDescriptor.h>

	#include <C2Component.h>		#include <C2Component.h>
	#include <C2Param.h>		#include <C2Param.h>
	#include <C2ParamDef.h>		#include <C2ParamDef.h>
	#include <C2Work.h>
	#include <util/C2Debug-base.h>		#include <util/C2Debug-base.h>

	#include <chrono>		namespace aidl {

	using namespace std::chrono_literals;

	namespace android {		namespace android {
	namespace hardware {		namespace hardware {
	namespace media {		namespace media {
	namespace c2 {		namespace c2 {
	namespace V1_0 {
	namespace utils {		namespace utils {

	using ::android::hardware::hidl_bitfield;
	using ::android::hardware::hidl_handle;
	using ::android::hardware::hidl_string;
	using ::android::hardware::hidl_vec;
	using ::android::status_t;
	using ::android::sp;
	using ::android::hardware::media::bufferpool::V2_0::implementation::
	ConnectionId;

	// Types of metadata for Blocks.
	struct C2Hidl_Range {
	uint32_t offset;
	uint32_t length; // Do not use "size" because the name collides with C2Info::size().
	};
	typedef C2GlobalParam<C2Info, C2Hidl_Range, 0> C2Hidl_RangeInfo;

	struct C2Hidl_Rect {
	uint32_t left;
	uint32_t top;
	uint32_t width;
	uint32_t height;
	};
	typedef C2GlobalParam<C2Info, C2Hidl_Rect, 1> C2Hidl_RectInfo;

	// Make asString() and operator<< work with Status as well as c2_status_t.		// Make asString() and operator<< work with Status as well as c2_status_t.
	C2_DECLARE_AS_STRING_AND_DEFINE_STREAM_OUT(Status);		C2_DECLARE_AS_STRING_AND_DEFINE_STREAM_OUT(Status);

	@@ -74,169 +46,66 @@ C2_DECLARE_AS_STRING_AND_DEFINE_STREAM_OUT(Status);
	*/		*/

	// C2SettingResult -> SettingResult		// C2SettingResult -> SettingResult
	bool objcpy(		bool ToAidl(
	SettingResult* d,		SettingResult* d,
	const C2SettingResult& s);		const C2SettingResult& s);

	// SettingResult -> std::unique_ptr<C2SettingResult>		// SettingResult -> std::unique_ptr<C2SettingResult>
	bool objcpy(		bool FromAidl(
	std::unique_ptr<C2SettingResult>* d,		std::unique_ptr<C2SettingResult>* d,
	const SettingResult& s);		const SettingResult& s);

	// C2ParamDescriptor -> ParamDescriptor		// C2ParamDescriptor -> ParamDescriptor
	bool objcpy(		bool ToAidl(
	ParamDescriptor* d,		ParamDescriptor* d,
	const C2ParamDescriptor& s);		const C2ParamDescriptor& s);

	// ParamDescriptor -> std::shared_ptr<C2ParamDescriptor>		// ParamDescriptor -> std::shared_ptr<C2ParamDescriptor>
	bool objcpy(		bool FromAidl(
	std::shared_ptr<C2ParamDescriptor>* d,		std::shared_ptr<C2ParamDescriptor>* d,
	const ParamDescriptor& s);		const ParamDescriptor& s);

	// C2FieldSupportedValuesQuery -> FieldSupportedValuesQuery		// C2FieldSupportedValuesQuery -> FieldSupportedValuesQuery
	bool objcpy(		bool ToAidl(
	FieldSupportedValuesQuery* d,		FieldSupportedValuesQuery* d,
	const C2FieldSupportedValuesQuery& s);		const C2FieldSupportedValuesQuery& s);

	// FieldSupportedValuesQuery -> C2FieldSupportedValuesQuery		// FieldSupportedValuesQuery -> C2FieldSupportedValuesQuery
	bool objcpy(		bool FromAidl(
	C2FieldSupportedValuesQuery* d,		C2FieldSupportedValuesQuery* d,
	const FieldSupportedValuesQuery& s);		const FieldSupportedValuesQuery& s);

	// C2FieldSupportedValuesQuery -> FieldSupportedValuesQueryResult		// C2FieldSupportedValuesQuery -> FieldSupportedValuesQueryResult
	bool objcpy(		bool ToAidl(
	FieldSupportedValuesQueryResult* d,		FieldSupportedValuesQueryResult* d,
	const C2FieldSupportedValuesQuery& s);		const C2FieldSupportedValuesQuery& s);

	// FieldSupportedValuesQuery, FieldSupportedValuesQueryResult -> C2FieldSupportedValuesQuery		// FieldSupportedValuesQuery, FieldSupportedValuesQueryResult -> C2FieldSupportedValuesQuery
	bool objcpy(		bool FromAidl(
	C2FieldSupportedValuesQuery* d,		C2FieldSupportedValuesQuery* d,
	const FieldSupportedValuesQuery& sq,		const FieldSupportedValuesQuery& sq,
	const FieldSupportedValuesQueryResult& sr);		const FieldSupportedValuesQueryResult& sr);

	// C2Component::Traits -> ComponentTraits		// C2Component::Traits -> ComponentTraits
	bool objcpy(		bool ToAidl(
	IComponentStore::ComponentTraits* d,		IComponentStore::ComponentTraits* d,
	const C2Component::Traits& s);		const C2Component::Traits& s);

	// ComponentTraits -> C2Component::Traits		// ComponentTraits -> C2Component::Traits
	bool objcpy(		bool FromAidl(
	C2Component::Traits* d,		C2Component::Traits* d,
	const IComponentStore::ComponentTraits& s);		const IComponentStore::ComponentTraits& s);

	// C2StructDescriptor -> StructDescriptor		// C2StructDescriptor -> StructDescriptor
	bool objcpy(		bool ToAidl(
	StructDescriptor* d,		StructDescriptor* d,
	const C2StructDescriptor& s);		const C2StructDescriptor& s);

	// StructDescriptor -> C2StructDescriptor		// StructDescriptor -> C2StructDescriptor
	bool objcpy(		bool FromAidl(
	std::unique_ptr<C2StructDescriptor>* d,		std::unique_ptr<C2StructDescriptor>* d,
	const StructDescriptor& s);		const StructDescriptor& s);

	// Abstract class to be used in
	// objcpy(std::list<std::unique_ptr<C2Work>> -> WorkBundle).
	struct BufferPoolSender {
	typedef ::android::hardware::media::bufferpool::V2_0::
	ResultStatus ResultStatus;
	typedef ::android::hardware::media::bufferpool::V2_0::
	BufferStatusMessage BufferStatusMessage;
	typedef ::android::hardware::media::bufferpool::
	BufferPoolData BufferPoolData;

	/**
	* Send bpData and return BufferStatusMessage that can be supplied to
	* IClientManager::receive() in the receiving process.
	*
	* This function will be called from within the function
	* objcpy(std::list<std::unique_ptr<C2Work>> -> WorkBundle).
	*
	* \param[in] bpData BufferPoolData identifying the buffer to send.
	* \param[out] bpMessage BufferStatusMessage of the transaction. Information
	* inside \p bpMessage should be passed to the receiving process by some
	* other means so it can call receive() properly.
	* \return ResultStatus value that determines the success of the operation.
	* (See the possible values of ResultStatus in
	* hardware/interfaces/media/bufferpool/2.0/types.hal.)
	*/
	virtual ResultStatus send(
	const std::shared_ptr<BufferPoolData>& bpData,
	BufferStatusMessage* bpMessage) = 0;

	virtual ~BufferPoolSender() = default;
	};

	// Default implementation of BufferPoolSender.
	//
	// To use DefaultBufferPoolSender, the IClientManager instance of the receiving
	// process must be set before send() can operate. DefaultBufferPoolSender will
	// hold a strong reference to the IClientManager instance and use it to call
	// IClientManager::registerSender() to establish the bufferpool connection when
	// send() is called.
	struct DefaultBufferPoolSender : BufferPoolSender {
	typedef ::android::hardware::media::bufferpool::V2_0::implementation::
	ClientManager ClientManager;
	typedef ::android::hardware::media::bufferpool::V2_0::
	IClientManager IClientManager;

	// Set the IClientManager instance of the receiving process and the refresh
	// interval for the connection. The default interval is 4.5 seconds, which
	// is slightly shorter than the amount of time the bufferpool will keep an
	// inactive connection for.
	DefaultBufferPoolSender(
	const sp<IClientManager>& receiverManager = nullptr,
	std::chrono::steady_clock::duration refreshInterval = 4500ms);

	// Set the IClientManager instance of the receiving process and the refresh
	// interval for the connection. The default interval is 4.5 seconds, which
	// is slightly shorter than the amount of time the bufferpool will keep an
	// inactive connection for.
	void setReceiver(
	const sp<IClientManager>& receiverManager,
	std::chrono::steady_clock::duration refreshInterval = 4500ms);

	// Implementation of BufferPoolSender::send(). send() will establish a
	// bufferpool connection if needed, then send the bufferpool data over to
	// the receiving process.
	virtual ResultStatus send(
	const std::shared_ptr<BufferPoolData>& bpData,
	BufferStatusMessage* bpMessage) override;

	private:
	std::mutex mMutex;
	sp<ClientManager> mSenderManager;
	sp<IClientManager> mReceiverManager;
	std::chrono::steady_clock::duration mRefreshInterval;

	struct Connection {
	int64_t receiverConnectionId;
	std::chrono::steady_clock::time_point lastSent;
	Connection(int64_t receiverConnectionId,
	std::chrono::steady_clock::time_point lastSent)
	: receiverConnectionId(receiverConnectionId),
	lastSent(lastSent) {
	}
	};

	// Map of connections.
	//
	// The key is the connection id. One sender-receiver pair may have multiple
	// connections.
	std::map<int64_t, Connection> mConnections;
	};

	// std::list<std::unique_ptr<C2Work>> -> WorkBundle
	// Note: If bufferpool will be used, bpSender must not be null.
	bool objcpy(
	WorkBundle* d,
	const std::list<std::unique_ptr<C2Work>>& s,
	BufferPoolSender* bpSender = nullptr);

	// WorkBundle -> std::list<std::unique_ptr<C2Work>>
	bool objcpy(
	std::list<std::unique_ptr<C2Work>>* d,
	const WorkBundle& s);

	/**		/**
	* Parses a params blob and returns C2Param pointers to its params. The pointers		* Parses a params blob and returns C2Param pointers to its params. The pointers
	* point to locations inside the underlying buffer of \p blob. If \p blob is		* point to locations inside the underlying buffer of \p blob. If \p blob is
	@@ -247,9 +116,9 @@ bool objcpy(
	* \retval true if the full blob was parsed		* \retval true if the full blob was parsed
	* \retval false otherwise		* \retval false otherwise
	*/		*/
	bool parseParamsBlob(		bool ParseParamsBlob(
	std::vector<C2Param> params,		std::vector<C2Param> params,
	const hidl_vec<uint8_t> &blob);		const Params &blob);

	/**		/**
	* Concatenates a list of C2Params into a params blob.		* Concatenates a list of C2Params into a params blob.
	@@ -260,17 +129,17 @@ bool parseParamsBlob(
	* \retval false if the blob was not successful (this only happens if the		* \retval false if the blob was not successful (this only happens if the
	* parameters were not const)		* parameters were not const)
	*/		*/
	bool createParamsBlob(		bool CreateParamsBlob(
	hidl_vec<uint8_t> *blob,		Params *blob,
	const std::vector<C2Param*> &params);		const std::vector<C2Param*> &params);
	bool createParamsBlob(		bool CreateParamsBlob(
	hidl_vec<uint8_t> *blob,		Params *blob,
	const std::vector<std::unique_ptr<C2Param>> &params);		const std::vector<std::unique_ptr<C2Param>> &params);
	bool createParamsBlob(		bool CreateParamsBlob(
	hidl_vec<uint8_t> *blob,		Params *blob,
	const std::vector<std::shared_ptr<const C2Info>> &params);		const std::vector<std::shared_ptr<const C2Info>> &params);
	bool createParamsBlob(		bool CreateParamsBlob(
	hidl_vec<uint8_t> *blob,		Params *blob,
	const std::vector<std::unique_ptr<C2Tuning>> &params);		const std::vector<std::unique_ptr<C2Tuning>> &params);

	/**		/**
	@@ -282,12 +151,12 @@ bool createParamsBlob(
	* \retval true if the full blob was parsed and params was constructed		* \retval true if the full blob was parsed and params was constructed
	* \retval false otherwise		* \retval false otherwise
	*/		*/
	bool copyParamsFromBlob(		bool CopyParamsFromBlob(
	std::vector<std::unique_ptr<C2Param>>* params,		std::vector<std::unique_ptr<C2Param>>* params,
	Params blob);		const Params &blob);
	bool copyParamsFromBlob(		bool CopyParamsFromBlob(
	std::vector<std::unique_ptr<C2Tuning>>* params,		std::vector<std::unique_ptr<C2Tuning>>* params,
	Params blob);		const Params &blob);

	/**		/**
	* Parses a params blob and applies updates to params.		* Parses a params blob and applies updates to params.
	@@ -297,67 +166,15 @@ bool copyParamsFromBlob(
	* \retval true if the full blob was parsed and params was updated		* \retval true if the full blob was parsed and params was updated
	* \retval false otherwise		* \retval false otherwise
	*/		*/
	bool updateParamsFromBlob(		bool UpdateParamsFromBlob(
	const std::vector<C2Param*>& params,		const std::vector<C2Param*>& params,
	const Params& blob);		const Params& blob);

	/**
	* Converts a BufferPool status value to c2_status_t.
	* \param BufferPool status
	* \return Corresponding c2_status_t
	*/
	c2_status_t toC2Status(::android::hardware::media::bufferpool::V2_0::
	ResultStatus rs);

	// BufferQueue-Based Block Operations
	// ==================================

	// Call before transferring block to other processes.
	//
	// The given block is ready to transfer to other processes. This will guarantee
	// the given block data is not mutated by bufferqueue migration.
	bool beginTransferBufferQueueBlock(const C2ConstGraphicBlock& block);

	// Call beginTransferBufferQueueBlock() on blocks in the given workList.
	// processInput determines whether input blocks are yielded. processOutput
	// works similarly on output blocks. (The default value of processInput is
	// false while the default value of processOutput is true. This implies that in
	// most cases, only output buffers contain bufferqueue-based blocks.)
	void beginTransferBufferQueueBlocks(
	const std::list<std::unique_ptr<C2Work>>& workList,
	bool processInput = false,
	bool processOutput = true);

	// Call after transferring block is finished and make sure that
	// beginTransferBufferQueueBlock() is called before.
	//
	// The transfer of given block is finished. If transfer is successful the given
	// block is not owned by process anymore. Since transfer is finished the given
	// block data is OK to mutate by bufferqueue migration after this call.
	bool endTransferBufferQueueBlock(const C2ConstGraphicBlock& block,
	bool transfer);

	// Call endTransferBufferQueueBlock() on blocks in the given workList.
	// processInput determines whether input blocks are yielded. processOutput
	// works similarly on output blocks. (The default value of processInput is
	// false while the default value of processOutput is true. This implies that in
	// most cases, only output buffers contain bufferqueue-based blocks.)
	void endTransferBufferQueueBlocks(
	const std::list<std::unique_ptr<C2Work>>& workList,
	bool transfer,
	bool processInput = false,
	bool processOutput = true);

	// The given block is ready to be rendered. the given block is not owned by
	// process anymore. If migration is in progress, this returns false in order
	// not to render.
	bool displayBufferQueueBlock(const C2ConstGraphicBlock& block);

	} // namespace utils		} // namespace utils
	} // namespace V1_0
	} // namespace c2		} // namespace c2
	} // namespace media		} // namespace media
	} // namespace hardware		} // namespace hardware
	} // namespace android		} // namespace android
			} // namespace aidl

	#endif // CODEC2_HIDL_V1_0_UTILS_TYPES_H		#endif // CODEC2_AIDL_UTILS_PARAM_TYPES_H