blob: 7ae9a66762b20298686a2419a081d3cfc405624d [file] [log] [blame]
Shunkai Yaoc23916b2022-07-13 04:59:37 +00001/*
2 * Copyright (C) 2022 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
Shunkai Yaoc12e0822022-12-12 07:13:58 +000017#include <iterator>
18#include <memory>
19#include <tuple>
20#include "include/effect-impl/EffectTypes.h"
Shunkai Yaoc23916b2022-07-13 04:59:37 +000021#define LOG_TAG "AHAL_EffectFactory"
Shunkai Yaoea24c1a2022-09-28 17:39:23 +000022#include <dlfcn.h>
Shunkai Yao60b34b72022-11-10 17:16:50 +000023#include <unordered_set>
Shunkai Yaoc23916b2022-07-13 04:59:37 +000024
Shunkai Yao39bf2c32022-12-06 03:25:59 +000025#include <android-base/logging.h>
26#include <android/binder_ibinder_platform.h>
27#include <system/thread_defs.h>
28
Shunkai Yao6afc8552022-10-26 22:47:20 +000029#include "effect-impl/EffectTypes.h"
Shunkai Yaoea24c1a2022-09-28 17:39:23 +000030#include "effect-impl/EffectUUID.h"
Shunkai Yaoc23916b2022-07-13 04:59:37 +000031#include "effectFactory-impl/EffectFactory.h"
Shunkai Yaoc23916b2022-07-13 04:59:37 +000032
33using aidl::android::media::audio::common::AudioUuid;
34
35namespace aidl::android::hardware::audio::effect {
36
Shunkai Yao60b34b72022-11-10 17:16:50 +000037Factory::Factory(const std::string& file) : mConfig(EffectConfig(file)) {
38 LOG(DEBUG) << __func__ << " with config file: " << file;
39 loadEffectLibs();
Shunkai Yaoc23916b2022-07-13 04:59:37 +000040}
41
Shunkai Yaoea24c1a2022-09-28 17:39:23 +000042Factory::~Factory() {
43 if (auto count = mEffectUuidMap.size()) {
44 LOG(ERROR) << __func__ << " remaining " << count
45 << " effect instances not destroyed indicating resource leak!";
46 for (const auto& it : mEffectUuidMap) {
47 if (auto spEffect = it.first.lock()) {
48 LOG(ERROR) << __func__ << " erase remaining instance UUID " << it.second.toString();
49 destroyEffectImpl(spEffect);
50 }
51 }
52 }
53}
54
55ndk::ScopedAStatus Factory::queryEffects(const std::optional<AudioUuid>& in_type_uuid,
56 const std::optional<AudioUuid>& in_impl_uuid,
Shunkai Yao6afc8552022-10-26 22:47:20 +000057 const std::optional<AudioUuid>& in_proxy_uuid,
Shunkai Yaoc12e0822022-12-12 07:13:58 +000058 std::vector<Descriptor>* _aidl_return) {
59 // get the matching list
60 std::vector<Descriptor::Identity> idList;
61 std::copy_if(mIdentitySet.begin(), mIdentitySet.end(), std::back_inserter(idList),
62 [&](auto& id) {
63 return (!in_type_uuid.has_value() || in_type_uuid.value() == id.type) &&
64 (!in_impl_uuid.has_value() || in_impl_uuid.value() == id.uuid) &&
65 (!in_proxy_uuid.has_value() ||
66 (id.proxy.has_value() && in_proxy_uuid.value() == id.proxy.value()));
67 });
68 // query through the matching list
69 for (const auto& id : idList) {
70 if (mEffectLibMap.count(id.uuid)) {
71 Descriptor desc;
72 auto& entry = mEffectLibMap[id.uuid];
73 getDlSyms(entry);
74 auto& libInterface = std::get<kMapEntryInterfaceIndex>(entry);
75 RETURN_IF(!libInterface || !libInterface->queryEffectFunc, EX_NULL_POINTER,
76 "dlNullQueryEffectFunc");
77 RETURN_IF_BINDER_EXCEPTION(libInterface->queryEffectFunc(&id.uuid, &desc));
78 _aidl_return->emplace_back(std::move(desc));
79 }
80 }
Shunkai Yaoc23916b2022-07-13 04:59:37 +000081 return ndk::ScopedAStatus::ok();
82}
83
Shunkai Yao08b687d2022-10-13 21:11:11 +000084ndk::ScopedAStatus Factory::queryProcessing(const std::optional<Processing::Type>& in_type,
85 std::vector<Processing>* _aidl_return) {
86 // TODO: implement this with audio_effect.xml.
87 if (in_type.has_value()) {
88 // return all matching process filter
89 LOG(DEBUG) << __func__ << " process type: " << in_type.value().toString();
90 }
91 LOG(DEBUG) << __func__ << " return " << _aidl_return->size();
92 return ndk::ScopedAStatus::ok();
93}
94
Shunkai Yaoea24c1a2022-09-28 17:39:23 +000095ndk::ScopedAStatus Factory::createEffect(const AudioUuid& in_impl_uuid,
96 std::shared_ptr<IEffect>* _aidl_return) {
Shunkai Yao45905172022-08-24 18:14:02 +000097 LOG(DEBUG) << __func__ << ": UUID " << in_impl_uuid.toString();
Shunkai Yao6afc8552022-10-26 22:47:20 +000098 if (mEffectLibMap.count(in_impl_uuid)) {
Shunkai Yaoc12e0822022-12-12 07:13:58 +000099 auto& entry = mEffectLibMap[in_impl_uuid];
100 getDlSyms(entry);
Shunkai Yao6afc8552022-10-26 22:47:20 +0000101
Shunkai Yaoc12e0822022-12-12 07:13:58 +0000102 auto& libInterface = std::get<kMapEntryInterfaceIndex>(entry);
103 RETURN_IF(!libInterface || !libInterface->createEffectFunc, EX_NULL_POINTER,
104 "dlNullcreateEffectFunc");
Shunkai Yao6afc8552022-10-26 22:47:20 +0000105 std::shared_ptr<IEffect> effectSp;
106 RETURN_IF_BINDER_EXCEPTION(libInterface->createEffectFunc(&in_impl_uuid, &effectSp));
107 if (!effectSp) {
108 LOG(ERROR) << __func__ << ": library created null instance without return error!";
109 return ndk::ScopedAStatus::fromExceptionCode(EX_TRANSACTION_FAILED);
110 }
111 *_aidl_return = effectSp;
Shunkai Yao39bf2c32022-12-06 03:25:59 +0000112 AIBinder_setMinSchedulerPolicy(effectSp->asBinder().get(), SCHED_NORMAL,
113 ANDROID_PRIORITY_AUDIO);
Shunkai Yao6afc8552022-10-26 22:47:20 +0000114 mEffectUuidMap[std::weak_ptr<IEffect>(effectSp)] = in_impl_uuid;
115 LOG(DEBUG) << __func__ << ": instance " << effectSp.get() << " created successfully";
116 return ndk::ScopedAStatus::ok();
Shunkai Yao45905172022-08-24 18:14:02 +0000117 } else {
Shunkai Yao6afc8552022-10-26 22:47:20 +0000118 LOG(ERROR) << __func__ << ": library doesn't exist";
Shunkai Yao45905172022-08-24 18:14:02 +0000119 return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
120 }
121 return ndk::ScopedAStatus::ok();
122}
123
Shunkai Yaoea24c1a2022-09-28 17:39:23 +0000124ndk::ScopedAStatus Factory::destroyEffectImpl(const std::shared_ptr<IEffect>& in_handle) {
125 std::weak_ptr<IEffect> wpHandle(in_handle);
126 // find UUID with key (std::weak_ptr<IEffect>)
127 if (auto uuidIt = mEffectUuidMap.find(wpHandle); uuidIt != mEffectUuidMap.end()) {
128 auto& uuid = uuidIt->second;
129 // find implementation library with UUID
130 if (auto libIt = mEffectLibMap.find(uuid); libIt != mEffectLibMap.end()) {
Shunkai Yaoc12e0822022-12-12 07:13:58 +0000131 auto& interface = std::get<kMapEntryInterfaceIndex>(libIt->second);
132 RETURN_IF(!interface || !interface->destroyEffectFunc, EX_NULL_POINTER,
133 "dlNulldestroyEffectFunc");
134 RETURN_IF_BINDER_EXCEPTION(interface->destroyEffectFunc(in_handle));
Shunkai Yaoea24c1a2022-09-28 17:39:23 +0000135 } else {
136 LOG(ERROR) << __func__ << ": UUID " << uuid.toString() << " does not exist in libMap!";
137 return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
138 }
139 mEffectUuidMap.erase(uuidIt);
Shunkai Yao45905172022-08-24 18:14:02 +0000140 return ndk::ScopedAStatus::ok();
141 } else {
Shunkai Yaoea24c1a2022-09-28 17:39:23 +0000142 LOG(ERROR) << __func__ << ": instance " << in_handle << " does not exist!";
Shunkai Yao45905172022-08-24 18:14:02 +0000143 return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
144 }
145}
146
Shunkai Yaoea24c1a2022-09-28 17:39:23 +0000147// go over the map and cleanup all expired weak_ptrs.
148void Factory::cleanupEffectMap() {
149 for (auto it = mEffectUuidMap.begin(); it != mEffectUuidMap.end();) {
150 if (nullptr == it->first.lock()) {
151 it = mEffectUuidMap.erase(it);
152 } else {
153 ++it;
154 }
155 }
156}
157
158ndk::ScopedAStatus Factory::destroyEffect(const std::shared_ptr<IEffect>& in_handle) {
159 LOG(DEBUG) << __func__ << ": instance " << in_handle.get();
160 ndk::ScopedAStatus status = destroyEffectImpl(in_handle);
161 // always do the cleanup
162 cleanupEffectMap();
163 return status;
164}
165
Shunkai Yao60b34b72022-11-10 17:16:50 +0000166void Factory::openEffectLibrary(const AudioUuid& impl, const std::string& libName) {
Shunkai Yao6afc8552022-10-26 22:47:20 +0000167 std::function<void(void*)> dlClose = [](void* handle) -> void {
168 if (handle && dlclose(handle)) {
169 LOG(ERROR) << "dlclose failed " << dlerror();
170 }
171 };
172
173 auto libHandle =
174 std::unique_ptr<void, decltype(dlClose)>{dlopen(libName.c_str(), RTLD_LAZY), dlClose};
175 if (!libHandle) {
176 LOG(ERROR) << __func__ << ": dlopen failed, err: " << dlerror();
177 return;
178 }
179
Shunkai Yaoc12e0822022-12-12 07:13:58 +0000180 LOG(INFO) << __func__ << " dlopen lib:" << libName << "\nimpl:" << impl.toString()
181 << "\nhandle:" << libHandle;
182 auto interface = new effect_dl_interface_s{nullptr, nullptr, nullptr};
183 mEffectLibMap.insert(
184 {impl,
185 std::make_tuple(std::move(libHandle),
186 std::unique_ptr<struct effect_dl_interface_s>(interface), libName)});
Shunkai Yao60b34b72022-11-10 17:16:50 +0000187}
Shunkai Yao6afc8552022-10-26 22:47:20 +0000188
Shunkai Yao60b34b72022-11-10 17:16:50 +0000189void Factory::createIdentityWithConfig(const EffectConfig::LibraryUuid& configLib,
190 const AudioUuid& typeUuid,
191 const std::optional<AudioUuid> proxyUuid) {
192 static const auto& libMap = mConfig.getLibraryMap();
193 const std::string& libName = configLib.name;
194 if (auto path = libMap.find(libName); path != libMap.end()) {
195 Descriptor::Identity id;
196 id.type = typeUuid;
197 id.uuid = configLib.uuid;
198 id.proxy = proxyUuid;
199 LOG(DEBUG) << __func__ << ": typeUuid " << id.type.toString() << "\nimplUuid "
200 << id.uuid.toString() << " proxyUuid "
201 << (proxyUuid.has_value() ? proxyUuid->toString() : "null");
202 openEffectLibrary(id.uuid, path->second);
203 mIdentitySet.insert(std::move(id));
204 } else {
205 LOG(ERROR) << __func__ << ": library " << libName << " not exist!";
206 return;
Shunkai Yao6afc8552022-10-26 22:47:20 +0000207 }
Shunkai Yao60b34b72022-11-10 17:16:50 +0000208}
209
210void Factory::loadEffectLibs() {
211 const auto& configEffectsMap = mConfig.getEffectsMap();
212 for (const auto& configEffects : configEffectsMap) {
213 if (auto typeUuid = kUuidNameTypeMap.find(configEffects.first /* effect name */);
214 typeUuid != kUuidNameTypeMap.end()) {
215 const auto& configLibs = configEffects.second;
216 std::optional<AudioUuid> proxyUuid;
217 if (configLibs.proxyLibrary.has_value()) {
218 const auto& proxyLib = configLibs.proxyLibrary.value();
219 proxyUuid = proxyLib.uuid;
220 }
221 for (const auto& configLib : configLibs.libraries) {
222 createIdentityWithConfig(configLib, typeUuid->second, proxyUuid);
223 }
224 } else {
225 LOG(ERROR) << __func__ << ": can not find type UUID for effect " << configEffects.first
226 << " skipping!";
227 }
228 }
Shunkai Yao6afc8552022-10-26 22:47:20 +0000229}
230
Shunkai Yaoc12e0822022-12-12 07:13:58 +0000231void Factory::getDlSyms(DlEntry& entry) {
232 auto& dlHandle = std::get<kMapEntryHandleIndex>(entry);
233 RETURN_VALUE_IF(!dlHandle, void(), "dlNullHandle");
234 // Get the reference of the DL interfaces in library map tuple.
235 auto& dlInterface = std::get<kMapEntryInterfaceIndex>(entry);
236 // return if interface already exist
237 if (!dlInterface->createEffectFunc) {
238 dlInterface->createEffectFunc = (EffectCreateFunctor)dlsym(dlHandle.get(), "createEffect");
239 }
240 if (!dlInterface->queryEffectFunc) {
241 dlInterface->queryEffectFunc = (EffectQueryFunctor)dlsym(dlHandle.get(), "queryEffect");
242 }
243 if (!dlInterface->destroyEffectFunc) {
244 dlInterface->destroyEffectFunc =
245 (EffectDestroyFunctor)dlsym(dlHandle.get(), "destroyEffect");
246 }
247
248 if (!dlInterface->createEffectFunc || !dlInterface->destroyEffectFunc ||
249 !dlInterface->queryEffectFunc) {
250 LOG(ERROR) << __func__ << ": create (" << dlInterface->createEffectFunc << "), query ("
251 << dlInterface->queryEffectFunc << "), or destroy ("
252 << dlInterface->destroyEffectFunc
253 << ") not exist in library: " << std::get<kMapEntryLibNameIndex>(entry)
254 << " handle: " << dlHandle << " with dlerror: " << dlerror();
255 return;
256 }
257}
258
Shunkai Yaoc23916b2022-07-13 04:59:37 +0000259} // namespace aidl::android::hardware::audio::effect