AIDL libAudioHal: Add effect AIDL conversion for HapticGenerator and LoudnessEnhancer (96a7c013) · Commits · e / os / android_frameworks_av

media/libaudiohal/impl/effectsAidlConversion/AidlConversionHapticGenerator.cpp

+39 −13

Original line number	Diff line number	Diff line
		@@ -34,6 +34,7 @@ namespace android {
		namespace effect {

		using ::aidl::android::aidl_utils::statusTFromBinderStatus;
		using ::aidl::android::hardware::audio::effect::HapticGenerator;
		using ::aidl::android::hardware::audio::effect::Parameter;
		using ::android::status_t;
		using utils::EffectParamReader;
		@@ -41,27 +42,52 @@ using utils::EffectParamWriter;

		status_t AidlConversionHapticGenerator::setParameter(EffectParamReader& param) {
		uint32_t type = 0;
		uint16_t value = 0;
		if (!param.validateParamValueSize(sizeof(uint32_t), sizeof(uint16_t)) \|\|
		OK != param.readFromParameter(&type) \|\| OK != param.readFromValue(&value)) {
		OK != param.readFromParameter(&type)) {
		ALOGE("%s invalid param %s", __func__, param.toString().c_str());
		return BAD_VALUE;
		}
		Parameter aidlParam;
		// TODO
		return statusTFromBinderStatus(mEffect->setParameter(aidlParam));
		switch (type) {
		case HG_PARAM_HAPTIC_INTENSITY: {
		int32_t id = 0, scale;
		if (OK != param.readFromValue(&id) \|\| OK != param.readFromValue(&scale)) {
		ALOGE("%s invalid intensity %s", __func__, param.toString().c_str());
		return BAD_VALUE;
		}

		status_t AidlConversionHapticGenerator::getParameter(EffectParamWriter& param) {
		uint32_t type = 0, value = 0;
		if (!param.validateParamValueSize(sizeof(uint32_t), sizeof(uint32_t)) \|\|
		OK != param.readFromParameter(&type)) {
		ALOGE("%s invalid param %s", __func__, param.toString().c_str());
		param.setStatus(BAD_VALUE);
		HapticGenerator::HapticScale hpScale(
		{.id = id, .scale = (HapticGenerator::VibratorScale)(scale)});
		aidlParam = MAKE_SPECIFIC_PARAMETER(HapticGenerator, hapticGenerator, hapticScales,
		{hpScale});
		break;
		}
		case HG_PARAM_VIBRATOR_INFO: {
		float resonantFrequencyHz, qFactor, maxAmplitude;
		if (OK != param.readFromValue(&resonantFrequencyHz) \|\|
		OK != param.readFromValue(&qFactor) \|\| OK != param.readFromValue(&maxAmplitude)) {
		ALOGE("%s invalid vibrator info %s", __func__, param.toString().c_str());
		return BAD_VALUE;
		}
		// TODO
		return param.writeToValue(&value);
		HapticGenerator::VibratorInformation info({.resonantFrequencyHz = resonantFrequencyHz,
		.qFactor = qFactor,
		.maxAmplitude = maxAmplitude});
		aidlParam =
		MAKE_SPECIFIC_PARAMETER(HapticGenerator, hapticGenerator, vibratorInfo, info);
		break;
		}
		default: {
		// TODO: implement vendor extension parameters
		ALOGW("%s unknown param %s", __func__, param.toString().c_str());
		return BAD_VALUE;
		}
		}

		return statusTFromBinderStatus(mEffect->setParameter(aidlParam));
		}

		// No parameter to get for HapticGenerator
		status_t AidlConversionHapticGenerator::getParameter(EffectParamWriter& param __unused) {
		return OK;
		}

		} // namespace effect

media/libaudiohal/impl/effectsAidlConversion/AidlConversionLoudnessEnhancer.cpp

+33 −6

Original line number	Diff line number	Diff line
		@@ -34,6 +34,8 @@ namespace android {
		namespace effect {

		using ::aidl::android::aidl_utils::statusTFromBinderStatus;
		using ::aidl::android::getParameterSpecificField;
		using ::aidl::android::hardware::audio::effect::LoudnessEnhancer;
		using ::aidl::android::hardware::audio::effect::Parameter;
		using ::android::status_t;
		using utils::EffectParamReader;
		@@ -41,27 +43,52 @@ using utils::EffectParamWriter;

		status_t AidlConversionLoudnessEnhancer::setParameter(EffectParamReader& param) {
		uint32_t type = 0;
		uint16_t value = 0;
		int32_t gain = 0;
		if (!param.validateParamValueSize(sizeof(uint32_t), sizeof(uint16_t)) \|\|
		OK != param.readFromParameter(&type) \|\| OK != param.readFromValue(&value)) {
		OK != param.readFromParameter(&type) \|\| OK != param.readFromValue(&gain)) {
		ALOGE("%s invalid param %s", __func__, param.toString().c_str());
		return BAD_VALUE;
		}
		Parameter aidlParam;
		// TODO
		switch (type) {
		case LOUDNESS_ENHANCER_PARAM_TARGET_GAIN_MB: {
		aidlParam = MAKE_SPECIFIC_PARAMETER(LoudnessEnhancer, loudnessEnhancer, gainMb, gain);
		break;
		}
		default: {
		// TODO: implement vendor extension parameters
		ALOGW("%s unknown param %s", __func__, param.toString().c_str());
		return BAD_VALUE;
		}
		}
		return statusTFromBinderStatus(mEffect->setParameter(aidlParam));
		}

		status_t AidlConversionLoudnessEnhancer::getParameter(EffectParamWriter& param) {
		uint32_t type = 0, value = 0;
		uint32_t type = 0;
		if (!param.validateParamValueSize(sizeof(uint32_t), sizeof(uint32_t)) \|\|
		OK != param.readFromParameter(&type)) {
		ALOGE("%s invalid param %s", __func__, param.toString().c_str());
		param.setStatus(BAD_VALUE);
		return BAD_VALUE;
		}
		// TODO
		return param.writeToValue(&value);
		switch (type) {
		case LOUDNESS_ENHANCER_PARAM_TARGET_GAIN_MB: {
		Parameter aidlParam;
		Parameter::Id id = MAKE_SPECIFIC_PARAMETER_ID(LoudnessEnhancer, loudnessEnhancerTag,
		LoudnessEnhancer::gainMb);
		RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(mEffect->getParameter(id, &aidlParam)));
		int32_t gain = VALUE_OR_RETURN_STATUS(GET_PARAMETER_SPECIFIC_FIELD(
		aidlParam, LoudnessEnhancer, loudnessEnhancer, LoudnessEnhancer::gainMb,
		std::decay_t<decltype(gain)>));
		return param.writeToValue(&gain);
		}
		default: {
		// TODO: implement vendor extension parameters
		ALOGW("%s unknown param %s", __func__, param.toString().c_str());
		return BAD_VALUE;
		}
		}
		}

		} // namespace effect

media/libaudiohal/tests/Android.bp

+1 −0

Original line number	Diff line number	Diff line
		@@ -46,6 +46,7 @@ cc_test {
		"libaudiohal",
		"liblog",
		"libutils",
		"libvibrator",
		],

		header_libs: [

media/libaudiohal/tests/EffectsFactoryHalInterface_test.cpp

+20 −4

Original line number	Diff line number	Diff line
		@@ -31,10 +31,13 @@
		#include <system/audio_effects/effect_bassboost.h>
		#include <system/audio_effects/effect_downmix.h>
		#include <system/audio_effects/effect_dynamicsprocessing.h>
		#include <system/audio_effects/effect_hapticgenerator.h>
		#include <system/audio_effects/effect_loudnessenhancer.h>
		#include <system/audio_effect.h>

		#include <gtest/gtest.h>
		#include <utils/RefBase.h>
		#include <vibrator/ExternalVibrationUtils.h>

		namespace android {

		@@ -162,7 +165,18 @@ std::vector<EffectParamTestTuple> testPairs = {
		std::make_tuple(SL_IID_DYNAMICSPROCESSING,
		createEffectParamCombination(
		std::array<uint32_t, 2>({DP_PARAM_INPUT_GAIN, 0 /* channel */}),
		30 /* gainDb /, sizeof(int32_t) / returnValueSize */))};
		30 /* gainDb /, sizeof(int32_t) / returnValueSize */)),
		std::make_tuple(
		FX_IID_HAPTICGENERATOR,
		createEffectParamCombination(
		HG_PARAM_HAPTIC_INTENSITY,
		std::array<uint32_t, 2>(
		{1, uint32_t(::android::os::HapticScale::HIGH) /* scale */}),
		0 /* returnValueSize */)),
		std::make_tuple(
		FX_IID_LOUDNESS_ENHANCER,
		createEffectParamCombination(LOUDNESS_ENHANCER_PARAM_TARGET_GAIN_MB, 5 /* gain */,
		sizeof(int32_t) /* returnValueSize */))};

		class libAudioHalEffectParamTest : public ::testing::TestWithParam<EffectParamTestTuple> {
		public:
		@@ -237,11 +251,13 @@ class libAudioHalEffectParamTest : public ::testing::TestWithParam<EffectParamTe
		&replySize, getParam));
		EffectParamReader parameterGet(*getParam);
		EXPECT_EQ(replySize, parameterGet.getTotalSize()) << parameterGet.toString();
		if (mCombination->valueSize) {
		std::vector<uint8_t> response(mCombination->valueSize);
		EXPECT_EQ(OK, parameterGet.readFromValue(response.data(), mCombination->valueSize))
		<< parameterGet.toString();
		EXPECT_EQ(response, mExpectedValue);
		}
		}

		const EffectParamTestTuple mParamTuple;
		const sp<EffectsFactoryHalInterface> mFactory;