Merge "EnvironmentalReverb: Add AIDL placeholder implementation and its unit test" (4d58d012) · Commits · e / os / android_hardware_interfaces

audio/aidl/TEST_MAPPING

+3 −0

Original line number	Diff line number	Diff line
		@@ -12,6 +12,9 @@
		{
		"name": "VtsHalDownmixTargetTest"
		},
		{
		"name": "VtsHalEnvironmentalReverbTargetTest"
		},
		{
		"name": "VtsHalEqualizerTargetTest"
		},

audio/aidl/aidl_api/android.hardware.audio.effect/current/android/hardware/audio/effect/EnvironmentalReverb.aidl

+16 −0

Original line number	Diff line number	Diff line
		@@ -44,6 +44,22 @@ union EnvironmentalReverb {
		int diffusionPm;
		int densityPm;
		boolean bypass;
		const int MIN_ROOM_LEVEL_MB = -6000;
		const int MAX_ROOM_LEVEL_MB = 0;
		const int MIN_ROOM_HF_LEVEL_MB = -4000;
		const int MAX_ROOM_HF_LEVEL_MB = 0;
		const int MIN_DECAY_TIME_MS = 100;
		const int MAX_DECAY_TIME_MS = 20000;
		const int MIN_DECAY_HF_RATIO_PM = 100;
		const int MAX_DECAY_HF_RATIO_PM = 1000;
		const int MIN_LEVEL_MB = -6000;
		const int MAX_LEVEL_MB = 0;
		const int MIN_DELAY_MS = 0;
		const int MAX_DELAY_MS = 65;
		const int MIN_DIFFUSION_PM = 0;
		const int MAX_DIFFUSION_PM = 1000;
		const int MIN_DENSITY_PM = 0;
		const int MAX_DENSITY_PM = 1000;
		@VintfStability
		union Id {
		int vendorExtensionTag;

audio/aidl/android/hardware/audio/effect/EnvironmentalReverb.aidl

+72 −0

Original line number	Diff line number	Diff line
		@@ -55,38 +55,110 @@ union EnvironmentalReverb {
		int maxDecayTimeMs;
		}

		/**
		* Minimal possible room level in millibels.
		*/
		const int MIN_ROOM_LEVEL_MB = -6000;
		/**
		* Maximum possible room level in millibels.
		*/
		const int MAX_ROOM_LEVEL_MB = 0;
		/**
		* Room level apply to the reverb effect in millibels.
		*/
		int roomLevelMb;

		/**
		* Minimal possible room hf level in millibels.
		*/
		const int MIN_ROOM_HF_LEVEL_MB = -4000;
		/**
		* Maximum possible room hf level in millibels.
		*/
		const int MAX_ROOM_HF_LEVEL_MB = 0;
		/**
		* Room HF level apply to the reverb effect in millibels.
		*/
		int roomHfLevelMb;

		/**
		* Minimal possible decay time in milliseconds.
		*/
		const int MIN_DECAY_TIME_MS = 100;
		/**
		* Maximum possible decay time in milliseconds.
		*/
		const int MAX_DECAY_TIME_MS = 20000;
		/**
		* Delay time apply to the reverb effect in milliseconds.
		*/
		int decayTimeMs;

		/**
		* Minimal possible per mille decay hf ratio.
		*/
		const int MIN_DECAY_HF_RATIO_PM = 100;
		/**
		* Maximum possible per mille decay hf ratio.
		*/
		const int MAX_DECAY_HF_RATIO_PM = 1000;
		/**
		* HF decay ratio in permilles.
		*/
		int decayHfRatioPm;

		/**
		* Minimal possible room level in millibels.
		*/
		const int MIN_LEVEL_MB = -6000;
		/**
		* Maximum possible room level in millibels.
		*/
		const int MAX_LEVEL_MB = 0;
		/**
		* Reverb level in millibels.
		*/
		int levelMb;

		/**
		* Minimal possible delay time in milliseconds.
		*/
		const int MIN_DELAY_MS = 0;
		/**
		* Maximum possible delay time in milliseconds.
		*/
		const int MAX_DELAY_MS = 65;
		/**
		* Reverb delay in milliseconds.
		*/
		int delayMs;

		/**
		* Minimal possible per mille diffusion.
		*/
		const int MIN_DIFFUSION_PM = 0;
		/**
		* Maximum possible per mille diffusion.
		*/
		const int MAX_DIFFUSION_PM = 1000;
		/**
		* Diffusion in permilles.
		*/
		int diffusionPm;

		/**
		* Minimal possible per mille density.
		*/
		const int MIN_DENSITY_PM = 0;
		/**
		* Maximum possible per mille density.
		*/
		const int MAX_DENSITY_PM = 1000;
		/**
		* Density in permilles.
		*/
		int densityPm;

		/**
		* Bypass reverb and copy input to output if set to true.
		*/

audio/aidl/default/envReverb/EnvReverbSw.cpp

+130 −5

Original line number	Diff line number	Diff line
		@@ -60,7 +60,8 @@ extern "C" binder_exception_t queryEffect(const AudioUuid* in_impl_uuid, Descrip
		namespace aidl::android::hardware::audio::effect {

		const std::string EnvReverbSw::kEffectName = "EnvReverbSw";
		const EnvironmentalReverb::Capability EnvReverbSw::kCapability;
		const EnvironmentalReverb::Capability EnvReverbSw::kCapability = {
		.maxDecayTimeMs = EnvironmentalReverb::MAX_DECAY_TIME_MS};
		const Descriptor EnvReverbSw::kDescriptor = {
		.common = {.id = {.type = kEnvReverbTypeUUID,
		.uuid = kEnvReverbSwImplUUID,
		@@ -82,16 +83,140 @@ ndk::ScopedAStatus EnvReverbSw::setParameterSpecific(const Parameter::Specific&
		RETURN_IF(Parameter::Specific::environmentalReverb != specific.getTag(), EX_ILLEGAL_ARGUMENT,
		"EffectNotSupported");

		mSpecificParam = specific.get<Parameter::Specific::environmentalReverb>();
		LOG(DEBUG) << __func__ << " success with: " << specific.toString();
		auto& erParam = specific.get<Parameter::Specific::environmentalReverb>();
		auto tag = erParam.getTag();

		switch (tag) {
		case EnvironmentalReverb::roomLevelMb: {
		RETURN_IF(mContext->setErRoomLevel(erParam.get<EnvironmentalReverb::roomLevelMb>()) !=
		RetCode::SUCCESS,
		EX_ILLEGAL_ARGUMENT, "setRoomLevelFailed");
		return ndk::ScopedAStatus::ok();
		}
		case EnvironmentalReverb::roomHfLevelMb: {
		RETURN_IF(
		mContext->setErRoomHfLevel(erParam.get<EnvironmentalReverb::roomHfLevelMb>()) !=
		RetCode::SUCCESS,
		EX_ILLEGAL_ARGUMENT, "setRoomHfLevelFailed");
		return ndk::ScopedAStatus::ok();
		}
		case EnvironmentalReverb::decayTimeMs: {
		RETURN_IF(mContext->setErDecayTime(erParam.get<EnvironmentalReverb::decayTimeMs>()) !=
		RetCode::SUCCESS,
		EX_ILLEGAL_ARGUMENT, "setDecayTimeFailed");
		return ndk::ScopedAStatus::ok();
		}
		case EnvironmentalReverb::decayHfRatioPm: {
		RETURN_IF(
		mContext->setErDecayHfRatio(
		erParam.get<EnvironmentalReverb::decayHfRatioPm>()) != RetCode::SUCCESS,
		EX_ILLEGAL_ARGUMENT, "setDecayHfRatioFailed");
		return ndk::ScopedAStatus::ok();
		}
		case EnvironmentalReverb::levelMb: {
		RETURN_IF(mContext->setErLevel(erParam.get<EnvironmentalReverb::levelMb>()) !=
		RetCode::SUCCESS,
		EX_ILLEGAL_ARGUMENT, "setLevelFailed");
		return ndk::ScopedAStatus::ok();
		}
		case EnvironmentalReverb::delayMs: {
		RETURN_IF(mContext->setErDelay(erParam.get<EnvironmentalReverb::delayMs>()) !=
		RetCode::SUCCESS,
		EX_ILLEGAL_ARGUMENT, "setDelayFailed");
		return ndk::ScopedAStatus::ok();
		}
		case EnvironmentalReverb::diffusionPm: {
		RETURN_IF(mContext->setErDiffusion(erParam.get<EnvironmentalReverb::diffusionPm>()) !=
		RetCode::SUCCESS,
		EX_ILLEGAL_ARGUMENT, "setDiffusionFailed");
		return ndk::ScopedAStatus::ok();
		}
		case EnvironmentalReverb::densityPm: {
		RETURN_IF(mContext->setErDensity(erParam.get<EnvironmentalReverb::densityPm>()) !=
		RetCode::SUCCESS,
		EX_ILLEGAL_ARGUMENT, "setDensityFailed");
		return ndk::ScopedAStatus::ok();
		}
		case EnvironmentalReverb::bypass: {
		RETURN_IF(mContext->setErBypass(erParam.get<EnvironmentalReverb::bypass>()) !=
		RetCode::SUCCESS,
		EX_ILLEGAL_ARGUMENT, "setBypassFailed");
		return ndk::ScopedAStatus::ok();
		}
		default: {
		LOG(ERROR) << __func__ << " unsupported tag: " << toString(tag);
		return ndk::ScopedAStatus::fromExceptionCodeWithMessage(
		EX_ILLEGAL_ARGUMENT, "EnvironmentalReverbTagNotSupported");
		}
		}
		}

		ndk::ScopedAStatus EnvReverbSw::getParameterSpecific(const Parameter::Id& id,
		Parameter::Specific* specific) {
		auto tag = id.getTag();
		RETURN_IF(Parameter::Id::environmentalReverbTag != tag, EX_ILLEGAL_ARGUMENT, "wrongIdTag");
		specific->set<Parameter::Specific::environmentalReverb>(mSpecificParam);
		auto erId = id.get<Parameter::Id::environmentalReverbTag>();
		auto erIdTag = erId.getTag();
		switch (erIdTag) {
		case EnvironmentalReverb::Id::commonTag:
		return getParameterEnvironmentalReverb(erId.get<EnvironmentalReverb::Id::commonTag>(),
		specific);
		default:
		LOG(ERROR) << __func__ << " unsupported tag: " << toString(erIdTag);
		return ndk::ScopedAStatus::fromExceptionCodeWithMessage(
		EX_ILLEGAL_ARGUMENT, "EnvironmentalReverbTagNotSupported");
		}
		}

		ndk::ScopedAStatus EnvReverbSw::getParameterEnvironmentalReverb(const EnvironmentalReverb::Tag& tag,
		Parameter::Specific* specific) {
		RETURN_IF(!mContext, EX_NULL_POINTER, "nullContext");
		EnvironmentalReverb erParam;
		switch (tag) {
		case EnvironmentalReverb::roomLevelMb: {
		erParam.set<EnvironmentalReverb::roomLevelMb>(mContext->getErRoomLevel());
		break;
		}
		case EnvironmentalReverb::roomHfLevelMb: {
		erParam.set<EnvironmentalReverb::roomHfLevelMb>(mContext->getErRoomHfLevel());
		break;
		}
		case EnvironmentalReverb::decayTimeMs: {
		erParam.set<EnvironmentalReverb::decayTimeMs>(mContext->getErDecayTime());
		break;
		}
		case EnvironmentalReverb::decayHfRatioPm: {
		erParam.set<EnvironmentalReverb::decayHfRatioPm>(mContext->getErDecayHfRatio());
		break;
		}
		case EnvironmentalReverb::levelMb: {
		erParam.set<EnvironmentalReverb::levelMb>(mContext->getErLevel());
		break;
		}
		case EnvironmentalReverb::delayMs: {
		erParam.set<EnvironmentalReverb::delayMs>(mContext->getErDelay());
		break;
		}
		case EnvironmentalReverb::diffusionPm: {
		erParam.set<EnvironmentalReverb::diffusionPm>(mContext->getErDiffusion());
		break;
		}
		case EnvironmentalReverb::densityPm: {
		erParam.set<EnvironmentalReverb::densityPm>(mContext->getErDensity());
		break;
		}
		case EnvironmentalReverb::bypass: {
		erParam.set<EnvironmentalReverb::bypass>(mContext->getErBypass());
		break;
		}
		default: {
		LOG(ERROR) << __func__ << " unsupported tag: " << toString(tag);
		return ndk::ScopedAStatus::fromExceptionCodeWithMessage(
		EX_ILLEGAL_ARGUMENT, "EnvironmentalReverbTagNotSupported");
		}
		}

		specific->set<Parameter::Specific::environmentalReverb>(erParam);
		return ndk::ScopedAStatus::ok();
		}

audio/aidl/default/envReverb/EnvReverbSw.h

+116 −3

Original line number	Diff line number	Diff line
		@@ -32,7 +32,120 @@ class EnvReverbSwContext final : public EffectContext {
		: EffectContext(statusDepth, common) {
		LOG(DEBUG) << __func__;
		}
		// TODO: add specific context here

		RetCode setErRoomLevel(int roomLevel) {
		if (roomLevel < EnvironmentalReverb::MIN_ROOM_LEVEL_MB \|\|
		roomLevel > EnvironmentalReverb::MAX_ROOM_LEVEL_MB) {
		LOG(ERROR) << __func__ << " invalid roomLevel: " << roomLevel;
		return RetCode::ERROR_ILLEGAL_PARAMETER;
		}
		// TODO : Add implementation to apply new room level
		mRoomLevel = roomLevel;
		return RetCode::SUCCESS;
		}
		int getErRoomLevel() const { return mRoomLevel; }

		RetCode setErRoomHfLevel(int roomHfLevel) {
		if (roomHfLevel < EnvironmentalReverb::MIN_ROOM_HF_LEVEL_MB \|\|
		roomHfLevel > EnvironmentalReverb::MAX_ROOM_HF_LEVEL_MB) {
		LOG(ERROR) << __func__ << " invalid roomHfLevel: " << roomHfLevel;
		return RetCode::ERROR_ILLEGAL_PARAMETER;
		}
		// TODO : Add implementation to apply new room HF level
		mRoomHfLevel = roomHfLevel;
		return RetCode::SUCCESS;
		}
		int getErRoomHfLevel() const { return mRoomHfLevel; }

		RetCode setErDecayTime(int decayTime) {
		if (decayTime < EnvironmentalReverb::MIN_DECAY_TIME_MS \|\|
		decayTime > EnvironmentalReverb::MAX_DECAY_TIME_MS) {
		LOG(ERROR) << __func__ << " invalid decayTime: " << decayTime;
		return RetCode::ERROR_ILLEGAL_PARAMETER;
		}
		// TODO : Add implementation to apply new decay time
		mDecayTime = decayTime;
		return RetCode::SUCCESS;
		}
		int getErDecayTime() const { return mDecayTime; }

		RetCode setErDecayHfRatio(int decayHfRatio) {
		if (decayHfRatio < EnvironmentalReverb::MIN_DECAY_HF_RATIO_PM \|\|
		decayHfRatio > EnvironmentalReverb::MAX_DECAY_HF_RATIO_PM) {
		LOG(ERROR) << __func__ << " invalid decayHfRatio: " << decayHfRatio;
		return RetCode::ERROR_ILLEGAL_PARAMETER;
		}
		// TODO : Add implementation to apply new decay HF ratio
		mDecayHfRatio = decayHfRatio;
		return RetCode::SUCCESS;
		}
		int getErDecayHfRatio() const { return mDecayHfRatio; }

		RetCode setErLevel(int level) {
		if (level < EnvironmentalReverb::MIN_LEVEL_MB \|\|
		level > EnvironmentalReverb::MAX_LEVEL_MB) {
		LOG(ERROR) << __func__ << " invalid level: " << level;
		return RetCode::ERROR_ILLEGAL_PARAMETER;
		}
		// TODO : Add implementation to apply new level
		mLevel = level;
		return RetCode::SUCCESS;
		}
		int getErLevel() const { return mLevel; }

		RetCode setErDelay(int delay) {
		if (delay < EnvironmentalReverb::MIN_DELAY_MS \|\|
		delay > EnvironmentalReverb::MAX_DELAY_MS) {
		LOG(ERROR) << __func__ << " invalid delay: " << delay;
		return RetCode::ERROR_ILLEGAL_PARAMETER;
		}
		// TODO : Add implementation to apply new delay
		mDelay = delay;
		return RetCode::SUCCESS;
		}
		int getErDelay() const { return mDelay; }

		RetCode setErDiffusion(int diffusion) {
		if (diffusion < EnvironmentalReverb::MIN_DIFFUSION_PM \|\|
		diffusion > EnvironmentalReverb::MAX_DIFFUSION_PM) {
		LOG(ERROR) << __func__ << " invalid diffusion: " << diffusion;
		return RetCode::ERROR_ILLEGAL_PARAMETER;
		}
		// TODO : Add implementation to apply new diffusion
		mDiffusion = diffusion;
		return RetCode::SUCCESS;
		}
		int getErDiffusion() const { return mDiffusion; }

		RetCode setErDensity(int density) {
		if (density < EnvironmentalReverb::MIN_DENSITY_PM \|\|
		density > EnvironmentalReverb::MAX_DENSITY_PM) {
		LOG(ERROR) << __func__ << " invalid density: " << density;
		return RetCode::ERROR_ILLEGAL_PARAMETER;
		}
		// TODO : Add implementation to apply new density
		mDensity = density;
		return RetCode::SUCCESS;
		}
		int getErDensity() const { return mDensity; }

		RetCode setErBypass(bool bypass) {
		// TODO : Add implementation to apply new bypass
		mBypass = bypass;
		return RetCode::SUCCESS;
		}
		bool getErBypass() const { return mBypass; }

		private:
		int mRoomLevel = EnvironmentalReverb::MIN_ROOM_LEVEL_MB; // Default room level
		int mRoomHfLevel = EnvironmentalReverb::MAX_ROOM_HF_LEVEL_MB; // Default room hf level
		int mDecayTime = 1000; // Default decay time
		int mDecayHfRatio = 500; // Default decay hf ratio
		int mLevel = EnvironmentalReverb::MIN_LEVEL_MB; // Default level
		int mDelay = 40; // Default delay
		int mDiffusion = EnvironmentalReverb::MAX_DIFFUSION_PM; // Default diffusion
		int mDensity = EnvironmentalReverb::MAX_DENSITY_PM; // Default density
		bool mBypass = false; // Default bypass
		};

		class EnvReverbSw final : public EffectImpl {
		@@ -60,7 +173,7 @@ class EnvReverbSw final : public EffectImpl {

		private:
		std::shared_ptr<EnvReverbSwContext> mContext;
		/* parameters */
		EnvironmentalReverb mSpecificParam;
		ndk::ScopedAStatus getParameterEnvironmentalReverb(const EnvironmentalReverb::Tag& tag,
		Parameter::Specific* specific);
		};
		} // namespace aidl::android::hardware::audio::effect