Merge "DynamicsProcessing: Add range limits for dynamics processing effect params" (c1071179) · Commits · e / os / android_frameworks_av

media/libeffects/dynamicsproc/Android.bp

+4 −0

Original line number	Diff line number	Diff line
		@@ -92,6 +92,10 @@ cc_library_shared {
		"dynamicsprocessingdefaults",
		],

		static_libs: [
		"libaudioaidlranges",
		],

		visibility: [
		"//hardware/interfaces/audio/aidl/default",
		],

media/libeffects/dynamicsproc/aidl/DynamicsProcessing.cpp

+126 −18

Original line number	Diff line number	Diff line
		@@ -62,32 +62,135 @@ namespace aidl::android::hardware::audio::effect {

		const std::string DynamicsProcessingImpl::kEffectName = "DynamicsProcessing";

		const DynamicsProcessing::EqBandConfig DynamicsProcessingImpl::kEqBandConfigMin =
		static const Range::DynamicsProcessingRange kEngineConfigRange = {
		.min = DynamicsProcessing::make<
		DynamicsProcessing::engineArchitecture>(DynamicsProcessing::EngineArchitecture(
		{.resolutionPreference =
		DynamicsProcessing::ResolutionPreference::FAVOR_FREQUENCY_RESOLUTION,
		.preferredProcessingDurationMs = 0,
		.preEqStage = {.inUse = false, .bandCount = 0},
		.postEqStage = {.inUse = false, .bandCount = 0},
		.mbcStage = {.inUse = false, .bandCount = 0},
		.limiterInUse = false})),
		.max = DynamicsProcessing::make<
		DynamicsProcessing::engineArchitecture>(DynamicsProcessing::EngineArchitecture(
		{.resolutionPreference =
		DynamicsProcessing::ResolutionPreference::FAVOR_FREQUENCY_RESOLUTION,
		.preferredProcessingDurationMs = std::numeric_limits<float>::max(),
		.preEqStage = {.inUse = true, .bandCount = std::numeric_limits<int>::max()},
		.postEqStage = {.inUse = true, .bandCount = std::numeric_limits<int>::max()},
		.mbcStage = {.inUse = true, .bandCount = std::numeric_limits<int>::max()},
		.limiterInUse = true}))};

		static const DynamicsProcessing::ChannelConfig kChannelConfigMin =
		DynamicsProcessing::ChannelConfig({.channel = 0, .enable = false});

		static const DynamicsProcessing::ChannelConfig kChannelConfigMax =
		DynamicsProcessing::ChannelConfig(
		{.channel = std::numeric_limits<int>::max(), .enable = true});

		static const Range::DynamicsProcessingRange kPreEqChannelConfigRange = {
		.min = DynamicsProcessing::make<DynamicsProcessing::preEq>({kChannelConfigMin}),
		.max = DynamicsProcessing::make<DynamicsProcessing::preEq>({kChannelConfigMax})};

		static const Range::DynamicsProcessingRange kPostEqChannelConfigRange = {
		.min = DynamicsProcessing::make<DynamicsProcessing::postEq>({kChannelConfigMin}),
		.max = DynamicsProcessing::make<DynamicsProcessing::postEq>({kChannelConfigMax})};

		static const Range::DynamicsProcessingRange kMbcChannelConfigRange = {
		.min = DynamicsProcessing::make<DynamicsProcessing::mbc>({kChannelConfigMin}),
		.max = DynamicsProcessing::make<DynamicsProcessing::mbc>({kChannelConfigMax})};

		static const DynamicsProcessing::EqBandConfig kEqBandConfigMin =
		DynamicsProcessing::EqBandConfig({.channel = 0,
		.band = 0,
		.enable = false,
		.cutoffFrequencyHz = 220,
		.gainDb = std::numeric_limits<float>::min()});
		const DynamicsProcessing::EqBandConfig DynamicsProcessingImpl::kEqBandConfigMax =
		.gainDb = std::numeric_limits<float>::lowest()});

		static const DynamicsProcessing::EqBandConfig kEqBandConfigMax =
		DynamicsProcessing::EqBandConfig({.channel = std::numeric_limits<int>::max(),
		.band = std::numeric_limits<int>::max(),
		.enable = true,
		.cutoffFrequencyHz = 20000,
		.gainDb = std::numeric_limits<float>::max()});
		const Range::DynamicsProcessingRange DynamicsProcessingImpl::kPreEqBandRange = {
		.min = DynamicsProcessing::make<DynamicsProcessing::preEqBand>(
		{DynamicsProcessingImpl::kEqBandConfigMin}),
		.max = DynamicsProcessing::make<DynamicsProcessing::preEqBand>(
		{DynamicsProcessingImpl::kEqBandConfigMax})};
		const Range::DynamicsProcessingRange DynamicsProcessingImpl::kPostEqBandRange = {
		.min = DynamicsProcessing::make<DynamicsProcessing::postEqBand>(
		{DynamicsProcessingImpl::kEqBandConfigMin}),
		.max = DynamicsProcessing::make<DynamicsProcessing::postEqBand>(
		{DynamicsProcessingImpl::kEqBandConfigMax})};
		const Range DynamicsProcessingImpl::kRange =
		Range::make<Range::dynamicsProcessing>({DynamicsProcessingImpl::kPreEqBandRange});

		const Capability DynamicsProcessingImpl::kCapability = {.range = {DynamicsProcessingImpl::kRange}};

		static const Range::DynamicsProcessingRange kPreEqBandConfigRange = {
		.min = DynamicsProcessing::make<DynamicsProcessing::preEqBand>({kEqBandConfigMin}),
		.max = DynamicsProcessing::make<DynamicsProcessing::preEqBand>({kEqBandConfigMax})};

		static const Range::DynamicsProcessingRange kPostEqBandConfigRange = {
		.min = DynamicsProcessing::make<DynamicsProcessing::postEqBand>({kEqBandConfigMin}),
		.max = DynamicsProcessing::make<DynamicsProcessing::postEqBand>({kEqBandConfigMax})};

		static const Range::DynamicsProcessingRange kMbcBandConfigRange = {
		.min = DynamicsProcessing::make<DynamicsProcessing::mbcBand>(
		{DynamicsProcessing::MbcBandConfig(
		{.channel = 0,
		.band = 0,
		.enable = false,
		.cutoffFrequencyHz = 220,
		.attackTimeMs = 0,
		.releaseTimeMs = 0,
		.ratio = 0,
		.thresholdDb = std::numeric_limits<float>::lowest(),
		.kneeWidthDb = 0,
		.noiseGateThresholdDb = std::numeric_limits<float>::lowest(),
		.expanderRatio = 0,
		.preGainDb = std::numeric_limits<float>::lowest(),
		.postGainDb = std::numeric_limits<float>::lowest()})}),
		.max = DynamicsProcessing::make<DynamicsProcessing::mbcBand>(
		{DynamicsProcessing::MbcBandConfig(
		{.channel = std::numeric_limits<int>::max(),
		.band = std::numeric_limits<int>::max(),
		.enable = true,
		.cutoffFrequencyHz = 20000,
		.attackTimeMs = std::numeric_limits<float>::max(),
		.releaseTimeMs = std::numeric_limits<float>::max(),
		.ratio = std::numeric_limits<float>::max(),
		.thresholdDb = 0,
		.kneeWidthDb = std::numeric_limits<float>::max(),
		.noiseGateThresholdDb = 0,
		.expanderRatio = std::numeric_limits<float>::max(),
		.preGainDb = std::numeric_limits<float>::max(),
		.postGainDb = std::numeric_limits<float>::max()})})};

		static const Range::DynamicsProcessingRange kInputGainRange = {
		.min = DynamicsProcessing::make<DynamicsProcessing::inputGain>(
		{DynamicsProcessing::InputGain(
		{.channel = 0, .gainDb = std::numeric_limits<float>::lowest()})}),
		.max = DynamicsProcessing::make<DynamicsProcessing::inputGain>(
		{DynamicsProcessing::InputGain({.channel = std::numeric_limits<int>::max(),
		.gainDb = std::numeric_limits<float>::max()})})};

		static const Range::DynamicsProcessingRange kLimiterRange = {
		.min = DynamicsProcessing::make<DynamicsProcessing::limiter>(
		{DynamicsProcessing::LimiterConfig(
		{.channel = 0,
		.enable = false,
		.linkGroup = std::numeric_limits<int>::min(),
		.attackTimeMs = 0,
		.releaseTimeMs = 0,
		.ratio = 0,
		.thresholdDb = std::numeric_limits<float>::min(),
		.postGainDb = std::numeric_limits<float>::min()})}),
		.max = DynamicsProcessing::make<DynamicsProcessing::limiter>(
		{DynamicsProcessing::LimiterConfig(
		{.channel = std::numeric_limits<int>::max(),
		.enable = true,
		.linkGroup = std::numeric_limits<int>::max(),
		.attackTimeMs = std::numeric_limits<float>::max(),
		.releaseTimeMs = std::numeric_limits<float>::max(),
		.ratio = std::numeric_limits<float>::max(),
		.thresholdDb = 0,
		.postGainDb = std::numeric_limits<float>::max()})})};

		const std::vector<Range::DynamicsProcessingRange> kRanges = {
		kEngineConfigRange, kPreEqChannelConfigRange, kPostEqChannelConfigRange,
		kMbcChannelConfigRange, kPreEqBandConfigRange, kPostEqBandConfigRange,
		kMbcBandConfigRange, kInputGainRange, kLimiterRange};

		const Capability DynamicsProcessingImpl::kCapability = {.range = kRanges};

		const Descriptor DynamicsProcessingImpl::kDescriptor = {
		.common = {.id = {.type = getEffectTypeUuidDynamicsProcessing(),
		@@ -158,14 +261,19 @@ ndk::ScopedAStatus DynamicsProcessingImpl::commandImpl(CommandId command) {
		}
		}

		bool DynamicsProcessingImpl::isParamInRange(const Parameter::Specific& specific) {
		auto& dp = specific.get<Parameter::Specific::dynamicsProcessing>();
		return DynamicsProcessingRanges::isParamInRange(dp, kRanges);
		}

		ndk::ScopedAStatus DynamicsProcessingImpl::setParameterSpecific(
		const Parameter::Specific& specific) {
		RETURN_IF(Parameter::Specific::dynamicsProcessing != specific.getTag(), EX_ILLEGAL_ARGUMENT,
		"EffectNotSupported");
		RETURN_IF(!mContext, EX_NULL_POINTER, "nullContext");

		RETURN_IF(!isParamInRange(specific), EX_ILLEGAL_ARGUMENT, "outOfRange");
		auto& param = specific.get<Parameter::Specific::dynamicsProcessing>();
		// TODO: check range here, dynamicsProcessing need customized method for nested parameters.
		auto tag = param.getTag();

		switch (tag) {

media/libeffects/dynamicsproc/aidl/DynamicsProcessing.h

+3 −6

Original line number	Diff line number	Diff line
		@@ -18,8 +18,9 @@

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

		#include "effect-impl/EffectImpl.h"
		#include "DynamicsProcessingContext.h"
		#include "EffectRangeSpecific.h"
		#include "effect-impl/EffectImpl.h"

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

		@@ -51,14 +52,10 @@ class DynamicsProcessingImpl final : public EffectImpl {
		std::string getEffectName() override { return kEffectName; }

		private:
		static const DynamicsProcessing::EqBandConfig kEqBandConfigMin;
		static const DynamicsProcessing::EqBandConfig kEqBandConfigMax;
		static const Range::DynamicsProcessingRange kPreEqBandRange;
		static const Range::DynamicsProcessingRange kPostEqBandRange;
		static const Range kRange;
		std::shared_ptr<DynamicsProcessingContext> mContext;
		ndk::ScopedAStatus getParameterDynamicsProcessing(const DynamicsProcessing::Tag& tag,
		Parameter::Specific* specific);
		bool isParamInRange(const Parameter::Specific& specific);
		};

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

media/libeffects/dynamicsproc/aidl/DynamicsProcessingContext.cpp

+47 −63

Original line number	Diff line number	Diff line
		@@ -16,11 +16,11 @@

		#define LOG_TAG "AHAL_DPLibEffectsContext"

		#include "DynamicsProcessing.h"
		#include "DynamicsProcessingContext.h"
		#include "DynamicsProcessing.h"

		#include <functional>
		#include <sys/param.h>
		#include <functional>
		#include <unordered_set>

		namespace aidl::android::hardware::audio::effect {
		@@ -91,9 +91,6 @@ void DynamicsProcessingContext::dpSetFreqDomainVariant_l(

		RetCode DynamicsProcessingContext::setEngineArchitecture(
		const DynamicsProcessing::EngineArchitecture& engineArchitecture) {
		RETURN_VALUE_IF(!validateEngineConfig(engineArchitecture), RetCode::ERROR_ILLEGAL_PARAMETER,
		"illegalEngineConfig");

		std::lock_guard lg(mMutex);
		if (!mEngineInited \|\| mEngineArchitecture != engineArchitecture) {
		if (engineArchitecture.resolutionPreference ==
		@@ -134,10 +131,12 @@ RetCode DynamicsProcessingContext::setMbc(
		RetCode DynamicsProcessingContext::setPreEqBand(
		const std::vector<DynamicsProcessing::EqBandConfig>& bands) {
		std::lock_guard lg(mMutex);
		RETURN_VALUE_IF(!mEngineArchitecture.postEqStage.inUse, RetCode::ERROR_ILLEGAL_PARAMETER,
		"postEqNotInUse");
		return setBands_l<DynamicsProcessing::EqBandConfig>(
		bands, mEngineArchitecture.preEqStage.bandCount, StageType::PREEQ);
		RETURN_VALUE_IF(!mEngineArchitecture.preEqStage.inUse, RetCode::ERROR_ILLEGAL_PARAMETER,
		"preEqNotInUse");
		RETURN_VALUE_IF(
		!validateBandConfig(bands, mChannelCount, mEngineArchitecture.preEqStage.bandCount),
		RetCode::ERROR_ILLEGAL_PARAMETER, "eqBandNotValid");
		return setBands_l<DynamicsProcessing::EqBandConfig>(bands, StageType::PREEQ);
		}

		RetCode DynamicsProcessingContext::setPostEqBand(
		@@ -145,8 +144,10 @@ RetCode DynamicsProcessingContext::setPostEqBand(
		std::lock_guard lg(mMutex);
		RETURN_VALUE_IF(!mEngineArchitecture.postEqStage.inUse, RetCode::ERROR_ILLEGAL_PARAMETER,
		"postEqNotInUse");
		return setBands_l<DynamicsProcessing::EqBandConfig>(
		bands, mEngineArchitecture.postEqStage.bandCount, StageType::POSTEQ);
		RETURN_VALUE_IF(
		!validateBandConfig(bands, mChannelCount, mEngineArchitecture.postEqStage.bandCount),
		RetCode::ERROR_ILLEGAL_PARAMETER, "eqBandNotValid");
		return setBands_l<DynamicsProcessing::EqBandConfig>(bands, StageType::POSTEQ);
		}

		RetCode DynamicsProcessingContext::setMbcBand(
		@@ -154,8 +155,10 @@ RetCode DynamicsProcessingContext::setMbcBand(
		std::lock_guard lg(mMutex);
		RETURN_VALUE_IF(!mEngineArchitecture.mbcStage.inUse, RetCode::ERROR_ILLEGAL_PARAMETER,
		"mbcNotInUse");
		return setBands_l<DynamicsProcessing::MbcBandConfig>(
		bands, mEngineArchitecture.preEqStage.bandCount, StageType::MBC);
		RETURN_VALUE_IF(
		!validateBandConfig(bands, mChannelCount, mEngineArchitecture.mbcStage.bandCount),
		RetCode::ERROR_ILLEGAL_PARAMETER, "eqBandNotValid");
		return setBands_l<DynamicsProcessing::MbcBandConfig>(bands, StageType::MBC);
		}

		RetCode DynamicsProcessingContext::setLimiter(
		@@ -163,13 +166,17 @@ RetCode DynamicsProcessingContext::setLimiter(
		std::lock_guard lg(mMutex);
		RETURN_VALUE_IF(!mEngineArchitecture.limiterInUse, RetCode::ERROR_ILLEGAL_PARAMETER,
		"limiterNotInUse");
		return setBands_l<DynamicsProcessing::LimiterConfig>(limiters, -1, StageType::LIMITER);
		RETURN_VALUE_IF(!validateLimiterConfig(limiters, mChannelCount),
		RetCode::ERROR_ILLEGAL_PARAMETER, "limiterConfigNotValid");
		return setBands_l<DynamicsProcessing::LimiterConfig>(limiters, StageType::LIMITER);
		}

		RetCode DynamicsProcessingContext::setInputGain(
		const std::vector<DynamicsProcessing::InputGain>& inputGains) {
		std::lock_guard lg(mMutex);
		return setBands_l<DynamicsProcessing::InputGain>(inputGains, -1, StageType::INPUTGAIN);
		RETURN_VALUE_IF(!validateInputGainConfig(inputGains, mChannelCount),
		RetCode::ERROR_ILLEGAL_PARAMETER, "inputGainNotValid");
		return setBands_l<DynamicsProcessing::InputGain>(inputGains, StageType::INPUTGAIN);
		}

		DynamicsProcessing::EngineArchitecture DynamicsProcessingContext::getEngineArchitecture() {
		@@ -406,45 +413,33 @@ std::vector<DynamicsProcessing::EqBandConfig> DynamicsProcessingContext::getEqBa
		return eqBands;
		}

		/**
		* When StageEnablement is in use, bandCount needs to be positive.
		*/
		bool DynamicsProcessingContext::validateStageEnablement(
		const DynamicsProcessing::StageEnablement& enablement) {
		return !enablement.inUse \|\| (enablement.inUse && enablement.bandCount > 0);
		template <typename T>
		bool DynamicsProcessingContext::validateBandConfig(const std::vector<T>& bands, int maxChannel,
		int maxBand) {
		std::vector<float> freqs(bands.size(), -1);
		for (auto band : bands) {
		if (!validateChannel(band.channel, maxChannel)) return false;
		if (!validateBand(band.band, maxBand)) return false;
		freqs[band.band] = band.cutoffFrequencyHz;
		}

		bool DynamicsProcessingContext::validateEngineConfig(
		const DynamicsProcessing::EngineArchitecture& engine) {
		return engine.preferredProcessingDurationMs >= 0 &&
		validateStageEnablement(engine.preEqStage) &&
		validateStageEnablement(engine.postEqStage) && validateStageEnablement(engine.mbcStage);
		if (std::count(freqs.begin(), freqs.end(), -1)) return false;
		return std::is_sorted(freqs.begin(), freqs.end());
		}

		bool DynamicsProcessingContext::validateEqBandConfig(const DynamicsProcessing::EqBandConfig& band,
		int maxChannel, int maxBand) {
		return validateChannel(band.channel, maxChannel) && validateBand(band.band, maxBand);
		bool DynamicsProcessingContext::validateLimiterConfig(
		const std::vector<DynamicsProcessing::LimiterConfig>& cfgs, int maxChannel) {
		for (auto cfg : cfgs) {
		if (!validateChannel(cfg.channel, maxChannel)) return false;
		}

		bool DynamicsProcessingContext::validateMbcBandConfig(const DynamicsProcessing::MbcBandConfig& band,
		int maxChannel, int maxBand) {
		return validateChannel(band.channel, maxChannel) && validateBand(band.band, maxBand) &&
		validateTime(band.attackTimeMs) && validateTime(band.releaseTimeMs) &&
		validateRatio(band.ratio) && validateBandDb(band.thresholdDb) &&
		validateBandDb(band.kneeWidthDb) && validateBandDb(band.noiseGateThresholdDb) &&
		validateRatio(band.expanderRatio);
		return true;
		}

		bool DynamicsProcessingContext::validateLimiterConfig(
		const DynamicsProcessing::LimiterConfig& limiter, int maxChannel) {
		return validateChannel(limiter.channel, maxChannel) && validateTime(limiter.attackTimeMs) &&
		validateTime(limiter.releaseTimeMs) && validateRatio(limiter.ratio) &&
		validateBandDb(limiter.thresholdDb);
		bool DynamicsProcessingContext::validateInputGainConfig(
		const std::vector<DynamicsProcessing::InputGain>& cfgs, int maxChannel) {
		for (auto cfg : cfgs) {
		if (!validateChannel(cfg.channel, maxChannel)) return false;
		}

		bool DynamicsProcessingContext::validateInputGainConfig(const DynamicsProcessing::InputGain& gain,
		int maxChannel) {
		return validateChannel(gain.channel, maxChannel);
		return true;
		}

		template <typename D>
		@@ -483,7 +478,6 @@ RetCode DynamicsProcessingContext::setDpChannels_l(
		}

		RetCode DynamicsProcessingContext::setDpChannelBand_l(const std::any& anyConfig, StageType type,
		int maxCh, int maxBand,
		std::set<std::pair<int, int>>& chBandSet) {
		RETURN_VALUE_IF(!anyConfig.has_value(), RetCode::ERROR_ILLEGAL_PARAMETER, "bandInvalid");
		RetCode ret = RetCode::SUCCESS;
		@@ -494,8 +488,6 @@ RetCode DynamicsProcessingContext::setDpChannelBand_l(const std::any& anyConfig,
		case StageType::POSTEQ: {
		dp_fx::DPEq* dp;
		const auto& config = std::any_cast<DynamicsProcessing::EqBandConfig>(anyConfig);
		RETURN_VALUE_IF(!validateEqBandConfig(config, maxCh, maxBand),
		RetCode::ERROR_ILLEGAL_PARAMETER, "eqBandNotValid");
		RETURN_VALUE_IF(
		nullptr == (dp = getEqWithType_l(type, config.channel)) \|\| !dp->isEnabled(),
		RetCode::ERROR_ILLEGAL_PARAMETER, "dpEqNotExist");
		@@ -508,8 +500,6 @@ RetCode DynamicsProcessingContext::setDpChannelBand_l(const std::any& anyConfig,
		case StageType::MBC: {
		dp_fx::DPMbc* dp;
		const auto& config = std::any_cast<DynamicsProcessing::MbcBandConfig>(anyConfig);
		RETURN_VALUE_IF(!validateMbcBandConfig(config, maxCh, maxBand),
		RetCode::ERROR_ILLEGAL_PARAMETER, "mbcBandNotValid");
		RETURN_VALUE_IF(nullptr == (dp = getMbc_l(config.channel)) \|\| !dp->isEnabled(),
		RetCode::ERROR_ILLEGAL_PARAMETER, "dpMbcNotExist");
		dp_fx::DPMbcBand band;
		@@ -524,8 +514,6 @@ RetCode DynamicsProcessingContext::setDpChannelBand_l(const std::any& anyConfig,
		case StageType::LIMITER: {
		dp_fx::DPChannel* dp;
		const auto& config = std::any_cast<DynamicsProcessing::LimiterConfig>(anyConfig);
		RETURN_VALUE_IF(!validateLimiterConfig(config, maxCh),
		RetCode::ERROR_ILLEGAL_PARAMETER, "limiterBandNotValid");
		RETURN_VALUE_IF(nullptr == (dp = getChannel_l(config.channel)),
		RetCode::ERROR_ILLEGAL_PARAMETER, "dpChNotExist");
		dp_fx::DPLimiter limiter;
		@@ -539,8 +527,6 @@ RetCode DynamicsProcessingContext::setDpChannelBand_l(const std::any& anyConfig,
		case StageType::INPUTGAIN: {
		dp_fx::DPChannel* dp;
		const auto& config = std::any_cast<DynamicsProcessing::InputGain>(anyConfig);
		RETURN_VALUE_IF(!validateInputGainConfig(config, maxCh),
		RetCode::ERROR_ILLEGAL_PARAMETER, "inputGainNotValid");
		RETURN_VALUE_IF(nullptr == (dp = getChannel_l(config.channel)),
		RetCode::ERROR_ILLEGAL_PARAMETER, "dpChNotExist");
		dp->setInputGain(config.gainDb);
		@@ -555,14 +541,12 @@ RetCode DynamicsProcessingContext::setDpChannelBand_l(const std::any& anyConfig,
		}

		template <typename T /* BandConfig */>
		RetCode DynamicsProcessingContext::setBands_l(
		const std::vector<T>& bands, int maxBand, StageType type) {
		RetCode DynamicsProcessingContext::setBands_l(const std::vector<T>& bands, StageType type) {
		RetCode ret = RetCode::SUCCESS;
		std::set<std::pair<int /* channel /, int / band */>> bandSet;

		for (const auto& it : bands) {
		if (RetCode::SUCCESS !=
		setDpChannelBand_l(std::make_any<T>(it), type, mChannelCount, maxBand, bandSet)) {
		if (RetCode::SUCCESS != setDpChannelBand_l(std::make_any<T>(it), type, bandSet)) {
		LOG(WARNING) << __func__ << " skipping band " << it.toString();
		ret = RetCode::ERROR_ILLEGAL_PARAMETER;
		continue;

media/libeffects/dynamicsproc/aidl/DynamicsProcessingContext.h

+8 −14

Original line number	Diff line number	Diff line
		@@ -103,28 +103,22 @@ class DynamicsProcessingContext final : public EffectContext {
		RetCode setDpChannels_l(const std::vector<DynamicsProcessing::ChannelConfig>& channels,
		bool stageInUse, StageType type) REQUIRES(mMutex);
		template <typename T /* BandConfig */>
		RetCode setBands_l(const std::vector<T>& bands, int maxBand, StageType type) REQUIRES(mMutex);
		RetCode setDpChannelBand_l(const std::any& anyConfig, StageType type, int maxCh, int maxBand,
		RetCode setBands_l(const std::vector<T>& bands, StageType type) REQUIRES(mMutex);
		RetCode setDpChannelBand_l(const std::any& anyConfig, StageType type,
		std::set<std::pair<int, int>>& chBandSet) REQUIRES(mMutex);

		std::vector<DynamicsProcessing::EqBandConfig> getEqBandConfigs(StageType type);
		std::vector<DynamicsProcessing::ChannelConfig> getChannelConfig(StageType type);

		bool validateStageEnablement(const DynamicsProcessing::StageEnablement& enablement);
		bool validateEngineConfig(const DynamicsProcessing::EngineArchitecture& engine);
		bool validateEqBandConfig(const DynamicsProcessing::EqBandConfig& band, int maxChannel,
		int maxBand);
		bool validateMbcBandConfig(const DynamicsProcessing::MbcBandConfig& band, int maxChannel,
		int maxBand);
		bool validateLimiterConfig(const DynamicsProcessing::LimiterConfig& limiter, int maxChannel);
		bool validateInputGainConfig(const DynamicsProcessing::InputGain& gain, int maxChannel);
		template <typename T /* BandConfig */>
		bool validateBandConfig(const std::vector<T>& bands, int maxChannel, int maxBand);
		bool validateLimiterConfig(const std::vector<DynamicsProcessing::LimiterConfig>& cfgs,
		int maxChannel);
		bool validateInputGainConfig(const std::vector<DynamicsProcessing::InputGain>& cfgs,
		int maxChannel);

		inline bool validateCutoffFrequency(float freq);
		inline bool validateChannel(int ch, int maxCh) { return ch >= 0 && ch < maxCh; }
		inline bool validateBand(int band, int maxBand) { return band >= 0 && band < maxBand; }
		inline bool validateTime(int time) { return time >= 0; }
		inline bool validateRatio(int ratio) { return ratio >= 0; }
		inline bool validateBandDb(int db) { return db <= 0; }
		};

		} // namespace aidl::android::hardware::audio::effect
		No newline at end of file