Merge "Virtualizer : Add libeffect bundle implementation" (a83f7748) · Commits · e / os / android_frameworks_av

media/libeffects/lvm/wrapper/Aidl/BundleContext.cpp

+111 −15

Original line number	Diff line number	Diff line
		@@ -89,6 +89,13 @@ RetCode BundleContext::enable() {
		mSamplesToExitCountBb = (mSamplesPerSecond * 0.1);
		tempDisabled = mBassTempDisabled;
		break;
		case lvm::BundleEffectType::VIRTUALIZER:
		LOG(DEBUG) << __func__ << " enable bundle VR";
		if (mSamplesToExitCountVirt <= 0) mNumberEffectsEnabled++;
		mEffectInDrain &= ~(1 << int(lvm::BundleEffectType::VIRTUALIZER));
		mSamplesToExitCountVirt = (mSamplesPerSecond * 0.1);
		tempDisabled = mVirtualizerTempDisabled;
		break;
		default:
		// Add handling for other effects
		break;
		@@ -112,6 +119,10 @@ RetCode BundleContext::enableOperatingMode() {
		LOG(DEBUG) << __func__ << " enable bundle BB";
		params.BE_OperatingMode = LVM_BE_ON;
		break;
		case lvm::BundleEffectType::VIRTUALIZER:
		LOG(DEBUG) << __func__ << " enable bundle VR";
		params.VirtualizerOperatingMode = LVM_MODE_ON;
		break;
		default:
		// Add handling for other effects
		break;
		@@ -133,6 +144,10 @@ RetCode BundleContext::disable() {
		LOG(DEBUG) << __func__ << " disable bundle BB";
		mEffectInDrain \|= 1 << int(lvm::BundleEffectType::BASS_BOOST);
		break;
		case lvm::BundleEffectType::VIRTUALIZER:
		LOG(DEBUG) << __func__ << " disable bundle VR";
		mEffectInDrain \|= 1 << int(lvm::BundleEffectType::VIRTUALIZER);
		break;
		default:
		// Add handling for other effects
		break;
		@@ -156,6 +171,10 @@ RetCode BundleContext::disableOperatingMode() {
		LOG(DEBUG) << __func__ << " disable bundle BB";
		params.BE_OperatingMode = LVM_BE_OFF;
		break;
		case lvm::BundleEffectType::VIRTUALIZER:
		LOG(DEBUG) << __func__ << " disable bundle VR";
		params.VirtualizerOperatingMode = LVM_MODE_OFF;
		break;
		default:
		// Add handling for other effects
		break;
		@@ -182,6 +201,7 @@ RetCode BundleContext::limitLevel() {

		bool eqEnabled = params.EQNB_OperatingMode == LVM_EQNB_ON;
		bool bbEnabled = params.BE_OperatingMode == LVM_BE_ON;
		bool viEnabled = params.VirtualizerOperatingMode == LVM_MODE_ON;

		if (eqEnabled) {
		for (int i = 0; i < lvm::MAX_NUM_BANDS; i++) {
		@@ -224,6 +244,10 @@ RetCode BundleContext::limitLevel() {
		}
		}
		}
		// Virtualizer contribution
		if (viEnabled) {
		energyContribution += lvm::kVirtualizerContribution * lvm::kVirtualizerContribution;
		}

		double totalEnergyEstimation =
		sqrt(energyContribution + energyCross + energyBassBoost) - crossCorrection;
		@@ -267,14 +291,27 @@ bool BundleContext::isDeviceSupportedBassBoost(
		AudioDeviceDescription::CONNECTION_BT_A2DP});
		}

		bool BundleContext::isDeviceSupportedVirtualizer(
		const aidl::android::media::audio::common::AudioDeviceDescription& device) {
		return (device == AudioDeviceDescription{AudioDeviceType::OUT_HEADSET,
		AudioDeviceDescription::CONNECTION_ANALOG} \|\|
		device == AudioDeviceDescription{AudioDeviceType::OUT_HEADPHONE,
		AudioDeviceDescription::CONNECTION_ANALOG} \|\|
		device == AudioDeviceDescription{AudioDeviceType::OUT_HEADPHONE,
		AudioDeviceDescription::CONNECTION_BT_A2DP} \|\|
		device == AudioDeviceDescription{AudioDeviceType::OUT_HEADSET,
		AudioDeviceDescription::CONNECTION_USB});
		}

		RetCode BundleContext::setOutputDevice(
		const aidl::android::media::audio::common::AudioDeviceDescription& device) {
		mOutputDevice = device;
		if (mType == lvm::BundleEffectType::BASS_BOOST) {
		switch (mType) {
		case lvm::BundleEffectType::BASS_BOOST:
		if (isDeviceSupportedBassBoost(device)) {
		// If a device doesn't support bass boost, the effect must be temporarily disabled.
		// The effect must still report its original state as this can only be changed by the
		// start/stop commands.
		// The effect must still report its original state as this can only be changed by
		// the start/stop commands.
		if (mEnabled) {
		disableOperatingMode();
		}
		@@ -287,6 +324,22 @@ RetCode BundleContext::setOutputDevice(
		}
		mBassTempDisabled = false;
		}
		break;
		case lvm::BundleEffectType::VIRTUALIZER:
		if (isDeviceSupportedVirtualizer(device)) {
		if (mEnabled) {
		disableOperatingMode();
		}
		mVirtualizerTempDisabled = true;
		} else {
		if (!mEnabled) {
		enableOperatingMode();
		}
		mVirtualizerTempDisabled = false;
		}
		break;
		default:
		break;
		}
		return RetCode::SUCCESS;
		}
		@@ -466,6 +519,30 @@ RetCode BundleContext::setBassBoostStrength(int strength) {
		return limitLevel();
		}

		RetCode BundleContext::setVirtualizerStrength(int strength) {
		if (strength < Virtualizer::MIN_PER_MILLE_STRENGTH \|\|
		strength > Virtualizer::MAX_PER_MILLE_STRENGTH) {
		return RetCode::ERROR_ILLEGAL_PARAMETER;
		}

		// Update Control Parameter
		LVM_ControlParams_t params;
		{
		std::lock_guard lg(mMutex);
		RETURN_VALUE_IF(LVM_SUCCESS != LVM_GetControlParameters(mInstance, &params),
		RetCode::ERROR_EFFECT_LIB_ERROR, " getControlParamFailed");

		params.CS_EffectLevel = ((strength * 32767) / 1000);

		RETURN_VALUE_IF(LVM_SUCCESS != LVM_SetControlParameters(mInstance, &params),
		RetCode::ERROR_EFFECT_LIB_ERROR, " setControlParamFailed");
		}

		mVirtStrengthSaved = strength;
		LOG(INFO) << __func__ << " success with strength " << strength;
		return limitLevel();
		}

		void BundleContext::initControlParameter(LVM_ControlParams_t& params) const {
		/* General parameters */
		params.OperatingMode = LVM_MODE_ON;
		@@ -579,6 +656,12 @@ IEffect::Status BundleContext::lvmProcess(float* in, float* out, int samples) {
		--mNumberEffectsEnabled;
		mEffectInDrain &= ~(1 << int(lvm::BundleEffectType::BASS_BOOST));
		}
		if ((undrainedEffects & 1 << int(lvm::BundleEffectType::VIRTUALIZER)) != 0) {
		LOG(DEBUG) << "Draining VIRTUALIZER";
		mSamplesToExitCountVirt = 0;
		--mNumberEffectsEnabled;
		mEffectInDrain &= ~(1 << int(lvm::BundleEffectType::VIRTUALIZER));
		}
		}
		mEffectProcessCalled \|= 1 << int(mType);
		if (!mEnabled) {
		@@ -609,6 +692,19 @@ IEffect::Status BundleContext::lvmProcess(float* in, float* out, int samples) {
		LOG(DEBUG) << "Effect_process() this is the last frame for BASS_BOOST";
		}
		break;
		case lvm::BundleEffectType::VIRTUALIZER:
		if (mSamplesToExitCountVirt > 0) {
		mSamplesToExitCountVirt -= samples;
		}
		if (mSamplesToExitCountVirt <= 0) {
		isDataAvailable = false;
		if ((mEffectInDrain & 1 << int(lvm::BundleEffectType::VIRTUALIZER)) != 0) {
		mNumberEffectsEnabled--;
		mEffectInDrain &= ~(1 << int(lvm::BundleEffectType::VIRTUALIZER));
		}
		LOG(DEBUG) << "Effect_process() this is the last frame for VIRTUALIZER";
		}
		break;
		default:
		// Add handling for other effects
		break;

media/libeffects/lvm/wrapper/Aidl/BundleContext.h

+6 −1

Original line number	Diff line number	Diff line
		@@ -58,6 +58,8 @@ class BundleContext final : public EffectContext {
		}
		bool isDeviceSupportedBassBoost(
		const aidl::android::media::audio::common::AudioDeviceDescription& device);
		bool isDeviceSupportedVirtualizer(
		const aidl::android::media::audio::common::AudioDeviceDescription& device);
		RetCode setOutputDevice(
		const aidl::android::media::audio::common::AudioDeviceDescription& device) override;

		@@ -69,6 +71,9 @@ class BundleContext final : public EffectContext {
		RetCode setBassBoostStrength(int strength);
		int getBassBoostStrength() const { return mBassStrengthSaved; }

		RetCode setVirtualizerStrength(int strength);
		int getVirtualizerStrength() const { return mVirtStrengthSaved; }

		RetCode setVolumeStereo(const Parameter::VolumeStereo& volumeStereo) override;
		Parameter::VolumeStereo getVolumeStereo() override { return mVolumeStereo; }

media/libeffects/lvm/wrapper/Aidl/BundleTypes.h

+18 −1

Original line number	Diff line number	Diff line
		@@ -103,8 +103,25 @@ static const Descriptor kBassBoostDesc = {
		.implementor = "NXP Software Ltd."},
		.capability = Capability::make<Capability::bassBoost>(kBassBoostCap)};

		static const Virtualizer::Capability kVirtualizerCap = {.strengthSupported = mStrengthSupported};

		static const std::string kVirtualizerEffectName = "Virtualizer";

		static const Descriptor kVirtualizerDesc = {
		.common = {.id = {.type = kVirtualizerTypeUUID,
		.uuid = kVirtualizerBundleImplUUID,
		.proxy = kVirtualizerProxyUUID},
		.flags = {.type = Flags::Type::INSERT,
		.insert = Flags::Insert::FIRST,
		.volume = Flags::Volume::CTRL,
		.deviceIndication = true},
		.cpuLoad = VIRTUALIZER_CUP_LOAD_ARM9E,
		.memoryUsage = BUNDLE_MEM_USAGE,
		.name = kVirtualizerEffectName,
		.implementor = "NXP Software Ltd."},
		.capability = Capability::make<Capability::virtualizer>(kVirtualizerCap)};

		// TODO: add descriptors for other bundle effect types here.
		static const Descriptor kVirtualizerDesc;
		static const Descriptor kVolumeDesc;

		/* The following tables have been computed using the actual levels measured by the output of

media/libeffects/lvm/wrapper/Aidl/EffectBundleAidl.cpp

+55 −1

Original line number	Diff line number	Diff line
		@@ -34,11 +34,13 @@ using aidl::android::hardware::audio::effect::EffectBundleAidl;
		using aidl::android::hardware::audio::effect::IEffect;
		using aidl::android::hardware::audio::effect::kBassBoostBundleImplUUID;
		using aidl::android::hardware::audio::effect::kEqualizerBundleImplUUID;
		using aidl::android::hardware::audio::effect::kVirtualizerBundleImplUUID;
		using aidl::android::hardware::audio::effect::State;
		using aidl::android::media::audio::common::AudioUuid;

		bool isUuidSupported(const AudioUuid* uuid) {
		return (uuid == kEqualizerBundleImplUUID \|\| uuid == kBassBoostBundleImplUUID);
		return (uuid == kEqualizerBundleImplUUID \|\| uuid == kBassBoostBundleImplUUID \|\|
		*uuid == kVirtualizerBundleImplUUID);
		}

		extern "C" binder_exception_t createEffect(const AudioUuid* uuid,
		@@ -66,6 +68,8 @@ extern "C" binder_exception_t queryEffect(const AudioUuid* in_impl_uuid, Descrip
		*_aidl_return = aidl::android::hardware::audio::effect::lvm::kEqualizerDesc;
		} else if (*in_impl_uuid == kBassBoostBundleImplUUID) {
		*_aidl_return = aidl::android::hardware::audio::effect::lvm:: kBassBoostDesc;
		} else if (*in_impl_uuid == kVirtualizerBundleImplUUID) {
		*_aidl_return = aidl::android::hardware::audio::effect::lvm::kVirtualizerDesc;
		}
		return EX_NONE;
		}
		@@ -82,6 +86,10 @@ EffectBundleAidl::EffectBundleAidl(const AudioUuid& uuid) {
		mType = lvm::BundleEffectType::BASS_BOOST;
		mDescriptor = &lvm::kBassBoostDesc;
		mEffectName = &lvm::kBassBoostEffectName;
		} else if (uuid == kVirtualizerBundleImplUUID) {
		mType = lvm::BundleEffectType::VIRTUALIZER;
		mDescriptor = &lvm::kVirtualizerDesc;
		mEffectName = &lvm::kVirtualizerEffectName;
		} else {
		// TODO: add other bundle effect types here.
		LOG(ERROR) << __func__ << uuid.toString() << " not supported yet!";
		@@ -146,6 +154,8 @@ ndk::ScopedAStatus EffectBundleAidl::setParameterSpecific(const Parameter::Speci
		return setParameterEqualizer(specific);
		case Parameter::Specific::bassBoost:
		return setParameterBassBoost(specific);
		case Parameter::Specific::virtualizer:
		return setParameterVirtualizer(specific);
		default:
		LOG(ERROR) << __func__ << " unsupported tag " << toString(tag);
		return ndk::ScopedAStatus::fromExceptionCodeWithMessage(EX_ILLEGAL_ARGUMENT,
		@@ -190,6 +200,23 @@ ndk::ScopedAStatus EffectBundleAidl::setParameterBassBoost(const Parameter::Spec
		}
		}

		ndk::ScopedAStatus EffectBundleAidl::setParameterVirtualizer(const Parameter::Specific& specific) {
		auto& vr = specific.get<Parameter::Specific::virtualizer>();
		auto vrTag = vr.getTag();
		switch (vrTag) {
		case Virtualizer::strengthPm: {
		RETURN_IF(mContext->setVirtualizerStrength(vr.get<Virtualizer::strengthPm>()) !=
		RetCode::SUCCESS,
		EX_ILLEGAL_ARGUMENT, "setStrengthFailed");
		return ndk::ScopedAStatus::ok();
		}
		default:
		LOG(ERROR) << __func__ << " unsupported parameter " << specific.toString();
		return ndk::ScopedAStatus::fromExceptionCodeWithMessage(EX_ILLEGAL_ARGUMENT,
		"vrTagNotSupported");
		}
		}

		ndk::ScopedAStatus EffectBundleAidl::getParameterSpecific(const Parameter::Id& id,
		Parameter::Specific* specific) {
		RETURN_IF(!specific, EX_NULL_POINTER, "nullPtr");
		@@ -200,6 +227,8 @@ ndk::ScopedAStatus EffectBundleAidl::getParameterSpecific(const Parameter::Id& i
		return getParameterEqualizer(id.get<Parameter::Id::equalizerTag>(), specific);
		case Parameter::Id::bassBoostTag:
		return getParameterBassBoost(id.get<Parameter::Id::bassBoostTag>(), specific);
		case Parameter::Id::virtualizerTag:
		return getParameterVirtualizer(id.get<Parameter::Id::virtualizerTag>(), specific);
		default:
		LOG(ERROR) << __func__ << " unsupported tag: " << toString(tag);
		return ndk::ScopedAStatus::fromExceptionCodeWithMessage(EX_ILLEGAL_ARGUMENT,
		@@ -259,6 +288,31 @@ ndk::ScopedAStatus EffectBundleAidl::getParameterBassBoost(const BassBoost::Id&
		return ndk::ScopedAStatus::ok();
		}

		ndk::ScopedAStatus EffectBundleAidl::getParameterVirtualizer(const Virtualizer::Id& id,
		Parameter::Specific* specific) {
		RETURN_IF(id.getTag() != Virtualizer::Id::commonTag, EX_ILLEGAL_ARGUMENT,
		"VirtualizerTagNotSupported");

		RETURN_IF(!mContext, EX_NULL_POINTER, "nullContext");
		Virtualizer vrParam;

		auto tag = id.get<Virtualizer::Id::commonTag>();
		switch (tag) {
		case Virtualizer::strengthPm: {
		vrParam.set<Virtualizer::strengthPm>(mContext->getVirtualizerStrength());
		break;
		}
		default: {
		LOG(ERROR) << __func__ << " not handled tag: " << toString(tag);
		return ndk::ScopedAStatus::fromExceptionCodeWithMessage(EX_ILLEGAL_ARGUMENT,
		"VirtualizerTagNotSupported");
		}
		}

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

		std::shared_ptr<EffectContext> EffectBundleAidl::createContext(const Parameter::Common& common) {
		if (mContext) {
		LOG(DEBUG) << __func__ << " context already exist";

media/libeffects/lvm/wrapper/Aidl/EffectBundleAidl.h

+3 −0

Original line number	Diff line number	Diff line
		@@ -67,6 +67,9 @@ class EffectBundleAidl final : public EffectImpl {
		ndk::ScopedAStatus setParameterEqualizer(const Parameter::Specific& specific);
		ndk::ScopedAStatus getParameterEqualizer(const Equalizer::Id& id,
		Parameter::Specific* specific);
		ndk::ScopedAStatus setParameterVirtualizer(const Parameter::Specific& specific);
		ndk::ScopedAStatus getParameterVirtualizer(const Virtualizer::Id& id,
		Parameter::Specific* specific);
		};

		} // namespace aidl::android::hardware::audio::effect