1 /*
2 * Copyright (c) 2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #undef LOG_TAG
17 #define LOG_TAG "AudioEnhanceChainManager"
18
19 #include "audio_enhance_chain_manager.h"
20
21 #include <algorithm>
22 #include <charconv>
23 #include <system_error>
24
25 #include "securec.h"
26 #include "system_ability_definition.h"
27
28 #include "audio_effect_log.h"
29 #include "audio_errors.h"
30 #include "audio_effect.h"
31 #include "audio_enhance_chain.h"
32 #include "audio_enhance_chain_adapter.h"
33 #include "audio_setting_provider.h"
34 #include "audio_device_type.h"
35 #include "audio_effect_map.h"
36
37 using namespace OHOS::AudioStandard;
38
39 namespace OHOS {
40 namespace AudioStandard {
41 namespace {
42 constexpr uint32_t SCENE_TYPE_OFFSET = 32;
43 constexpr uint32_t CAPTURER_ID_OFFSET = 16;
44 constexpr uint64_t SCENE_TYPE_MASK = 0xFF00000000;
45 constexpr uint64_t CAPTURER_ID_MASK = 0x0000FFFF0000;
46 constexpr uint64_t RENDERER_ID_MASK = 0x00000000FFFF;
47 constexpr uint32_t VOLUME_FACTOR = 100;
48 const std::unordered_map<AudioEnhanceMode, std::string> AUDIO_ENHANCE_SUPPORTED_SCENE_MODES {
49 {ENHANCE_NONE, "ENHANCE_NONE"},
50 {ENHANCE_DEFAULT, "ENHANCE_DEFAULT"},
51 };
52 const std::vector<AudioEnhanceScene> AUDIO_WITH_DEVICE_ENHANCES {SCENE_VOIP_UP};
53 const std::string MAINKEY_DEVICE_STATUS = "device_status";
54 const std::string SUBKEY_FOLD_STATE = "fold_state";
55 }
56
FindEnhanceLib(const std::string & enhance,const std::vector<std::shared_ptr<AudioEffectLibEntry>> & enhanceLibraryList,std::shared_ptr<AudioEffectLibEntry> & libEntry,std::string & libName)57 static int32_t FindEnhanceLib(const std::string &enhance,
58 const std::vector<std::shared_ptr<AudioEffectLibEntry>> &enhanceLibraryList,
59 std::shared_ptr<AudioEffectLibEntry> &libEntry, std::string &libName)
60 {
61 for (const std::shared_ptr<AudioEffectLibEntry> &lib : enhanceLibraryList) {
62 if (std::any_of(lib->effectName.begin(), lib->effectName.end(),
63 [&enhance](const std::string &effectName) {
64 return effectName == enhance;
65 })) {
66 libName = lib->libraryName;
67 libEntry = lib;
68 return SUCCESS;
69 }
70 }
71 return ERROR;
72 }
73
CheckValidEnhanceLibEntry(const std::shared_ptr<AudioEffectLibEntry> & libEntry,const std::string & enhance,const std::string & libName)74 static int32_t CheckValidEnhanceLibEntry(const std::shared_ptr<AudioEffectLibEntry> &libEntry,
75 const std::string &enhance, const std::string &libName)
76 {
77 CHECK_AND_RETURN_RET_LOG(libEntry, ERROR, "Enhance [%{public}s] in lib [%{public}s] is nullptr",
78 enhance.c_str(), libName.c_str());
79 CHECK_AND_RETURN_RET_LOG(libEntry->audioEffectLibHandle, ERROR,
80 "AudioEffectLibHandle of Enhance [%{public}s] in lib [%{public}s] is nullptr",
81 enhance.c_str(), libName.c_str());
82 CHECK_AND_RETURN_RET_LOG(libEntry->audioEffectLibHandle->createEffect, ERROR,
83 "CreateEffect function of Enhance [%{public}s] in lib [%{public}s] is nullptr",
84 enhance.c_str(), libName.c_str());
85 CHECK_AND_RETURN_RET_LOG(libEntry->audioEffectLibHandle->releaseEffect, ERROR,
86 "ReleaseEffect function of Enhance [%{public}s] in lib [%{public}s] is nullptr",
87 enhance.c_str(), libName.c_str());
88 return SUCCESS;
89 }
90
AudioEnhanceChainManager()91 AudioEnhanceChainManager::AudioEnhanceChainManager()
92 {
93 sceneTypeToEnhanceChainMap_.clear();
94 sceneTypeToEnhanceChainCountMap_.clear();
95 sceneTypeAndModeToEnhanceChainNameMap_.clear();
96 enhanceChainToEnhancesMap_.clear();
97 enhanceToLibraryEntryMap_.clear();
98 enhanceToLibraryNameMap_.clear();
99 captureIdToDeviceMap_.clear();
100 captureIdToDeviceNameMap_.clear();
101 renderIdToDeviceMap_.clear();
102 enhanceBuffer_ = nullptr;
103 isInitialized_ = false;
104 foldState_ = FOLD_STATE_MIDDLE;
105 }
106
~AudioEnhanceChainManager()107 AudioEnhanceChainManager::~AudioEnhanceChainManager()
108 {
109 AUDIO_INFO_LOG("~AudioEnhanceChainManager destroy");
110 }
111
GetInstance()112 AudioEnhanceChainManager *AudioEnhanceChainManager::GetInstance()
113 {
114 static AudioEnhanceChainManager audioEnhanceChainManager;
115 return &audioEnhanceChainManager;
116 }
117
ResetInfo()118 void AudioEnhanceChainManager::ResetInfo()
119 {
120 sceneTypeToEnhanceChainMap_.clear();
121 sceneTypeToEnhanceChainCountMap_.clear();
122 sceneTypeAndModeToEnhanceChainNameMap_.clear();
123 enhanceChainToEnhancesMap_.clear();
124 enhanceToLibraryEntryMap_.clear();
125 enhanceToLibraryNameMap_.clear();
126 enhancePropertyMap_.clear();
127 defaultPropertyMap_.clear();
128 captureIdToDeviceMap_.clear();
129 captureIdToDeviceNameMap_.clear();
130 renderIdToDeviceMap_.clear();
131 FreeEnhanceBuffer();
132 isInitialized_ = false;
133 sessionId_ = 0;
134 volumeType_ = STREAM_MUSIC;
135 systemVol_ = 0.0f;
136 streamVol_ = 0.0f;
137 isMute_ = false;
138 }
139
ConstructEnhanceChainMgrMaps(std::vector<EffectChain> & enhanceChains,const EffectChainManagerParam & managerParam,std::vector<std::shared_ptr<AudioEffectLibEntry>> & enhanceLibraryList)140 void AudioEnhanceChainManager::ConstructEnhanceChainMgrMaps(std::vector<EffectChain> &enhanceChains,
141 const EffectChainManagerParam &managerParam, std::vector<std::shared_ptr<AudioEffectLibEntry>> &enhanceLibraryList)
142 {
143 std::set<std::string> enhanceSet;
144 for (EffectChain enhanceChain : enhanceChains) {
145 for (std::string enhance : enhanceChain.apply) {
146 enhanceSet.insert(enhance);
147 }
148 }
149 // Construct enhanceToLibraryEntryMap_ that stores libEntry for each effect name
150 std::shared_ptr<AudioEffectLibEntry> libEntry = nullptr;
151 std::string libName;
152 for (std::string enhance : enhanceSet) {
153 int32_t ret = FindEnhanceLib(enhance, enhanceLibraryList, libEntry, libName);
154 CHECK_AND_CONTINUE_LOG(ret != ERROR, "Couldn't find libEntry of effect %{public}s", enhance.c_str());
155 ret = CheckValidEnhanceLibEntry(libEntry, enhance, libName);
156 enhanceToLibraryEntryMap_[enhance] = libEntry;
157 enhanceToLibraryNameMap_[enhance] = libName;
158 }
159 // Construct enhanceChainToEnhancesMap_ that stores all effect names of each effect chain
160 for (EffectChain enhanceChain : enhanceChains) {
161 std::string key = enhanceChain.name;
162 std::vector<std::string> enhances;
163 for (std::string enhanceName : enhanceChain.apply) {
164 if (enhanceToLibraryEntryMap_.count(enhanceName)) {
165 enhances.emplace_back(enhanceName);
166 }
167 }
168 enhanceChainToEnhancesMap_[key] = enhances;
169 }
170 // Construct sceneTypeAndModeToEnhanceChainNameMap_ that stores effectMode associated with the effectChainName
171 sceneTypeAndModeToEnhanceChainNameMap_ = managerParam.sceneTypeToChainNameMap;
172 // Construct enhancePropertyMap_ that stores effect's property
173 enhancePropertyMap_ = managerParam.effectDefaultProperty;
174 defaultPropertyMap_ = managerParam.effectDefaultProperty;
175 ConstructDeviceEnhances();
176 }
177
ConstructDeviceEnhances()178 void AudioEnhanceChainManager::ConstructDeviceEnhances()
179 {
180 CHECK_AND_RETURN_LOG(sceneTypeAndModeToEnhanceChainNameMap_.size() != 0, "no enhance algos");
181 const std::unordered_map<AudioEnhanceScene, std::string> &audioEnhanceSupportedSceneTypes =
182 GetEnhanceSupportedSceneType();
183 for (const auto& sceneType: AUDIO_WITH_DEVICE_ENHANCES) {
184 std::string scene = audioEnhanceSupportedSceneTypes.find(sceneType)->second;
185 std::string sceneAndMode = scene + "_&_" + "ENHANCE_DEFAULT";
186 std::string enhanceChain = "";
187 auto item = sceneTypeAndModeToEnhanceChainNameMap_.find(sceneAndMode);
188 CHECK_AND_CONTINUE_LOG(item != sceneTypeAndModeToEnhanceChainNameMap_.end(),
189 "no such sceneAndMode %{public}s", sceneAndMode.c_str());
190 enhanceChain = item->second;
191 auto mapIter = enhanceChainToEnhancesMap_.find(enhanceChain);
192 std::vector<std::string> deviceEnhances;
193 CHECK_AND_CONTINUE_LOG(mapIter != enhanceChainToEnhancesMap_.end(),
194 "no such enhanceChain %{public}s", enhanceChain.c_str());
195 deviceEnhances = mapIter->second;
196 for (std::string enhance: deviceEnhances) {
197 auto iter = enhancePropertyMap_.find(enhance);
198 if (iter == enhancePropertyMap_.end()) {
199 continue;
200 }
201 withDeviceEnhances_.insert(iter->first);
202 }
203 }
204 }
205
UpdateEnhancePropertyMapFromDb(DeviceType deviceType)206 void AudioEnhanceChainManager::UpdateEnhancePropertyMapFromDb(DeviceType deviceType)
207 {
208 std::string deviceTypeName = "";
209 GetDeviceTypeName(deviceType, deviceTypeName);
210 AudioSettingProvider &settingProvider = AudioSettingProvider::GetInstance(AUDIO_POLICY_SERVICE_ID);
211 CHECK_AND_RETURN_LOG(settingProvider.CheckOsAccountReady(), "os account not ready");
212 for (auto &[enhance, prop] : enhancePropertyMap_) {
213 std::string property = "";
214 if (deviceTypeName == "") {
215 AUDIO_ERR_LOG("DeviceTypeName Null");
216 return;
217 }
218 std::string key = "";
219 if (withDeviceEnhances_.find(enhance) == withDeviceEnhances_.end()) {
220 key = enhance;
221 } else {
222 key = enhance + "_&_" + deviceTypeName;
223 }
224 ErrCode ret = settingProvider.GetStringValue(key, property, "system");
225 if (ret == SUCCESS) {
226 prop = property;
227 AUDIO_INFO_LOG("Get Effect_&_DeviceType:%{public}s is Property:%{public}s",
228 key.c_str(), property.c_str());
229 } else {
230 ret = settingProvider.PutStringValue(key, defaultPropertyMap_[enhance], "system");
231 if (ret != SUCCESS) {
232 AUDIO_ERR_LOG("set to default Property:%{public}s, failed, ErrCode : %{public}d",
233 defaultPropertyMap_[enhance].c_str(), ret);
234 return;
235 }
236 prop = defaultPropertyMap_[enhance];
237 AUDIO_INFO_LOG("Get prop failed,Effect_&_DeviceType:%{public}s is set to default Property:%{public}s",
238 key.c_str(), prop.c_str());
239 }
240 }
241 }
242
InitAudioEnhanceChainManager(std::vector<EffectChain> & enhanceChains,const EffectChainManagerParam & managerParam,std::vector<std::shared_ptr<AudioEffectLibEntry>> & enhanceLibraryList)243 void AudioEnhanceChainManager::InitAudioEnhanceChainManager(std::vector<EffectChain> &enhanceChains,
244 const EffectChainManagerParam &managerParam, std::vector<std::shared_ptr<AudioEffectLibEntry>> &enhanceLibraryList)
245 {
246 std::lock_guard<std::mutex> lock(chainManagerMutex_);
247 normalSceneLimit_ = managerParam.maxExtraNum;
248 chainNum_ = 0;
249 priorSceneSet_.insert(managerParam.priorSceneList.begin(), managerParam.priorSceneList.end());
250 defaultScene_ = managerParam.defaultSceneName;
251 AUDIO_INFO_LOG("defaultSceneName is %{public}s", defaultScene_.c_str());
252 for (const auto &priorScene : priorSceneSet_) {
253 AUDIO_INFO_LOG("priorScene contains %{public}s", priorScene.c_str());
254 }
255 AUDIO_INFO_LOG("normalSceneLimit is %{public}u", normalSceneLimit_);
256 ConstructEnhanceChainMgrMaps(enhanceChains, managerParam, enhanceLibraryList);
257
258 AUDIO_INFO_LOG("enhanceToLibraryEntryMap_ size %{public}zu \
259 enhanceChainToEnhancesMap_ size %{public}zu \
260 sceneTypeAndModeToEnhanceChainNameMap_ size %{public}zu",
261 enhanceToLibraryEntryMap_.size(),
262 enhanceChainToEnhancesMap_.size(),
263 sceneTypeAndModeToEnhanceChainNameMap_.size());
264 isInitialized_ = true;
265 }
266
InitEnhanceBuffer()267 int32_t AudioEnhanceChainManager::InitEnhanceBuffer()
268 {
269 std::lock_guard<std::mutex> lock(chainManagerMutex_);
270 uint32_t len = 0;
271 uint32_t lenEc = 0;
272 uint32_t lenMicRef = 0;
273 for (auto &[scode, chain] : sceneTypeToEnhanceChainMap_) {
274 if (chain) {
275 len = std::max(len, chain->GetAlgoBufferSize());
276 lenEc = std::max(lenEc, chain->GetAlgoBufferSizeEc());
277 lenMicRef = std::max(lenMicRef, chain->GetAlgoBufferSizeMicRef());
278 }
279 }
280 if (enhanceBuffer_ == nullptr) {
281 enhanceBuffer_ = std::make_unique<EnhanceBuffer>();
282 enhanceBuffer_->micBufferIn.resize(len);
283 enhanceBuffer_->micBufferOut.resize(len);
284 enhanceBuffer_->ecBuffer.resize(lenEc);
285 enhanceBuffer_->micRefBuffer.resize(lenMicRef);
286 AUDIO_INFO_LOG("enhanceBuffer_ init len:%{public}u lenEc:%{public}u lenMicRef:%{public}u",
287 len, lenEc, lenMicRef);
288 return SUCCESS;
289 }
290 if ((len > enhanceBuffer_->micBufferIn.size())) {
291 enhanceBuffer_->micBufferIn.resize(len);
292 enhanceBuffer_->micBufferOut.resize(len);
293 }
294 if (lenEc > enhanceBuffer_->ecBuffer.size()) {
295 enhanceBuffer_->ecBuffer.resize(lenEc);
296 }
297 if (lenMicRef > enhanceBuffer_->micRefBuffer.size()) {
298 enhanceBuffer_->micRefBuffer.resize(lenMicRef);
299 }
300 AUDIO_INFO_LOG("enhanceBuffer_ update len:%{public}u lenEc:%{public}u lenMicRef:%{public}u",
301 len, lenEc, lenMicRef);
302 return SUCCESS;
303 }
304
ParseSceneKeyCode(const uint64_t sceneKeyCode,std::string & sceneType,std::string & capturerDeviceStr,std::string & rendererDeviceStr)305 int32_t AudioEnhanceChainManager::ParseSceneKeyCode(const uint64_t sceneKeyCode, std::string &sceneType,
306 std::string &capturerDeviceStr, std::string &rendererDeviceStr)
307 {
308 uint32_t sceneCode = (sceneKeyCode & SCENE_TYPE_MASK) >> SCENE_TYPE_OFFSET;
309 AUDIO_INFO_LOG("sceneKeyCode = %{public}" PRIu64 ", sceneCode = %{public}u", sceneKeyCode, sceneCode);
310 AudioEnhanceScene scene = static_cast<AudioEnhanceScene>(sceneCode);
311 DeviceType capturerDevice = DEVICE_TYPE_INVALID;
312 const std::unordered_map<DeviceType, std::string> &supportDeviceType = GetSupportedDeviceType();
313 const std::unordered_map<AudioEnhanceScene, std::string> &audioEnhanceSupportedSceneTypes =
314 GetEnhanceSupportedSceneType();
315 auto item = audioEnhanceSupportedSceneTypes.find(scene);
316 if (item != audioEnhanceSupportedSceneTypes.end()) {
317 sceneType = item->second;
318 } else {
319 AUDIO_ERR_LOG("scene[%{public}d] not be supported", scene);
320 return ERROR;
321 }
322 uint32_t captureId = (sceneKeyCode & CAPTURER_ID_MASK) >> CAPTURER_ID_OFFSET;
323 uint32_t renderId = (sceneKeyCode & RENDERER_ID_MASK);
324 auto capItem = captureIdToDeviceMap_.find(captureId);
325 if (capItem != captureIdToDeviceMap_.end()) {
326 capturerDevice = capItem->second;
327 } else {
328 AUDIO_ERR_LOG("can't find captureId[%{public}u] in captureIdToDeviceMap_", captureId);
329 return ERROR;
330 }
331
332 DeviceType rendererDevice = renderIdToDeviceMap_[renderId];
333
334 auto deviceItem = supportDeviceType.find(capturerDevice);
335 if (deviceItem != supportDeviceType.end()) {
336 if ((capturerDevice == DEVICE_TYPE_INVALID) || (capturerDevice == DEVICE_TYPE_NONE)) {
337 capturerDeviceStr = "DEVICE_TYPE_MIC";
338 AUDIO_ERR_LOG("capturerDevice not availd");
339 } else {
340 capturerDeviceStr = deviceItem->second;
341 }
342 } else {
343 AUDIO_ERR_LOG("capturerDevice[%{public}d] not in supportDeviceType", capturerDevice);
344 return ERROR;
345 }
346 deviceItem = supportDeviceType.find(rendererDevice);
347 if (deviceItem != supportDeviceType.end()) {
348 rendererDeviceStr = deviceItem->second;
349 } else {
350 AUDIO_ERR_LOG("rendererDevice[%{public}d] not in supportDeviceType", rendererDevice);
351 return ERROR;
352 }
353 return SUCCESS;
354 }
355
CreateAudioEnhanceChainDynamic(const uint64_t sceneKeyCode,const AudioEnhanceDeviceAttr & deviceAttr)356 int32_t AudioEnhanceChainManager::CreateAudioEnhanceChainDynamic(const uint64_t sceneKeyCode,
357 const AudioEnhanceDeviceAttr &deviceAttr)
358 {
359 std::lock_guard<std::mutex> lock(chainManagerMutex_);
360 if (sceneTypeAndModeToEnhanceChainNameMap_.size() == 0) {
361 AUDIO_INFO_LOG("no algo on audio_framework");
362 return ERROR;
363 }
364
365 std::shared_ptr<AudioEnhanceChain> audioEnhanceChain = nullptr;
366 auto it = sceneTypeToEnhanceChainMap_.find(sceneKeyCode);
367 if (it != sceneTypeToEnhanceChainMap_.end() && it->second != nullptr) {
368 sceneTypeToEnhanceChainCountMap_[sceneKeyCode]++;
369 AUDIO_INFO_LOG("Now enhanceChain num is:%{public}u scenKey[%{public}" PRIu64 "] count: %{public}d", chainNum_,
370 sceneKeyCode, sceneTypeToEnhanceChainCountMap_[sceneKeyCode]);
371 audioEnhanceChain = it->second;
372 if (audioEnhanceChain->IsEmptyEnhanceHandles()) {
373 return ERROR;
374 }
375 return audioEnhanceChain->IsDefaultChain();
376 }
377 bool createFlag = false;
378 bool defaultFlag = false;
379 if (CreateEnhanceChainInner(audioEnhanceChain, sceneKeyCode, deviceAttr, createFlag, defaultFlag)) {
380 AUDIO_ERR_LOG("CreateEnhanceChainInner failed!");
381 return ERROR;
382 }
383 AUDIO_INFO_LOG("Now enhanceChain num is:%{public}u scenKey[%{public}" PRIu64 "] count: %{public}d", chainNum_,
384 sceneKeyCode, sceneTypeToEnhanceChainCountMap_[sceneKeyCode]);
385 // means map to default chain
386 if (!createFlag) {
387 return audioEnhanceChain->IsDefaultChain();
388 }
389 std::string effectChainName = GetEnhanceChainNameBySceneCode(sceneKeyCode, defaultFlag);
390 if (AddAudioEnhanceChainHandles(audioEnhanceChain, effectChainName) != SUCCESS) {
391 sceneTypeToEnhanceChainCountMap_.erase(sceneKeyCode);
392 sceneTypeToEnhanceChainMap_.erase(sceneKeyCode);
393 chainNum_--;
394 AUDIO_ERR_LOG("%{public}" PRIu64 " create failed.", sceneKeyCode);
395 return ERROR;
396 }
397 AUDIO_INFO_LOG("%{public}" PRIu64 " create success", sceneKeyCode);
398 return audioEnhanceChain->IsDefaultChain();
399 }
400
GetEnhanceChainNameBySceneCode(const uint64_t sceneKeyCode,const bool defaultFlag)401 std::string AudioEnhanceChainManager::GetEnhanceChainNameBySceneCode(const uint64_t sceneKeyCode,
402 const bool defaultFlag)
403 {
404 std::string enhanceNone = AUDIO_ENHANCE_SUPPORTED_SCENE_MODES.find(ENHANCE_NONE)->second;
405 std::string sceneType = "";
406 std::string capturerDevice = "";
407 std::string rendererDeivce = "";
408 if (ParseSceneKeyCode(sceneKeyCode, sceneType, capturerDevice, rendererDeivce) != SUCCESS) {
409 return enhanceNone;
410 }
411 if (defaultFlag) {
412 AUDIO_INFO_LOG("sceneType %{public}s set to defaultScene %{public}s", sceneType.c_str(),
413 defaultScene_.c_str());
414 sceneType = defaultScene_;
415 }
416 // first check specific device, then check no device
417 std::string enhanceChainKey = sceneType + "_&_" + "ENHANCE_DEFAULT" + "_&_" + capturerDevice;
418 auto mapIter = sceneTypeAndModeToEnhanceChainNameMap_.find(enhanceChainKey);
419 if (mapIter == sceneTypeAndModeToEnhanceChainNameMap_.end()) {
420 enhanceChainKey = sceneType + "_&_" + "ENHANCE_DEFAULT";
421 mapIter = sceneTypeAndModeToEnhanceChainNameMap_.find(enhanceChainKey);
422 }
423 if (mapIter == sceneTypeAndModeToEnhanceChainNameMap_.end() ||
424 !enhanceChainToEnhancesMap_.count(mapIter->second)) {
425 AUDIO_ERR_LOG("EnhanceChain key [%{public}s] does not exist, auto set to %{public}s",
426 enhanceChainKey.c_str(), enhanceNone.c_str());
427 return enhanceNone;
428 } else {
429 return mapIter->second;
430 }
431 }
432
GetDeviceNameByCaptureId(const uint32_t captureId,std::string & deviceName)433 void AudioEnhanceChainManager::GetDeviceNameByCaptureId(const uint32_t captureId, std::string &deviceName)
434 {
435 auto item = captureIdToDeviceNameMap_.find(captureId);
436 if (item != captureIdToDeviceNameMap_.end()) {
437 deviceName = captureIdToDeviceNameMap_[captureId];
438 }
439 }
440
CreateEnhanceChainInner(std::shared_ptr<AudioEnhanceChain> & audioEnhanceChain,const uint64_t sceneKeyCode,const AudioEnhanceDeviceAttr & deviceAttr,bool & createFlag,bool & defaultFlag)441 int32_t AudioEnhanceChainManager::CreateEnhanceChainInner(std::shared_ptr<AudioEnhanceChain> &audioEnhanceChain,
442 const uint64_t sceneKeyCode, const AudioEnhanceDeviceAttr &deviceAttr, bool &createFlag, bool &defaultFlag)
443 {
444 std::string sceneType = "";
445 std::string capturerDevice = "";
446 std::string rendererDeivce = "";
447 if (ParseSceneKeyCode(sceneKeyCode, sceneType, capturerDevice, rendererDeivce) != SUCCESS) {
448 AUDIO_ERR_LOG("ParseSceneKeyCode failed!!!");
449 return ERROR;
450 }
451 uint32_t captureId = (sceneKeyCode & CAPTURER_ID_MASK) >> 8;
452 std::string deviceName = "";
453 GetDeviceNameByCaptureId(captureId, deviceName);
454 createFlag = true;
455 // normal scene
456 if (priorSceneSet_.find(sceneType) == priorSceneSet_.end()) {
457 // effect instance exceeded
458 if (captureId2SceneCount_[captureId] == normalSceneLimit_) {
459 // default enhance chain not exsist
460 if (captureId2DefaultChainCount_[captureId] != 0) {
461 createFlag = false;
462 audioEnhanceChain = captureId2DefaultChain_[captureId];
463 // add sceneType change after integration supported
464 AUDIO_INFO_LOG("sceneKey[%{public}" PRIu64 "] defaultChainExsist", sceneKeyCode);
465 } else {
466 AudioEnhanceParamAdapter algoParam = {(uint32_t)isMute_, (uint32_t)(systemVol_ * VOLUME_FACTOR),
467 foldState_, capturerDevice, rendererDeivce, defaultScene_, deviceName};
468 audioEnhanceChain = std::make_shared<AudioEnhanceChain>(defaultScene_, algoParam, deviceAttr, 1);
469 captureId2DefaultChain_[captureId] = audioEnhanceChain;
470 AUDIO_INFO_LOG("captureId %{public}u defaultScene chain not exsist, create it", captureId);
471 chainNum_++;
472 }
473 captureId2DefaultChainCount_[captureId]++;
474 defaultFlag = true;
475 } else {
476 AudioEnhanceParamAdapter algoParam = {(uint32_t)isMute_, (uint32_t)(systemVol_ * VOLUME_FACTOR),
477 foldState_, capturerDevice, rendererDeivce, sceneType, deviceName};
478 audioEnhanceChain = std::make_shared<AudioEnhanceChain>(sceneType, algoParam, deviceAttr, 0);
479 captureId2SceneCount_[captureId]++;
480 AUDIO_INFO_LOG("captureId %{public}u create normalScene %{public}s chain", captureId, sceneType.c_str());
481 chainNum_++;
482 }
483 } else {
484 AudioEnhanceParamAdapter algoParam = {(uint32_t)isMute_, (uint32_t)(systemVol_ * VOLUME_FACTOR),
485 foldState_, capturerDevice, rendererDeivce, sceneType, deviceName};
486 audioEnhanceChain = std::make_shared<AudioEnhanceChain>(sceneType, algoParam, deviceAttr, 0);
487 AUDIO_INFO_LOG("priorScene %{public}s chain created", sceneType.c_str());
488 chainNum_++;
489 }
490 CHECK_AND_RETURN_RET_LOG(audioEnhanceChain != nullptr, ERROR, "AudioEnhanceChain construct failed.");
491 sceneTypeToEnhanceChainMap_[sceneKeyCode] = audioEnhanceChain;
492 sceneTypeToEnhanceChainCountMap_[sceneKeyCode] = 1;
493 return SUCCESS;
494 }
495
AddAudioEnhanceChainHandles(std::shared_ptr<AudioEnhanceChain> & audioEnhanceChain,const std::string & enhanceChain)496 int32_t AudioEnhanceChainManager::AddAudioEnhanceChainHandles(std::shared_ptr<AudioEnhanceChain> &audioEnhanceChain,
497 const std::string &enhanceChain)
498 {
499 for (std::string enhance : enhanceChainToEnhancesMap_[enhanceChain]) {
500 AudioEffectHandle handle = nullptr;
501 AudioEffectDescriptor descriptor;
502 descriptor.libraryName = enhanceToLibraryNameMap_[enhance];
503 descriptor.effectName = enhance;
504
505 AUDIO_INFO_LOG("libraryName: %{public}s effectName:%{public}s",
506 descriptor.libraryName.c_str(), descriptor.effectName.c_str());
507 int32_t ret = enhanceToLibraryEntryMap_[enhance]->audioEffectLibHandle->createEffect(descriptor, &handle);
508 CHECK_AND_CONTINUE_LOG(ret == 0, "EnhanceToLibraryEntryMap[%{public}s] createEffect fail",
509 enhance.c_str());
510 auto propIter = enhancePropertyMap_.find(enhance);
511 ret = audioEnhanceChain->AddEnhanceHandle(handle, enhanceToLibraryEntryMap_[enhance]->audioEffectLibHandle,
512 enhance, propIter == enhancePropertyMap_.end() ? "" : propIter->second);
513 if (ret != SUCCESS) {
514 AUDIO_ERR_LOG("AddEnhanceHandle fail");
515 enhanceToLibraryEntryMap_[enhance]->audioEffectLibHandle->releaseEffect(handle);
516 }
517 }
518
519 if (audioEnhanceChain->IsEmptyEnhanceHandles()) {
520 AUDIO_ERR_LOG("EnhanceChain is empty, copy bufIn to bufOut like EFFECT_NONE mode");
521 return ERROR;
522 }
523 return SUCCESS;
524 }
525
FreeEnhanceBuffer()526 int32_t AudioEnhanceChainManager::FreeEnhanceBuffer()
527 {
528 if (enhanceBuffer_ != nullptr) {
529 std::vector<uint8_t>().swap(enhanceBuffer_->ecBuffer);
530 std::vector<uint8_t>().swap(enhanceBuffer_->micBufferIn);
531 std::vector<uint8_t>().swap(enhanceBuffer_->micBufferOut);
532 std::vector<uint8_t>().swap(enhanceBuffer_->micRefBuffer);
533 enhanceBuffer_ = nullptr;
534 AUDIO_INFO_LOG("release EnhanceBuffer success");
535 }
536 return SUCCESS;
537 }
538
ReleaseAudioEnhanceChainDynamic(const uint64_t sceneKeyCode)539 int32_t AudioEnhanceChainManager::ReleaseAudioEnhanceChainDynamic(const uint64_t sceneKeyCode)
540 {
541 std::lock_guard<std::mutex> lock(chainManagerMutex_);
542 CHECK_AND_RETURN_RET_LOG(isInitialized_, ERROR, "has not been initialized");
543 if (sceneTypeAndModeToEnhanceChainNameMap_.size() == 0) {
544 AUDIO_INFO_LOG("no algo on audio_framework");
545 return ERROR;
546 }
547
548 auto chainMapIter = sceneTypeToEnhanceChainMap_.find(sceneKeyCode);
549 if (chainMapIter == sceneTypeToEnhanceChainMap_.end() || chainMapIter->second == nullptr) {
550 AUDIO_INFO_LOG("Now enhanceChain num is:%{public}u cannot find scenKey[%{public}" PRIu64 "]",
551 chainNum_, sceneKeyCode);
552 sceneTypeToEnhanceChainCountMap_.erase(sceneKeyCode);
553 sceneTypeToEnhanceChainMap_.erase(sceneKeyCode);
554 return SUCCESS;
555 }
556 auto chainCountIter = sceneTypeToEnhanceChainCountMap_.find(sceneKeyCode);
557 if (chainCountIter->second > 1) {
558 chainCountIter->second--;
559 AUDIO_INFO_LOG("Now enhanceChain num is:%{public}u scenKey[%{public}" PRIu64 "] count: %{public}d", chainNum_,
560 sceneKeyCode, chainCountIter->second);
561 return SUCCESS;
562 }
563 if (DeleteEnhanceChainInner(chainMapIter->second, sceneKeyCode) != SUCCESS) {
564 return ERROR;
565 }
566 AUDIO_INFO_LOG("release %{public}" PRIu64, sceneKeyCode);
567 if (sceneTypeToEnhanceChainMap_.size() == 0) {
568 FreeEnhanceBuffer();
569 }
570 return SUCCESS;
571 }
572
DeleteEnhanceChainInner(std::shared_ptr<AudioEnhanceChain> & audioEnhanceChain,const uint64_t sceneKeyCode)573 int32_t AudioEnhanceChainManager::DeleteEnhanceChainInner(std::shared_ptr<AudioEnhanceChain> &audioEnhanceChain,
574 const uint64_t sceneKeyCode)
575 {
576 std::string sceneType = "";
577 std::string capturerDevice = "";
578 std::string rendererDeivce = "";
579 if (ParseSceneKeyCode(sceneKeyCode, sceneType, capturerDevice, rendererDeivce) != SUCCESS) {
580 AUDIO_ERR_LOG("ParseSceneKeyCode failed!!!");
581 return ERROR;
582 }
583 uint32_t captureId = (sceneKeyCode & CAPTURER_ID_MASK) >> 8;
584 // not prior scene
585 if (priorSceneSet_.find(sceneType) == priorSceneSet_.end()) {
586 // default chain
587 if (audioEnhanceChain->IsDefaultChain()) {
588 auto &defaultChainCount = captureId2DefaultChainCount_.find(captureId)->second;
589 defaultChainCount--;
590 // delete default chain
591 if (!defaultChainCount) {
592 captureId2DefaultChain_[captureId] = nullptr;
593 chainNum_--;
594 AUDIO_INFO_LOG("sceneKey[%{public}" PRIu64 "] defaultScene chain release", sceneKeyCode);
595 } else {
596 AUDIO_INFO_LOG("sceneKey[%{public}" PRIu64 "] defaultScene chain count:%{public}u", sceneKeyCode,
597 defaultChainCount);
598 }
599 } else {
600 captureId2SceneCount_[captureId]--;
601 chainNum_--;
602 AUDIO_INFO_LOG("captureId %{public}u normalScene %{public}s chain release", captureId, sceneType.c_str());
603 }
604 } else {
605 chainNum_--;
606 AUDIO_INFO_LOG("priorScene %{public}s chain release", sceneType.c_str());
607 }
608 sceneTypeToEnhanceChainCountMap_.erase(sceneKeyCode);
609 sceneTypeToEnhanceChainMap_.erase(sceneKeyCode);
610 AUDIO_INFO_LOG("Now enhanceChain num is:%{public}u sceneKey[%{public}" PRIu64 "] count: %{public}d", chainNum_,
611 sceneKeyCode, 0);
612 return SUCCESS;
613 }
614
ExistAudioEnhanceChain(const uint64_t sceneKeyCode)615 bool AudioEnhanceChainManager::ExistAudioEnhanceChain(const uint64_t sceneKeyCode)
616 {
617 std::lock_guard<std::mutex> lock(chainManagerMutex_);
618 CHECK_AND_RETURN_RET_LOG(isInitialized_, false, "has not been initialized");
619
620 if (!sceneTypeToEnhanceChainMap_.count(sceneKeyCode)) {
621 return false;
622 }
623 auto audioEnhanceChain = sceneTypeToEnhanceChainMap_[sceneKeyCode];
624 CHECK_AND_RETURN_RET_LOG(audioEnhanceChain != nullptr, false,
625 "null sceneTypeToEnhanceChainMap_[%{public}" PRIu64 "]", sceneKeyCode);
626 return !audioEnhanceChain->IsEmptyEnhanceHandles();
627 }
628
AudioEnhanceChainGetAlgoConfig(const uint64_t sceneKeyCode,AudioBufferConfig & micConfig,AudioBufferConfig & ecConfig,AudioBufferConfig & micRefConfig)629 int32_t AudioEnhanceChainManager::AudioEnhanceChainGetAlgoConfig(const uint64_t sceneKeyCode,
630 AudioBufferConfig &micConfig, AudioBufferConfig &ecConfig, AudioBufferConfig &micRefConfig)
631 {
632 std::lock_guard<std::mutex> lock(chainManagerMutex_);
633 CHECK_AND_RETURN_RET_LOG(isInitialized_, ERROR, "has not been initialized");
634 if (!sceneTypeToEnhanceChainMap_.count(sceneKeyCode)) {
635 AUDIO_ERR_LOG("sceneTypeToEnhanceChainMap_ have not %{public}" PRIu64, sceneKeyCode);
636 return ERROR;
637 }
638 auto audioEnhanceChain = sceneTypeToEnhanceChainMap_[sceneKeyCode];
639 CHECK_AND_RETURN_RET_LOG(audioEnhanceChain != nullptr, ERROR, "[%{public}" PRIu64 "] get config faild",
640 sceneKeyCode);
641 audioEnhanceChain->GetAlgoConfig(micConfig, ecConfig, micRefConfig);
642 return SUCCESS;
643 }
644
IsEmptyEnhanceChain()645 bool AudioEnhanceChainManager::IsEmptyEnhanceChain()
646 {
647 std::lock_guard<std::mutex> lock(chainManagerMutex_);
648 CHECK_AND_RETURN_RET_LOG(isInitialized_, ERROR, "has not been initialized");
649 if (sceneTypeAndModeToEnhanceChainNameMap_.size() == 0) {
650 return true;
651 }
652 for (auto &[scode, chain] : sceneTypeToEnhanceChainMap_) {
653 if (chain != nullptr && !chain->IsEmptyEnhanceHandles()) {
654 return false;
655 }
656 }
657 return true;
658 }
659
CopyToEnhanceBuffer(void * data,uint32_t length)660 int32_t AudioEnhanceChainManager::CopyToEnhanceBuffer(void *data, uint32_t length)
661 {
662 std::lock_guard<std::mutex> lock(chainManagerMutex_);
663 if (enhanceBuffer_ == nullptr) {
664 return ERROR;
665 }
666 AUDIO_DEBUG_LOG("length: %{public}zu chunk length: %{public}u", enhanceBuffer_->micBufferIn.size(), length);
667 CHECK_AND_RETURN_RET_LOG(memcpy_s(enhanceBuffer_->micBufferIn.data(), enhanceBuffer_->micBufferIn.size(), data,
668 length) == 0, ERROR, "memcpy error in data to enhanceBuffer->micBufferIn");
669 return SUCCESS;
670 }
671
CopyEcToEnhanceBuffer(void * data,uint32_t length)672 int32_t AudioEnhanceChainManager::CopyEcToEnhanceBuffer(void *data, uint32_t length)
673 {
674 std::lock_guard<std::mutex> lock(chainManagerMutex_);
675 if (enhanceBuffer_ == nullptr) {
676 return ERROR;
677 }
678 AUDIO_DEBUG_LOG("lengthEc: %{public}zu chunkEc length: %{public}u", enhanceBuffer_->ecBuffer.size(), length);
679 CHECK_AND_RETURN_RET_LOG(memcpy_s(enhanceBuffer_->ecBuffer.data(), enhanceBuffer_->ecBuffer.size(), data,
680 length) == 0, ERROR, "memcpy error in data to enhanceBuffer->ecBuffer");
681 return SUCCESS;
682 }
683
CopyMicRefToEnhanceBuffer(void * data,uint32_t length)684 int32_t AudioEnhanceChainManager::CopyMicRefToEnhanceBuffer(void *data, uint32_t length)
685 {
686 std::lock_guard<std::mutex> lock(chainManagerMutex_);
687 if (enhanceBuffer_ == nullptr) {
688 return ERROR;
689 }
690 AUDIO_DEBUG_LOG("lengthMicRef: %{public}zu chunkMicRef length: %{public}u", enhanceBuffer_->micRefBuffer.size(),
691 length);
692 CHECK_AND_RETURN_RET_LOG(memcpy_s(enhanceBuffer_->micRefBuffer.data(), enhanceBuffer_->micRefBuffer.size(),
693 data, length) == 0, ERROR, "memcpy error in data to enhanceBuffer->micBufferIn");
694 return SUCCESS;
695 }
696
CopyFromEnhanceBuffer(void * data,uint32_t length)697 int32_t AudioEnhanceChainManager::CopyFromEnhanceBuffer(void *data, uint32_t length)
698 {
699 std::lock_guard<std::mutex> lock(chainManagerMutex_);
700 if (enhanceBuffer_ == nullptr) {
701 return ERROR;
702 }
703 if (length > enhanceBuffer_->micBufferOut.size()) {
704 return ERROR;
705 }
706 CHECK_AND_RETURN_RET_LOG(memcpy_s(data, length, enhanceBuffer_->micBufferOut.data(), length) == 0,
707 ERROR, "memcpy error in micBufferOut to data");
708 return SUCCESS;
709 }
710
ApplyAudioEnhanceChain(const uint64_t sceneKeyCode,uint32_t length)711 int32_t AudioEnhanceChainManager::ApplyAudioEnhanceChain(const uint64_t sceneKeyCode, uint32_t length)
712 {
713 std::lock_guard<std::mutex> lock(chainManagerMutex_);
714 CHECK_AND_RETURN_RET_LOG(enhanceBuffer_ != nullptr, ERROR, "enhance buffer is null");
715 auto chainMapIter = sceneTypeToEnhanceChainMap_.find(sceneKeyCode);
716 if (chainMapIter == sceneTypeToEnhanceChainMap_.end() || chainMapIter->second == nullptr) {
717 CHECK_AND_RETURN_RET_LOG(memcpy_s(enhanceBuffer_->micBufferOut.data(), enhanceBuffer_->micBufferOut.size(),
718 enhanceBuffer_->micBufferIn.data(), length) == 0, ERROR, "memcpy error in apply enhance");
719 AUDIO_ERR_LOG("Can not find %{public}" PRIu64 " in sceneTypeToEnhanceChainMap_", sceneKeyCode);
720 return ERROR;
721 }
722 auto audioEnhanceChain = chainMapIter->second;
723 if (audioEnhanceChain->ApplyEnhanceChain(enhanceBuffer_, length) != SUCCESS) {
724 AUDIO_ERR_LOG("Apply %{public}" PRIu64 " failed.", sceneKeyCode);
725 return ERROR;
726 }
727 AUDIO_DEBUG_LOG("Apply %{public}" PRIu64 " success", sceneKeyCode);
728 return SUCCESS;
729 }
730
UpdatePropertyAndSendToAlgo(const DeviceType & inputDevice)731 int32_t AudioEnhanceChainManager::UpdatePropertyAndSendToAlgo(const DeviceType &inputDevice)
732 {
733 UpdateEnhancePropertyMapFromDb(inputDevice);
734 for (const auto &[enhance, prop] : enhancePropertyMap_) {
735 for (const auto &[sceneType, enhanceChain] : sceneTypeToEnhanceChainMap_) {
736 if (enhanceChain) {
737 int32_t ret = enhanceChain->SetEnhanceProperty(enhance, prop);
738 CHECK_AND_RETURN_RET_LOG(ret == 0, ERR_OPERATION_FAILED, "set property failed");
739 }
740 }
741 }
742 return SUCCESS;
743 }
744
SetInputDevice(const uint32_t & captureId,const DeviceType & inputDevice,const std::string & deviceName)745 int32_t AudioEnhanceChainManager::SetInputDevice(const uint32_t &captureId, const DeviceType &inputDevice,
746 const std::string &deviceName)
747 {
748 const std::unordered_map<DeviceType, std::string> &supportDeviceType = GetSupportedDeviceType();
749 std::lock_guard<std::mutex> lock(chainManagerMutex_);
750 auto item = captureIdToDeviceMap_.find(captureId);
751 if (item == captureIdToDeviceMap_.end()) {
752 captureIdToDeviceMap_[captureId] = inputDevice;
753 AUDIO_INFO_LOG("set new inputdevice, captureId: %{public}d, inputDevice: %{public}d", captureId, inputDevice);
754 return SUCCESS;
755 }
756 if (item->second == inputDevice) {
757 AUDIO_INFO_LOG("set same device, captureId: %{public}d, inputDevice: %{public}d", captureId, inputDevice);
758 return SUCCESS;
759 }
760 // item->second != inputDevice
761 captureIdToDeviceMap_[captureId] = inputDevice;
762 captureIdToDeviceNameMap_.insert_or_assign(captureId, deviceName);
763 std::string inputDeviceStr = "";
764 auto deviceItem = supportDeviceType.find(inputDevice);
765 if (deviceItem != supportDeviceType.end()) {
766 inputDeviceStr = deviceItem->second;
767 } else {
768 return ERROR;
769 }
770 for (auto &[sceneKeyCode, chain] : sceneTypeToEnhanceChainMap_) {
771 uint32_t tempId = (sceneKeyCode & CAPTURER_ID_MASK) >> 8;
772 if ((tempId == captureId) && chain) {
773 if (chain->SetInputDevice(inputDeviceStr, deviceName) != SUCCESS) {
774 AUDIO_ERR_LOG("chain:%{public}u set input device failed", tempId);
775 }
776 }
777 }
778 if (UpdatePropertyAndSendToAlgo(inputDevice) != SUCCESS) {
779 return ERROR;
780 }
781 AUDIO_INFO_LOG("success, captureId: %{public}d, inputDevice: %{public}d deviceName:%{public}s",
782 captureId, inputDevice, deviceName.c_str());
783 return SUCCESS;
784 }
785
SetOutputDevice(const uint32_t & renderId,const DeviceType & outputDevice)786 int32_t AudioEnhanceChainManager::SetOutputDevice(const uint32_t &renderId, const DeviceType &outputDevice)
787 {
788 std::lock_guard<std::mutex> lock(chainManagerMutex_);
789 renderIdToDeviceMap_.insert_or_assign(renderId, outputDevice);
790 AUDIO_INFO_LOG("success, renderId: %{public}d, outputDevice: %{public}d", renderId, outputDevice);
791 return SUCCESS;
792 }
793
SetVolumeInfo(const AudioVolumeType & volumeType,const float & systemVol)794 int32_t AudioEnhanceChainManager::SetVolumeInfo(const AudioVolumeType &volumeType, const float &systemVol)
795 {
796 volumeType_ = volumeType;
797 systemVol_ = systemVol;
798 if (sceneTypeAndModeToEnhanceChainNameMap_.size() == 0 || sceneTypeToEnhanceChainMap_.size() == 0) {
799 return SUCCESS;
800 }
801 AUDIO_DEBUG_LOG("success, volumeType: %{public}d, systemVol: %{public}f", volumeType_, systemVol_);
802 return SUCCESS;
803 }
804
SetMicrophoneMuteInfo(const bool & isMute)805 int32_t AudioEnhanceChainManager::SetMicrophoneMuteInfo(const bool &isMute)
806 {
807 isMute_ = isMute;
808 std::lock_guard<std::mutex> lock(chainManagerMutex_);
809 int32_t ret = 0;
810 for (const auto &[sceneType, enhanceChain] : sceneTypeToEnhanceChainMap_) {
811 if (enhanceChain) {
812 ret = enhanceChain->SetEnhanceParam(isMute_, systemVol_);
813 CHECK_AND_RETURN_RET_LOG(ret == 0, ERROR,
814 "[%{public}" PRIu64 "] set mute:%{public}d vol:%{public}f failed", sceneType, isMute_, systemVol_);
815 }
816 }
817 AUDIO_INFO_LOG("success, isMute: %{public}d", isMute_);
818 return SUCCESS;
819 }
820
SetStreamVolumeInfo(const uint32_t & sessionId,const float & streamVol)821 int32_t AudioEnhanceChainManager::SetStreamVolumeInfo(const uint32_t &sessionId, const float &streamVol)
822 {
823 sessionId_ = sessionId;
824 streamVol_ = streamVol;
825 if (sceneTypeAndModeToEnhanceChainNameMap_.size() == 0 || sceneTypeToEnhanceChainMap_.size() == 0) {
826 return SUCCESS;
827 }
828 AUDIO_DEBUG_LOG("success, sessionId: %{public}d, streamVol: %{public}f", sessionId_, streamVol_);
829 return SUCCESS;
830 }
831
SetAudioEnhanceProperty(const AudioEffectPropertyArrayV3 & propertyArray,DeviceType deviceType)832 int32_t AudioEnhanceChainManager::SetAudioEnhanceProperty(const AudioEffectPropertyArrayV3 &propertyArray,
833 DeviceType deviceType)
834 {
835 int32_t ret = SUCCESS;
836 std::lock_guard<std::mutex> lock(chainManagerMutex_);
837 for (const auto &property : propertyArray.property) {
838 std::string key = "";
839 enhancePropertyMap_.insert_or_assign(property.name, property.category);
840 if (withDeviceEnhances_.find(property.name) == withDeviceEnhances_.end()) {
841 key = property.name;
842 } else {
843 std::string deviceTypeName = "";
844 GetDeviceTypeName(deviceType, deviceTypeName);
845 key = property.name + "_&_" + deviceTypeName;
846 }
847 ret = WriteEnhancePropertyToDb(key, property.category);
848 if (ret != SUCCESS) {
849 AUDIO_ERR_LOG("fail, WriteEnhancePropertyToDb, ErrCode: %{public}d", ret);
850 continue;
851 }
852 SetAudioEnhancePropertyToChains(property);
853 }
854 return SUCCESS;
855 }
856
SetAudioEnhancePropertyToChains(AudioEffectPropertyV3 property)857 int32_t AudioEnhanceChainManager::SetAudioEnhancePropertyToChains(AudioEffectPropertyV3 property)
858 {
859 int32_t ret = SUCCESS;
860 for (const auto &[sceneType, enhanceChain] : sceneTypeToEnhanceChainMap_) {
861 if (enhanceChain) {
862 AUDIO_DEBUG_LOG("effectClass->name %{public}s effectProp->category %{public}s",
863 property.name.c_str(), property.category.c_str());
864 ret = enhanceChain->SetEnhanceProperty(property.name, property.category);
865 CHECK_AND_CONTINUE_LOG(ret == SUCCESS, "set property failed[%{public}d]", ret);
866 }
867 }
868 return ret;
869 }
870
SetAudioEnhanceProperty(const AudioEnhancePropertyArray & propertyArray,DeviceType deviceType)871 int32_t AudioEnhanceChainManager::SetAudioEnhanceProperty(const AudioEnhancePropertyArray &propertyArray,
872 DeviceType deviceType)
873 {
874 int32_t ret = SUCCESS;
875 std::lock_guard<std::mutex> lock(chainManagerMutex_);
876 for (const auto &property : propertyArray.property) {
877 std::string key = "";
878 enhancePropertyMap_.insert_or_assign(property.enhanceClass, property.enhanceProp);
879 if (withDeviceEnhances_.find(property.enhanceClass) == withDeviceEnhances_.end()) {
880 key = property.enhanceClass;
881 } else {
882 std::string deviceTypeName = "";
883 GetDeviceTypeName(deviceType, deviceTypeName);
884 key = property.enhanceClass + "_&_" + deviceTypeName;
885 }
886 ret = WriteEnhancePropertyToDb(key, property.enhanceProp);
887 if (ret != SUCCESS) {
888 AUDIO_ERR_LOG("fail, WriteEnhancePropertyToDb, ErrCode: %{public}d", ret);
889 continue;
890 }
891 SetAudioEnhancePropertyToChains(property);
892 }
893 return SUCCESS;
894 }
895
SetAudioEnhancePropertyToChains(AudioEnhanceProperty property)896 int32_t AudioEnhanceChainManager::SetAudioEnhancePropertyToChains(AudioEnhanceProperty property)
897 {
898 int32_t ret = SUCCESS;
899 for (const auto &[sceneType, enhanceChain] : sceneTypeToEnhanceChainMap_) {
900 if (enhanceChain) {
901 ret = enhanceChain->SetEnhanceProperty(property.enhanceClass, property.enhanceProp);
902 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ERR_OPERATION_FAILED, "set property failed");
903 }
904 }
905 return ret;
906 }
907
WriteEnhancePropertyToDb(const std::string & key,const std::string & property)908 int32_t AudioEnhanceChainManager::WriteEnhancePropertyToDb(const std::string &key, const std::string &property)
909 {
910 AudioSettingProvider &settingProvider = AudioSettingProvider::GetInstance(AUDIO_POLICY_SERVICE_ID);
911 CHECK_AND_RETURN_RET_LOG(settingProvider.CheckOsAccountReady(), ERROR, "os account not ready");
912 ErrCode ret = settingProvider.PutStringValue(key, property, "system");
913 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ERR_OPERATION_FAILED, "Write Enhance Property to Database failed");
914 AUDIO_INFO_LOG("success, write Enhance_&_DeviceType:%{public}s is Property:%{public}s to Database",
915 key.c_str(), property.c_str());
916 return SUCCESS;
917 }
918
GetDeviceTypeName(DeviceType deviceType,std::string & deviceName)919 void AudioEnhanceChainManager::GetDeviceTypeName(DeviceType deviceType, std::string &deviceName)
920 {
921 const std::unordered_map<DeviceType, std::string> &supportDeviceType = GetSupportedDeviceType();
922 auto item = supportDeviceType.find(deviceType);
923 if (item != supportDeviceType.end()) {
924 deviceName = item->second;
925 }
926 }
927
GetAudioEnhanceProperty(AudioEffectPropertyArrayV3 & propertyArray,DeviceType deviceType)928 int32_t AudioEnhanceChainManager::GetAudioEnhanceProperty(AudioEffectPropertyArrayV3 &propertyArray,
929 DeviceType deviceType)
930 {
931 std::lock_guard<std::mutex> lock(chainManagerMutex_);
932 propertyArray.property.clear();
933 if (deviceType != DEVICE_TYPE_NONE) {
934 UpdateEnhancePropertyMapFromDb(deviceType);
935 }
936 for (const auto &[effect, prop] : enhancePropertyMap_) {
937 if (!prop.empty()) {
938 AUDIO_DEBUG_LOG("effect->name %{public}s prop->category %{public}s", effect.c_str(), prop.c_str());
939 propertyArray.property.emplace_back(AudioEffectPropertyV3{effect, prop, CAPTURE_EFFECT_FLAG});
940 }
941 }
942 return SUCCESS;
943 }
944
GetAudioEnhanceProperty(AudioEnhancePropertyArray & propertyArray,DeviceType deviceType)945 int32_t AudioEnhanceChainManager::GetAudioEnhanceProperty(AudioEnhancePropertyArray &propertyArray,
946 DeviceType deviceType)
947 {
948 std::lock_guard<std::mutex> lock(chainManagerMutex_);
949 propertyArray.property.clear();
950 if (deviceType != DEVICE_TYPE_NONE) {
951 UpdateEnhancePropertyMapFromDb(deviceType);
952 }
953 for (const auto &[effect, prop] : enhancePropertyMap_) {
954 if (!prop.empty()) {
955 propertyArray.property.emplace_back(AudioEnhanceProperty{effect, prop});
956 AUDIO_INFO_LOG("effect %{public}s is now %{public}s mode",
957 effect.c_str(), prop.c_str());
958 }
959 }
960 return SUCCESS;
961 }
962
ApplyAudioEnhanceChainDefault(const uint32_t captureId,uint32_t length)963 int32_t AudioEnhanceChainManager::ApplyAudioEnhanceChainDefault(const uint32_t captureId, uint32_t length)
964 {
965 std::lock_guard<std::mutex> lock(chainManagerMutex_);
966 CHECK_AND_RETURN_RET_LOG(enhanceBuffer_ != nullptr, ERROR, "enhance buffer is null");
967 auto chainMapIter = captureId2DefaultChain_.find(captureId);
968 if (chainMapIter == captureId2DefaultChain_.end() || chainMapIter->second == nullptr) {
969 CHECK_AND_RETURN_RET_LOG(memcpy_s(enhanceBuffer_->micBufferOut.data(), enhanceBuffer_->micBufferOut.size(),
970 enhanceBuffer_->micBufferIn.data(), length) == 0, ERROR, "memcpy error in apply enhance");
971 AUDIO_ERR_LOG("Can not find %{public}u in captureId2DefaultChain_", captureId);
972 return ERROR;
973 }
974 auto audioEnhanceChain = chainMapIter->second;
975 if (audioEnhanceChain->ApplyEnhanceChain(enhanceBuffer_, length) != SUCCESS) {
976 AUDIO_ERR_LOG("Apply default chain failed with captureId %{public}u.", captureId);
977 return ERROR;
978 }
979 AUDIO_DEBUG_LOG("Apply default chain success with captureId %{public}u.", captureId);
980 return SUCCESS;
981 }
982
UpdateExtraSceneType(const std::string & mainkey,const std::string & subkey,const std::string & extraSceneType)983 void AudioEnhanceChainManager::UpdateExtraSceneType(const std::string &mainkey, const std::string &subkey,
984 const std::string &extraSceneType)
985 {
986 std::lock_guard<std::mutex> lock(chainManagerMutex_);
987 if (mainkey == MAINKEY_DEVICE_STATUS && subkey == SUBKEY_FOLD_STATE) {
988 AUDIO_INFO_LOG("Set fold state: %{public}s to arm", extraSceneType.c_str());
989 uint32_t tempState = 0;
990 auto result = std::from_chars(extraSceneType.data(), extraSceneType.data() + extraSceneType.size(), tempState);
991 if (result.ec == std::errc() && result.ptr == (extraSceneType.data() + extraSceneType.size())) {
992 foldState_ = tempState;
993 } else {
994 AUDIO_ERR_LOG("extraSceneType: %{public}s is invalid", extraSceneType.c_str());
995 return;
996 }
997
998 for (const auto &[sceneType, enhanceChain] : sceneTypeToEnhanceChainMap_) {
999 if (enhanceChain == nullptr) {
1000 continue;
1001 }
1002 if (enhanceChain->SetFoldState(foldState_) != SUCCESS) {
1003 AUDIO_WARNING_LOG("Set fold state to enhance chain failed");
1004 continue;
1005 }
1006 }
1007 } else {
1008 AUDIO_INFO_LOG("UpdateExtraSceneType failed, mainkey is %{public}s, subkey is %{public}s, "
1009 "extraSceneType is %{public}s", mainkey.c_str(), subkey.c_str(), extraSceneType.c_str());
1010 return;
1011 }
1012 }
1013
SendInitCommand()1014 int32_t AudioEnhanceChainManager::SendInitCommand()
1015 {
1016 std::lock_guard<std::mutex> lock(chainManagerMutex_);
1017 int32_t ret = 0;
1018 for (const auto &[sceneType, enhanceChain] : sceneTypeToEnhanceChainMap_) {
1019 if (enhanceChain) {
1020 ret = enhanceChain->InitCommand();
1021 CHECK_AND_RETURN_RET_LOG(ret == 0, ERROR, "[%{public}" PRIu64 "] set init enhance command failed",
1022 sceneType);
1023 }
1024 }
1025 AUDIO_INFO_LOG("SendInitCommand success");
1026 return SUCCESS;
1027 }
1028 } // namespace AudioStandard
1029 } // namespace OHOS
1030