Add AIDL support for effect bundle with lvm implementation. (1b7c6ad2) · Commits · e / os / android_frameworks_av

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

0 → 100644

+326 −0

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

		#define LOG_TAG "BundleContext"
		#include <Utils.h>

		#include "BundleContext.h"
		#include "BundleTypes.h"

		namespace aidl::android::hardware::audio::effect {

		RetCode BundleContext::init() {
		// init with pre-defined preset NORMAL
		for (int i = 0; i < lvm::MAX_NUM_BANDS; i++) {
		mBandGaindB[i] = lvm::kSoftPresets[0 /* normal */][i];
		}

		// allocate lvm instance
		LVM_ReturnStatus_en status;
		LVM_InstParams_t params = {.BufferMode = LVM_UNMANAGED_BUFFERS,
		.MaxBlockSize = lvm::MAX_CALL_SIZE,
		.EQNB_NumBands = lvm::MAX_NUM_BANDS,
		.PSA_Included = LVM_PSA_ON};
		status = LVM_GetInstanceHandle(&mInstance, &params);
		GOTO_IF_LVM_ERROR(status, deinit, "LVM_GetInstanceHandleFailed");

		// set control
		LVM_ControlParams_t controlParams;
		initControlParameter(controlParams);
		status = LVM_SetControlParameters(mInstance, &controlParams);
		GOTO_IF_LVM_ERROR(status, deinit, "LVM_SetControlParametersFailed");

		/* Set the headroom parameters */
		LVM_HeadroomParams_t headroomParams;
		initHeadroomParameter(headroomParams);
		status = LVM_SetHeadroomParams(mInstance, &headroomParams);
		GOTO_IF_LVM_ERROR(status, deinit, "LVM_SetHeadroomParamsFailed");

		return RetCode::SUCCESS;

		deinit:
		deInit();
		return RetCode::ERROR_EFFECT_LIB_ERROR;
		}

		void BundleContext::deInit() {
		if (mInstance) {
		LVM_DelInstanceHandle(&mInstance);
		mInstance = nullptr;
		}
		}

		RetCode BundleContext::enable() {
		LVM_ControlParams_t params;
		RETURN_VALUE_IF(LVM_SUCCESS != LVM_GetControlParameters(mInstance, &params),
		RetCode::ERROR_EFFECT_LIB_ERROR, "failGetControlParams");
		if (mType == lvm::BundleEffectType::EQUALIZER) {
		LOG(DEBUG) << __func__ << " enable bundle EQ";
		params.EQNB_OperatingMode = LVM_EQNB_ON;
		}
		RETURN_VALUE_IF(LVM_SUCCESS != LVM_SetControlParameters(mInstance, &params),
		RetCode::ERROR_EFFECT_LIB_ERROR, "failSetControlParams");
		mEnabled = true;
		// LvmEffect_limitLevel(pContext);
		return RetCode::SUCCESS;
		}

		RetCode BundleContext::disable() {
		LVM_ControlParams_t params;
		RETURN_VALUE_IF(LVM_SUCCESS != LVM_GetControlParameters(mInstance, &params),
		RetCode::ERROR_EFFECT_LIB_ERROR, "failGetControlParams");
		if (mType == lvm::BundleEffectType::EQUALIZER) {
		LOG(DEBUG) << __func__ << " disable bundle EQ";
		params.EQNB_OperatingMode = LVM_EQNB_OFF;
		}
		RETURN_VALUE_IF(LVM_SUCCESS != LVM_SetControlParameters(mInstance, &params),
		RetCode::ERROR_EFFECT_LIB_ERROR, "failSetControlParams");
		mEnabled = false;
		// LvmEffect_limitLevel(pContext);
		return RetCode::SUCCESS;
		}

		LVM_INT16 BundleContext::LVC_ToDB_s32Tos16(LVM_INT32 Lin_fix) const {
		LVM_INT16 db_fix;
		LVM_INT16 Shift;
		LVM_INT16 SmallRemainder;
		LVM_UINT32 Remainder = (LVM_UINT32)Lin_fix;

		/* Count leading bits, 1 cycle in assembly*/
		for (Shift = 0; Shift < 32; Shift++) {
		if ((Remainder & 0x80000000U) != 0) {
		break;
		}
		Remainder = Remainder << 1;
		}

		/*
		* Based on the approximation equation (for Q11.4 format):
		*
		* dB = -96 * Shift + 16 * (8 * Remainder - 2 * Remainder^2)
		*/
		db_fix = (LVM_INT16)(-96 * Shift); /* Six dB steps in Q11.4 format*/
		SmallRemainder = (LVM_INT16)((Remainder & 0x7fffffff) >> 24);
		db_fix = (LVM_INT16)(db_fix + SmallRemainder);
		SmallRemainder = (LVM_INT16)(SmallRemainder * SmallRemainder);
		db_fix = (LVM_INT16)(db_fix - (LVM_INT16)((LVM_UINT16)SmallRemainder >> 9));

		/* Correct for small offset */
		db_fix = (LVM_INT16)(db_fix - 5);

		return db_fix;
		}

		// TODO: replace with more generic approach, like: audio_utils_power_from_amplitude
		int16_t BundleContext::VolToDb(uint32_t vol) const {
		int16_t dB;

		dB = LVC_ToDB_s32Tos16(vol << 7);
		dB = (dB + 8) >> 4;
		dB = (dB < -96) ? -96 : dB;

		return dB;
		}

		RetCode BundleContext::setVolumeStereo(const Parameter::VolumeStereo& volume) {
		LVM_ControlParams_t params;
		LVM_ReturnStatus_en status = LVM_SUCCESS;

		// Convert volume to dB
		int leftdB = VolToDb(volume.left);
		int rightdB = VolToDb(volume.right);
		int maxdB = std::max(leftdB, rightdB);
		int pandB = rightdB - leftdB;
		// TODO: add volume effect implementation here:
		// android::VolumeSetVolumeLevel(pContext, (int16_t)(maxdB * 100));
		LOG(DEBUG) << __func__ << " pandB: " << pandB << " maxdB " << maxdB;

		RETURN_VALUE_IF(LVM_SUCCESS != LVM_GetControlParameters(mInstance, &params),
		RetCode::ERROR_EFFECT_LIB_ERROR, "");

		params.VC_Balance = pandB;

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

		mVolumeStereo = volume;
		return RetCode::SUCCESS;
		}

		RetCode BundleContext::setEqualizerPreset(const int presetIdx) {
		if (presetIdx < 0 \|\| presetIdx >= lvm::MAX_NUM_PRESETS) {
		return RetCode::ERROR_ILLEGAL_PARAMETER;
		}

		std::vector<Equalizer::BandLevel> bandLevels;
		bandLevels.reserve(lvm::MAX_NUM_BANDS);
		for (int i = 0; i < lvm::MAX_NUM_BANDS; i++) {
		bandLevels.emplace_back(Equalizer::BandLevel{i, lvm::kSoftPresets[presetIdx][i]});
		}

		RetCode ret = updateControlParameter(bandLevels);
		if (RetCode::SUCCESS == ret) {
		mCurPresetIdx = presetIdx;
		LOG(INFO) << __func__ << " success with " << presetIdx;
		} else {
		LOG(ERROR) << __func__ << " failed to setPreset " << presetIdx;
		}
		return ret;
		}

		RetCode BundleContext::setEqualizerBandLevels(const std::vector<Equalizer::BandLevel>& bandLevels) {
		RETURN_VALUE_IF(bandLevels.size() > lvm::MAX_NUM_BANDS \|\| bandLevels.empty(),
		RetCode::ERROR_ILLEGAL_PARAMETER, "sizeExceedMax");
		RetCode ret = updateControlParameter(bandLevels);
		if (RetCode::SUCCESS == ret) {
		mCurPresetIdx = lvm::PRESET_CUSTOM;
		LOG(INFO) << __func__ << " succeed with " << ::android::internal::ToString(bandLevels);
		} else {
		LOG(ERROR) << __func__ << " failed with " << ::android::internal::ToString(bandLevels);
		}
		return ret;
		}

		std::vector<Equalizer::BandLevel> BundleContext::getEqualizerBandLevels() const {
		std::vector<Equalizer::BandLevel> bandLevels;
		bandLevels.reserve(lvm::MAX_NUM_BANDS);
		for (int i = 0; i < lvm::MAX_NUM_BANDS; i++) {
		bandLevels.emplace_back(Equalizer::BandLevel{i, mBandGaindB[i]});
		}
		return bandLevels;
		}

		bool BundleContext::isBandLevelIndexInRange(
		const std::vector<Equalizer::BandLevel>& bandLevels) const {
		const auto [min, max] =
		std::minmax_element(bandLevels.begin(), bandLevels.end(),
		[](const auto& a, const auto& b) { return a.index < b.index; });
		return min->index >= 0 && max->index < lvm::MAX_NUM_BANDS;
		}

		RetCode BundleContext::updateControlParameter(const std::vector<Equalizer::BandLevel>& bandLevels) {
		RETURN_VALUE_IF(!isBandLevelIndexInRange(bandLevels), RetCode::ERROR_ILLEGAL_PARAMETER,
		"indexOutOfRange");

		std::array<int, lvm::MAX_NUM_BANDS> tempLevel;
		for (const auto& it : bandLevels) {
		tempLevel[it.index] = it.levelMb;
		}

		LVM_ControlParams_t params;
		RETURN_VALUE_IF(LVM_SUCCESS != LVM_GetControlParameters(mInstance, &params),
		RetCode::ERROR_EFFECT_LIB_ERROR, " getControlParamFailed");

		for (int i = 0; i < lvm::MAX_NUM_BANDS; i++) {
		params.pEQNB_BandDefinition[i].Frequency = lvm::kPresetsFrequencies[i];
		params.pEQNB_BandDefinition[i].QFactor = lvm::kPresetsQFactors[i];
		params.pEQNB_BandDefinition[i].Gain = tempLevel[i];
		}

		RETURN_VALUE_IF(LVM_SUCCESS != LVM_SetControlParameters(mInstance, &params),
		RetCode::ERROR_EFFECT_LIB_ERROR, " setControlParamFailed");
		mBandGaindB = tempLevel;
		LOG(INFO) << __func__ << " update bandGain to " << ::android::internal::ToString(mBandGaindB);

		return RetCode::SUCCESS;
		}

		void BundleContext::initControlParameter(LVM_ControlParams_t& params) const {
		/* General parameters */
		params.OperatingMode = LVM_MODE_ON;
		params.SampleRate = LVM_FS_44100;
		params.SourceFormat = LVM_STEREO;
		params.SpeakerType = LVM_HEADPHONES;

		/* Concert Sound parameters */
		params.VirtualizerOperatingMode = LVM_MODE_OFF;
		params.VirtualizerType = LVM_CONCERTSOUND;
		params.VirtualizerReverbLevel = 100;
		params.CS_EffectLevel = LVM_CS_EFFECT_NONE;

		params.EQNB_OperatingMode = LVM_EQNB_OFF;
		params.EQNB_NBands = lvm::MAX_NUM_BANDS;
		params.pEQNB_BandDefinition = getDefaultEqualizerBandDefs();

		/* Volume Control parameters */
		params.VC_EffectLevel = 0;
		params.VC_Balance = 0;

		/* Treble Enhancement parameters */
		params.TE_OperatingMode = LVM_TE_OFF;
		params.TE_EffectLevel = 0;

		/* PSA Control parameters */
		params.PSA_Enable = LVM_PSA_OFF;
		params.PSA_PeakDecayRate = (LVM_PSA_DecaySpeed_en)0;

		/* Bass Enhancement parameters */
		params.BE_OperatingMode = LVM_BE_OFF;
		params.BE_EffectLevel = 0;
		params.BE_CentreFreq = LVM_BE_CENTRE_90Hz;
		params.BE_HPF = LVM_BE_HPF_ON;

		/* PSA Control parameters */
		params.PSA_Enable = LVM_PSA_OFF;
		params.PSA_PeakDecayRate = LVM_PSA_SPEED_MEDIUM;

		/* TE Control parameters */
		params.TE_OperatingMode = LVM_TE_OFF;
		params.TE_EffectLevel = 0;

		params.NrChannels = audio_channel_count_from_out_mask(AUDIO_CHANNEL_OUT_STEREO);
		params.ChMask = AUDIO_CHANNEL_OUT_STEREO;
		params.SourceFormat = LVM_STEREO;
		}

		void BundleContext::initHeadroomParameter(LVM_HeadroomParams_t& params) const {
		params.pHeadroomDefinition = getDefaultEqualizerHeadroomBanDefs();
		params.NHeadroomBands = 2;
		params.Headroom_OperatingMode = LVM_HEADROOM_OFF;
		}

		LVM_EQNB_BandDef_t *BundleContext::getDefaultEqualizerBandDefs() {
		static LVM_EQNB_BandDef_t* BandDefs = []() {
		static LVM_EQNB_BandDef_t tempDefs[lvm::MAX_NUM_BANDS];
		/* N-Band Equaliser parameters */
		for (int i = 0; i < lvm::MAX_NUM_BANDS; i++) {
		tempDefs[i].Frequency = lvm::kPresetsFrequencies[i];
		tempDefs[i].QFactor = lvm::kPresetsQFactors[i];
		tempDefs[i].Gain = lvm::kSoftPresets[0/* normal */][i];
		}
		return tempDefs;
		}();

		return BandDefs;
		}

		LVM_HeadroomBandDef_t *BundleContext::getDefaultEqualizerHeadroomBanDefs() {
		static LVM_HeadroomBandDef_t HeadroomBandDef[LVM_HEADROOM_MAX_NBANDS] = {
		{
		.Limit_Low = 20,
		.Limit_High = 4999,
		.Headroom_Offset = 0,
		},
		{
		.Limit_Low = 5000,
		.Limit_High = 24000,
		.Headroom_Offset = 0,
		},
		};
		return HeadroomBandDef;
		}

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

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

0 → 100644

+115 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2022 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-base/logging.h>
		#include <array>

		#include "BundleTypes.h"
		#include "effect-impl/EffectContext.h"

		namespace aidl::android::hardware::audio::effect {

		class BundleContext final : public EffectContext {
		public:
		BundleContext(int statusDepth, const Parameter::Common& common,
		const lvm::BundleEffectType& type)
		: EffectContext(statusDepth, common), mType(type) {
		LOG(DEBUG) << __func__ << type;
		}
		~BundleContext() override {
		LOG(DEBUG) << __func__;
		deInit();
		}

		RetCode init();
		void deInit();
		lvm::BundleEffectType getBundleType() const { return mType; }

		RetCode enable();
		RetCode disable();

		LVM_Handle_t getLvmInstance() const { return mInstance; }

		void setSampleRate (const int sampleRate) { mSampleRate = sampleRate; }
		int getSampleRate() const { return mSampleRate; }

		void setChannelMask(const aidl::android::media::audio::common::AudioChannelLayout& chMask) {
		mChMask = chMask;
		}
		aidl::android::media::audio::common::AudioChannelLayout getChannelMask() const {
		return mChMask;
		}

		RetCode setEqualizerPreset(const int presetIdx);
		int getEqualizerPreset() const { return mCurPresetIdx; }
		RetCode setEqualizerBandLevels(const std::vector<Equalizer::BandLevel>& bandLevels);
		std::vector<Equalizer::BandLevel> getEqualizerBandLevels() const;

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

		private:
		const lvm::BundleEffectType mType;
		bool mEnabled = false;
		LVM_Handle_t mInstance = nullptr;

		aidl::android::media::audio::common::AudioDeviceDescription mVirtualizerForcedDevice;
		aidl::android::media::audio::common::AudioChannelLayout mChMask;

		int mSampleRate = LVM_FS_44100;
		int mSamplesPerSecond = 0;
		int mSamplesToExitCountEq = 0;
		int mSamplesToExitCountBb = 0;
		int mSamplesToExitCountVirt = 0;
		int mFrameCount = 0;

		/* Bitmask whether drain is in progress due to disabling the effect.
		The corresponding bit to an effect is set by 1 << lvm_effect_en. */
		int mEffectInDrain = 0;

		/* Bitmask whether process() was called for a particular effect.
		The corresponding bit to an effect is set by 1 << lvm_effect_en. */
		int mEffectProcessCalled = 0;
		int mNumberEffectsEnabled = 0;
		int mNumberEffectsCalled = 0;
		bool mFirstVolume = false;
		// Bass
		bool mBassTempDisabled = false;
		int mBassStrengthSaved = 0;
		// Equalizer
		int mCurPresetIdx = lvm::PRESET_CUSTOM; /* Current preset being used */
		std::array<int, lvm::MAX_NUM_BANDS> mBandGaindB;
		// Virtualizer
		int mVirtStrengthSaved = 0; /* Conversion between Get/Set */
		bool mVirtualizerTempDisabled = false;
		// Volume
		int mLevelSaved = 0; /* for when mute is set, level must be saved */
		bool mMuteEnabled = false; /* Must store as mute = -96dB level */

		void initControlParameter(LVM_ControlParams_t& params) const;
		void initHeadroomParameter(LVM_HeadroomParams_t& params) const;
		int16_t VolToDb(uint32_t vol) const;
		LVM_INT16 LVC_ToDB_s32Tos16(LVM_INT32 Lin_fix) const;
		RetCode updateControlParameter(const std::vector<Equalizer::BandLevel>& bandLevels);
		bool isBandLevelIndexInRange(const std::vector<Equalizer::BandLevel>& bandLevels) const;
		static LVM_EQNB_BandDef_t* getDefaultEqualizerBandDefs();
		static LVM_HeadroomBandDef_t* getDefaultEqualizerHeadroomBanDefs();
		};

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

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

0 → 100644

+163 −0

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

		#include <aidl/android/hardware/audio/effect/BnEffect.h>
		#include "effect-impl/EffectUUID.h"
		#include "effect-impl/EffectTypes.h"
		#include "LVM.h"

		namespace aidl::android::hardware::audio::effect {
		namespace lvm {

		constexpr inline size_t MAX_NUM_PRESETS = 10;
		constexpr inline size_t MAX_NUM_BANDS = 5;
		constexpr inline size_t MAX_CALL_SIZE = 256;
		constexpr inline int BASS_BOOST_CUP_LOAD_ARM9E = 150; // Expressed in 0.1 MIPS
		constexpr inline int VIRTUALIZER_CUP_LOAD_ARM9E = 120; // Expressed in 0.1 MIPS
		constexpr inline int EQUALIZER_CUP_LOAD_ARM9E = 220; // Expressed in 0.1 MIPS
		constexpr inline int VOLUME_CUP_LOAD_ARM9E = 0; // Expressed in 0.1 MIPS
		constexpr inline int BUNDLE_MEM_USAGE = 25; // Expressed in kB
		constexpr inline int PRESET_CUSTOM = -1;

		static const std::vector<Equalizer::BandFrequency> kEqBandFrequency = {{0, 30000, 120000},
		{1, 120001, 460000},
		{2, 460001, 1800000},
		{3, 1800001, 7000000},
		{4, 7000001, 20000000}};

		/*
		Frequencies in Hz
		Note: If these frequencies change, please update LimitLevel values accordingly.
		*/
		constexpr inline std::array<uint16_t, MAX_NUM_BANDS> kPresetsFrequencies = {60, 230, 910, 3600,
		14000};

		/* Q factor multiplied by 100 */
		constexpr inline std::array<uint16_t, MAX_NUM_BANDS> kPresetsQFactors = {96, 96, 96, 96, 96};

		constexpr inline std::array<std::array<int16_t, MAX_NUM_BANDS>, MAX_NUM_PRESETS> kSoftPresets = {
		{{3, 0, 0, 0, 3}, /* Normal Preset */
		{5, 3, -2, 4, 4}, /* Classical Preset */
		{6, 0, 2, 4, 1}, /* Dance Preset */
		{0, 0, 0, 0, 0}, /* Flat Preset */
		{3, 0, 0, 2, -1}, /* Folk Preset */
		{4, 1, 9, 3, 0}, /* Heavy Metal Preset */
		{5, 3, 0, 1, 3}, /* Hip Hop Preset */
		{4, 2, -2, 2, 5}, /* Jazz Preset */
		{-1, 2, 5, 1, -2}, /* Pop Preset */
		{5, 3, -1, 3, 5}}}; /* Rock Preset */

		static const std::vector<Equalizer::Preset> kEqPresets = {
		{0, "Normal"}, {1, "Classical"}, {2, "Dance"}, {3, "Flat"}, {4, "Folk"},
		{5, "Heavy Metal"}, {6, "Hip Hop"}, {7, "Jazz"}, {8, "Pop"}, {9, "Rock"}};

		static const Equalizer::Capability kEqCap = {.bandFrequencies = kEqBandFrequency,
		.presets = kEqPresets};

		static const Descriptor kEqualizerDesc = {
		.common = {.id = {.type = EqualizerTypeUUID,
		.uuid = EqualizerBundleImplUUID,
		.proxy = std::nullopt},
		.flags = {.type = Flags::Type::INSERT,
		.insert = Flags::Insert::FIRST,
		.volume = Flags::Volume::CTRL},
		.name = "EqualizerBundle",
		.implementor = "NXP Software Ltd."},
		.capability = Capability::make<Capability::equalizer>(kEqCap)};

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

		/* The following tables have been computed using the actual levels measured by the output of
		* white noise or pink noise (IEC268-1) for the EQ and BassBoost Effects. These are estimates of
		* the actual energy that 'could' be present in the given band.
		* If the frequency values in EQNB_5BandPresetsFrequencies change, these values might need to be
		* updated.
		*/
		constexpr inline std::array<float, MAX_NUM_BANDS> kBandEnergyCoefficient = {7.56, 9.69, 9.59, 7.37,
		2.88};

		constexpr inline std::array<float, MAX_NUM_BANDS - 1> kBandEnergyCrossCoefficient = {126.0, 115.0,
		125.0, 104.0};

		constexpr inline std::array<float, MAX_NUM_BANDS> kBassBoostEnergyCrossCoefficient = {
		221.21, 208.10, 28.16, 0.0, 0.0};

		constexpr inline float kBassBoostEnergyCoefficient = 9.00;

		constexpr inline float kVirtualizerContribution = 1.9;

		enum class BundleEffectType {
		BASS_BOOST,
		VIRTUALIZER,
		EQUALIZER,
		VOLUME,
		};

		inline std::ostream& operator<<(std::ostream& out, const BundleEffectType& type) {
		switch (type) {
		case BundleEffectType::BASS_BOOST:
		return out << "BASS_BOOST";
		case BundleEffectType::VIRTUALIZER:
		return out << "VIRTUALIZER";
		case BundleEffectType::EQUALIZER:
		return out << "EQUALIZER";
		case BundleEffectType::VOLUME:
		return out << "VOLUME";
		}
		return out << "EnumBundleEffectTypeError";
		}

		inline std::ostream& operator<<(std::ostream& out, const LVM_ReturnStatus_en& status) {
		switch (status) {
		case LVM_SUCCESS:
		return out << "LVM_SUCCESS";
		case LVM_ALIGNMENTERROR:
		return out << "LVM_ALIGNMENTERROR";
		case LVM_NULLADDRESS:
		return out << "LVM_NULLADDRESS";
		case LVM_OUTOFRANGE:
		return out << "LVM_OUTOFRANGE";
		case LVM_INVALIDNUMSAMPLES:
		return out << "LVM_INVALIDNUMSAMPLES";
		case LVM_WRONGAUDIOTIME:
		return out << "LVM_WRONGAUDIOTIME";
		case LVM_ALGORITHMDISABLED:
		return out << "LVM_ALGORITHMDISABLED";
		case LVM_ALGORITHMPSA:
		return out << "LVM_ALGORITHMPSA";
		case LVM_RETURNSTATUS_DUMMY:
		return out << "LVM_RETURNSTATUS_DUMMY";
		}
		return out << "EnumLvmRetStatusError";
		}

		#define GOTO_IF_LVM_ERROR(status, tag, log) \
		do { \
		LVM_ReturnStatus_en temp = (status); \
		if (temp != LVM_SUCCESS) { \
		LOG(ERROR) << __func__ << " return status: " << temp << " " << (log); \
		goto tag; \
		} \
		} while (0)

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

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

0 → 100644

+244 −0

File added.

Preview size limit exceeded, changes collapsed.

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

0 → 100644

+86 −0

File added.

Preview size limit exceeded, changes collapsed.