From 52abf0a662a530b0df13c44001e23acf8134e910 Mon Sep 17 00:00:00 2001 From: Shunkai Yao Date: Tue, 8 Nov 2022 02:44:03 +0000 Subject: [PATCH 1/2] Support effect config parser in effect AIDL Bug: 255361653 Test: parse an example audio_effects.xml atest VtsHalAudioEffectFactoryTargetTest atest VtsHalAudioEffectTargetTest atest VtsHalEqualizerTargetTest Change-Id: I086905bcbe113a56767cae45102c84f5250d348e --- audio/aidl/default/Android.bp | 5 +- audio/aidl/default/EffectConfig.cpp | 165 ++++++++++++++++++ .../default/include/effect-impl/EffectTypes.h | 20 +++ .../default/include/effect-impl/EffectUUID.h | 28 ++- .../include/effectFactory-impl/EffectConfig.h | 96 ++++++++++ 5 files changed, 311 insertions(+), 3 deletions(-) create mode 100644 audio/aidl/default/EffectConfig.cpp create mode 100644 audio/aidl/default/include/effectFactory-impl/EffectConfig.h diff --git a/audio/aidl/default/Android.bp b/audio/aidl/default/Android.bp index d34d68c88b..2a4d66344f 100644 --- a/audio/aidl/default/Android.bp +++ b/audio/aidl/default/Android.bp @@ -81,6 +81,7 @@ cc_defaults { ], header_libs: [ "libaudioaidl_headers", + "libaudio_system_headers", "libsystem_headers", ], cflags: [ @@ -112,13 +113,15 @@ cc_binary { "libhapticgeneratorsw", "libloudnessenhancersw", "libreverbsw", + "libtinyxml2", "libvirtualizersw", "libvisualizersw", "libvolumesw", ], srcs: [ - "EffectMain.cpp", + "EffectConfig.cpp", "EffectFactory.cpp", + "EffectMain.cpp", ], } diff --git a/audio/aidl/default/EffectConfig.cpp b/audio/aidl/default/EffectConfig.cpp new file mode 100644 index 0000000000..e1427ec3d3 --- /dev/null +++ b/audio/aidl/default/EffectConfig.cpp @@ -0,0 +1,165 @@ +/* + * 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 "AHAL_EffectConfig" +#include + +#include "effectFactory-impl/EffectConfig.h" + +using aidl::android::media::audio::common::AudioUuid; + +namespace aidl::android::hardware::audio::effect { + +EffectConfig::EffectConfig(const std::string& file) { + tinyxml2::XMLDocument doc; + doc.LoadFile(file.c_str()); + LOG(DEBUG) << __func__ << " loading " << file; + // parse the xml file into maps + if (doc.Error()) { + LOG(ERROR) << __func__ << " tinyxml2 failed to load " << file + << " error: " << doc.ErrorStr(); + return; + } + + auto registerFailure = [&](bool result) { mSkippedElements += result ? 0 : 1; }; + + for (auto& xmlConfig : getChildren(doc, "audio_effects_conf")) { + // Parse library + for (auto& xmlLibraries : getChildren(xmlConfig, "libraries")) { + for (auto& xmlLibrary : getChildren(xmlLibraries, "library")) { + registerFailure(parseLibrary(xmlLibrary)); + } + } + + // Parse effects + for (auto& xmlEffects : getChildren(xmlConfig, "effects")) { + for (auto& xmlEffect : getChildren(xmlEffects)) { + registerFailure(parseEffect(xmlEffect)); + } + } + + // Parse pre processing chains + for (auto& xmlPreprocess : getChildren(xmlConfig, "preprocess")) { + for (auto& xmlStream : getChildren(xmlPreprocess, "stream")) { + registerFailure(parseStream(xmlStream)); + } + } + + // Parse post processing chains + for (auto& xmlPostprocess : getChildren(xmlConfig, "postprocess")) { + for (auto& xmlStream : getChildren(xmlPostprocess, "stream")) { + registerFailure(parseStream(xmlStream)); + } + } + } + LOG(DEBUG) << __func__ << " successfully parsed " << file << ", skipping " << mSkippedElements + << " element(s)"; +} + +std::vector> EffectConfig::getChildren( + const tinyxml2::XMLNode& node, const char* childTag) { + std::vector> children; + for (auto* child = node.FirstChildElement(childTag); child != nullptr; + child = child->NextSiblingElement(childTag)) { + children.emplace_back(*child); + } + return children; +} + +bool EffectConfig::parseLibrary(const tinyxml2::XMLElement& xml) { + const char* name = xml.Attribute("name"); + RETURN_VALUE_IF(!name, false, "noNameAttribute"); + const char* path = xml.Attribute("path"); + RETURN_VALUE_IF(!path, false, "noPathAttribute"); + + mLibraryMap[name] = path; + LOG(DEBUG) << __func__ << " " << name << " : " << path; + return true; +} + +bool EffectConfig::parseEffect(const tinyxml2::XMLElement& xml) { + struct EffectLibraries effectLibraries; + std::vector libraryUuids; + std::string name = xml.Attribute("name"); + RETURN_VALUE_IF(name == "", false, "effectsNoName"); + + LOG(DEBUG) << __func__ << dump(xml); + struct LibraryUuid libraryUuid; + if (std::strcmp(xml.Name(), "effectProxy") == 0) { + // proxy lib and uuid + RETURN_VALUE_IF(!parseLibraryUuid(xml, libraryUuid, true), false, "parseProxyLibFailed"); + effectLibraries.proxyLibrary = libraryUuid; + // proxy effect libs and UUID + auto xmlProxyLib = xml.FirstChildElement(); + RETURN_VALUE_IF(!xmlProxyLib, false, "noLibForProxy"); + while (xmlProxyLib) { + struct LibraryUuid tempLibraryUuid; + RETURN_VALUE_IF(!parseLibraryUuid(*xmlProxyLib, tempLibraryUuid), false, + "parseEffectLibFailed"); + libraryUuids.push_back(std::move(tempLibraryUuid)); + xmlProxyLib = xmlProxyLib->NextSiblingElement(); + } + } else { + // expect only one library if not proxy + RETURN_VALUE_IF(!parseLibraryUuid(xml, libraryUuid), false, "parseEffectLibFailed"); + libraryUuids.push_back(std::move(libraryUuid)); + } + + effectLibraries.libraries = std::move(libraryUuids); + mEffectsMap[name] = std::move(effectLibraries); + return true; +} + +bool EffectConfig::parseStream(const tinyxml2::XMLElement& xml) { + LOG(DEBUG) << __func__ << dump(xml); + const char* type = xml.Attribute("type"); + RETURN_VALUE_IF(!type, false, "noTypeInProcess"); + RETURN_VALUE_IF(0 != mProcessingMap.count(type), false, "duplicateType"); + + for (auto& apply : getChildren(xml, "apply")) { + const char* name = apply.get().Attribute("effect"); + RETURN_VALUE_IF(!name, false, "noEffectAttribute"); + mProcessingMap[type].push_back(name); + LOG(DEBUG) << __func__ << " " << type << " : " << name; + } + return true; +} + +bool EffectConfig::parseLibraryUuid(const tinyxml2::XMLElement& xml, + struct LibraryUuid& libraryUuid, bool isProxy) { + // Retrieve library name only if not effectProxy element + if (!isProxy) { + const char* name = xml.Attribute("library"); + RETURN_VALUE_IF(!name, false, "noLibraryAttribute"); + libraryUuid.name = name; + } + + const char* uuid = xml.Attribute("uuid"); + RETURN_VALUE_IF(!uuid, false, "noUuidAttribute"); + RETURN_VALUE_IF(!stringToUuid(uuid, &libraryUuid.uuid), false, "invalidUuidAttribute"); + + LOG(DEBUG) << __func__ << (isProxy ? " proxy " : libraryUuid.name) << " : " + << libraryUuid.uuid.toString(); + return true; +} + +const char* EffectConfig::dump(const tinyxml2::XMLElement& element, + tinyxml2::XMLPrinter&& printer) const { + element.Accept(&printer); + return printer.CStr(); +} + +} // namespace aidl::android::hardware::audio::effect diff --git a/audio/aidl/default/include/effect-impl/EffectTypes.h b/audio/aidl/default/include/effect-impl/EffectTypes.h index edce26b8ef..fc6a01d61f 100644 --- a/audio/aidl/default/include/effect-impl/EffectTypes.h +++ b/audio/aidl/default/include/effect-impl/EffectTypes.h @@ -19,6 +19,7 @@ #include #include +#include typedef binder_exception_t (*EffectCreateFunctor)( const ::aidl::android::media::audio::common::AudioUuid*, @@ -101,4 +102,23 @@ inline std::ostream& operator<<(std::ostream& out, const RetCode& code) { } \ } while (0) +static inline bool stringToUuid(const char* str, + ::aidl::android::media::audio::common::AudioUuid* uuid) { + RETURN_VALUE_IF(!uuid || !str, false, "nullPtr"); + + uint32_t tmp[10]; + if (sscanf(str, "%08x-%04x-%04x-%04x-%02x%02x%02x%02x%02x%02x", tmp, tmp + 1, tmp + 2, tmp + 3, + tmp + 4, tmp + 5, tmp + 6, tmp + 7, tmp + 8, tmp + 9) < 10) { + return false; + } + + uuid->timeLow = (uint32_t)tmp[0]; + uuid->timeMid = (uint16_t)tmp[1]; + uuid->timeHiAndVersion = (uint16_t)tmp[2]; + uuid->clockSeq = (uint16_t)tmp[3]; + uuid->node.insert(uuid->node.end(), {(uint8_t)tmp[4], (uint8_t)tmp[5], (uint8_t)tmp[6], + (uint8_t)tmp[7], (uint8_t)tmp[8], (uint8_t)tmp[9]}); + return true; +} + } // namespace aidl::android::hardware::audio::effect diff --git a/audio/aidl/default/include/effect-impl/EffectUUID.h b/audio/aidl/default/include/effect-impl/EffectUUID.h index 767cf6c053..184a587291 100644 --- a/audio/aidl/default/include/effect-impl/EffectUUID.h +++ b/audio/aidl/default/include/effect-impl/EffectUUID.h @@ -15,6 +15,8 @@ */ #pragma once +#include + #include namespace aidl::android::hardware::audio::effect { @@ -39,14 +41,14 @@ static const AudioUuid EqualizerTypeUUID = {static_cast(0x0bed4300), 0x8f34, {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}}; -// Equalizer implementation UUID. +// 0bed4300-847d-11df-bb17-0002a5d5c51b static const AudioUuid EqualizerSwImplUUID = {static_cast(0x0bed4300), 0x847d, 0x11df, 0xbb17, {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}}; -// Equalizer bundle implementation UUID. +// ce772f20-847d-11df-bb17-0002a5d5c51b static const AudioUuid EqualizerBundleImplUUID = {static_cast(0xce772f20), 0x847d, 0x11df, @@ -166,4 +168,26 @@ static const AudioUuid VolumeSwImplUUID = {static_cast(0xfa81a718), 0x9b6a, {0x02, 0x42, 0xac, 0x12, 0x00, 0x02}}; +/** + * @brief A map between effect name and effect type UUID. + * All attribution in effect/effectProxy of audio_effects.xml should be listed in this map. + * We need this map is because existing audio_effects.xml don't have a type UUID defined. + */ +static const std::map kUuidNameTypeMap = { + {"bassboost", BassBoostTypeUUID}, + {"downmix", DownmixTypeUUID}, + {"dynamics_processing", DynamicsProcessingTypeUUID}, + {"equalizer", EqualizerTypeUUID}, + {"haptic_generator", HapticGeneratorTypeUUID}, + {"loudness_enhancer", LoudnessEnhancerTypeUUID}, + {"reverb", ReverbTypeUUID}, + {"reverb_env_aux", ReverbTypeUUID}, + {"reverb_env_ins", ReverbTypeUUID}, + {"reverb_pre_aux", ReverbTypeUUID}, + {"reverb_pre_ins", ReverbTypeUUID}, + {"virtualizer", VirtualizerTypeUUID}, + {"visualizer", VisualizerTypeUUID}, + {"volume", VolumeTypeUUID}, +}; + } // namespace aidl::android::hardware::audio::effect diff --git a/audio/aidl/default/include/effectFactory-impl/EffectConfig.h b/audio/aidl/default/include/effectFactory-impl/EffectConfig.h new file mode 100644 index 0000000000..2b904f5e2c --- /dev/null +++ b/audio/aidl/default/include/effectFactory-impl/EffectConfig.h @@ -0,0 +1,96 @@ +/* + * Copyright (C) 2017 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. + */ + +#pragma once + +#include +#include +#include +#include +#include + +#include +#include + +#include "effect-impl/EffectTypes.h" + +namespace aidl::android::hardware::audio::effect { + +/** + * Library contains a mapping from library name to path. + * Effect contains a mapping from effect name to Libraries and implementation UUID. + * Pre/post processor contains a mapping from processing name to effect names. + */ +class EffectConfig { + public: + explicit EffectConfig(const std::string& file); + + // + struct Library { + std::string name; + std::string path; + }; + struct LibraryUuid { + std::string name; // library name + ::aidl::android::media::audio::common::AudioUuid uuid; + }; + // + struct EffectLibraries { + std::optional proxyLibrary; + std::vector libraries; + }; + + int getSkippedElements() const { return mSkippedElements; } + const std::unordered_map getLibraryMap() const { return mLibraryMap; } + const std::unordered_map getEffectsMap() const { + return mEffectsMap; + } + const std::unordered_map> getProcessingMap() const { + return mProcessingMap; + } + + private: + int mSkippedElements; + /* Parsed Libraries result */ + std::unordered_map mLibraryMap; + /* Parsed Effects result */ + std::unordered_map mEffectsMap; + /* Parsed pre/post processing result */ + std::unordered_map> mProcessingMap; + + /** @return all `node`s children that are elements and match the tag if provided. */ + std::vector> getChildren( + const tinyxml2::XMLNode& node, const char* childTag = nullptr); + + /** Parse a library xml note and push the result in mLibraryMap or return false on failure. */ + bool parseLibrary(const tinyxml2::XMLElement& xml); + + /** Parse an effect from an xml element describing it. + * @return true and pushes the effect in mEffectsMap on success, false on failure. + */ + bool parseEffect(const tinyxml2::XMLElement& xml); + + bool parseStream(const tinyxml2::XMLElement& xml); + + // Function to parse effect.library name and effect.uuid from xml + bool parseLibraryUuid(const tinyxml2::XMLElement& xml, struct LibraryUuid& libraryUuid, + bool isProxy = false); + + const char* dump(const tinyxml2::XMLElement& element, + tinyxml2::XMLPrinter&& printer = {}) const; +}; + +} // namespace aidl::android::hardware::audio::effect From 60b34b78a430922e3f50223ecabd039265a1bb8f Mon Sep 17 00:00:00 2001 From: Shunkai Yao Date: Thu, 10 Nov 2022 17:16:50 +0000 Subject: [PATCH 2/2] Add effect config xml parser in AIDL effect factory Bug: 255361653 Test: parse an example audio_effects.xml atest VtsHalAudioEffectFactoryTargetTest atest VtsHalAudioEffectTargetTest atest VtsHalEqualizerTargetTest Change-Id: I566aaf814470342f1ef55414889bbd3aea462f9a --- audio/aidl/default/EffectFactory.cpp | 75 +++++++---- audio/aidl/default/EffectMain.cpp | 14 +- audio/aidl/default/audio_effects_config.xml | 120 ++++++++++++++++++ .../effectFactory-impl/EffectFactory.h | 22 ++-- 4 files changed, 193 insertions(+), 38 deletions(-) create mode 100644 audio/aidl/default/audio_effects_config.xml diff --git a/audio/aidl/default/EffectFactory.cpp b/audio/aidl/default/EffectFactory.cpp index e03dda378f..820b447dd1 100644 --- a/audio/aidl/default/EffectFactory.cpp +++ b/audio/aidl/default/EffectFactory.cpp @@ -17,6 +17,7 @@ #define LOG_TAG "AHAL_EffectFactory" #include #include +#include #include "effect-impl/EffectTypes.h" #include "effect-impl/EffectUUID.h" @@ -26,22 +27,9 @@ using aidl::android::media::audio::common::AudioUuid; namespace aidl::android::hardware::audio::effect { -Factory::Factory() { - // TODO: get list of library UUID and name from audio_effect.xml. - openEffectLibrary(EqualizerTypeUUID, EqualizerSwImplUUID, std::nullopt, "libequalizersw.so"); - openEffectLibrary(EqualizerTypeUUID, EqualizerBundleImplUUID, std::nullopt, "libbundleaidl.so"); - openEffectLibrary(BassBoostTypeUUID, BassBoostSwImplUUID, std::nullopt, "libbassboostsw.so"); - openEffectLibrary(DynamicsProcessingTypeUUID, DynamicsProcessingSwImplUUID, std::nullopt, - "libdynamicsprocessingsw.so"); - openEffectLibrary(HapticGeneratorTypeUUID, HapticGeneratorSwImplUUID, std::nullopt, - "libhapticgeneratorsw.so"); - openEffectLibrary(LoudnessEnhancerTypeUUID, LoudnessEnhancerSwImplUUID, std::nullopt, - "libloudnessenhancersw.so"); - openEffectLibrary(ReverbTypeUUID, ReverbSwImplUUID, std::nullopt, "libreverbsw.so"); - openEffectLibrary(VirtualizerTypeUUID, VirtualizerSwImplUUID, std::nullopt, - "libvirtualizersw.so"); - openEffectLibrary(VisualizerTypeUUID, VisualizerSwImplUUID, std::nullopt, "libvisualizersw.so"); - openEffectLibrary(VolumeTypeUUID, VolumeSwImplUUID, std::nullopt, "libvolumesw.so"); +Factory::Factory(const std::string& file) : mConfig(EffectConfig(file)) { + LOG(DEBUG) << __func__ << " with config file: " << file; + loadEffectLibs(); } Factory::~Factory() { @@ -62,7 +50,7 @@ ndk::ScopedAStatus Factory::queryEffects(const std::optional& in_type const std::optional& in_proxy_uuid, std::vector* _aidl_return) { std::copy_if( - mIdentityList.begin(), mIdentityList.end(), std::back_inserter(*_aidl_return), + mIdentitySet.begin(), mIdentitySet.end(), std::back_inserter(*_aidl_return), [&](auto& desc) { return (!in_type_uuid.has_value() || in_type_uuid.value() == desc.type) && (!in_impl_uuid.has_value() || in_impl_uuid.value() == desc.uuid) && @@ -172,8 +160,7 @@ ndk::ScopedAStatus Factory::destroyEffect(const std::shared_ptr& in_han return status; } -void Factory::openEffectLibrary(const AudioUuid& type, const AudioUuid& impl, - const std::optional& proxy, const std::string& libName) { +void Factory::openEffectLibrary(const AudioUuid& impl, const std::string& libName) { std::function dlClose = [](void* handle) -> void { if (handle && dlclose(handle)) { LOG(ERROR) << "dlclose failed " << dlerror(); @@ -187,19 +174,51 @@ void Factory::openEffectLibrary(const AudioUuid& type, const AudioUuid& impl, return; } - LOG(DEBUG) << __func__ << " dlopen lib:" << libName << " for uuid:\ntype:" << type.toString() - << "\nimpl:" << impl.toString() - << "\nproxy:" << (proxy.has_value() ? proxy.value().toString() : "null") + LOG(DEBUG) << __func__ << " dlopen lib:" << libName << "\nimpl:" << impl.toString() << "\nhandle:" << libHandle; mEffectLibMap.insert({impl, std::make_pair(std::move(libHandle), nullptr)}); +} - Descriptor::Identity id; - id.type = type; - id.uuid = impl; - if (proxy.has_value()) { - id.proxy = proxy.value(); +void Factory::createIdentityWithConfig(const EffectConfig::LibraryUuid& configLib, + const AudioUuid& typeUuid, + const std::optional proxyUuid) { + static const auto& libMap = mConfig.getLibraryMap(); + const std::string& libName = configLib.name; + if (auto path = libMap.find(libName); path != libMap.end()) { + Descriptor::Identity id; + id.type = typeUuid; + id.uuid = configLib.uuid; + id.proxy = proxyUuid; + LOG(DEBUG) << __func__ << ": typeUuid " << id.type.toString() << "\nimplUuid " + << id.uuid.toString() << " proxyUuid " + << (proxyUuid.has_value() ? proxyUuid->toString() : "null"); + openEffectLibrary(id.uuid, path->second); + mIdentitySet.insert(std::move(id)); + } else { + LOG(ERROR) << __func__ << ": library " << libName << " not exist!"; + return; + } +} + +void Factory::loadEffectLibs() { + const auto& configEffectsMap = mConfig.getEffectsMap(); + for (const auto& configEffects : configEffectsMap) { + if (auto typeUuid = kUuidNameTypeMap.find(configEffects.first /* effect name */); + typeUuid != kUuidNameTypeMap.end()) { + const auto& configLibs = configEffects.second; + std::optional proxyUuid; + if (configLibs.proxyLibrary.has_value()) { + const auto& proxyLib = configLibs.proxyLibrary.value(); + proxyUuid = proxyLib.uuid; + } + for (const auto& configLib : configLibs.libraries) { + createIdentityWithConfig(configLib, typeUuid->second, proxyUuid); + } + } else { + LOG(ERROR) << __func__ << ": can not find type UUID for effect " << configEffects.first + << " skipping!"; + } } - mIdentityList.push_back(id); } } // namespace aidl::android::hardware::audio::effect diff --git a/audio/aidl/default/EffectMain.cpp b/audio/aidl/default/EffectMain.cpp index 3219dd66a4..ca81204823 100644 --- a/audio/aidl/default/EffectMain.cpp +++ b/audio/aidl/default/EffectMain.cpp @@ -19,21 +19,31 @@ #include #include #include +#include + +/** Default name of effect configuration file. */ +static const char* kDefaultConfigName = "audio_effects_config.xml"; int main() { // This is a debug implementation, always enable debug logging. android::base::SetMinimumLogSeverity(::android::base::DEBUG); ABinderProcess_setThreadPoolMaxThreadCount(0); + auto configFile = android::audio_find_readable_configuration_file(kDefaultConfigName); + if (configFile == "") { + LOG(ERROR) << __func__ << ": config file " << kDefaultConfigName << " not found!"; + return EXIT_FAILURE; + } + LOG(DEBUG) << __func__ << ": start factory with configFile:" << configFile; auto effectFactory = - ndk::SharedRefBase::make(); + ndk::SharedRefBase::make(configFile); std::string serviceName = std::string() + effectFactory->descriptor + "/default"; binder_status_t status = AServiceManager_addService(effectFactory->asBinder().get(), serviceName.c_str()); CHECK_EQ(STATUS_OK, status); - LOG(DEBUG) << __func__ << ": effectFactoryName:" << serviceName; + LOG(DEBUG) << __func__ << ": effectFactory: " << serviceName << " start"; ABinderProcess_joinThreadPool(); return EXIT_FAILURE; // should not reach } diff --git a/audio/aidl/default/audio_effects_config.xml b/audio/aidl/default/audio_effects_config.xml new file mode 100644 index 0000000000..b6fea27159 --- /dev/null +++ b/audio/aidl/default/audio_effects_config.xml @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/audio/aidl/default/include/effectFactory-impl/EffectFactory.h b/audio/aidl/default/include/effectFactory-impl/EffectFactory.h index d50bd63d30..7edace06e0 100644 --- a/audio/aidl/default/include/effectFactory-impl/EffectFactory.h +++ b/audio/aidl/default/include/effectFactory-impl/EffectFactory.h @@ -19,15 +19,17 @@ #include #include #include +#include #include #include +#include "EffectConfig.h" namespace aidl::android::hardware::audio::effect { class Factory : public BnFactory { public: - Factory(); + explicit Factory(const std::string& file); /** * @brief Get identity of all effects supported by the device, with the optional filter by type * and/or by instance UUID. @@ -77,9 +79,10 @@ class Factory : public BnFactory { override; private: + const EffectConfig mConfig; ~Factory(); - // List of effect descriptors supported by the devices. - std::vector mIdentityList; + // Set of effect descriptors supported by the devices. + std::set mIdentitySet; std::map> /* dlHandle */, @@ -91,10 +94,13 @@ class Factory : public BnFactory { ndk::ScopedAStatus destroyEffectImpl(const std::shared_ptr& in_handle); void cleanupEffectMap(); - void openEffectLibrary( - const ::aidl::android::media::audio::common::AudioUuid& type, - const ::aidl::android::media::audio::common::AudioUuid& impl, - const std::optional<::aidl::android::media::audio::common::AudioUuid>& proxy, - const std::string& libName); + void openEffectLibrary(const ::aidl::android::media::audio::common::AudioUuid& impl, + const std::string& libName); + void createIdentityWithConfig( + const EffectConfig::LibraryUuid& configLib, + const ::aidl::android::media::audio::common::AudioUuid& typeUuid, + const std::optional<::aidl::android::media::audio::common::AudioUuid> proxyUuid); + void loadEffectLibs(); }; + } // namespace aidl::android::hardware::audio::effect