PresetReverb: Add AIDL placeholder implementation and vts test (73aa2c38) · Commits · e / os / android_hardware_interfaces

audio/aidl/TEST_MAPPING

+3 −0

Original line number	Diff line number	Diff line
		@@ -24,6 +24,9 @@
		{
		"name": "VtsHalLoudnessEnhancerTargetTest"
		},
		{
		"name": "VtsHalPresetReverbTargetTest"
		},
		{
		"name": "VtsHalVirtualizerTargetTest"
		},

audio/aidl/default/presetReverb/PresetReverbSw.cpp

+55 −5

Original line number	Diff line number	Diff line
		@@ -21,6 +21,7 @@
		#include <unordered_set>

		#include <android-base/logging.h>
		#include <android/binder_enums.h>
		#include <fmq/AidlMessageQueue.h>

		#include "PresetReverbSw.h"
		@@ -60,7 +61,13 @@ extern "C" binder_exception_t queryEffect(const AudioUuid* in_impl_uuid, Descrip
		namespace aidl::android::hardware::audio::effect {

		const std::string PresetReverbSw::kEffectName = "PresetReverbSw";
		const PresetReverb::Capability PresetReverbSw::kCapability;

		const std::vector<PresetReverb::Presets> kSupportedPresets{
		ndk::enum_range<PresetReverb::Presets>().begin(),
		ndk::enum_range<PresetReverb::Presets>().end()};

		const PresetReverb::Capability PresetReverbSw::kCapability = {.supportedPresets =
		kSupportedPresets};
		const Descriptor PresetReverbSw::kDescriptor = {
		.common = {.id = {.type = kPresetReverbTypeUUID,
		.uuid = kPresetReverbSwImplUUID,
		@@ -82,16 +89,59 @@ ndk::ScopedAStatus PresetReverbSw::setParameterSpecific(const Parameter::Specifi
		RETURN_IF(Parameter::Specific::presetReverb != specific.getTag(), EX_ILLEGAL_ARGUMENT,
		"EffectNotSupported");

		mSpecificParam = specific.get<Parameter::Specific::presetReverb>();
		LOG(DEBUG) << __func__ << " success with: " << specific.toString();
		RETURN_IF(!mContext, EX_NULL_POINTER, "nullContext");

		auto& prParam = specific.get<Parameter::Specific::presetReverb>();
		auto tag = prParam.getTag();

		switch (tag) {
		case PresetReverb::preset: {
		RETURN_IF(
		mContext->setPRPreset(prParam.get<PresetReverb::preset>()) != RetCode::SUCCESS,
		EX_ILLEGAL_ARGUMENT, "setPresetFailed");
		return ndk::ScopedAStatus::ok();
		}
		default: {
		LOG(ERROR) << __func__ << " unsupported tag: " << toString(tag);
		return ndk::ScopedAStatus::fromExceptionCodeWithMessage(EX_ILLEGAL_ARGUMENT,
		"PresetReverbTagNotSupported");
		}
		}
		}

		ndk::ScopedAStatus PresetReverbSw::getParameterSpecific(const Parameter::Id& id,
		Parameter::Specific* specific) {
		auto tag = id.getTag();
		RETURN_IF(Parameter::Id::presetReverbTag != tag, EX_ILLEGAL_ARGUMENT, "wrongIdTag");
		specific->set<Parameter::Specific::presetReverb>(mSpecificParam);
		auto prId = id.get<Parameter::Id::presetReverbTag>();
		auto prIdTag = prId.getTag();
		switch (prIdTag) {
		case PresetReverb::Id::commonTag:
		return getParameterPresetReverb(prId.get<PresetReverb::Id::commonTag>(), specific);
		default:
		LOG(ERROR) << __func__ << " unsupported tag: " << toString(tag);
		return ndk::ScopedAStatus::fromExceptionCodeWithMessage(EX_ILLEGAL_ARGUMENT,
		"PresetReverbTagNotSupported");
		}
		}

		ndk::ScopedAStatus PresetReverbSw::getParameterPresetReverb(const PresetReverb::Tag& tag,
		Parameter::Specific* specific) {
		RETURN_IF(!mContext, EX_NULL_POINTER, "nullContext");
		PresetReverb prParam;
		switch (tag) {
		case PresetReverb::preset: {
		prParam.set<PresetReverb::preset>(mContext->getPRPreset());
		break;
		}
		default: {
		LOG(ERROR) << __func__ << " unsupported tag: " << toString(tag);
		return ndk::ScopedAStatus::fromExceptionCodeWithMessage(EX_ILLEGAL_ARGUMENT,
		"PresetReverbTagNotSupported");
		}
		}

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

audio/aidl/default/presetReverb/PresetReverbSw.h

+12 −3

Original line number	Diff line number	Diff line
		@@ -32,7 +32,15 @@ class PresetReverbSwContext final : public EffectContext {
		: EffectContext(statusDepth, common) {
		LOG(DEBUG) << __func__;
		}
		// TODO: add specific context here
		RetCode setPRPreset(PresetReverb::Presets preset) {
		// TODO : Add implementation to modify Presets
		mPreset = preset;
		return RetCode::SUCCESS;
		}
		PresetReverb::Presets getPRPreset() const { return mPreset; }

		private:
		PresetReverb::Presets mPreset = PresetReverb::Presets::NONE;
		};

		class PresetReverbSw final : public EffectImpl {
		@@ -60,7 +68,8 @@ class PresetReverbSw final : public EffectImpl {

		private:
		std::shared_ptr<PresetReverbSwContext> mContext;
		/* parameters */
		PresetReverb mSpecificParam;

		ndk::ScopedAStatus getParameterPresetReverb(const PresetReverb::Tag& tag,
		Parameter::Specific* specific);
		};
		} // namespace aidl::android::hardware::audio::effect

audio/aidl/vts/Android.bp

+6 −0

Original line number	Diff line number	Diff line
		@@ -103,6 +103,12 @@ cc_test {
		srcs: ["VtsHalLoudnessEnhancerTargetTest.cpp"],
		}

		cc_test {
		name: "VtsHalPresetReverbTargetTest",
		defaults: ["VtsHalAudioTargetTestDefaults"],
		srcs: ["VtsHalPresetReverbTargetTest.cpp"],
		}

		cc_test {
		name: "VtsHalVirtualizerTargetTest",
		defaults: ["VtsHalAudioTargetTestDefaults"],

audio/aidl/vts/VtsHalPresetReverbTargetTest.cpp

0 → 100644

+178 −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 "VtsHalPresetReverbTargetTest"

		#include <Utils.h>
		#include <aidl/Vintf.h>
		#include <android/binder_enums.h>
		#include "EffectHelper.h"

		using namespace android;

		using aidl::android::hardware::audio::effect::Capability;
		using aidl::android::hardware::audio::effect::Descriptor;
		using aidl::android::hardware::audio::effect::IEffect;
		using aidl::android::hardware::audio::effect::IFactory;
		using aidl::android::hardware::audio::effect::kEffectNullUuid;
		using aidl::android::hardware::audio::effect::kPresetReverbTypeUUID;
		using aidl::android::hardware::audio::effect::Parameter;
		using aidl::android::hardware::audio::effect::PresetReverb;

		/**
		* Here we focus on specific parameter checking, general IEffect interfaces testing performed in
		* VtsAudioEffectTargetTest.
		*/
		enum ParamName { PARAM_INSTANCE_NAME, PARAM_PRESETS };
		using PresetReverbParamTestParam =
		std::tuple<std::pair<std::shared_ptr<IFactory>, Descriptor>, PresetReverb::Presets>;

		// Testing for enum values
		const std::vector<PresetReverb::Presets> kPresetsValues{
		ndk::enum_range<PresetReverb::Presets>().begin(),
		ndk::enum_range<PresetReverb::Presets>().end()};

		class PresetReverbParamTest : public ::testing::TestWithParam<PresetReverbParamTestParam>,
		public EffectHelper {
		public:
		PresetReverbParamTest() : mParamPresets(std::get<PARAM_PRESETS>(GetParam())) {
		std::tie(mFactory, mDescriptor) = std::get<PARAM_INSTANCE_NAME>(GetParam());
		}

		void SetUp() override {
		ASSERT_NE(nullptr, mFactory);
		ASSERT_NO_FATAL_FAILURE(create(mFactory, mEffect, mDescriptor));

		Parameter::Specific specific = getDefaultParamSpecific();
		Parameter::Common common = EffectHelper::createParamCommon(
		0 /* session /, 1 / ioHandle /, 44100 / iSampleRate /, 44100 / oSampleRate */,
		kInputFrameCount /* iFrameCount /, kOutputFrameCount / oFrameCount */);
		IEffect::OpenEffectReturn ret;
		ASSERT_NO_FATAL_FAILURE(open(mEffect, common, specific, &ret, EX_NONE));
		ASSERT_NE(nullptr, mEffect);
		}

		void TearDown() override {
		ASSERT_NO_FATAL_FAILURE(close(mEffect));
		ASSERT_NO_FATAL_FAILURE(destroy(mFactory, mEffect));
		}

		static const long kInputFrameCount = 0x100, kOutputFrameCount = 0x100;
		std::shared_ptr<IFactory> mFactory;
		std::shared_ptr<IEffect> mEffect;
		Descriptor mDescriptor;
		PresetReverb::Presets mParamPresets = PresetReverb::Presets::NONE;

		void SetAndGetPresetReverbParameters() {
		for (auto& it : mTags) {
		auto& tag = it.first;
		auto& pr = it.second;

		// validate parameter
		Descriptor desc;
		ASSERT_STATUS(EX_NONE, mEffect->getDescriptor(&desc));
		const bool valid = isTagInRange(it.first, it.second, desc);
		const binder_exception_t expected = valid ? EX_NONE : EX_ILLEGAL_ARGUMENT;

		// set parameter
		Parameter expectParam;
		Parameter::Specific specific;
		specific.set<Parameter::Specific::presetReverb>(pr);
		expectParam.set<Parameter::specific>(specific);
		// All values are valid, set parameter should succeed
		EXPECT_STATUS(expected, mEffect->setParameter(expectParam)) << expectParam.toString();

		// get parameter
		Parameter getParam;
		Parameter::Id id;
		PresetReverb::Id prId;
		prId.set<PresetReverb::Id::commonTag>(tag);
		id.set<Parameter::Id::presetReverbTag>(prId);
		EXPECT_STATUS(expected, mEffect->getParameter(id, &getParam));

		EXPECT_EQ(expectParam, getParam);
		}
		}

		void addPresetsParam(PresetReverb::Presets preset) {
		PresetReverb pr;
		pr.set<PresetReverb::preset>(preset);
		mTags.push_back({PresetReverb::preset, pr});
		}

		bool isTagInRange(const PresetReverb::Tag& tag, const PresetReverb& pr,
		const Descriptor& desc) const {
		const PresetReverb::Capability& prCap = desc.capability.get<Capability::presetReverb>();
		switch (tag) {
		case PresetReverb::preset: {
		PresetReverb::Presets preset = pr.get<PresetReverb::preset>();
		return isPresetInRange(prCap, preset);
		}
		default:
		return false;
		}
		return false;
		}

		bool isPresetInRange(const PresetReverb::Capability& cap, PresetReverb::Presets preset) const {
		for (auto i : cap.supportedPresets) {
		if (preset == i) return true;
		}
		return false;
		}

		Parameter::Specific getDefaultParamSpecific() {
		PresetReverb pr = PresetReverb::make<PresetReverb::preset>(PresetReverb::Presets::NONE);
		Parameter::Specific specific =
		Parameter::Specific::make<Parameter::Specific::presetReverb>(pr);
		return specific;
		}

		private:
		std::vector<std::pair<PresetReverb::Tag, PresetReverb>> mTags;
		void CleanUp() { mTags.clear(); }
		};

		TEST_P(PresetReverbParamTest, SetAndGetPresets) {
		EXPECT_NO_FATAL_FAILURE(addPresetsParam(mParamPresets));
		SetAndGetPresetReverbParameters();
		}

		INSTANTIATE_TEST_SUITE_P(
		PresetReverbTest, PresetReverbParamTest,
		::testing::Combine(testing::ValuesIn(EffectFactoryHelper::getAllEffectDescriptors(
		IFactory::descriptor, kPresetReverbTypeUUID)),
		testing::ValuesIn(kPresetsValues)),
		[](const testing::TestParamInfo<PresetReverbParamTest::ParamType>& info) {
		auto descriptor = std::get<PARAM_INSTANCE_NAME>(info.param).second;
		std::string preset =
		std::to_string(static_cast<int>(std::get<PARAM_PRESETS>(info.param)));
		std::string name = "Implementor_" + descriptor.common.implementor + "_name_" +
		descriptor.common.name + "_UUID_" +
		descriptor.common.id.uuid.toString() + "_preset" + preset;
		std::replace_if(
		name.begin(), name.end(), [](const char c) { return !std::isalnum(c); }, '_');
		return name;
		});

		GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(PresetReverbParamTest);

		int main(int argc, char** argv) {
		::testing::InitGoogleTest(&argc, argv);
		ABinderProcess_setThreadPoolMaxThreadCount(1);
		ABinderProcess_startThreadPool();
		return RUN_ALL_TESTS();
		}