Evolution-x/hardware_interfaces
1
0
Fork 0
mirror of https://github.com/Evolution-X/hardware_interfaces synced 2026-02-01 16:23:37 +00:00
Code Issues Packages Projects Releases Wiki Activity

Effect AIDL Add visualizer libeffect implementation am: e39cd36545

Browse Source 
Original change: https://android-review.googlesource.com/c/platform/hardware/interfaces/+/2366331

Change-Id: I52091208838330655f076f673f80bfc5189c3ee1
Signed-off-by: Automerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
This commit is contained in:
Shunkai Yao
2022-12-22 22:49:24 +00:00
committed by Automerger Merge Worker
parent 54effb5212 e39cd36545
commit 526c2a8829
10 changed files with 128 additions and 73 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
audio/aidl/aidl_api/android.hardware.audio.effect/current/android/hardware/audio/effect/Visualizer.aidl
View File

@@ -38,7 +38,7 @@ union Visualizer {
android.hardware.audio.effect.VendorExtension vendor;
android.hardware.audio.effect.Visualizer.GetOnlyParameters getOnlyParameters;
android.hardware.audio.effect.Visualizer.SetOnlyParameters setOnlyParameters;
int captureSizeBytes;
int captureSamples;
android.hardware.audio.effect.Visualizer.ScalingMode scalingMode;
android.hardware.audio.effect.Visualizer.MeasurementMode measurementMode;
@VintfStability
@@ -52,12 +52,12 @@ union Visualizer {
parcelable Capability {
android.hardware.audio.effect.VendorExtension extension;
int maxLatencyMs;
android.hardware.audio.effect.Visualizer.CaptureSizeRange captureSizeRange;
android.hardware.audio.effect.Visualizer.CaptureSamplesRange captureSampleRange;
}
@VintfStability
parcelable CaptureSizeRange {
int minBytes;
int maxBytes;
parcelable CaptureSamplesRange {
int min;
int max;
}
@VintfStability
enum ScalingMode {
@@ -72,7 +72,7 @@ union Visualizer {
@VintfStability
union GetOnlyParameters {
android.hardware.audio.effect.Visualizer.GetOnlyParameters.Measurement measurement;
byte[] captureBytes;
byte[] captureSampleBuffer;
@VintfStability
parcelable Measurement {
int rms;

10
audio/aidl/android/hardware/audio/effect/IEffect.aidl
View File

@@ -34,12 +34,10 @@ interface IEffect {
/**
* One of Binder STATUS_* statuses:
* - STATUS_OK: the command has completed successfully;
* - STATUS_BAD_VALUE: invalid value in the 'Command' structure;
* - STATUS_INVALID_OPERATION: the mix port is not connected
* to any producer or consumer, thus
* positions can not be reported;
* - STATUS_NOT_ENOUGH_DATA: a read or write error has
* occurred for the 'audio.fmq' queue;
* - STATUS_BAD_VALUE: invalid parameters or state detected in effects;
* - STATUS_INVALID_OPERATION: an internal error happens in effect audio buffer processing;
* - STATUS_NOT_ENOUGH_DATA: a read or write error has occurred for the 'inputDataMQ' or
* 'outputDataMQ';
*
*/
int status;

18
audio/aidl/android/hardware/audio/effect/Visualizer.aidl
View File

@@ -63,16 +63,16 @@ union Visualizer {
/**
* Capture size range.
*/
CaptureSizeRange captureSizeRange;
CaptureSamplesRange captureSampleRange;
}
/**
* Supported capture size range in bytes.
* Supported capture size range in samples.
*/
@VintfStability
parcelable CaptureSizeRange {
int minBytes;
int maxBytes;
parcelable CaptureSamplesRange {
int min;
int max;
}
/**
@@ -131,9 +131,9 @@ union Visualizer {
Measurement measurement;
/**
* Gets the latest PCM capture, size of returned vector equals to @c captureSize.
* Get the latest captureSamples of PCM samples (8 bits per sample).
*/
byte[] captureBytes;
byte[] captureSampleBuffer;
}
GetOnlyParameters getOnlyParameters;
@@ -152,10 +152,10 @@ union Visualizer {
SetOnlyParameters setOnlyParameters;
/**
* Current capture size in bytes. The capture size must be a power of 2 in the range
* Current capture size in number of samples. The capture size must be inside
* Capability.captureSizeRange.
*/
int captureSizeBytes;
int captureSamples;
/**
* Visualizer capture mode
*/

2
audio/aidl/default/Android.bp
View File

@@ -160,7 +160,7 @@ cc_binary {
"libpresetreverbsw",
"libtinyxml2",
"libvirtualizersw",
"libvisualizersw",
"libvisualizeraidl",
"libvolumesw",
],
srcs: [

5
audio/aidl/default/EffectImpl.cpp
View File

@@ -21,6 +21,7 @@
using aidl::android::hardware::audio::effect::IEffect;
using aidl::android::hardware::audio::effect::State;
using aidl::android::media::audio::common::PcmType;
extern "C" binder_exception_t destroyEffect(const std::shared_ptr<IEffect>& instanceSp) {
State state;
@@ -40,6 +41,10 @@ ndk::ScopedAStatus EffectImpl::open(const Parameter::Common& common,
const std::optional<Parameter::Specific>& specific,
OpenEffectReturn* ret) {
LOG(DEBUG) << __func__;
// effect only support 32bits float
RETURN_IF(common.input.base.format.pcm != common.output.base.format.pcm ||
common.input.base.format.pcm != PcmType::FLOAT_32_BIT,
EX_ILLEGAL_ARGUMENT, "dataMustBe32BitsFloat");
RETURN_OK_IF(mState != State::INIT);
auto context = createContext(common);
RETURN_IF(!context, EX_NULL_POINTER, "createContextFailed");

4
audio/aidl/default/audio_effects_config.xml
View File

@@ -41,7 +41,7 @@
<library name="env_reverbsw" path="libenvreverbsw.so"/>
<library name="preset_reverbsw" path="libpresetreverbsw.so"/>
<library name="virtualizersw" path="libvirtualizersw.so"/>
<library name="visualizersw" path="libvisualizersw.so"/>
<library name="visualizer" path="libvisualizeraidl.so"/>
<library name="volumesw" path="libvolumesw.so"/>
</libraries>
@@ -82,7 +82,7 @@
<libsw library="virtualizersw" uuid="fa819d86-588b-11ed-9b6a-0242ac120002"/>
<libsw library="bundle" uuid="1d4033c0-8557-11df-9f2d-0002a5d5c51b"/>
</effectProxy>
<effect name="visualizer" library="visualizersw" uuid="fa81a0f6-588b-11ed-9b6a-0242ac120002"/>
<effect name="visualizer" library="visualizer" uuid="d069d9e0-8329-11df-9168-0002a5d5c51b"/>
<effect name="volume" library="bundle" uuid="119341a0-8469-11df-81f9-0002a5d5c51b"/>
<effectProxy name="equalizer" uuid="c8e70ecd-48ca-456e-8a4f-0002a5d5c51b">
<libsw library="equalizersw" uuid="0bed4300-847d-11df-bb17-0002a5d5c51b"/>

7
audio/aidl/default/include/effect-impl/EffectUUID.h
View File

@@ -243,6 +243,13 @@ static const AudioUuid kVisualizerSwImplUUID = {static_cast<int32_t>(0xfa81a0f6)
0x11ed,
0x9b6a,
{0x02, 0x42, 0xac, 0x12, 0x00, 0x02}};
// d069d9e0-8329-11df-9168-0002a5d5c51b
// {0xd069d9e0, 0x8329, 0x11df, 0x9168, {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}},
static const AudioUuid kVisualizerImplUUID = {static_cast<int32_t>(0xd069d9e0),
0x8329,
0x11df,
0x9168,
{0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}};
// fa81a2b8-588b-11ed-9b6a-0242ac120002
static const AudioUuid kVolumeTypeUUID = {static_cast<int32_t>(0xfa81a2b8),
0x588b,

23
audio/aidl/default/visualizer/VisualizerSw.cpp
View File

@@ -56,9 +56,12 @@ namespace aidl::android::hardware::audio::effect {
const std::string VisualizerSw::kEffectName = "VisualizerSw";
/* capabilities */
const Visualizer::CaptureSizeRange mCaptureSizeRange = {MIN_CAPTURE_SIZE, MAX_CAPTURE_SIZE};
const Visualizer::Capability VisualizerSw::kCapability = {.maxLatencyMs = MAX_LATENCY,
.captureSizeRange = mCaptureSizeRange};
const Visualizer::CaptureSamplesRange VisualizerSwContext::kCaptureSamplesRange = {
VisualizerSwContext::kMinCaptureSize, VisualizerSwContext::kMaxCaptureSize};
const Visualizer::Capability VisualizerSw::kCapability = {
.maxLatencyMs = VisualizerSwContext::kMaxLatencyMs,
.captureSampleRange = VisualizerSwContext::kCaptureSamplesRange};
const Descriptor VisualizerSw::kDescriptor = {
.common = {.id = {.type = kVisualizerTypeUUID,
.uuid = kVisualizerSwImplUUID,
@@ -84,8 +87,8 @@ ndk::ScopedAStatus VisualizerSw::setParameterSpecific(const Parameter::Specific&
auto tag = vsParam.getTag();
switch (tag) {
case Visualizer::captureSizeBytes: {
RETURN_IF(mContext->setVsCaptureSize(vsParam.get<Visualizer::captureSizeBytes>()) !=
case Visualizer::captureSamples: {
RETURN_IF(mContext->setVsCaptureSize(vsParam.get<Visualizer::captureSamples>()) !=
RetCode::SUCCESS,
EX_ILLEGAL_ARGUMENT, "captureSizeNotSupported");
return ndk::ScopedAStatus::ok();
@@ -159,8 +162,8 @@ ndk::ScopedAStatus VisualizerSw::getParameterVisualizer(const Visualizer::Tag& t
Visualizer vsParam;
switch (tag) {
case Visualizer::captureSizeBytes: {
vsParam.set<Visualizer::captureSizeBytes>(mContext->getVsCaptureSize());
case Visualizer::captureSamples: {
vsParam.set<Visualizer::captureSamples>(mContext->getVsCaptureSize());
break;
}
case Visualizer::scalingMode: {
@@ -190,9 +193,9 @@ ndk::ScopedAStatus VisualizerSw::getGetOnlyParameterVisualizer(
mContext->getVsMeasurement());
break;
}
case Visualizer::GetOnlyParameters::captureBytes: {
getOnlyParam.set<Visualizer::GetOnlyParameters::captureBytes>(
mContext->getVsCaptureBytes());
case Visualizer::GetOnlyParameters::captureSampleBuffer: {
getOnlyParam.set<Visualizer::GetOnlyParameters::captureSampleBuffer>(
mContext->getVsCaptureSampleBuffer());
break;
}
default: {

24
audio/aidl/default/visualizer/VisualizerSw.h
View File

@@ -22,24 +22,24 @@
#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 {
public:
static const int kMinCaptureSize = 0x80;
static const int kMaxCaptureSize = 0x400;
static const int kMaxLatencyMs = 3000;
static const int kMaxCaptureBufSize = 0xffff;
static const Visualizer::CaptureSamplesRange kCaptureSamplesRange;
VisualizerSwContext(int statusDepth, const Parameter::Common& common)
: EffectContext(statusDepth, common) {
LOG(DEBUG) << __func__;
mCaptureBytes.resize(CAPTURE_BUF_SIZE);
fill(mCaptureBytes.begin(), mCaptureBytes.end(), 0x80);
mCaptureSampleBuffer.resize(kMaxCaptureBufSize);
fill(mCaptureSampleBuffer.begin(), mCaptureSampleBuffer.end(), 0x80);
}
RetCode setVsCaptureSize(int captureSize) {
if (captureSize < MIN_CAPTURE_SIZE || captureSize > MAX_CAPTURE_SIZE) {
if (captureSize < kMinCaptureSize || captureSize > kMaxCaptureSize) {
LOG(ERROR) << __func__ << " invalid captureSize " << captureSize;
return RetCode::ERROR_ILLEGAL_PARAMETER;
}
@@ -64,7 +64,7 @@ class VisualizerSwContext final : public EffectContext {
Visualizer::MeasurementMode getVsMeasurementMode() const { return mMeasurementMode; }
RetCode setVsLatency(int latency) {
if (latency < 0 || latency > MAX_LATENCY) {
if (latency < 0 || latency > kMaxLatencyMs) {
LOG(ERROR) << __func__ << " invalid latency " << latency;
return RetCode::ERROR_ILLEGAL_PARAMETER;
}
@@ -74,15 +74,15 @@ class VisualizerSwContext final : public EffectContext {
}
Visualizer::GetOnlyParameters::Measurement getVsMeasurement() const { return mMeasurement; }
std::vector<uint8_t> getVsCaptureBytes() const { return mCaptureBytes; }
std::vector<uint8_t> getVsCaptureSampleBuffer() const { return mCaptureSampleBuffer; }
private:
int mCaptureSize = MAX_CAPTURE_SIZE;
int mCaptureSize = kMaxCaptureSize;
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;
std::vector<uint8_t> mCaptureSampleBuffer;
};
class VisualizerSw final : public EffectImpl {

96
audio/aidl/vts/VtsHalVisualizerTargetTest.cpp
View File

@@ -19,6 +19,9 @@
#define LOG_TAG "VtsHalVisualizerTest"
#include <Utils.h>
#include <android/binder_enums.h>
#include <unordered_set>
#include "EffectHelper.h"
using namespace android;
@@ -46,18 +49,6 @@ 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:
@@ -86,19 +77,25 @@ class VisualizerParamTest : public ::testing::TestWithParam<VisualizerParamTestP
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);
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 = MAX_CAPTURE_SIZE;
int mCaptureSize;
Visualizer::ScalingMode mScalingMode = Visualizer::ScalingMode::NORMALIZED;
Visualizer::MeasurementMode mMeasurementMode = Visualizer::MeasurementMode::NONE;
int mLatency = 0;
@@ -184,8 +181,8 @@ class VisualizerParamTest : public ::testing::TestWithParam<VisualizerParamTestP
void addCaptureSizeParam(int captureSize) {
Visualizer vs;
vs.set<Visualizer::captureSizeBytes>(captureSize);
mCommonTags.push_back({Visualizer::captureSizeBytes, vs});
vs.set<Visualizer::captureSamples>(captureSize);
mCommonTags.push_back({Visualizer::captureSamples, vs});
}
void addScalingModeParam(Visualizer::ScalingMode scalingMode) {
@@ -213,15 +210,15 @@ class VisualizerParamTest : public ::testing::TestWithParam<VisualizerParamTestP
}
void addCaptureBytesTag() {
mGetOnlyParamTags.push_back(Visualizer::GetOnlyParameters::captureBytes);
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::captureSizeBytes: {
int captureSize = vs.get<Visualizer::captureSizeBytes>();
case Visualizer::captureSamples: {
int captureSize = vs.get<Visualizer::captureSamples>();
return isCaptureSizeInRange(vsCap, captureSize);
}
case Visualizer::scalingMode:
@@ -243,14 +240,45 @@ class VisualizerParamTest : public ::testing::TestWithParam<VisualizerParamTestP
}
bool isCaptureSizeInRange(const Visualizer::Capability& cap, int captureSize) const {
return (captureSize >= cap.captureSizeRange.minBytes &&
captureSize <= cap.captureSizeRange.maxBytes);
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;
@@ -262,6 +290,20 @@ class VisualizerParamTest : public ::testing::TestWithParam<VisualizerParamTestP
}
};
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();
@@ -293,13 +335,13 @@ TEST_P(VisualizerParamTest, GetAndSetCaptureBytes) {
}
INSTANTIATE_TEST_SUITE_P(
VisualizerTest, VisualizerParamTest,
VisualizerParamTest, VisualizerParamTest,
::testing::Combine(testing::ValuesIn(EffectFactoryHelper::getAllEffectDescriptors(
IFactory::descriptor, kVisualizerTypeUUID)),
testing::ValuesIn(kCaptureSizeValues),
testing::ValuesIn(kScalingModeValues),
testing::ValuesIn(kMeasurementModeValues),
testing::ValuesIn(kLatencyValues)),
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));