Merge "AIDL conversion: split effect hal AIDL conversion into separate lib" (0a76aa1e) · Commits · e / os / android_frameworks_av

media/audioaidlconversion/AidlConversionEffect.cpp

0 → 100644

+326 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2023 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 "AidlConversionEffect"
		//#define LOG_NDEBUG 0
		#include <utils/Log.h>

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

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

		namespace aidl {
		namespace android {

		using ::aidl::android::hardware::audio::effect::AcousticEchoCanceler;
		using ::aidl::android::hardware::audio::effect::AutomaticGainControl;
		using ::aidl::android::hardware::audio::effect::BassBoost;
		using ::aidl::android::hardware::audio::effect::Descriptor;
		using ::aidl::android::hardware::audio::effect::Downmix;
		using ::aidl::android::hardware::audio::effect::Flags;
		using ::aidl::android::hardware::audio::effect::Parameter;
		using ::aidl::android::media::audio::common::AudioDeviceDescription;

		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<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<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<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<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<Flags::Volume> legacy2aidl_uint32_Flags_Volume(uint32_t legacy) {
		switch (legacy & EFFECT_FLAG_VOLUME_MASK) {
		case EFFECT_FLAG_VOLUME_CTRL:
		return Flags::Volume::CTRL;
		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<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> 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<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<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;
		case 0:
		return Flags::HardwareAccelerator::NONE;
		}
		return unexpected(BAD_VALUE);
		}

		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<uint32_t> aidl2legacy_Parameter_aec_uint32_echoDelay(const Parameter& aidl) {
		int echoDelay = VALUE_OR_RETURN(GET_PARAMETER_SPECIFIC_FIELD(
		aidl, AcousticEchoCanceler, acousticEchoCanceler, echoDelayUs, int));
		return VALUE_OR_RETURN(convertReinterpret<uint32_t>(echoDelay));
		}

		ConversionResult<Parameter> legacy2aidl_uint32_echoDelay_Parameter_aec(uint32_t legacy) {
		int delay = VALUE_OR_RETURN(convertReinterpret<int32_t>(legacy));
		return MAKE_SPECIFIC_PARAMETER(AcousticEchoCanceler, acousticEchoCanceler, echoDelayUs, delay);
		}

		ConversionResult<uint32_t> aidl2legacy_Parameter_aec_uint32_mobileMode(const Parameter& aidl) {
		bool mobileMode = VALUE_OR_RETURN(GET_PARAMETER_SPECIFIC_FIELD(
		aidl, AcousticEchoCanceler, acousticEchoCanceler, mobileMode, bool));
		return VALUE_OR_RETURN(convertIntegral<uint32_t>(mobileMode));
		}

		ConversionResult<Parameter> legacy2aidl_uint32_mobileMode_Parameter_aec(uint32_t legacy) {
		bool mode = VALUE_OR_RETURN(convertIntegral<bool>(legacy));
		return MAKE_SPECIFIC_PARAMETER(AcousticEchoCanceler, acousticEchoCanceler, mobileMode, mode);
		}

		ConversionResult<uint32_t> aidl2legacy_Parameter_agc_uint32_fixedDigitalGain(
		const Parameter& aidl) {
		int gain = VALUE_OR_RETURN(GET_PARAMETER_SPECIFIC_FIELD(
		aidl, AutomaticGainControl, automaticGainControl, fixedDigitalGainMb, int));
		return VALUE_OR_RETURN(convertReinterpret<uint32_t>(gain));
		}

		ConversionResult<Parameter> legacy2aidl_uint32_fixedDigitalGain_Parameter_agc(uint32_t legacy) {
		int gain = VALUE_OR_RETURN(convertReinterpret<int>(legacy));
		return MAKE_SPECIFIC_PARAMETER(AutomaticGainControl, automaticGainControl, fixedDigitalGainMb,
		gain);
		}

		ConversionResult<uint32_t> aidl2legacy_Parameter_agc_uint32_levelEstimator(
		const Parameter& aidl) {
		const auto& le = VALUE_OR_RETURN(
		GET_PARAMETER_SPECIFIC_FIELD(aidl, AutomaticGainControl, automaticGainControl,
		levelEstimator, AutomaticGainControl::LevelEstimator));
		return static_cast<uint32_t>(le);
		}

		ConversionResult<Parameter> legacy2aidl_uint32_levelEstimator_Parameter_agc(uint32_t legacy) {
		if (legacy > (uint32_t) AutomaticGainControl::LevelEstimator::PEAK) {
		return unexpected(BAD_VALUE);
		}
		AutomaticGainControl::LevelEstimator le =
		static_cast<AutomaticGainControl::LevelEstimator>(legacy);
		return MAKE_SPECIFIC_PARAMETER(AutomaticGainControl, automaticGainControl, levelEstimator, le);
		}

		ConversionResult<uint32_t> aidl2legacy_Parameter_agc_uint32_saturationMargin(
		const Parameter& aidl) {
		int saturationMargin = VALUE_OR_RETURN(GET_PARAMETER_SPECIFIC_FIELD(
		aidl, AutomaticGainControl, automaticGainControl, saturationMarginMb, int));
		return VALUE_OR_RETURN(convertIntegral<uint32_t>(saturationMargin));
		}

		ConversionResult<Parameter> legacy2aidl_uint32_saturationMargin_Parameter_agc(uint32_t legacy) {
		int saturationMargin = VALUE_OR_RETURN(convertIntegral<int>(legacy));
		return MAKE_SPECIFIC_PARAMETER(AutomaticGainControl, automaticGainControl, saturationMarginMb,
		saturationMargin);
		}

		ConversionResult<uint16_t> aidl2legacy_Parameter_BassBoost_uint16_strengthPm(
		const Parameter& aidl) {
		int strength = VALUE_OR_RETURN(
		GET_PARAMETER_SPECIFIC_FIELD(aidl, BassBoost, bassBoost, strengthPm, int));
		return VALUE_OR_RETURN(convertIntegral<uint16_t>(strength));
		}

		ConversionResult<Parameter> legacy2aidl_uint16_strengthPm_Parameter_BassBoost(uint16_t legacy) {
		int strength = VALUE_OR_RETURN(convertIntegral<int>(legacy));
		return MAKE_SPECIFIC_PARAMETER(BassBoost, bassBoost, strengthPm, strength);
		}

		ConversionResult<int16_t> aidl2legacy_Parameter_Downmix_int16_type(const Parameter& aidl) {
		Downmix::Type aidlType = VALUE_OR_RETURN(
		GET_PARAMETER_SPECIFIC_FIELD(aidl, Downmix, downmix, type, Downmix::Type));
		return VALUE_OR_RETURN(convertIntegral<int16_t>(static_cast<uint32_t>(aidlType)));
		}

		ConversionResult<Parameter> legacy2aidl_int16_type_Parameter_Downmix(int16_t legacy) {
		if (legacy > (uint32_t) Downmix::Type::FOLD) {
		return unexpected(BAD_VALUE);
		}
		Downmix::Type aidlType = static_cast<Downmix::Type>(legacy);
		return MAKE_SPECIFIC_PARAMETER(Downmix, downmix, type, aidlType);
		}

		} // namespace android
		} // aidl

