Merge "Add libAudioHal AIDL interface placeholder" (ca6fd4e2) · Commits · e / os / android_frameworks_av

media/audioaidlconversion/AidlConversionCppNdk.cpp

+8 −8

Original line number	Diff line number	Diff line
		@@ -29,7 +29,7 @@
		#include <media/stagefright/foundation/MediaDefs.h>

		////////////////////////////////////////////////////////////////////////////////////////////////////
		// Utilities
		// AIDL CPP/NDK backend to legacy audio data structure conversion utilities.

		#if defined(BACKEND_NDK)
		/* AIDL String generated in NDK is different than CPP */
		@@ -847,7 +847,7 @@ ConversionResult<audio_channel_mask_t> aidl2legacy_AudioChannelLayout_audio_chan
		// Index masks do not have pre-defined values.
		if (const int bits = aidl.get<Tag::indexMask>();
		__builtin_popcount(bits) != 0 &&
		__builtin_popcount(bits) <= AUDIO_CHANNEL_COUNT_MAX) {
		__builtin_popcount(bits) <= (int)AUDIO_CHANNEL_COUNT_MAX) {
		return audio_channel_mask_from_representation_and_bits(
		AUDIO_CHANNEL_REPRESENTATION_INDEX, bits);
		} else {
		@@ -1123,7 +1123,7 @@ ConversionResult<audio_gain_config> aidl2legacy_AudioGainConfig_audio_gain_confi
		for (size_t i = 0; i < numValues; ++i) {
		legacy.values[i] = VALUE_OR_RETURN(convertIntegral<int>(aidl.values[i]));
		}
		legacy.ramp_duration_ms = VALUE_OR_RETURN(convertIntegral<unsigned int>(aidl.rampDurationMs));
		legacy.ramp_duration_ms = VALUE_OR_RETURN(convertIntegral<int>(aidl.rampDurationMs));
		return legacy;
		}

		@@ -1710,12 +1710,12 @@ aidl2legacy_AudioOffloadInfo_audio_offload_info_t(const AudioOffloadInfo& aidl)
		legacy.format = base.format;
		legacy.stream_type = VALUE_OR_RETURN(
		aidl2legacy_AudioStreamType_audio_stream_type_t(aidl.streamType));
		legacy.bit_rate = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.bitRatePerSecond));
		legacy.bit_rate = VALUE_OR_RETURN(convertIntegral<int32_t>(aidl.bitRatePerSecond));
		legacy.duration_us = VALUE_OR_RETURN(convertIntegral<int64_t>(aidl.durationUs));
		legacy.has_video = aidl.hasVideo;
		legacy.is_streaming = aidl.isStreaming;
		legacy.bit_width = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.bitWidth));
		legacy.offload_buffer_size = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.offloadBufferSize));
		legacy.bit_width = VALUE_OR_RETURN(convertIntegral<int32_t>(aidl.bitWidth));
		legacy.offload_buffer_size = VALUE_OR_RETURN(convertIntegral<int32_t>(aidl.offloadBufferSize));
		legacy.usage = VALUE_OR_RETURN(aidl2legacy_AudioUsage_audio_usage_t(aidl.usage));
		legacy.encapsulation_mode = VALUE_OR_RETURN(
		aidl2legacy_AudioEncapsulationMode_audio_encapsulation_mode_t(aidl.encapsulationMode));
		@@ -1789,7 +1789,7 @@ legacy2aidl_audio_config_t_AudioConfig(const audio_config_t& legacy, bool isInpu
		ConversionResult<audio_config_base_t>
		aidl2legacy_AudioConfigBase_audio_config_base_t(const AudioConfigBase& aidl, bool isInput) {
		audio_config_base_t legacy;
		legacy.sample_rate = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.sampleRate));
		legacy.sample_rate = VALUE_OR_RETURN(convertIntegral<int>(aidl.sampleRate));
		legacy.channel_mask = VALUE_OR_RETURN(
		aidl2legacy_AudioChannelLayout_audio_channel_mask_t(aidl.channelMask, isInput));
		legacy.format = VALUE_OR_RETURN(aidl2legacy_AudioFormatDescription_audio_format_t(aidl.format));

media/audioaidlconversion/AidlConversionNdk.cpp

0 → 100644

