Merge "[AIDL CTS] pass Visualizer implementation cts" (4f17e4ed) · Commits · e / os / android_frameworks_av

media/audioaidlconversion/AidlConversionEffect.cpp

+104 −0

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

		#include <cstdint>
		#include <inttypes.h>
		#include <utility>

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

		#include <aidl/android/hardware/audio/effect/DefaultExtension.h>
		#include <aidl/android/hardware/audio/effect/VendorExtension.h>
		#include <media/AidlConversionCppNdk.h>
		#include <media/AidlConversionEffect.h>

		@@ -32,16 +36,21 @@ namespace android {
		using ::aidl::android::hardware::audio::effect::AcousticEchoCanceler;
		using ::aidl::android::hardware::audio::effect::AutomaticGainControlV2;
		using ::aidl::android::hardware::audio::effect::BassBoost;
		using ::aidl::android::hardware::audio::effect::DefaultExtension;
		using ::aidl::android::hardware::audio::effect::Descriptor;
		using ::aidl::android::hardware::audio::effect::Downmix;
		using ::aidl::android::hardware::audio::effect::DynamicsProcessing;
		using ::aidl::android::hardware::audio::effect::Flags;
		using ::aidl::android::hardware::audio::effect::Parameter;
		using ::aidl::android::hardware::audio::effect::PresetReverb;
		using ::aidl::android::hardware::audio::effect::VendorExtension;
		using ::aidl::android::hardware::audio::effect::Visualizer;
		using ::aidl::android::media::audio::common::AudioDeviceDescription;

		using ::android::BAD_VALUE;
		using ::android::base::unexpected;
		using ::android::effect::utils::EffectParamReader;
		using ::android::effect::utils::EffectParamWriter;

		////////////////////////////////////////////////////////////////////////////////////////////////////
		// Converters
		@@ -349,5 +358,100 @@ ConversionResult<int32_t> aidl2legacy_DynamicsProcessing_ResolutionPreference_in
		return static_cast<int32_t>(aidl);
		}

		ConversionResult<uint32_t> aidl2legacy_Parameter_Visualizer_ScalingMode_uint32(
		Visualizer::ScalingMode aidl) {
		switch (aidl) {
		case Visualizer::ScalingMode::NORMALIZED: {
		return 0;
		}
		case Visualizer::ScalingMode::AS_PLAYED: {
		return 1;
		}
		}
		return unexpected(BAD_VALUE);
		}

		ConversionResult<Visualizer::ScalingMode> legacy2aidl_Parameter_Visualizer_uint32_ScalingMode(
		uint32_t legacy) {
		if (legacy == 0) {
		return Visualizer::ScalingMode::NORMALIZED;
		} else if (legacy == 1) {
		return Visualizer::ScalingMode::AS_PLAYED;
		} else {
		return unexpected(BAD_VALUE);
		}
		}

		ConversionResult<uint32_t> aidl2legacy_Parameter_Visualizer_MeasurementMode_uint32(
		Visualizer::MeasurementMode aidl) {
		switch (aidl) {
		case Visualizer::MeasurementMode::NONE: {
		return 0;
		}
		case Visualizer::MeasurementMode::PEAK_RMS: {
		return 1;
		}
		}
		return unexpected(BAD_VALUE);
		}

		ConversionResult<Visualizer::MeasurementMode>
		legacy2aidl_Parameter_Visualizer_uint32_MeasurementMode(uint32_t legacy) {
		if (legacy == 0) {
		return Visualizer::MeasurementMode::NONE;
		} else if (legacy == 1) {
		return Visualizer::MeasurementMode::PEAK_RMS;
		} else {
		return unexpected(BAD_VALUE);
		}
		}

		/**
		* Copy the entire effect_param_t to DefaultExtension::bytes.
		*/
		ConversionResult<Parameter> legacy2aidl_EffectParameterReader_ParameterExtension(
		EffectParamReader& param) {
		size_t len = param.getTotalSize();
		DefaultExtension ext;
		ext.bytes.resize(len);
		std::memcpy(ext.bytes.data(), &param.getEffectParam(), len);

		VendorExtension effectParam;
		effectParam.extension.setParcelable(ext);
		return UNION_MAKE(Parameter, specific,
		UNION_MAKE(Parameter::Specific, vendorEffect, effectParam));
		}

		ConversionResult<std::vector<uint8_t>> aidl2legacy_ParameterExtension_vector_uint8(
		const Parameter& param) {
		VendorExtension effectParam = VALUE_OR_RETURN(
		(::aidl::android::getParameterSpecific<Parameter, VendorExtension,
		Parameter::Specific::vendorEffect>(param)));
		std::optional<DefaultExtension> ext;
		if (STATUS_OK != effectParam.extension.getParcelable(&ext) \|\| !ext.has_value()) {
		return unexpected(BAD_VALUE);
		}
		return ext.value().bytes;
		}

		ConversionResult<::android::status_t> aidl2legacy_ParameterExtension_EffectParameterWriter(
		const ::aidl::android::hardware::audio::effect::Parameter& aidl,
		EffectParamWriter& legacy) {
		const std::vector<uint8_t>& extBytes = VALUE_OR_RETURN_STATUS(
		::aidl::android::aidl2legacy_ParameterExtension_vector_uint8(aidl));
		if (legacy.getTotalSize() < extBytes.size()) {
		legacy.setStatus(BAD_VALUE);
		return unexpected(BAD_VALUE);
		}

		// create a reader wrapper and read the content to legacy EffectParamWriter
		EffectParamReader reader((effect_param_t)extBytes.data());
		if (STATUS_OK != legacy.writeToValue(reader.getValueAddress(), reader.getValueSize())) {
		legacy.setStatus(BAD_VALUE);
		return unexpected(BAD_VALUE);
		}
		return STATUS_OK;
		}

		} // namespace android
		} // aidl

