Merge "Merge 24Q3 (ab/11976889) to aosp-main-future" into aosp-main-future (5b64d613) · Commits · e / os / android_hardware_interfaces

audio/aidl/Android.bp

+10 −0

Original line number	Original line	Diff line number	Diff line
	@@ -64,6 +64,9 @@ aidl_interface {
	],		],
	min_sdk_version: "31",		min_sdk_version: "31",
	},		},
			rust: {
			enabled: true,
			},
	},		},
	versions_with_info: [		versions_with_info: [
	{		{
	@@ -112,6 +115,13 @@ cc_defaults {
	],		],
	}		}

			rust_defaults {
			name: "latest_android_hardware_audio_common_rust",
			rustlibs: [
			latest_android_hardware_audio_common + "-rust",
			],
			}

	aidl_interface_defaults {		aidl_interface_defaults {
	name: "latest_android_hardware_audio_common_import_interface",		name: "latest_android_hardware_audio_common_import_interface",
	imports: [		imports: [

audio/aidl/common/include/Utils.h

+3 −0

Original line number	Original line	Diff line number	Diff line
	@@ -47,6 +47,9 @@ inline std::string errorToString(const ScopedAStatus& s) {

	namespace aidl::android::hardware::audio::common {		namespace aidl::android::hardware::audio::common {

			// TODO: b/275135031 - move this string to AIDL interfaces.
			static constexpr char kDumpFromAudioServerArgument[] = "dump_from_audioserver";

	// Some values are reserved for use by the system code only.		// Some values are reserved for use by the system code only.
	// HALs must not accept or emit values outside from the provided list.		// HALs must not accept or emit values outside from the provided list.
	constexpr std::array<::aidl::android::media::audio::common::AudioMode, 5> kValidAudioModes = {		constexpr std::array<::aidl::android::media::audio::common::AudioMode, 5> kValidAudioModes = {

audio/aidl/vts/VtsHalDynamicsProcessingTest.cpp

+29 −62

Original line number	Original line	Diff line number	Diff line
	@@ -453,12 +453,11 @@ enum EngineArchitectureTestParamName {
	ENGINE_TEST_INSTANCE_NAME,		ENGINE_TEST_INSTANCE_NAME,
	ENGINE_TEST_RESOLUTION_PREFERENCE,		ENGINE_TEST_RESOLUTION_PREFERENCE,
	ENGINE_TEST_PREFERRED_DURATION,		ENGINE_TEST_PREFERRED_DURATION,
	ENGINE_TEST_STAGE_ENABLEMENT,		ENGINE_TEST_STAGE_ENABLEMENT
	ENGINE_TEST_LIMITER_IN_USE
	};		};
	using EngineArchitectureTestParams = std::tuple<std::pair<std::shared_ptr<IFactory>, Descriptor>,		using EngineArchitectureTestParams = std::tuple<std::pair<std::shared_ptr<IFactory>, Descriptor>,
	DynamicsProcessing::ResolutionPreference, float,		DynamicsProcessing::ResolutionPreference, float,
	DynamicsProcessing::StageEnablement, bool>;		DynamicsProcessing::StageEnablement>;

	void fillEngineArchConfig(DynamicsProcessing::EngineArchitecture& cfg,		void fillEngineArchConfig(DynamicsProcessing::EngineArchitecture& cfg,
	const EngineArchitectureTestParams& params) {		const EngineArchitectureTestParams& params) {
	@@ -466,7 +465,7 @@ void fillEngineArchConfig(DynamicsProcessing::EngineArchitecture& cfg,
	cfg.preferredProcessingDurationMs = std::get<ENGINE_TEST_PREFERRED_DURATION>(params);		cfg.preferredProcessingDurationMs = std::get<ENGINE_TEST_PREFERRED_DURATION>(params);
	cfg.preEqStage = cfg.postEqStage = cfg.mbcStage =		cfg.preEqStage = cfg.postEqStage = cfg.mbcStage =
	std::get<ENGINE_TEST_STAGE_ENABLEMENT>(params);		std::get<ENGINE_TEST_STAGE_ENABLEMENT>(params);
	cfg.limiterInUse = std::get<ENGINE_TEST_LIMITER_IN_USE>(params);		cfg.limiterInUse = true;
	}		}

	class DynamicsProcessingTestEngineArchitecture		class DynamicsProcessingTestEngineArchitecture
	@@ -501,8 +500,8 @@ INSTANTIATE_TEST_SUITE_P(
	static_cast<DynamicsProcessing::ResolutionPreference>(-1)), // variant		static_cast<DynamicsProcessing::ResolutionPreference>(-1)), // variant
	testing::Values(-10.f, 0.f, 10.f), // processing duration		testing::Values(-10.f, 0.f, 10.f), // processing duration
	testing::ValuesIn(		testing::ValuesIn(
	DynamicsProcessingTestHelper::kStageEnablementTestSet), // preEQ/postEQ/mbc		DynamicsProcessingTestHelper::kStageEnablementTestSet) // preEQ/postEQ/mbc
	testing::Bool()), // limiter enable		),
	[](const auto& info) {		[](const auto& info) {
	auto descriptor = std::get<ENGINE_TEST_INSTANCE_NAME>(info.param).second;		auto descriptor = std::get<ENGINE_TEST_INSTANCE_NAME>(info.param).second;
	DynamicsProcessing::EngineArchitecture cfg;		DynamicsProcessing::EngineArchitecture cfg;
	@@ -568,7 +567,6 @@ enum LimiterConfigTestParamName {
	LIMITER_CHANNEL,		LIMITER_CHANNEL,
	LIMITER_ENABLE,		LIMITER_ENABLE,
	LIMITER_LINK_GROUP,		LIMITER_LINK_GROUP,
	LIMITER_ENGINE_IN_USE,
	LIMITER_ADDITIONAL,		LIMITER_ADDITIONAL,
	};		};
	enum LimiterConfigTestAdditionalParam {		enum LimiterConfigTestAdditionalParam {
	@@ -587,9 +585,8 @@ static constexpr std::array<LimiterConfigTestAdditional, 4> kLimiterConfigTestAd
	{1, -60, 2.5, -2, 3.14},		{1, -60, 2.5, -2, 3.14},
	{1, 60, 2.5, -2, 3.14}}};		{1, 60, 2.5, -2, 3.14}}};

	using LimiterConfigTestParams =		using LimiterConfigTestParams = std::tuple<std::pair<std::shared_ptr<IFactory>, Descriptor>,
	std::tuple<std::pair<std::shared_ptr<IFactory>, Descriptor>, int32_t, bool, int32_t, bool,		int32_t, bool, int32_t, LimiterConfigTestAdditional>;
	LimiterConfigTestAdditional>;

	void fillLimiterConfig(DynamicsProcessing::LimiterConfig& cfg,		void fillLimiterConfig(DynamicsProcessing::LimiterConfig& cfg,
	const LimiterConfigTestParams& params) {		const LimiterConfigTestParams& params) {
	@@ -609,8 +606,7 @@ class DynamicsProcessingTestLimiterConfig
	public DynamicsProcessingTestHelper {		public DynamicsProcessingTestHelper {
	public:		public:
	DynamicsProcessingTestLimiterConfig()		DynamicsProcessingTestLimiterConfig()
	: DynamicsProcessingTestHelper(std::get<LIMITER_INSTANCE_NAME>(GetParam())),		: DynamicsProcessingTestHelper(std::get<LIMITER_INSTANCE_NAME>(GetParam())) {
	mLimiterInUseEngine(std::get<LIMITER_ENGINE_IN_USE>(GetParam())) {
	fillLimiterConfig(mCfg, GetParam());		fillLimiterConfig(mCfg, GetParam());
	}		}

	@@ -619,11 +615,9 @@ class DynamicsProcessingTestLimiterConfig
	void TearDown() override { TearDownDynamicsProcessingEffect(); }		void TearDown() override { TearDownDynamicsProcessingEffect(); }

	DynamicsProcessing::LimiterConfig mCfg;		DynamicsProcessing::LimiterConfig mCfg;
	bool mLimiterInUseEngine;
	};		};

	TEST_P(DynamicsProcessingTestLimiterConfig, SetAndGetLimiterConfig) {		TEST_P(DynamicsProcessingTestLimiterConfig, SetAndGetLimiterConfig) {
	mEngineConfigPreset.limiterInUse = mLimiterInUseEngine;
	EXPECT_NO_FATAL_FAILURE(addEngineConfig(mEngineConfigPreset));		EXPECT_NO_FATAL_FAILURE(addEngineConfig(mEngineConfigPreset));
	EXPECT_NO_FATAL_FAILURE(addLimiterConfig({mCfg}));		EXPECT_NO_FATAL_FAILURE(addLimiterConfig({mCfg}));
	SetAndGetDynamicsProcessingParameters();		SetAndGetDynamicsProcessingParameters();
	@@ -636,18 +630,15 @@ INSTANTIATE_TEST_SUITE_P(
	testing::Values(-1, 0, 1, 2), // channel count		testing::Values(-1, 0, 1, 2), // channel count
	testing::Bool(), // enable		testing::Bool(), // enable
	testing::Values(3), // link group		testing::Values(3), // link group
	testing::Bool(), // engine limiter enable
	testing::ValuesIn(kLimiterConfigTestAdditionalParam)), // Additional		testing::ValuesIn(kLimiterConfigTestAdditionalParam)), // Additional
	[](const auto& info) {		[](const auto& info) {
	auto descriptor = std::get<LIMITER_INSTANCE_NAME>(info.param).second;		auto descriptor = std::get<LIMITER_INSTANCE_NAME>(info.param).second;
	DynamicsProcessing::LimiterConfig cfg;		DynamicsProcessing::LimiterConfig cfg;
	fillLimiterConfig(cfg, info.param);		fillLimiterConfig(cfg, info.param);
	std::string engineLimiterInUse =
	std::to_string(std::get<LIMITER_ENGINE_IN_USE>(info.param));
	std::string name = "Implementor_" + descriptor.common.implementor + "_name_" +		std::string name = "Implementor_" + descriptor.common.implementor + "_name_" +
	descriptor.common.name + "_UUID_" +		descriptor.common.name + "_UUID_" +
	toString(descriptor.common.id.uuid) + "_limiterConfig_" +		toString(descriptor.common.id.uuid) + "_limiterConfig_" +
	cfg.toString() + "_engineSetting_" + engineLimiterInUse;		cfg.toString();
	std::replace_if(		std::replace_if(
	name.begin(), name.end(), [](const char c) { return !std::isalnum(c); }, '_');		name.begin(), name.end(), [](const char c) { return !std::isalnum(c); }, '_');
	return name;		return name;
	@@ -659,11 +650,10 @@ GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(DynamicsProcessingTestLimiterConfi
	*/		*/
	enum ChannelConfigTestParamName {		enum ChannelConfigTestParamName {
	BAND_CHANNEL_TEST_INSTANCE_NAME,		BAND_CHANNEL_TEST_INSTANCE_NAME,
	BAND_CHANNEL_TEST_CHANNEL_CONFIG,		BAND_CHANNEL_TEST_CHANNEL_CONFIG
	BAND_CHANNEL_TEST_ENGINE_IN_USE
	};		};
	using ChannelConfigTestParams = std::tuple<std::pair<std::shared_ptr<IFactory>, Descriptor>,		using ChannelConfigTestParams = std::tuple<std::pair<std::shared_ptr<IFactory>, Descriptor>,
	std::vector<DynamicsProcessing::ChannelConfig>, bool>;		std::vector<DynamicsProcessing::ChannelConfig>>;

	class DynamicsProcessingTestChannelConfig		class DynamicsProcessingTestChannelConfig
	: public ::testing::TestWithParam<ChannelConfigTestParams>,		: public ::testing::TestWithParam<ChannelConfigTestParams>,
	@@ -671,33 +661,28 @@ class DynamicsProcessingTestChannelConfig
	public:		public:
	DynamicsProcessingTestChannelConfig()		DynamicsProcessingTestChannelConfig()
	: DynamicsProcessingTestHelper(std::get<BAND_CHANNEL_TEST_INSTANCE_NAME>(GetParam())),		: DynamicsProcessingTestHelper(std::get<BAND_CHANNEL_TEST_INSTANCE_NAME>(GetParam())),
	mCfg(std::get<BAND_CHANNEL_TEST_CHANNEL_CONFIG>(GetParam())),		mCfg(std::get<BAND_CHANNEL_TEST_CHANNEL_CONFIG>(GetParam())) {}
	mInUseEngine(std::get<BAND_CHANNEL_TEST_ENGINE_IN_USE>(GetParam())) {}

	void SetUp() override { SetUpDynamicsProcessingEffect(); }		void SetUp() override { SetUpDynamicsProcessingEffect(); }

	void TearDown() override { TearDownDynamicsProcessingEffect(); }		void TearDown() override { TearDownDynamicsProcessingEffect(); }

	std::vector<DynamicsProcessing::ChannelConfig> mCfg;		std::vector<DynamicsProcessing::ChannelConfig> mCfg;
	const bool mInUseEngine;
	};		};

	TEST_P(DynamicsProcessingTestChannelConfig, SetAndGetPreEqChannelConfig) {		TEST_P(DynamicsProcessingTestChannelConfig, SetAndGetPreEqChannelConfig) {
	mEngineConfigPreset.preEqStage.inUse = mInUseEngine;
	EXPECT_NO_FATAL_FAILURE(addEngineConfig(mEngineConfigPreset));		EXPECT_NO_FATAL_FAILURE(addEngineConfig(mEngineConfigPreset));
	EXPECT_NO_FATAL_FAILURE(addPreEqChannelConfig(mCfg));		EXPECT_NO_FATAL_FAILURE(addPreEqChannelConfig(mCfg));
	SetAndGetDynamicsProcessingParameters();		SetAndGetDynamicsProcessingParameters();
	}		}

	TEST_P(DynamicsProcessingTestChannelConfig, SetAndGetPostEqChannelConfig) {		TEST_P(DynamicsProcessingTestChannelConfig, SetAndGetPostEqChannelConfig) {
	mEngineConfigPreset.postEqStage.inUse = mInUseEngine;
	EXPECT_NO_FATAL_FAILURE(addEngineConfig(mEngineConfigPreset));		EXPECT_NO_FATAL_FAILURE(addEngineConfig(mEngineConfigPreset));
	EXPECT_NO_FATAL_FAILURE(addPostEqChannelConfig(mCfg));		EXPECT_NO_FATAL_FAILURE(addPostEqChannelConfig(mCfg));
	SetAndGetDynamicsProcessingParameters();		SetAndGetDynamicsProcessingParameters();
	}		}

	TEST_P(DynamicsProcessingTestChannelConfig, SetAndGetMbcChannelConfig) {		TEST_P(DynamicsProcessingTestChannelConfig, SetAndGetMbcChannelConfig) {
	mEngineConfigPreset.mbcStage.inUse = mInUseEngine;
	EXPECT_NO_FATAL_FAILURE(addEngineConfig(mEngineConfigPreset));		EXPECT_NO_FATAL_FAILURE(addEngineConfig(mEngineConfigPreset));
	EXPECT_NO_FATAL_FAILURE(addMbcChannelConfig(mCfg));		EXPECT_NO_FATAL_FAILURE(addMbcChannelConfig(mCfg));
	SetAndGetDynamicsProcessingParameters();		SetAndGetDynamicsProcessingParameters();
	@@ -709,19 +694,15 @@ INSTANTIATE_TEST_SUITE_P(
	testing::ValuesIn(EffectFactoryHelper::getAllEffectDescriptors(		testing::ValuesIn(EffectFactoryHelper::getAllEffectDescriptors(
	IFactory::descriptor, getEffectTypeUuidDynamicsProcessing())),		IFactory::descriptor, getEffectTypeUuidDynamicsProcessing())),
	testing::ValuesIn(		testing::ValuesIn(
	DynamicsProcessingTestHelper::kChannelConfigTestSet), // channel config		DynamicsProcessingTestHelper::kChannelConfigTestSet)), // channel config
	testing::Bool()), // Engine inUse
	[](const auto& info) {		[](const auto& info) {
	auto descriptor = std::get<BAND_CHANNEL_TEST_INSTANCE_NAME>(info.param).second;		auto descriptor = std::get<BAND_CHANNEL_TEST_INSTANCE_NAME>(info.param).second;
	std::string engineInUse =
	std::to_string(std::get<BAND_CHANNEL_TEST_ENGINE_IN_USE>(info.param));
	std::string channelConfig = ::android::internal::ToString(		std::string channelConfig = ::android::internal::ToString(
	std::get<BAND_CHANNEL_TEST_CHANNEL_CONFIG>(info.param));		std::get<BAND_CHANNEL_TEST_CHANNEL_CONFIG>(info.param));

	std::string name = "Implementor_" + descriptor.common.implementor + "_name_" +		std::string name = "Implementor_" + descriptor.common.implementor + "_name_" +
	descriptor.common.name + "_UUID_" +		descriptor.common.name + "_UUID_" +
	toString(descriptor.common.id.uuid) + "_" + channelConfig +		toString(descriptor.common.id.uuid) + "_" + channelConfig;
	"_engineInUse_" + engineInUse;
	std::replace_if(		std::replace_if(
	name.begin(), name.end(), [](const char c) { return !std::isalnum(c); }, '_');		name.begin(), name.end(), [](const char c) { return !std::isalnum(c); }, '_');
	return name;		return name;
	@@ -736,11 +717,10 @@ enum EqBandConfigTestParamName {
	EQ_BAND_CHANNEL,		EQ_BAND_CHANNEL,
	EQ_BAND_ENABLE,		EQ_BAND_ENABLE,
	EQ_BAND_CUT_OFF_FREQ,		EQ_BAND_CUT_OFF_FREQ,
	EQ_BAND_GAIN,		EQ_BAND_GAIN
	EQ_BAND_STAGE_IN_USE
	};		};
	using EqBandConfigTestParams = std::tuple<std::pair<std::shared_ptr<IFactory>, Descriptor>, int32_t,		using EqBandConfigTestParams = std::tuple<std::pair<std::shared_ptr<IFactory>, Descriptor>, int32_t,
	bool, std::vector<std::pair<int, float>>, float, bool>;		bool, std::vector<std::pair<int, float>>, float>;

	void fillEqBandConfig(std::vector<DynamicsProcessing::EqBandConfig>& cfgs,		void fillEqBandConfig(std::vector<DynamicsProcessing::EqBandConfig>& cfgs,
	const EqBandConfigTestParams& params) {		const EqBandConfigTestParams& params) {
	@@ -760,8 +740,7 @@ class DynamicsProcessingTestEqBandConfig : public ::testing::TestWithParam<EqBan
	public DynamicsProcessingTestHelper {		public DynamicsProcessingTestHelper {
	public:		public:
	DynamicsProcessingTestEqBandConfig()		DynamicsProcessingTestEqBandConfig()
	: DynamicsProcessingTestHelper(std::get<EQ_BAND_INSTANCE_NAME>(GetParam())),		: DynamicsProcessingTestHelper(std::get<EQ_BAND_INSTANCE_NAME>(GetParam())) {
	mStageInUse(std::get<EQ_BAND_STAGE_IN_USE>(GetParam())) {
	fillEqBandConfig(mCfgs, GetParam());		fillEqBandConfig(mCfgs, GetParam());
	}		}

	@@ -770,11 +749,9 @@ class DynamicsProcessingTestEqBandConfig : public ::testing::TestWithParam<EqBan
	void TearDown() override { TearDownDynamicsProcessingEffect(); }		void TearDown() override { TearDownDynamicsProcessingEffect(); }

	std::vector<DynamicsProcessing::EqBandConfig> mCfgs;		std::vector<DynamicsProcessing::EqBandConfig> mCfgs;
	const bool mStageInUse;
	};		};

	TEST_P(DynamicsProcessingTestEqBandConfig, SetAndGetPreEqBandConfig) {		TEST_P(DynamicsProcessingTestEqBandConfig, SetAndGetPreEqBandConfig) {
	mEngineConfigPreset.preEqStage.inUse = mStageInUse;
	mEngineConfigPreset.preEqStage.bandCount = mCfgs.size();		mEngineConfigPreset.preEqStage.bandCount = mCfgs.size();
	EXPECT_NO_FATAL_FAILURE(addEngineConfig(mEngineConfigPreset));		EXPECT_NO_FATAL_FAILURE(addEngineConfig(mEngineConfigPreset));
	std::vector<DynamicsProcessing::ChannelConfig> cfgs(mChannelCount);		std::vector<DynamicsProcessing::ChannelConfig> cfgs(mChannelCount);
	@@ -788,7 +765,6 @@ TEST_P(DynamicsProcessingTestEqBandConfig, SetAndGetPreEqBandConfig) {
	}		}

	TEST_P(DynamicsProcessingTestEqBandConfig, SetAndGetPostEqBandConfig) {		TEST_P(DynamicsProcessingTestEqBandConfig, SetAndGetPostEqBandConfig) {
	mEngineConfigPreset.postEqStage.inUse = mStageInUse;
	mEngineConfigPreset.postEqStage.bandCount = mCfgs.size();		mEngineConfigPreset.postEqStage.bandCount = mCfgs.size();
	EXPECT_NO_FATAL_FAILURE(addEngineConfig(mEngineConfigPreset));		EXPECT_NO_FATAL_FAILURE(addEngineConfig(mEngineConfigPreset));
	std::vector<DynamicsProcessing::ChannelConfig> cfgs(mChannelCount);		std::vector<DynamicsProcessing::ChannelConfig> cfgs(mChannelCount);
	@@ -852,18 +828,16 @@ INSTANTIATE_TEST_SUITE_P(
	testing::Values(-1, 0, 10), // channel ID		testing::Values(-1, 0, 10), // channel ID
	testing::Bool(), // band enable		testing::Bool(), // band enable
	testing::ValuesIn(kBands), // cut off frequencies		testing::ValuesIn(kBands), // cut off frequencies
	testing::Values(-3.14f, 3.14f), // gain		testing::Values(-3.14f, 3.14f) // gain
	testing::Values(true)), // stage in use		),
	[](const auto& info) {		[](const auto& info) {
	auto descriptor = std::get<EQ_BAND_INSTANCE_NAME>(info.param).second;		auto descriptor = std::get<EQ_BAND_INSTANCE_NAME>(info.param).second;
	std::vector<DynamicsProcessing::EqBandConfig> cfgs;		std::vector<DynamicsProcessing::EqBandConfig> cfgs;
	fillEqBandConfig(cfgs, info.param);		fillEqBandConfig(cfgs, info.param);
	std::string bands = ::android::internal::ToString(cfgs);		std::string bands = ::android::internal::ToString(cfgs);
	std::string stageInUse = std::to_string(std::get<EQ_BAND_STAGE_IN_USE>(info.param));
	std::string name = "Implementor_" + descriptor.common.implementor + "_name_" +		std::string name = "Implementor_" + descriptor.common.implementor + "_name_" +
	descriptor.common.name + "_UUID_" +		descriptor.common.name + "_UUID_" +
	toString(descriptor.common.id.uuid) + "_bands_" + bands +		toString(descriptor.common.id.uuid) + "_bands_" + bands;
	"_stageInUse_" + stageInUse;
	std::replace_if(		std::replace_if(
	name.begin(), name.end(), [](const char c) { return !std::isalnum(c); }, '_');		name.begin(), name.end(), [](const char c) { return !std::isalnum(c); }, '_');
	return name;		return name;
	@@ -879,7 +853,6 @@ enum MbcBandConfigParamName {
	MBC_BAND_CHANNEL,		MBC_BAND_CHANNEL,
	MBC_BAND_ENABLE,		MBC_BAND_ENABLE,
	MBC_BAND_CUTOFF_FREQ,		MBC_BAND_CUTOFF_FREQ,
	MBC_BAND_STAGE_IN_USE,
	MBC_BAND_ADDITIONAL		MBC_BAND_ADDITIONAL
	};		};
	enum MbcBandConfigAdditional {		enum MbcBandConfigAdditional {
	@@ -905,7 +878,7 @@ static constexpr std::array<TestParamsMbcBandConfigAdditional, 4> kMbcBandConfig

	using TestParamsMbcBandConfig =		using TestParamsMbcBandConfig =
	std::tuple<std::pair<std::shared_ptr<IFactory>, Descriptor>, int32_t, bool,		std::tuple<std::pair<std::shared_ptr<IFactory>, Descriptor>, int32_t, bool,
	std::vector<std::pair<int, float>>, bool, TestParamsMbcBandConfigAdditional>;		std::vector<std::pair<int, float>>, TestParamsMbcBandConfigAdditional>;

	void fillMbcBandConfig(std::vector<DynamicsProcessing::MbcBandConfig>& cfgs,		void fillMbcBandConfig(std::vector<DynamicsProcessing::MbcBandConfig>& cfgs,
	const TestParamsMbcBandConfig& params) {		const TestParamsMbcBandConfig& params) {
	@@ -936,8 +909,7 @@ class DynamicsProcessingTestMbcBandConfig
	public DynamicsProcessingTestHelper {		public DynamicsProcessingTestHelper {
	public:		public:
	DynamicsProcessingTestMbcBandConfig()		DynamicsProcessingTestMbcBandConfig()
	: DynamicsProcessingTestHelper(std::get<MBC_BAND_INSTANCE_NAME>(GetParam())),		: DynamicsProcessingTestHelper(std::get<MBC_BAND_INSTANCE_NAME>(GetParam())) {
	mStageInUse(std::get<MBC_BAND_STAGE_IN_USE>(GetParam())) {
	fillMbcBandConfig(mCfgs, GetParam());		fillMbcBandConfig(mCfgs, GetParam());
	}		}

	@@ -946,11 +918,9 @@ class DynamicsProcessingTestMbcBandConfig
	void TearDown() override { TearDownDynamicsProcessingEffect(); }		void TearDown() override { TearDownDynamicsProcessingEffect(); }

	std::vector<DynamicsProcessing::MbcBandConfig> mCfgs;		std::vector<DynamicsProcessing::MbcBandConfig> mCfgs;
	const bool mStageInUse;
	};		};

	TEST_P(DynamicsProcessingTestMbcBandConfig, SetAndGetMbcBandConfig) {		TEST_P(DynamicsProcessingTestMbcBandConfig, SetAndGetMbcBandConfig) {
	mEngineConfigPreset.mbcStage.inUse = mStageInUse;
	mEngineConfigPreset.mbcStage.bandCount = mCfgs.size();		mEngineConfigPreset.mbcStage.bandCount = mCfgs.size();
	EXPECT_NO_FATAL_FAILURE(addEngineConfig(mEngineConfigPreset));		EXPECT_NO_FATAL_FAILURE(addEngineConfig(mEngineConfigPreset));
	std::vector<DynamicsProcessing::ChannelConfig> cfgs(mChannelCount);		std::vector<DynamicsProcessing::ChannelConfig> cfgs(mChannelCount);
	@@ -970,18 +940,15 @@ INSTANTIATE_TEST_SUITE_P(
	testing::Values(-1, 0, 10), // channel count		testing::Values(-1, 0, 10), // channel count
	testing::Bool(), // enable		testing::Bool(), // enable
	testing::ValuesIn(kBands), // cut off frequencies		testing::ValuesIn(kBands), // cut off frequencies
	testing::Bool(), // stage in use
	testing::ValuesIn(kMbcBandConfigAdditionalParam)), // Additional		testing::ValuesIn(kMbcBandConfigAdditionalParam)), // Additional
	[](const auto& info) {		[](const auto& info) {
	auto descriptor = std::get<MBC_BAND_INSTANCE_NAME>(info.param).second;		auto descriptor = std::get<MBC_BAND_INSTANCE_NAME>(info.param).second;
	std::vector<DynamicsProcessing::MbcBandConfig> cfgs;		std::vector<DynamicsProcessing::MbcBandConfig> cfgs;
	fillMbcBandConfig(cfgs, info.param);		fillMbcBandConfig(cfgs, info.param);
	std::string mbcBands = ::android::internal::ToString(cfgs);		std::string mbcBands = ::android::internal::ToString(cfgs);
	std::string stageInUse = std::to_string(std::get<MBC_BAND_STAGE_IN_USE>(info.param));
	std::string name = "Implementor_" + descriptor.common.implementor + "_name_" +		std::string name = "Implementor_" + descriptor.common.implementor + "_name_" +
	descriptor.common.name + "_UUID_" +		descriptor.common.name + "_UUID_" +
	toString(descriptor.common.id.uuid) + "_bands_" + mbcBands +		toString(descriptor.common.id.uuid) + "_bands_" + mbcBands;
	"_stageInUse_" + stageInUse;
	std::replace_if(		std::replace_if(
	name.begin(), name.end(), [](const char c) { return !std::isalnum(c); }, '_');		name.begin(), name.end(), [](const char c) { return !std::isalnum(c); }, '_');
	return name;		return name;

audio/aidl/vts/VtsHalVolumeTargetTest.cpp

+7 −1

Original line number	Original line	Diff line number	Diff line
	@@ -140,7 +140,9 @@ using VolumeDataTestParam = std::pair<std::shared_ptr<IFactory>, Descriptor>;
	class VolumeDataTest : public ::testing::TestWithParam<VolumeDataTestParam>,		class VolumeDataTest : public ::testing::TestWithParam<VolumeDataTestParam>,
	public VolumeControlHelper {		public VolumeControlHelper {
	public:		public:
	VolumeDataTest() {		VolumeDataTest()
			: kVsrApiLevel(
			android::base::GetIntProperty("ro.vendor.api_level", __ANDROID_API_FUTURE__)) {
	std::tie(mFactory, mDescriptor) = GetParam();		std::tie(mFactory, mDescriptor) = GetParam();
	mInput.resize(kBufferSize);		mInput.resize(kBufferSize);
	mInputMag.resize(mTestFrequencies.size());		mInputMag.resize(mTestFrequencies.size());
	@@ -165,13 +167,17 @@ class VolumeDataTest : public ::testing::TestWithParam<VolumeDataTestParam>,

	void SetUp() override {		void SetUp() override {
	SKIP_TEST_IF_DATA_UNSUPPORTED(mDescriptor.common.flags);		SKIP_TEST_IF_DATA_UNSUPPORTED(mDescriptor.common.flags);
			// Skips test fixture if api_level <= 34 (__ANDROID_API_U__).
			if (kVsrApiLevel <= __ANDROID_API_U__) GTEST_SKIP();
	ASSERT_NO_FATAL_FAILURE(SetUpVolumeControl());		ASSERT_NO_FATAL_FAILURE(SetUpVolumeControl());
	}		}
	void TearDown() override {		void TearDown() override {
	SKIP_TEST_IF_DATA_UNSUPPORTED(mDescriptor.common.flags);		SKIP_TEST_IF_DATA_UNSUPPORTED(mDescriptor.common.flags);
			if (kVsrApiLevel <= __ANDROID_API_U__) GTEST_SKIP();
	TearDownVolumeControl();		TearDownVolumeControl();
	}		}

			const int kVsrApiLevel;
	static constexpr int kMaxAudioSample = 1;		static constexpr int kMaxAudioSample = 1;
	static constexpr int kTransitionDuration = 300;		static constexpr int kTransitionDuration = 300;
	static constexpr int kNPointFFT = 16384;		static constexpr int kNPointFFT = 16384;

automotive/audiocontrol/aidl/Android.bp

+17 −0

Original line number	Original line	Diff line number	Diff line
	@@ -27,6 +27,9 @@ aidl_interface {
	"com.android.car.framework",		"com.android.car.framework",
	],		],
	},		},
			rust: {
			enabled: true,
			},
	},		},
	versions_with_info: [		versions_with_info: [
	{		{
	@@ -93,3 +96,17 @@ cc_defaults {
	latest_android_hardware_automotive_audiocontrol + "-ndk",		latest_android_hardware_automotive_audiocontrol + "-ndk",
	],		],
	}		}

			java_defaults {
			name: "latest_android_hardware_automotive_audiocontrol_java_static",
			static_libs: [
			latest_android_hardware_automotive_audiocontrol + "-java",
			],
			}

			rust_defaults {
			name: "latest_android_hardware_automotive_audiocontrol_rust",
			rustlibs: [
			latest_android_hardware_automotive_audiocontrol + "-rust",
			],
			}