+259 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 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.
		*/

		#include <utility>

		#define LOG_TAG "AidlConversionNdk"
		//#define LOG_NDEBUG 0
		#include <utils/Log.h>

		#include <media/AidlConversionCppNdk.h>
		#include <media/AidlConversionNdk.h>

		////////////////////////////////////////////////////////////////////////////////////////////////////
		// AIDL NDK backend to legacy audio data structure conversion utilities.

		namespace aidl {
		namespace android {

		using ::aidl::android::hardware::audio::effect::Descriptor;
		using ::aidl::android::hardware::audio::effect::Flags;

		using ::android::BAD_VALUE;
		using ::android::base::unexpected;

		////////////////////////////////////////////////////////////////////////////////////////////////////
		// Converters

		ConversionResult<uint32_t> aidl2legacy_Flags_Type_uint32(Flags::Type type) {
		switch (type) {
		case Flags::Type::INSERT:
		return EFFECT_FLAG_TYPE_INSERT;
		case Flags::Type::AUXILIARY:
		return EFFECT_FLAG_TYPE_AUXILIARY;
		case Flags::Type::REPLACE:
		return EFFECT_FLAG_TYPE_REPLACE;
		case Flags::Type::PRE_PROC:
		return EFFECT_FLAG_TYPE_PRE_PROC;
		case Flags::Type::POST_PROC:
		return EFFECT_FLAG_TYPE_POST_PROC;
		}
		return unexpected(BAD_VALUE);
		}

		ConversionResult<uint32_t> aidl2legacy_Flags_Insert_uint32(Flags::Insert insert) {
		switch (insert) {
		case Flags::Insert::ANY:
		return EFFECT_FLAG_INSERT_ANY;
		case Flags::Insert::FIRST:
		return EFFECT_FLAG_INSERT_FIRST;
		case Flags::Insert::LAST:
		return EFFECT_FLAG_INSERT_LAST;
		case Flags::Insert::EXCLUSIVE:
		return EFFECT_FLAG_INSERT_EXCLUSIVE;
		}
		return unexpected(BAD_VALUE);
		}

		ConversionResult<uint32_t> aidl2legacy_Flags_Volume_uint32(Flags::Volume volume) {
		switch (volume) {
		case Flags::Volume::NONE:
		return 0;
		case Flags::Volume::CTRL:
		return EFFECT_FLAG_VOLUME_CTRL;
		case Flags::Volume::IND:
		return EFFECT_FLAG_VOLUME_IND;
		case Flags::Volume::MONITOR:
		return EFFECT_FLAG_VOLUME_MONITOR;
		}
		return unexpected(BAD_VALUE);
		}
		ConversionResult<uint32_t> aidl2legacy_Flags_HardwareAccelerator_uint32(
		Flags::HardwareAccelerator hwAcceleratorMode) {
		switch (hwAcceleratorMode) {
		case Flags::HardwareAccelerator::NONE:
		return 0;
		case Flags::HardwareAccelerator::SIMPLE:
		return EFFECT_FLAG_HW_ACC_SIMPLE;
		case Flags::HardwareAccelerator::TUNNEL:
		return EFFECT_FLAG_HW_ACC_TUNNEL;
		}
		return unexpected(BAD_VALUE);
		}

		ConversionResult<uint32_t> aidl2legacy_Flags_uint32(Flags aidl) {
		uint32_t legacy = 0;
		legacy \|= VALUE_OR_RETURN(aidl2legacy_Flags_Type_uint32(aidl.type));
		legacy \|= VALUE_OR_RETURN(aidl2legacy_Flags_Insert_uint32(aidl.insert));
		legacy \|= VALUE_OR_RETURN(aidl2legacy_Flags_Volume_uint32(aidl.volume));
		legacy \|= VALUE_OR_RETURN(aidl2legacy_Flags_HardwareAccelerator_uint32(aidl.hwAcceleratorMode));

		if (aidl.offloadIndication) {
		legacy \|= EFFECT_FLAG_OFFLOAD_SUPPORTED;
		}
		if (aidl.deviceIndication) {
		legacy \|= EFFECT_FLAG_DEVICE_IND;
		}
		if (aidl.audioModeIndication) {
		legacy \|= EFFECT_FLAG_AUDIO_MODE_IND;
		}
		if (aidl.audioSourceIndication) {
		legacy \|= EFFECT_FLAG_AUDIO_SOURCE_IND;
		}
		if (aidl.noProcessing) {
		legacy \|= EFFECT_FLAG_NO_PROCESS;
		}
		return legacy;
		}

		ConversionResult<Flags::Type> legacy2aidl_uint32_Flags_Type(uint32_t legacy) {
		switch (legacy & EFFECT_FLAG_TYPE_MASK) {
		case EFFECT_FLAG_TYPE_INSERT:
		return Flags::Type::INSERT;
		case EFFECT_FLAG_TYPE_AUXILIARY:
		return Flags::Type::AUXILIARY;
		case EFFECT_FLAG_TYPE_REPLACE:
		return Flags::Type::REPLACE;
		case EFFECT_FLAG_TYPE_PRE_PROC:
		return Flags::Type::PRE_PROC;
		case EFFECT_FLAG_TYPE_POST_PROC:
		return Flags::Type::POST_PROC;
		}
		return unexpected(BAD_VALUE);
		}

		ConversionResult<Flags::Insert> legacy2aidl_uint32_Flags_Insert(uint32_t legacy) {
		switch (legacy & EFFECT_FLAG_INSERT_MASK) {
		case EFFECT_FLAG_INSERT_ANY:
		return Flags::Insert::ANY;
		case EFFECT_FLAG_INSERT_FIRST:
		return Flags::Insert::FIRST;
		case EFFECT_FLAG_INSERT_LAST:
		return Flags::Insert::LAST;
		case EFFECT_FLAG_INSERT_EXCLUSIVE:
		return Flags::Insert::EXCLUSIVE;
		}
		return unexpected(BAD_VALUE);
		}

		ConversionResult<Flags::Volume> legacy2aidl_uint32_Flags_Volume(uint32_t legacy) {
		switch (legacy & EFFECT_FLAG_VOLUME_MASK) {
		case EFFECT_FLAG_VOLUME_IND:
		return Flags::Volume::IND;
		case EFFECT_FLAG_VOLUME_MONITOR:
		return Flags::Volume::MONITOR;
		case EFFECT_FLAG_VOLUME_NONE:
		return Flags::Volume::NONE;
		}
		return unexpected(BAD_VALUE);
		}

		ConversionResult<Flags::HardwareAccelerator> legacy2aidl_uint32_Flags_HardwareAccelerator(
		uint32_t legacy) {
		switch (legacy & EFFECT_FLAG_HW_ACC_MASK) {
		case EFFECT_FLAG_HW_ACC_SIMPLE:
		return Flags::HardwareAccelerator::SIMPLE;
		case EFFECT_FLAG_HW_ACC_TUNNEL:
		return Flags::HardwareAccelerator::TUNNEL;
		}
		return unexpected(BAD_VALUE);
		}

		ConversionResult<Flags> legacy2aidl_uint32_Flags(uint32_t legacy) {
		Flags aidl;

		aidl.type = VALUE_OR_RETURN(legacy2aidl_uint32_Flags_Type(legacy));
		aidl.insert = VALUE_OR_RETURN(legacy2aidl_uint32_Flags_Insert(legacy));
		aidl.volume = VALUE_OR_RETURN(legacy2aidl_uint32_Flags_Volume(legacy));
		aidl.hwAcceleratorMode = VALUE_OR_RETURN(legacy2aidl_uint32_Flags_HardwareAccelerator(legacy));
		aidl.offloadIndication = (legacy & EFFECT_FLAG_OFFLOAD_SUPPORTED);
		aidl.deviceIndication = (legacy & EFFECT_FLAG_DEVICE_IND);
		aidl.audioModeIndication = (legacy & EFFECT_FLAG_AUDIO_MODE_IND);
		aidl.audioSourceIndication = (legacy & EFFECT_FLAG_AUDIO_SOURCE_IND);
		aidl.noProcessing = (legacy & EFFECT_FLAG_NO_PROCESS);
		return aidl;
		}

		ConversionResult<effect_descriptor_t>
		aidl2legacy_Descriptor_effect_descriptor(const Descriptor& aidl) {
		effect_descriptor_t legacy;
		legacy.type = VALUE_OR_RETURN(aidl2legacy_AudioUuid_audio_uuid_t(aidl.common.id.type));
		legacy.uuid = VALUE_OR_RETURN(aidl2legacy_AudioUuid_audio_uuid_t(aidl.common.id.uuid));
		// legacy descriptor doesn't have proxy information
		// proxy = VALUE_OR_RETURN(aidl2legacy_AudioUuid_audio_uuid_t(aidl.proxy));
		legacy.apiVersion = EFFECT_CONTROL_API_VERSION;
		legacy.flags = VALUE_OR_RETURN(aidl2legacy_Flags_uint32(aidl.common.flags));
		legacy.cpuLoad = VALUE_OR_RETURN(convertIntegral<uint16_t>(aidl.common.cpuLoad));
		legacy.memoryUsage = VALUE_OR_RETURN(convertIntegral<uint16_t>(aidl.common.memoryUsage));
		RETURN_IF_ERROR(aidl2legacy_string(aidl.common.name, legacy.name, sizeof(legacy.name)));
		RETURN_IF_ERROR(aidl2legacy_string(aidl.common.implementor, legacy.implementor,
		sizeof(legacy.implementor)));
		return legacy;
		}

		ConversionResult<Descriptor>
		legacy2aidl_effect_descriptor_Descriptor(const effect_descriptor_t& legacy) {
		Descriptor aidl;
		aidl.common.id.type = VALUE_OR_RETURN(legacy2aidl_audio_uuid_t_AudioUuid(legacy.type));
		aidl.common.id.uuid = VALUE_OR_RETURN(legacy2aidl_audio_uuid_t_AudioUuid(legacy.uuid));
		// legacy descriptor doesn't have proxy information
		// aidl.common.id.proxy
		aidl.common.flags = VALUE_OR_RETURN(legacy2aidl_uint32_Flags(legacy.flags));
		aidl.common.cpuLoad = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.cpuLoad));
		aidl.common.memoryUsage = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.memoryUsage));
		aidl.common.name = VALUE_OR_RETURN(legacy2aidl_string(legacy.name, sizeof(legacy.name)));
		aidl.common.implementor =
		VALUE_OR_RETURN(legacy2aidl_string(legacy.implementor, sizeof(legacy.implementor)));
		return aidl;
		}

		ConversionResult<buffer_config_t> aidl2legacy_AudioConfigBase_buffer_config_t(
		const media::audio::common::AudioConfigBase& aidl, bool isInput) {
		buffer_config_t legacy;

		legacy.samplingRate = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.sampleRate));
		legacy.mask \|= EFFECT_CONFIG_SMP_RATE;

		legacy.channels = VALUE_OR_RETURN(
		aidl2legacy_AudioChannelLayout_audio_channel_mask_t(aidl.channelMask, isInput));
		legacy.mask \|= EFFECT_CONFIG_CHANNELS;

		legacy.format = VALUE_OR_RETURN(aidl2legacy_AudioFormatDescription_audio_format_t(aidl.format));
		legacy.mask \|= EFFECT_CONFIG_FORMAT;

		return legacy;
		}

		ConversionResult<media::audio::common::AudioConfigBase>
		legacy2aidl_AudioConfigBase_buffer_config_t(const buffer_config_t& legacy, bool isInput) {
		media::audio::common::AudioConfigBase aidl;

		if (legacy.mask & EFFECT_CONFIG_SMP_RATE) {
		aidl.sampleRate = VALUE_OR_RETURN(convertIntegral<int32_t>(legacy.samplingRate));
		}
		if (legacy.mask & EFFECT_CONFIG_CHANNELS) {
		aidl.channelMask = VALUE_OR_RETURN(legacy2aidl_audio_channel_mask_t_AudioChannelLayout(
		static_cast<audio_channel_mask_t>(legacy.channels), isInput));
		}
		if (legacy.mask & EFFECT_CONFIG_FORMAT) {
		aidl.format = VALUE_OR_RETURN(legacy2aidl_audio_format_t_AudioFormatDescription(
		static_cast<audio_format_t>(legacy.format)));
		}
		return aidl;
		}

		} // namespace android
		} // aidl