media/audioaidlconversion/AidlConversionNdk.cpp

+0 −293

File changed.

Preview size limit exceeded, changes collapsed.

media/audioaidlconversion/Android.bp

+29 −0

Original line number	Diff line number	Diff line
		@@ -133,6 +133,34 @@ cc_library {
		export_header_lib_headers: [
		"libaudio_aidl_conversion_common_util_ndk",
		],
		defaults: [
		"audio_aidl_conversion_common_default",
		"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
		}

		/**
		* Only including AIDL effect HAL conversion.
		*/
		cc_library {
		name: "libaudio_aidl_conversion_effect_ndk",
		srcs: [
		"AidlConversionEffect.cpp",
		],
		header_libs: [
		"libaudio_aidl_conversion_common_util_ndk",
		],
		export_header_lib_headers: [
		"libaudio_aidl_conversion_common_util_ndk",
		],
		defaults: [
		"audio_aidl_conversion_common_default",
		"latest_android_hardware_audio_common_ndk_shared",
		@@ -140,6 +168,7 @@ cc_library {
		"latest_android_media_audio_common_types_ndk_shared",
		],
		shared_libs: [
		"libaudio_aidl_conversion_common_ndk",
		"libbinder_ndk",
		"libbase",
		],

media/audioaidlconversion/include/media/AidlConversionEffect.h

0 → 100644

+125 −0

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

		template <typename P, typename T, typename P::Specific::Tag tag>
		ConversionResult<T> getParameterSpecific(const P& u) {
		const auto& spec = VALUE_OR_RETURN(UNION_GET(u, specific));
		return unionGetField<typename P::Specific, tag>(spec);
		}

		template <typename P, typename T, typename P::Specific::Tag tag, typename T::Tag field, typename F>
		ConversionResult<F> getParameterSpecificField(const P& u) {
		const auto& spec =
		VALUE_OR_RETURN((getParameterSpecific<std::decay_t<decltype(u)>, T, tag>(u)));
		return VALUE_OR_RETURN((unionGetField<T, field>(spec)));
		}

		#define GET_PARAMETER_SPECIFIC_FIELD(u, specific, tag, field, fieldType) \
		getParameterSpecificField<std::decay_t<decltype(u)>, specific, \
		aidl::android::hardware::audio::effect::Parameter::Specific::tag, \
		specific::field, fieldType>(u)

		#define MAKE_SPECIFIC_PARAMETER(spec, tag, field, value) \
		UNION_MAKE(aidl::android::hardware::audio::effect::Parameter, specific, \
		UNION_MAKE(aidl::android::hardware::audio::effect::Parameter::Specific, tag, \
		UNION_MAKE(spec, field, value)))

		#define MAKE_SPECIFIC_PARAMETER_ID(spec, tag, field) \
		UNION_MAKE(aidl::android::hardware::audio::effect::Parameter::Id, tag, \
		UNION_MAKE(spec::Id, commonTag, spec::field))

		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<uint32_t> aidl2legacy_Parameter_aec_uint32_echoDelay(
		const ::aidl::android::hardware::audio::effect::Parameter& aidl);
		ConversionResult<::aidl::android::hardware::audio::effect::Parameter>
		legacy2aidl_uint32_echoDelay_Parameter_aec(uint32_t legacy);

		ConversionResult<uint32_t> aidl2legacy_Parameter_aec_uint32_mobileMode(
		const ::aidl::android::hardware::audio::effect::Parameter& aidl);
		ConversionResult<::aidl::android::hardware::audio::effect::Parameter>
		legacy2aidl_uint32_mobileMode_Parameter_aec(uint32_t legacy);

		ConversionResult<uint32_t> aidl2legacy_Parameter_agc_uint32_fixedDigitalGain(
		const ::aidl::android::hardware::audio::effect::Parameter& aidl);
		ConversionResult<::aidl::android::hardware::audio::effect::Parameter>
		legacy2aidl_uint32_fixedDigitalGain_Parameter_agc(uint32_t legacy);

		ConversionResult<uint32_t> aidl2legacy_Parameter_agc_uint32_levelEstimator(
		const ::aidl::android::hardware::audio::effect::Parameter& aidl);
		ConversionResult<::aidl::android::hardware::audio::effect::Parameter>
		legacy2aidl_uint32_levelEstimator_Parameter_agc(uint32_t legacy);

		ConversionResult<uint32_t> aidl2legacy_Parameter_agc_uint32_saturationMargin(
		const ::aidl::android::hardware::audio::effect::Parameter& aidl);
		ConversionResult<::aidl::android::hardware::audio::effect::Parameter>
		legacy2aidl_uint32_saturationMargin_Parameter_agc(uint32_t legacy);

		ConversionResult<uint16_t> aidl2legacy_Parameter_BassBoost_uint16_strengthPm(
		const ::aidl::android::hardware::audio::effect::Parameter& aidl);
		ConversionResult<::aidl::android::hardware::audio::effect::Parameter>
		legacy2aidl_uint16_strengthPm_Parameter_BassBoost(uint16_t legacy);

		ConversionResult<int16_t> aidl2legacy_Parameter_Downmix_int16_type(
		const ::aidl::android::hardware::audio::effect::Parameter& aidl);
		ConversionResult<::aidl::android::hardware::audio::effect::Parameter>
		legacy2aidl_int16_type_Parameter_Downmix(int16_t legacy);

		} // namespace android
		} // namespace aidl

media/audioaidlconversion/include/media/AidlConversionNdk.h

+1 −91

File changed.

Preview size limit exceeded, changes collapsed.