media/audioaidlconversion/include/media/AidlConversionCppNdk.h

+5 −0

Original line number	Diff line number	Diff line
		@@ -127,6 +127,11 @@ ConversionResult<audio_channel_mask_t> aidl2legacy_AudioChannelLayout_audio_chan
		ConversionResult<media::audio::common::AudioChannelLayout>
		legacy2aidl_audio_channel_mask_t_AudioChannelLayout(audio_channel_mask_t legacy, bool isInput);

		audio_channel_mask_t aidl2legacy_AudioChannelLayout_layout_audio_channel_mask_t_bits(
		int aidlLayout, bool isInput);
		int legacy2aidl_audio_channel_mask_t_bits_AudioChannelLayout_layout(
		audio_channel_mask_t legacy, bool isInput);

		enum class AudioPortDirection {
		INPUT, OUTPUT
		};

media/audioaidlconversion/include/media/AidlConversionEffect.h

+20 −0

Original line number	Diff line number	Diff line
		@@ -26,6 +26,7 @@
		#include <hardware/audio_effect.h>
		#include <media/AidlConversionUtil.h>
		#include <system/audio_effect.h>
		#include <system/audio_effects/audio_effects_utils.h>

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

		@@ -126,5 +127,24 @@ legacy2aidl_int32_DynamicsProcessing_ResolutionPreference(int32_t legacy);
		ConversionResult<int32_t> aidl2legacy_DynamicsProcessing_ResolutionPreference_int32(
		::aidl::android::hardware::audio::effect::DynamicsProcessing::ResolutionPreference aidl);

		ConversionResult<uint32_t> aidl2legacy_Parameter_Visualizer_ScalingMode_uint32(
		::aidl::android::hardware::audio::effect::Visualizer::ScalingMode aidl);
		ConversionResult<::aidl::android::hardware::audio::effect::Visualizer::ScalingMode>
		legacy2aidl_Parameter_Visualizer_uint32_ScalingMode(uint32_t legacy);

		ConversionResult<uint32_t> aidl2legacy_Parameter_Visualizer_MeasurementMode_uint32(
		::aidl::android::hardware::audio::effect::Visualizer::MeasurementMode aidl);
		ConversionResult<::aidl::android::hardware::audio::effect::Visualizer::MeasurementMode>
		legacy2aidl_Parameter_Visualizer_uint32_MeasurementMode(uint32_t legacy);

		ConversionResult<::aidl::android::hardware::audio::effect::Parameter>
		legacy2aidl_EffectParameterReader_ParameterExtension(
		::android::effect::utils::EffectParamReader& param);
		ConversionResult<std::vector<uint8_t>> aidl2legacy_ParameterExtension_vector_uint8(
		const ::aidl::android::hardware::audio::effect::Parameter& legacy);
		ConversionResult<::android::status_t> aidl2legacy_ParameterExtension_EffectParameterWriter(
		const ::aidl::android::hardware::audio::effect::Parameter& aidl,
		::android::effect::utils::EffectParamWriter& legacy);

		} // namespace android
		} // namespace aidl

media/libaudiohal/impl/EffectConversionHelperAidl.cpp

+45 −1

