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 "AudioEnhanceChainAdapter"
18
19 #include "audio_enhance_chain_adapter.h"
20
21 #include <algorithm>
22 #include <map>
23
24 #include "audio_effect_log.h"
25 #include "audio_errors.h"
26 #include "audio_enhance_chain_manager.h"
27 #include "audio_effect_map.h"
28
29 using namespace OHOS::AudioStandard;
30
31 constexpr int32_t SAMPLE_FORMAT_U8 = 8;
32 constexpr int32_t SAMPLE_FORMAT_S16LE = 16;
33 constexpr int32_t SAMPLE_FORMAT_S24LE = 24;
34 constexpr int32_t SAMPLE_FORMAT_S32LE = 32;
35 constexpr int32_t SAMPLE_FORMAT_F32LE = 32;
36
37 namespace {
38 static const std::map<int32_t, pa_sample_format_t> FORMAT_CONVERT_MAP {
39 {SAMPLE_FORMAT_U8, PA_SAMPLE_U8},
40 {SAMPLE_FORMAT_S16LE, PA_SAMPLE_S16LE},
41 {SAMPLE_FORMAT_S24LE, PA_SAMPLE_S24LE},
42 {SAMPLE_FORMAT_S32LE, PA_SAMPLE_S32LE},
43 {SAMPLE_FORMAT_F32LE, PA_SAMPLE_FLOAT32LE },
44 };
45 }
46
ConvertFormat(uint8_t format)47 static pa_sample_format_t ConvertFormat(uint8_t format)
48 {
49 auto item = FORMAT_CONVERT_MAP.find(format);
50 if (item != FORMAT_CONVERT_MAP.end()) {
51 return item->second;
52 }
53 return PA_SAMPLE_INVALID;
54 }
55
EnhanceChainManagerCreateCb(const uint64_t sceneKeyCode,const struct DeviceAttrAdapter * adapter)56 int32_t EnhanceChainManagerCreateCb(const uint64_t sceneKeyCode, const struct DeviceAttrAdapter *adapter)
57 {
58 AudioEnhanceChainManager *audioEnhanceChainMananger = AudioEnhanceChainManager::GetInstance();
59 CHECK_AND_RETURN_RET_LOG(audioEnhanceChainMananger != nullptr,
60 ERR_INVALID_HANDLE, "null audioEnhanceChainManager");
61 AudioEnhanceDeviceAttr deviceAttr = {};
62 deviceAttr.micRate = adapter->micRate;
63 deviceAttr.micChannels = adapter->micChannels;
64 deviceAttr.micFormat = adapter->micFormat;
65 if (adapter->needEc) {
66 deviceAttr.needEc = adapter->needEc;
67 deviceAttr.ecRate = adapter->ecRate;
68 deviceAttr.ecChannels = adapter->ecChannels;
69 deviceAttr.ecFormat = adapter->ecFormat;
70 } else {
71 deviceAttr.needEc = false;
72 }
73 if (adapter->needMicRef) {
74 deviceAttr.needMicRef = adapter->needMicRef;
75 deviceAttr.micRefRate = adapter->micRefRate;
76 deviceAttr.micRefChannels = adapter->micRefChannels;
77 deviceAttr.micRefFormat = adapter->micRefFormat;
78 } else {
79 deviceAttr.needMicRef = false;
80 }
81 return audioEnhanceChainMananger->CreateAudioEnhanceChainDynamic(sceneKeyCode, deviceAttr);
82 }
83
EnhanceChainManagerReleaseCb(const uint64_t sceneKeyCode)84 int32_t EnhanceChainManagerReleaseCb(const uint64_t sceneKeyCode)
85 {
86 AudioEnhanceChainManager *audioEnhanceChainMananger = AudioEnhanceChainManager::GetInstance();
87 CHECK_AND_RETURN_RET_LOG(audioEnhanceChainMananger != nullptr,
88 ERR_INVALID_HANDLE, "null audioEnhanceChainManager");
89 return audioEnhanceChainMananger->ReleaseAudioEnhanceChainDynamic(sceneKeyCode);
90 }
91
EnhanceChainManagerExist(const uint64_t sceneKeyCode)92 bool EnhanceChainManagerExist(const uint64_t sceneKeyCode)
93 {
94 AudioEnhanceChainManager *audioEnhanceChainMananger = AudioEnhanceChainManager::GetInstance();
95 CHECK_AND_RETURN_RET_LOG(audioEnhanceChainMananger != nullptr,
96 ERR_INVALID_HANDLE, "null audioEnhanceChainManager");
97 return audioEnhanceChainMananger->ExistAudioEnhanceChain(sceneKeyCode);
98 }
99
EnhanceChainManagerGetAlgoConfig(const uint64_t sceneKeyCode,pa_sample_spec * micSpec,pa_sample_spec * ecSpec,pa_sample_spec * micRefSpec)100 int32_t EnhanceChainManagerGetAlgoConfig(const uint64_t sceneKeyCode, pa_sample_spec *micSpec,
101 pa_sample_spec *ecSpec, pa_sample_spec *micRefSpec)
102 {
103 AudioEnhanceChainManager *audioEnhanceChainMananger = AudioEnhanceChainManager::GetInstance();
104 CHECK_AND_RETURN_RET_LOG(audioEnhanceChainMananger != nullptr,
105 ERROR, "null audioEnhanceChainManager");
106 AudioBufferConfig micConfig = {};
107 AudioBufferConfig ecConfig = {};
108 AudioBufferConfig micRefConfig = {};
109
110 int32_t ret = audioEnhanceChainMananger->AudioEnhanceChainGetAlgoConfig(sceneKeyCode, micConfig, ecConfig,
111 micRefConfig);
112 if (ret != 0 || micConfig.samplingRate == 0) {
113 return ERROR;
114 }
115
116 micSpec->rate = micConfig.samplingRate;
117 micSpec->channels = static_cast<uint8_t>(micConfig.channels);
118 micSpec->format = ConvertFormat(micConfig.format);
119
120 ecSpec->rate = ecConfig.samplingRate;
121 ecSpec->channels = static_cast<uint8_t>(ecConfig.channels);
122 ecSpec->format = ConvertFormat(ecConfig.format);
123
124 micRefSpec->rate = micRefConfig.samplingRate;
125 micRefSpec->channels = static_cast<uint8_t>(micRefConfig.channels);
126 micRefSpec->format = ConvertFormat(micRefConfig.format);
127
128 return SUCCESS;
129 }
130
EnhanceChainManagerIsEmptyEnhanceChain(void)131 bool EnhanceChainManagerIsEmptyEnhanceChain(void)
132 {
133 AudioEnhanceChainManager *audioEnhanceChainMananger = AudioEnhanceChainManager::GetInstance();
134 CHECK_AND_RETURN_RET_LOG(audioEnhanceChainMananger != nullptr,
135 true, "null audioEnhanceChainManager");
136 return audioEnhanceChainMananger->IsEmptyEnhanceChain();
137 }
138
EnhanceChainManagerInitEnhanceBuffer(void)139 int32_t EnhanceChainManagerInitEnhanceBuffer(void)
140 {
141 AudioEnhanceChainManager *audioEnhanceChainMananger = AudioEnhanceChainManager::GetInstance();
142 CHECK_AND_RETURN_RET_LOG(audioEnhanceChainMananger != nullptr,
143 ERROR, "null audioEnhanceChainManager");
144 if (audioEnhanceChainMananger->IsEmptyEnhanceChain()) {
145 AUDIO_DEBUG_LOG("audioEnhanceChainMananger is empty EnhanceChain.");
146 return ERROR;
147 }
148 return audioEnhanceChainMananger->InitEnhanceBuffer();
149 }
150
CopyToEnhanceBufferAdapter(void * data,uint32_t length)151 int32_t CopyToEnhanceBufferAdapter(void *data, uint32_t length)
152 {
153 AudioEnhanceChainManager *audioEnhanceChainMananger = AudioEnhanceChainManager::GetInstance();
154 CHECK_AND_RETURN_RET_LOG(audioEnhanceChainMananger != nullptr,
155 ERROR, "null audioEnhanceChainManager");
156 CHECK_AND_RETURN_RET_LOG(data != nullptr, ERROR, "data null");
157 return audioEnhanceChainMananger->CopyToEnhanceBuffer(data, length);
158 }
159
CopyEcdataToEnhanceBufferAdapter(void * data,uint32_t length)160 int32_t CopyEcdataToEnhanceBufferAdapter(void *data, uint32_t length)
161 {
162 AudioEnhanceChainManager *audioEnhanceChainMananger = AudioEnhanceChainManager::GetInstance();
163 CHECK_AND_RETURN_RET_LOG(audioEnhanceChainMananger != nullptr,
164 ERROR, "null audioEnhanceChainManager");
165 CHECK_AND_RETURN_RET_LOG(data != nullptr, ERROR, "data null");
166 return audioEnhanceChainMananger->CopyEcToEnhanceBuffer(data, length);
167 }
168
CopyMicRefdataToEnhanceBufferAdapter(void * data,uint32_t length)169 int32_t CopyMicRefdataToEnhanceBufferAdapter(void *data, uint32_t length)
170 {
171 AudioEnhanceChainManager *audioEnhanceChainMananger = AudioEnhanceChainManager::GetInstance();
172 CHECK_AND_RETURN_RET_LOG(audioEnhanceChainMananger != nullptr,
173 ERROR, "null audioEnhanceChainManager");
174 CHECK_AND_RETURN_RET_LOG(data != nullptr, ERROR, "data null");
175 return audioEnhanceChainMananger->CopyMicRefToEnhanceBuffer(data, length);
176 }
177
CopyFromEnhanceBufferAdapter(void * data,uint32_t length)178 int32_t CopyFromEnhanceBufferAdapter(void *data, uint32_t length)
179 {
180 AudioEnhanceChainManager *audioEnhanceChainMananger = AudioEnhanceChainManager::GetInstance();
181 CHECK_AND_RETURN_RET_LOG(audioEnhanceChainMananger != nullptr,
182 ERROR, "null audioEnhanceChainManager");
183 CHECK_AND_RETURN_RET_LOG(data != nullptr, ERROR, "data null");
184 return audioEnhanceChainMananger->CopyFromEnhanceBuffer(data, length);
185 }
186
EnhanceChainManagerProcess(const uint64_t sceneKeyCode,uint32_t length)187 int32_t EnhanceChainManagerProcess(const uint64_t sceneKeyCode, uint32_t length)
188 {
189 AudioEnhanceChainManager *audioEnhanceChainMananger = AudioEnhanceChainManager::GetInstance();
190 CHECK_AND_RETURN_RET_LOG(audioEnhanceChainMananger != nullptr,
191 ERR_INVALID_HANDLE, "null audioEnhanceChainManager");
192
193 CHECK_AND_RETURN_RET_LOG(audioEnhanceChainMananger->ApplyAudioEnhanceChain(sceneKeyCode, length) == SUCCESS,
194 ERROR, "%{public}" PRIu64 " process failed", sceneKeyCode);
195 return SUCCESS;
196 }
197
EnhanceChainManagerProcessDefault(const uint32_t captureId,uint32_t length)198 int32_t EnhanceChainManagerProcessDefault(const uint32_t captureId, uint32_t length)
199 {
200 AudioEnhanceChainManager *audioEnhanceChainMananger = AudioEnhanceChainManager::GetInstance();
201 CHECK_AND_RETURN_RET_LOG(audioEnhanceChainMananger != nullptr,
202 ERR_INVALID_HANDLE, "null audioEnhanceChainManager");
203 if (audioEnhanceChainMananger->ApplyAudioEnhanceChainDefault(captureId, length) != SUCCESS) {
204 AUDIO_ERR_LOG("%{public}u default process failed", captureId);
205 return ERROR;
206 }
207 AUDIO_DEBUG_LOG("%{public}u default process success", captureId);
208 return SUCCESS;
209 }
210
GetSceneTypeCode(const char * sceneType,uint64_t * sceneTypeCode)211 int32_t GetSceneTypeCode(const char *sceneType, uint64_t *sceneTypeCode)
212 {
213 std::string sceneTypeString = "";
214 const std::unordered_map<AudioEnhanceScene, std::string> &audioEnhanceSupportedSceneTypes =
215 GetEnhanceSupportedSceneType();
216 if (sceneType) {
217 sceneTypeString = sceneType;
218 } else {
219 return ERROR;
220 }
221 auto item = std::find_if(audioEnhanceSupportedSceneTypes.begin(), audioEnhanceSupportedSceneTypes.end(),
222 [&sceneTypeString](const std::pair<AudioEnhanceScene, std::string>& element) -> bool {
223 return element.second == sceneTypeString;
224 });
225 if (item == audioEnhanceSupportedSceneTypes.end()) {
226 return ERROR;
227 }
228 *sceneTypeCode = static_cast<uint64_t>(item->first);
229 return SUCCESS;
230 }
231
EnhanceChainManagerSendInitCommand()232 int32_t EnhanceChainManagerSendInitCommand()
233 {
234 AudioEnhanceChainManager *audioEnhanceChainMananger = AudioEnhanceChainManager::GetInstance();
235 CHECK_AND_RETURN_RET_LOG(audioEnhanceChainMananger != nullptr,
236 ERROR, "null audioEnhanceChainManager");
237 return audioEnhanceChainMananger->SendInitCommand();
238 }