media/audioaidlconversion/Android.bp

+13 −3

Original line number	Diff line number	Diff line
		@@ -61,9 +61,9 @@ cc_defaults {
		host_supported: true,
		vendor_available: true,
		double_loadable: true,
		min_sdk_version: "29",
		header_libs: [
		"libaudio_system_headers",
		"libhardware_headers",
		],
		shared_libs: [
		"libbase",
		@@ -102,7 +102,9 @@ cc_defaults {
		*/
		cc_library {
		name: "libaudio_aidl_conversion_common_cpp",
		srcs: ["AidlConversionCppNdk.cpp"],
		srcs: [
		"AidlConversionCppNdk.cpp",
		],
		header_libs: [
		"libaudio_aidl_conversion_common_util_cpp",
		],
		@@ -113,6 +115,7 @@ cc_library {
		"audio_aidl_conversion_common_default",
		"latest_android_media_audio_common_types_cpp_export_shared",
		],
		min_sdk_version: "29",
		}

		/**
		@@ -120,7 +123,10 @@ cc_library {
		*/
		cc_library {
		name: "libaudio_aidl_conversion_common_ndk",
		srcs: ["AidlConversionCppNdk.cpp"],
		srcs: [
		"AidlConversionCppNdk.cpp",
		"AidlConversionNdk.cpp",
		],
		header_libs: [
		"libaudio_aidl_conversion_common_util_ndk",
		],
		@@ -129,12 +135,16 @@ cc_library {
		],
		defaults: [
		"audio_aidl_conversion_common_default",
		"latest_android_hardware_audio_common_ndk_shared",
		"latest_android_hardware_audio_effect_ndk_shared",
		"latest_android_media_audio_common_types_ndk_shared",
		],
		shared_libs: [
		"libbinder_ndk",
		"libbase",
		],
		cflags: [
		"-DBACKEND_NDK",
		],
		min_sdk_version: "31", //AParcelableHolder has been introduced in 31
		}

media/audioaidlconversion/include/media/AidlConversionNdk.h

0 → 100644

+68 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 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.
		*/

		#pragma once

		#include <android/binder_auto_utils.h>
		#include <android/binder_manager.h>
		#include <android/binder_process.h>

		/**
		* Can only handle conversion between AIDL (NDK backend) and legacy type.
		*/
		#include <hardware/audio_effect.h>
		#include <media/AidlConversionUtil.h>
		#include <system/audio_effect.h>

		#include <aidl/android/hardware/audio/effect/IEffect.h>

		namespace aidl {
		namespace android {

		ConversionResult<uint32_t> aidl2legacy_Flags_Type_uint32(
		::aidl::android::hardware::audio::effect::Flags::Type type);
		ConversionResult<uint32_t> aidl2legacy_Flags_Insert_uint32(
		::aidl::android::hardware::audio::effect::Flags::Insert insert);
		ConversionResult<uint32_t> aidl2legacy_Flags_Volume_uint32(
		::aidl::android::hardware::audio::effect::Flags::Volume volume);
		ConversionResult<uint32_t> aidl2legacy_Flags_HardwareAccelerator_uint32(
		::aidl::android::hardware::audio::effect::Flags::HardwareAccelerator hwAcceleratorMode);
		ConversionResult<uint32_t> aidl2legacy_Flags_uint32(
		const ::aidl::android::hardware::audio::effect::Flags aidl);

		ConversionResult<::aidl::android::hardware::audio::effect::Flags::Type>
		legacy2aidl_uint32_Flags_Type(uint32_t legacy);
		ConversionResult<::aidl::android::hardware::audio::effect::Flags::Insert>
		legacy2aidl_uint32_Flags_Insert(uint32_t legacy);
		ConversionResult<::aidl::android::hardware::audio::effect::Flags::Volume>
		legacy2aidl_uint32_Flags_Volume(uint32_t legacy);
		ConversionResult<::aidl::android::hardware::audio::effect::Flags::HardwareAccelerator>
		legacy2aidl_uint32_Flags_HardwareAccelerator(uint32_t legacy);
		ConversionResult<::aidl::android::hardware::audio::effect::Flags> legacy2aidl_uint32_Flags(
		uint32_t hal);

		ConversionResult<effect_descriptor_t> aidl2legacy_Descriptor_effect_descriptor(
		const ::aidl::android::hardware::audio::effect::Descriptor& aidl);
		ConversionResult<::aidl::android::hardware::audio::effect::Descriptor>
		legacy2aidl_effect_descriptor_Descriptor(const effect_descriptor_t& hal);

		ConversionResult<buffer_config_t> aidl2legacy_AudioConfigBase_buffer_config_t(
		const media::audio::common::AudioConfigBase& aidl, bool isInput);
		ConversionResult<media::audio::common::AudioConfigBase> legacy2aidl_AudioConfigBase_buffer_config_t(
		const buffer_config_t& legacy, bool isInput);

		} // namespace android
		} // namespace aidl

media/audioaidlconversion/include/media/AidlConversionUtil.h

+2 −0

Original line number	Diff line number	Diff line
		@@ -25,7 +25,9 @@
		#include <error/Result.h>

		#if defined(BACKEND_NDK)
		#include <android/binder_enums.h>
		#include <android/binder_status.h>

		namespace aidl {
		#else
		#include <binder/Enums.h>