Merge "Visualizer: Add AIDL placeholder implementation and vts test cases" am:... (48e3824c) · Commits · e / os / android_hardware_interfaces

audio/aidl/TEST_MAPPING

+3 −0

Original line number	Diff line number	Diff line
		@@ -14,6 +14,9 @@
		},
		{
		"name": "VtsHalLoudnessEnhancerTargetTest"
		},
		{
		"name": "VtsHalVisualizerTargetTest"
		}
		]
		}

audio/aidl/default/visualizer/VisualizerSw.cpp

+121 −9

Original line number	Diff line number	Diff line
		@@ -14,14 +14,9 @@
		* limitations under the License.
		*/

		#include <cstddef>
		#define LOG_TAG "AHAL_VisualizerSw"
		#include <Utils.h>
		#include <algorithm>
		#include <unordered_set>

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

		#include "VisualizerSw.h"

		@@ -60,7 +55,10 @@ extern "C" binder_exception_t queryEffect(const AudioUuid* in_impl_uuid, Descrip
		namespace aidl::android::hardware::audio::effect {

		const std::string VisualizerSw::kEffectName = "VisualizerSw";
		const Visualizer::Capability VisualizerSw::kCapability;
		/* capabilities */
		const Visualizer::CaptureSizeRange mCaptureSizeRange = {MIN_CAPTURE_SIZE, MAX_CAPTURE_SIZE};
		const Visualizer::Capability VisualizerSw::kCapability = {.maxLatencyMs = MAX_LATENCY,
		.captureSizeRange = mCaptureSizeRange};
		const Descriptor VisualizerSw::kDescriptor = {
		.common = {.id = {.type = kVisualizerTypeUUID,
		.uuid = kVisualizerSwImplUUID,
		@@ -82,8 +80,53 @@ ndk::ScopedAStatus VisualizerSw::setParameterSpecific(const Parameter::Specific&
		RETURN_IF(Parameter::Specific::visualizer != specific.getTag(), EX_ILLEGAL_ARGUMENT,
		"EffectNotSupported");

		mSpecificParam = specific.get<Parameter::Specific::visualizer>();
		LOG(DEBUG) << __func__ << " success with: " << specific.toString();
		auto& vsParam = specific.get<Parameter::Specific::visualizer>();
		auto tag = vsParam.getTag();

		switch (tag) {
		case Visualizer::captureSizeBytes: {
		RETURN_IF(mContext->setVsCaptureSize(vsParam.get<Visualizer::captureSizeBytes>()) !=
		RetCode::SUCCESS,
		EX_ILLEGAL_ARGUMENT, "captureSizeNotSupported");
		return ndk::ScopedAStatus::ok();
		}
		case Visualizer::scalingMode: {
		RETURN_IF(mContext->setVsScalingMode(vsParam.get<Visualizer::scalingMode>()) !=
		RetCode::SUCCESS,
		EX_ILLEGAL_ARGUMENT, "scalingModeNotSupported");
		return ndk::ScopedAStatus::ok();
		}
		case Visualizer::measurementMode: {
		RETURN_IF(mContext->setVsMeasurementMode(vsParam.get<Visualizer::measurementMode>()) !=
		RetCode::SUCCESS,
		EX_ILLEGAL_ARGUMENT, "measurementModeNotSupported");
		return ndk::ScopedAStatus::ok();
		}
		case Visualizer::setOnlyParameters: {
		return setSetOnlyParameterVisualizer(vsParam.get<Visualizer::setOnlyParameters>());
		}
		case Visualizer::getOnlyParameters: {
		LOG(ERROR) << __func__ << " unsupported settable getOnlyParam";
		return ndk::ScopedAStatus::fromExceptionCodeWithMessage(
		EX_ILLEGAL_ARGUMENT, "SetofGetOnlyParamsNotSupported");
		}
		default: {
		LOG(ERROR) << __func__ << " unsupported tag: " << toString(tag);
		return ndk::ScopedAStatus::fromExceptionCodeWithMessage(EX_ILLEGAL_ARGUMENT,
		"VisualizerTagNotSupported");
		}
		}
		}

		ndk::ScopedAStatus VisualizerSw::setSetOnlyParameterVisualizer(
		Visualizer::SetOnlyParameters setOnlyParam) {
		auto tag = setOnlyParam.getTag();
		RETURN_IF(Visualizer::SetOnlyParameters::latencyMs != tag, EX_ILLEGAL_ARGUMENT,
		"SetOnlyParametersTagNotSupported");
		RETURN_IF(
		mContext->setVsLatency(setOnlyParam.get<Visualizer::SetOnlyParameters::latencyMs>()) !=
		RetCode::SUCCESS,
		EX_ILLEGAL_ARGUMENT, "latencyNotSupported");
		return ndk::ScopedAStatus::ok();
		}

		@@ -91,7 +134,76 @@ ndk::ScopedAStatus VisualizerSw::getParameterSpecific(const Parameter::Id& id,
		Parameter::Specific* specific) {
		auto tag = id.getTag();
		RETURN_IF(Parameter::Id::visualizerTag != tag, EX_ILLEGAL_ARGUMENT, "wrongIdTag");
		specific->set<Parameter::Specific::visualizer>(mSpecificParam);
		auto vsId = id.get<Parameter::Id::visualizerTag>();
		auto vsIdTag = vsId.getTag();
		switch (vsIdTag) {
		case Visualizer::Id::commonTag:
		return getParameterVisualizer(vsId.get<Visualizer::Id::commonTag>(), specific);
		case Visualizer::Id::getOnlyParamTag:
		return getGetOnlyParameterVisualizer(vsId.get<Visualizer::Id::getOnlyParamTag>(),
		specific);
		case Visualizer::Id::setOnlyParamTag: {
		LOG(ERROR) << __func__ << " unsupported gettable setOnlyParam";
		return ndk::ScopedAStatus::fromExceptionCodeWithMessage(
		EX_ILLEGAL_ARGUMENT, "GetofSetOnlyParamsNotSupported");
		}
		default:
		LOG(ERROR) << __func__ << " unsupported tag: " << toString(tag);
		return ndk::ScopedAStatus::fromExceptionCodeWithMessage(EX_ILLEGAL_ARGUMENT,
		"VisualizerTagNotSupported");
		}
		}
		ndk::ScopedAStatus VisualizerSw::getParameterVisualizer(const Visualizer::Tag& tag,
		Parameter::Specific* specific) {
		RETURN_IF(!mContext, EX_NULL_POINTER, "nullContext");

		Visualizer vsParam;
		switch (tag) {
		case Visualizer::captureSizeBytes: {
		vsParam.set<Visualizer::captureSizeBytes>(mContext->getVsCaptureSize());
		break;
		}
		case Visualizer::scalingMode: {
		vsParam.set<Visualizer::scalingMode>(mContext->getVsScalingMode());
		break;
		}
		case Visualizer::measurementMode: {
		vsParam.set<Visualizer::measurementMode>(mContext->getVsMeasurementMode());
		break;
		}
		default: {
		LOG(ERROR) << __func__ << " unsupported tag: " << toString(tag);
		return ndk::ScopedAStatus::fromExceptionCodeWithMessage(EX_ILLEGAL_ARGUMENT,
		"VisualizerTagNotSupported");
		}
		}
		specific->set<Parameter::Specific::visualizer>(vsParam);
		return ndk::ScopedAStatus::ok();
		}

		ndk::ScopedAStatus VisualizerSw::getGetOnlyParameterVisualizer(
		const Visualizer::GetOnlyParameters::Tag& tag, Parameter::Specific* specific) {
		Visualizer::GetOnlyParameters getOnlyParam;
		switch (tag) {
		case Visualizer::GetOnlyParameters::measurement: {
		getOnlyParam.set<Visualizer::GetOnlyParameters::measurement>(
		mContext->getVsMeasurement());
		break;
		}
		case Visualizer::GetOnlyParameters::captureBytes: {
		getOnlyParam.set<Visualizer::GetOnlyParameters::captureBytes>(
		mContext->getVsCaptureBytes());
		break;
		}
		default: {
		LOG(ERROR) << __func__ << " unsupported tag: " << toString(tag);
		return ndk::ScopedAStatus::fromExceptionCodeWithMessage(
		EX_ILLEGAL_ARGUMENT, "GetOnlyParameterTagNotSupported");
		}
		}
		Visualizer vsParam;
		vsParam.set<Visualizer::getOnlyParameters>(getOnlyParam);
		specific->set<Parameter::Specific::visualizer>(vsParam);
		return ndk::ScopedAStatus::ok();
		}

audio/aidl/default/visualizer/VisualizerSw.h

+60 −6

Original line number	Diff line number	Diff line
		@@ -17,13 +17,16 @@
		#pragma once

		#include <aidl/android/hardware/audio/effect/BnEffect.h>
		#include <fmq/AidlMessageQueue.h>
		#include <cstdlib>
		#include <memory>
		#include <vector>

		#include "effect-impl/EffectImpl.h"
		#include "effect-impl/EffectUUID.h"

		#define MIN_CAPTURE_SIZE 128
		#define MAX_CAPTURE_SIZE 1024
		#define MAX_LATENCY 3000
		#define CAPTURE_BUF_SIZE 65536

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

		class VisualizerSwContext final : public EffectContext {
		@@ -31,8 +34,55 @@ class VisualizerSwContext final : public EffectContext {
		VisualizerSwContext(int statusDepth, const Parameter::Common& common)
		: EffectContext(statusDepth, common) {
		LOG(DEBUG) << __func__;
		mCaptureBytes.resize(CAPTURE_BUF_SIZE);
		fill(mCaptureBytes.begin(), mCaptureBytes.end(), 0x80);
		}

		RetCode setVsCaptureSize(int captureSize) {
		if (captureSize < MIN_CAPTURE_SIZE \|\| captureSize > MAX_CAPTURE_SIZE) {
		LOG(ERROR) << __func__ << " invalid captureSize " << captureSize;
		return RetCode::ERROR_ILLEGAL_PARAMETER;
		}
		// TODO : Add implementation to apply new captureSize
		mCaptureSize = captureSize;
		return RetCode::SUCCESS;
		}
		int getVsCaptureSize() const { return mCaptureSize; }

		RetCode setVsScalingMode(Visualizer::ScalingMode scalingMode) {
		// TODO : Add implementation to apply new scalingMode
		mScalingMode = scalingMode;
		return RetCode::SUCCESS;
		}
		Visualizer::ScalingMode getVsScalingMode() const { return mScalingMode; }

		RetCode setVsMeasurementMode(Visualizer::MeasurementMode measurementMode) {
		// TODO : Add implementation to apply new measurementMode
		mMeasurementMode = measurementMode;
		return RetCode::SUCCESS;
		}
		// TODO: add specific context here
		Visualizer::MeasurementMode getVsMeasurementMode() const { return mMeasurementMode; }

		RetCode setVsLatency(int latency) {
		if (latency < 0 \|\| latency > MAX_LATENCY) {
		LOG(ERROR) << __func__ << " invalid latency " << latency;
		return RetCode::ERROR_ILLEGAL_PARAMETER;
		}
		// TODO : Add implementation to modify latency
		mLatency = latency;
		return RetCode::SUCCESS;
		}

		Visualizer::GetOnlyParameters::Measurement getVsMeasurement() const { return mMeasurement; }
		std::vector<uint8_t> getVsCaptureBytes() const { return mCaptureBytes; }

		private:
		int mCaptureSize = MAX_CAPTURE_SIZE;
		Visualizer::ScalingMode mScalingMode = Visualizer::ScalingMode::NORMALIZED;
		Visualizer::MeasurementMode mMeasurementMode = Visualizer::MeasurementMode::NONE;
		int mLatency;
		const Visualizer::GetOnlyParameters::Measurement mMeasurement = {0, 0};
		std::vector<uint8_t> mCaptureBytes;
		};

		class VisualizerSw final : public EffectImpl {
		@@ -60,7 +110,11 @@ class VisualizerSw final : public EffectImpl {

		private:
		std::shared_ptr<VisualizerSwContext> mContext;
		/* parameters */
		Visualizer mSpecificParam;

		ndk::ScopedAStatus setSetOnlyParameterVisualizer(Visualizer::SetOnlyParameters setOnlyParam);
		ndk::ScopedAStatus getParameterVisualizer(const Visualizer::Tag& tag,
		Parameter::Specific* specific);
		ndk::ScopedAStatus getGetOnlyParameterVisualizer(const Visualizer::GetOnlyParameters::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
		@@ -83,3 +83,9 @@ cc_test {
		defaults: ["VtsHalAudioTargetTestDefaults"],
		srcs: ["VtsHalLoudnessEnhancerTargetTest.cpp"],
		}

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

audio/aidl/vts/VtsHalVisualizerTargetTest.cpp

0 → 100644

+329 −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.
		*/

		#include <aidl/Vintf.h>

		#define LOG_TAG "VtsHalVisualizerTest"

		#include <Utils.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::kVisualizerTypeUUID;
		using aidl::android::hardware::audio::effect::Parameter;
		using aidl::android::hardware::audio::effect::Visualizer;

		/**
		* Here we focus on specific parameter checking, general IEffect interfaces testing performed in
		* VtsAudioEffectTargetTest.
		*/
		enum ParamName {
		PARAM_INSTANCE_NAME,
		PARAM_CAPTURE_SIZE,
		PARAM_SCALING_MODE,
		PARAM_MEASUREMENT_MODE,
		PARAM_LATENCY,
		};
		using VisualizerParamTestParam =
		std::tuple<std::pair<std::shared_ptr<IFactory>, Descriptor>, int, Visualizer::ScalingMode,
		Visualizer::MeasurementMode, int>;

		const int MIN_CAPTURE_SIZE = 128;
		const int MAX_CAPTURE_SIZE = 1024;
		const int MAX_LATENCY = 3000;

		const std::vector<int> kCaptureSizeValues = {MIN_CAPTURE_SIZE - 1, MIN_CAPTURE_SIZE,
		MAX_CAPTURE_SIZE, MAX_CAPTURE_SIZE + 1};
		const std::vector<Visualizer::ScalingMode> kScalingModeValues = {
		Visualizer::ScalingMode::NORMALIZED, Visualizer::ScalingMode::AS_PLAYED};
		const std::vector<Visualizer::MeasurementMode> kMeasurementModeValues = {
		Visualizer::MeasurementMode::NONE, Visualizer::MeasurementMode::PEAK_RMS};
		const std::vector<int> kLatencyValues = {-1, 0, MAX_LATENCY, MAX_LATENCY + 1};

		class VisualizerParamTest : public ::testing::TestWithParam<VisualizerParamTestParam>,
		public EffectHelper {
		public:
		VisualizerParamTest()
		: mCaptureSize(std::get<PARAM_CAPTURE_SIZE>(GetParam())),
		mScalingMode(std::get<PARAM_SCALING_MODE>(GetParam())),
		mMeasurementMode(std::get<PARAM_MEASUREMENT_MODE>(GetParam())),
		mLatency(std::get<PARAM_LATENCY>(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));
		}

		Parameter::Specific getDefaultParamSpecific() {
		Visualizer vs = Visualizer::make<Visualizer::captureSizeBytes>(MIN_CAPTURE_SIZE);
		Parameter::Specific specific =
		Parameter::Specific::make<Parameter::Specific::visualizer>(vs);
		return specific;
		}

		static const long kInputFrameCount = 0x100, kOutputFrameCount = 0x100;
		std::shared_ptr<IFactory> mFactory;
		std::shared_ptr<IEffect> mEffect;
		Descriptor mDescriptor;
		int mCaptureSize = MAX_CAPTURE_SIZE;
		Visualizer::ScalingMode mScalingMode = Visualizer::ScalingMode::NORMALIZED;
		Visualizer::MeasurementMode mMeasurementMode = Visualizer::MeasurementMode::NONE;
		int mLatency = 0;

		void SetAndGetCommonParameters() {
		for (auto& it : mCommonTags) {
		auto& tag = it.first;
		auto& vs = it.second;

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

		// set parameter
		Parameter expectParam;
		Parameter::Specific specific;
		specific.set<Parameter::Specific::visualizer>(vs);
		expectParam.set<Parameter::specific>(specific);
		EXPECT_STATUS(expected, mEffect->setParameter(expectParam)) << expectParam.toString();

		// only get if parameter in range and set success
		if (expected == EX_NONE) {
		Parameter getParam;
		Parameter::Id id;
		Visualizer::Id vsId;
		vsId.set<Visualizer::Id::commonTag>(tag);
		id.set<Parameter::Id::visualizerTag>(vsId);
		EXPECT_STATUS(EX_NONE, mEffect->getParameter(id, &getParam));

		EXPECT_EQ(expectParam, getParam) << "\nexpect:" << expectParam.toString()
		<< "\ngetParam:" << getParam.toString();
		}
		}
		}

		void SetAndGetSetOnlyParameters() {
		for (auto& it : mSetOnlyParamTags) {
		auto& tag = it.first;
		auto& vs = it.second;

		// validate parameter
		Descriptor desc;
		ASSERT_STATUS(EX_NONE, mEffect->getDescriptor(&desc));
		const bool valid = isSetOnlyParamTagInRange(tag, vs, desc);
		const binder_exception_t expected = valid ? EX_NONE : EX_ILLEGAL_ARGUMENT;

		// set parameter
		Parameter expectParam;
		Parameter::Specific specific;
		specific.set<Parameter::Specific::visualizer>(vs);
		expectParam.set<Parameter::specific>(specific);
		ASSERT_STATUS(expected, mEffect->setParameter(expectParam));

		// parameter defined in this setOnlyParameter union must be settable via
		// setParameter(), but must not be gettable
		Parameter getParam;
		Parameter::Id id;
		Visualizer::Id vsId;
		vsId.set<Visualizer::Id::setOnlyParamTag>(tag);
		id.set<Parameter::Id::visualizerTag>(vsId);
		EXPECT_STATUS(EX_ILLEGAL_ARGUMENT, mEffect->getParameter(id, &getParam));
		}
		}

		void GetandSetGetOnlyParameters() {
		for (auto& tag : mGetOnlyParamTags) {
		// get parameter
		Parameter getParam;
		Parameter::Id id;
		Visualizer::Id vsId;
		vsId.set<Visualizer::Id::getOnlyParamTag>(tag);
		id.set<Parameter::Id::visualizerTag>(vsId);
		ASSERT_STATUS(EX_NONE, mEffect->getParameter(id, &getParam));

		// parameter defined in this getOnlyParameter union must be gettable via
		// getParameter(), but must not be settable
		// set parameter
		ASSERT_STATUS(EX_ILLEGAL_ARGUMENT, mEffect->setParameter(getParam));
		}
		}

		void addCaptureSizeParam(int captureSize) {
		Visualizer vs;
		vs.set<Visualizer::captureSizeBytes>(captureSize);
		mCommonTags.push_back({Visualizer::captureSizeBytes, vs});
		}

		void addScalingModeParam(Visualizer::ScalingMode scalingMode) {
		Visualizer vs;
		vs.set<Visualizer::scalingMode>(scalingMode);
		mCommonTags.push_back({Visualizer::scalingMode, vs});
		}

		void addMeasurementModeParam(Visualizer::MeasurementMode measurementMode) {
		Visualizer vs;
		vs.set<Visualizer::measurementMode>(measurementMode);
		mCommonTags.push_back({Visualizer::measurementMode, vs});
		}

		void addLatencyParam(int latency) {
		Visualizer vs;
		Visualizer::SetOnlyParameters setOnlyParam;
		setOnlyParam.set<Visualizer::SetOnlyParameters::latencyMs>(latency);
		vs.set<Visualizer::setOnlyParameters>(setOnlyParam);
		mSetOnlyParamTags.push_back({Visualizer::SetOnlyParameters::latencyMs, vs});
		}

		void addMeasurementTag() {
		mGetOnlyParamTags.push_back(Visualizer::GetOnlyParameters::measurement);
		}

		void addCaptureBytesTag() {
		mGetOnlyParamTags.push_back(Visualizer::GetOnlyParameters::captureBytes);
		}

		bool isTagInRange(const Visualizer::Tag& tag, const Visualizer& vs,
		const Descriptor& desc) const {
		const Visualizer::Capability& vsCap = desc.capability.get<Capability::visualizer>();
		switch (tag) {
		case Visualizer::captureSizeBytes: {
		int captureSize = vs.get<Visualizer::captureSizeBytes>();
		return isCaptureSizeInRange(vsCap, captureSize);
		}
		case Visualizer::scalingMode:
		case Visualizer::measurementMode:
		return true;
		default:
		return false;
		}
		}

		bool isSetOnlyParamTagInRange(Visualizer::SetOnlyParameters::Tag, const Visualizer& vs,
		const Descriptor& desc) const {
		const Visualizer::Capability& vsCap = desc.capability.get<Capability::visualizer>();
		if (vs.getTag() != Visualizer::setOnlyParameters) return false;
		Visualizer::SetOnlyParameters setOnlyParam = vs.get<Visualizer::setOnlyParameters>();
		if (setOnlyParam.getTag() != Visualizer::SetOnlyParameters::latencyMs) return false;
		int latency = setOnlyParam.get<Visualizer::SetOnlyParameters::latencyMs>();
		return isLatencyInRange(vsCap, latency);
		}

		bool isCaptureSizeInRange(const Visualizer::Capability& cap, int captureSize) const {
		return (captureSize >= cap.captureSizeRange.minBytes &&
		captureSize <= cap.captureSizeRange.maxBytes);
		}

		bool isLatencyInRange(const Visualizer::Capability& cap, int latency) const {
		return (latency >= 0 && latency <= cap.maxLatencyMs);
		}

		private:
		std::vector<std::pair<Visualizer::Tag, Visualizer>> mCommonTags;
		std::vector<std::pair<Visualizer::SetOnlyParameters::Tag, Visualizer>> mSetOnlyParamTags;
		std::vector<Visualizer::GetOnlyParameters::Tag> mGetOnlyParamTags;
		void CleanUp() {
		mCommonTags.clear();
		mSetOnlyParamTags.clear();
		mGetOnlyParamTags.clear();
		}
		};

		TEST_P(VisualizerParamTest, SetAndGetCaptureSize) {
		EXPECT_NO_FATAL_FAILURE(addCaptureSizeParam(mCaptureSize));
		SetAndGetCommonParameters();
		}

		TEST_P(VisualizerParamTest, SetAndGetScalingMode) {
		EXPECT_NO_FATAL_FAILURE(addScalingModeParam(mScalingMode));
		SetAndGetCommonParameters();
		}

		TEST_P(VisualizerParamTest, SetAndGetMeasurementMode) {
		EXPECT_NO_FATAL_FAILURE(addMeasurementModeParam(mMeasurementMode));
		SetAndGetCommonParameters();
		}

		TEST_P(VisualizerParamTest, SetAndGetLatency) {
		EXPECT_NO_FATAL_FAILURE(addLatencyParam(mLatency));
		SetAndGetSetOnlyParameters();
		}

		TEST_P(VisualizerParamTest, GetAndSetMeasurement) {
		EXPECT_NO_FATAL_FAILURE(addMeasurementTag());
		GetandSetGetOnlyParameters();
		}

		TEST_P(VisualizerParamTest, GetAndSetCaptureBytes) {
		EXPECT_NO_FATAL_FAILURE(addCaptureBytesTag());
		GetandSetGetOnlyParameters();
		}

		INSTANTIATE_TEST_SUITE_P(
		VisualizerTest, VisualizerParamTest,
		::testing::Combine(testing::ValuesIn(EffectFactoryHelper::getAllEffectDescriptors(
		IFactory::descriptor, kVisualizerTypeUUID)),
		testing::ValuesIn(kCaptureSizeValues),
		testing::ValuesIn(kScalingModeValues),
		testing::ValuesIn(kMeasurementModeValues),
		testing::ValuesIn(kLatencyValues)),
		[](const testing::TestParamInfo<VisualizerParamTest::ParamType>& info) {
		auto descriptor = std::get<PARAM_INSTANCE_NAME>(info.param).second;
		std::string captureSize = std::to_string(std::get<PARAM_CAPTURE_SIZE>(info.param));
		std::string scalingMode =
		std::to_string(static_cast<int>(std::get<PARAM_SCALING_MODE>(info.param)));
		std::string measurementMode =
		std::to_string(static_cast<int>(std::get<PARAM_MEASUREMENT_MODE>(info.param)));
		std::string latency = std::to_string(std::get<PARAM_LATENCY>(info.param));

		std::string name = "Implementor_" + descriptor.common.implementor + "_name_" +
		descriptor.common.name + "_UUID_" +
		descriptor.common.id.uuid.toString() + "_captureSize" + captureSize +
		"_scalingMode" + scalingMode + "_measurementMode" + measurementMode +
		"_latency" + latency;
		std::replace_if(
		name.begin(), name.end(), [](const char c) { return !std::isalnum(c); }, '_');
		return name;
		});

		GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(VisualizerParamTest);

		int main(int argc, char** argv) {
		::testing::InitGoogleTest(&argc, argv);
		ABinderProcess_setThreadPoolMaxThreadCount(1);
		ABinderProcess_startThreadPool();
		return RUN_ALL_TESTS();
		}
		No newline at end of file