Original line number	Diff line number	Diff line
		@@ -24,6 +24,7 @@
		#include <media/AidlConversionCppNdk.h>
		#include <media/AidlConversionNdk.h>
		#include <media/AidlConversionEffect.h>
		#include <system/audio_effects/effect_visualizer.h>

		#include <utils/Log.h>

		@@ -59,7 +60,10 @@ const std::map<uint32_t /* effect_command_e */, EffectConversionHelperAidl::Comm
		{EFFECT_CMD_SET_INPUT_DEVICE, &EffectConversionHelperAidl::handleSetDevice},
		{EFFECT_CMD_SET_VOLUME, &EffectConversionHelperAidl::handleSetVolume},
		{EFFECT_CMD_OFFLOAD, &EffectConversionHelperAidl::handleSetOffload},
		{EFFECT_CMD_FIRST_PROPRIETARY, &EffectConversionHelperAidl::handleFirstPriority}};
		{EFFECT_CMD_FIRST_PROPRIETARY, &EffectConversionHelperAidl::handleFirstPriority},
		// Only visualizer support these commands
		{VISUALIZER_CMD_CAPTURE, &EffectConversionHelperAidl::handleVisualizerCapture},
		{VISUALIZER_CMD_MEASURE, &EffectConversionHelperAidl::handleVisualizerMeasure}};

		EffectConversionHelperAidl::EffectConversionHelperAidl(
		std::shared_ptr<::aidl::android::hardware::audio::effect::IEffect> effect,
		@@ -286,5 +290,45 @@ status_t EffectConversionHelperAidl::handleFirstPriority(uint32_t cmdSize __unus
		return OK;
		}

		status_t EffectConversionHelperAidl::handleVisualizerCapture(uint32_t cmdSize __unused,
		const void* pCmdData __unused,
		uint32_t* replySize,
		void* pReplyData) {
		if (!replySize \|\| !pReplyData) {
		ALOGE("%s parameter invalid %p %p", __func__, replySize, pReplyData);
		return BAD_VALUE;
		}

		const auto& uuid = VALUE_OR_RETURN_STATUS(
		::aidl::android::aidl2legacy_AudioUuid_audio_uuid_t(mDesc.common.id.type));
		if (0 != memcmp(&uuid, SL_IID_VISUALIZATION, sizeof(effect_uuid_t))) {
		ALOGE("%s visualizer command not supported by %s", __func__,
		mDesc.common.id.toString().c_str());
		return BAD_VALUE;
		}

		return visualizerCapture(replySize, pReplyData);
		}

		status_t EffectConversionHelperAidl::handleVisualizerMeasure(uint32_t cmdSize __unused,
		const void* pCmdData __unused,
		uint32_t* replySize,
		void* pReplyData) {
		if (!replySize \|\| !pReplyData) {
		ALOGE("%s parameter invalid %p %p", __func__, replySize, pReplyData);
		return BAD_VALUE;
		}

		const auto& uuid = VALUE_OR_RETURN_STATUS(
		::aidl::android::aidl2legacy_AudioUuid_audio_uuid_t(mDesc.common.id.type));
		if (0 != memcmp(&uuid, SL_IID_VISUALIZATION, sizeof(effect_uuid_t))) {
		ALOGE("%s visualizer command not supported by %s", __func__,
		mDesc.common.id.toString().c_str());
		return BAD_VALUE;
		}

		return visualizerMeasure(replySize, pReplyData);
		}

		} // namespace effect
		} // namespace android

media/libaudiohal/impl/EffectConversionHelperAidl.h

+10 −0

Original line number	Diff line number	Diff line
		@@ -94,10 +94,20 @@ class EffectConversionHelperAidl {
		void* pReplyData);
		status_t handleFirstPriority(uint32_t cmdSize, const void* pCmdData, uint32_t* replySize,
		void* pReplyData);
		status_t handleVisualizerCapture(uint32_t cmdSize, const void* pCmdData, uint32_t* replySize,
		void* pReplyData);
		status_t handleVisualizerMeasure(uint32_t cmdSize, const void* pCmdData, uint32_t* replySize,
		void* pReplyData);

		// implemented by conversion of each effect
		virtual status_t setParameter(utils::EffectParamReader& param) = 0;
		virtual status_t getParameter(utils::EffectParamWriter& param) = 0;
		virtual status_t visualizerCapture(uint32_t* replySize __unused, void* pReplyData __unused) {
		return BAD_VALUE;
		}
		virtual status_t visualizerMeasure(uint32_t* replySize __unused, void* pReplyData __unused) {
		return BAD_VALUE;
		}
		};

		} // namespace effect