mirror of
https://github.com/Evolution-X/hardware_interfaces
synced 2026-02-01 16:50:18 +00:00
e39cd36545
Bug: 258124419 Test: atest VtsHalVisualizerTargetTest Change-Id: I4ad827a4e8951a16738580ecf91fe1b9cf65cc20
371 lines
16 KiB
C++
371 lines
16 KiB
C++
/*
|
|
* 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 <android/binder_enums.h>
|
|
#include <unordered_set>
|
|
|
|
#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>;
|
|
|
|
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::captureSamples>(
|
|
mDescriptor.capability.get<Capability::visualizer>().captureSampleRange.max);
|
|
Parameter::Specific specific =
|
|
Parameter::Specific::make<Parameter::Specific::visualizer>(vs);
|
|
return specific;
|
|
}
|
|
|
|
static const std::vector<std::pair<std::shared_ptr<IFactory>, Descriptor>> kFactoryDescList;
|
|
static const std::unordered_set<Visualizer::ScalingMode> kScalingModeValues;
|
|
static const std::unordered_set<Visualizer::MeasurementMode> kMeasurementModeValues;
|
|
static const std::unordered_set<int> kLatencyValues;
|
|
static const std::unordered_set<int> kCaptureSizeValues;
|
|
|
|
static const long kInputFrameCount = 0x100, kOutputFrameCount = 0x100;
|
|
std::shared_ptr<IFactory> mFactory;
|
|
std::shared_ptr<IEffect> mEffect;
|
|
Descriptor mDescriptor;
|
|
int mCaptureSize;
|
|
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::captureSamples>(captureSize);
|
|
mCommonTags.push_back({Visualizer::captureSamples, 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::captureSampleBuffer);
|
|
}
|
|
|
|
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::captureSamples: {
|
|
int captureSize = vs.get<Visualizer::captureSamples>();
|
|
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.captureSampleRange.min &&
|
|
captureSize <= cap.captureSampleRange.max);
|
|
}
|
|
|
|
bool isLatencyInRange(const Visualizer::Capability& cap, int latency) const {
|
|
return (latency >= 0 && latency <= cap.maxLatencyMs);
|
|
}
|
|
|
|
static std::unordered_set<int> getCaptureSizeValues() {
|
|
int minCaptureSize = std::numeric_limits<int>::max();
|
|
int maxCaptureSize = std::numeric_limits<int>::min();
|
|
for (const auto& it : kFactoryDescList) {
|
|
maxCaptureSize = std::max(
|
|
it.second.capability.get<Capability::visualizer>().captureSampleRange.max,
|
|
maxCaptureSize);
|
|
minCaptureSize = std::min(
|
|
it.second.capability.get<Capability ::visualizer>().captureSampleRange.min,
|
|
minCaptureSize);
|
|
}
|
|
return {std::numeric_limits<int>::min(), minCaptureSize - 1, minCaptureSize,
|
|
(minCaptureSize + maxCaptureSize) >> 1, maxCaptureSize, maxCaptureSize + 1,
|
|
std::numeric_limits<int>::max()};
|
|
}
|
|
|
|
static std::unordered_set<int> getLatencyValues() {
|
|
const auto max = std::max_element(
|
|
kFactoryDescList.begin(), kFactoryDescList.end(),
|
|
[](const std::pair<std::shared_ptr<IFactory>, Descriptor>& a,
|
|
const std::pair<std::shared_ptr<IFactory>, Descriptor>& b) {
|
|
return a.second.capability.get<Capability::visualizer>().maxLatencyMs <
|
|
b.second.capability.get<Capability::visualizer>().maxLatencyMs;
|
|
});
|
|
if (max == kFactoryDescList.end()) {
|
|
return {0};
|
|
}
|
|
int maxDelay = max->second.capability.get<Capability::visualizer>().maxLatencyMs;
|
|
return {-1, 0, maxDelay >> 1, maxDelay - 1, maxDelay, maxDelay + 1};
|
|
}
|
|
|
|
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();
|
|
}
|
|
};
|
|
|
|
const std::vector<std::pair<std::shared_ptr<IFactory>, Descriptor>>
|
|
VisualizerParamTest::kFactoryDescList = EffectFactoryHelper::getAllEffectDescriptors(
|
|
IFactory::descriptor, kVisualizerTypeUUID);
|
|
const std::unordered_set<int> VisualizerParamTest::kCaptureSizeValues =
|
|
VisualizerParamTest::getCaptureSizeValues();
|
|
const std::unordered_set<Visualizer::MeasurementMode> VisualizerParamTest::kMeasurementModeValues(
|
|
ndk::enum_range<Visualizer::MeasurementMode>().begin(),
|
|
ndk::enum_range<Visualizer::MeasurementMode>().end());
|
|
const std::unordered_set<Visualizer::ScalingMode> VisualizerParamTest::kScalingModeValues(
|
|
ndk::enum_range<Visualizer::ScalingMode>().begin(),
|
|
ndk::enum_range<Visualizer::ScalingMode>().end());
|
|
const std::unordered_set<int> VisualizerParamTest::kLatencyValues =
|
|
VisualizerParamTest::getLatencyValues();
|
|
|
|
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(
|
|
VisualizerParamTest, VisualizerParamTest,
|
|
::testing::Combine(testing::ValuesIn(EffectFactoryHelper::getAllEffectDescriptors(
|
|
IFactory::descriptor, kVisualizerTypeUUID)),
|
|
testing::ValuesIn(VisualizerParamTest::kCaptureSizeValues),
|
|
testing::ValuesIn(VisualizerParamTest::kScalingModeValues),
|
|
testing::ValuesIn(VisualizerParamTest::kMeasurementModeValues),
|
|
testing::ValuesIn(VisualizerParamTest::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();
|
|
} |