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 "OfflineAudioEffectServerChain"
18
19 #include "offline_audio_effect_server_chain.h"
20
21 #include <algorithm>
22 #include <chrono>
23 #include <cinttypes>
24 #include <cstdio>
25 #include <cstdlib>
26 #include <cstring>
27 #include <string>
28 #include <unistd.h>
29 #include "securec.h"
30
31 #include "audio_common_log.h"
32 #include "audio_errors.h"
33 #include "audio_utils.h"
34
35 using namespace OHOS::AudioStandard;
36
37 namespace OHOS {
38 namespace AudioStandard {
39 namespace {
40 constexpr uint32_t MAX_DESCRIPTOR_NUM = 20;
41 constexpr uint32_t MAX_CMD_LEN = 10;
42 constexpr uint32_t MAX_REPLY_LEN = 10;
43 constexpr uint32_t MAX_TIME_INTERVAL_MS = 160; // ms
44 // key for effectName, value for (libName, effectId)
45 static std::map<std::string, std::pair<std::string, std::string>> g_chainName2infoMap;
46 static std::mutex g_chainMutex;
47 }
48
49 template<typename T>
FreeIfNotNull(T * & ptr)50 static inline void FreeIfNotNull(T*& ptr)
51 {
52 if (ptr != nullptr) {
53 free(ptr);
54 ptr = nullptr;
55 }
56 }
57
GetByteSize(AudioSampleFormat format)58 static inline int32_t GetByteSize(AudioSampleFormat format)
59 {
60 static const std::unordered_map<AudioSampleFormat, int32_t> sizeMap = {
61 {SAMPLE_U8, 1},
62 {SAMPLE_S16LE, 2},
63 {SAMPLE_S24LE, 3},
64 {SAMPLE_S32LE, 4},
65 {SAMPLE_F32LE, 4}
66 };
67
68 auto it = sizeMap.find(format);
69 return (it != sizeMap.end()) ? it->second : 2; // Default size is 2
70 }
71
OfflineAudioEffectServerChain(const std::string & chainName)72 OfflineAudioEffectServerChain::OfflineAudioEffectServerChain(const std::string &chainName) : chainName_(chainName) {}
73
~OfflineAudioEffectServerChain()74 OfflineAudioEffectServerChain::~OfflineAudioEffectServerChain()
75 {
76 if (controller_) {
77 Release();
78 }
79 FreeIfNotNull(controllerId_.libName);
80 FreeIfNotNull(controllerId_.effectId);
81 serverBufferIn_ = nullptr;
82 serverBufferOut_ = nullptr;
83 DumpFileUtil::CloseDumpFile(&dumpFileIn_);
84 DumpFileUtil::CloseDumpFile(&dumpFileOut_);
85 }
86
InitEffectModel()87 static struct IEffectModel *InitEffectModel()
88 {
89 static struct IEffectModel *effectModel = IEffectModelGet(false);
90 return effectModel;
91 }
92
InitControllerDescriptor()93 static void InitControllerDescriptor()
94 {
95 std::lock_guard<std::mutex> maplock(g_chainMutex);
96 if (g_chainName2infoMap.size() > 0) {
97 return;
98 }
99 static uint32_t descsLen = MAX_DESCRIPTOR_NUM;
100 auto model = InitEffectModel();
101 CHECK_AND_RETURN_LOG(model, "get all descriptor failed, effectmodel is nullptr");
102 struct EffectControllerDescriptor descs[MAX_DESCRIPTOR_NUM];
103 int32_t ret = model->GetAllEffectDescriptors(model, descs, &descsLen);
104 CHECK_AND_RETURN_LOG(model, "get all descriptor failed, errCode is %{public}d", ret);
105 for (uint32_t i = 0; i < descsLen; i++) {
106 g_chainName2infoMap.insert_or_assign(descs[i].effectName,
107 std::make_pair(std::string(descs[i].libName), std::string(descs[i].effectId)));
108 FreeIfNotNull(descs[i].effectName);
109 FreeIfNotNull(descs[i].libName);
110 FreeIfNotNull(descs[i].effectId);
111 FreeIfNotNull(descs[i].supplier);
112 }
113 }
114
InitDump()115 void OfflineAudioEffectServerChain::InitDump()
116 {
117 static uint32_t chainId = 0;
118 std::string dumpFileName = "OfflineEffectServer";
119 std::string dumpFileInName = dumpFileName + "_" + std::to_string(chainId) + "_In.pcm";
120 std::string dumpFileOutName = dumpFileName + "_" + std::to_string(chainId) + "_Out.pcm";
121 DumpFileUtil::OpenDumpFile(DUMP_SERVER_PARA, dumpFileInName, &dumpFileIn_);
122 DumpFileUtil::OpenDumpFile(DUMP_SERVER_PARA, dumpFileOutName, &dumpFileOut_);
123 chainId++;
124 }
125
GetOfflineAudioEffectChains(std::vector<std::string> & chainNamesVector)126 int32_t OfflineAudioEffectServerChain::GetOfflineAudioEffectChains(std::vector<std::string> &chainNamesVector)
127 {
128 InitControllerDescriptor();
129 std::lock_guard<std::mutex> maplock(g_chainMutex);
130 for (auto item : g_chainName2infoMap) {
131 chainNamesVector.emplace_back(item.first);
132 }
133 AUDIO_INFO_LOG("GetOfflineAudioEffectChains done");
134 return SUCCESS;
135 }
136
Create()137 int32_t OfflineAudioEffectServerChain::Create()
138 {
139 InitControllerDescriptor();
140 std::lock_guard<std::mutex> maplock(g_chainMutex);
141 auto mapIter = g_chainName2infoMap.find(chainName_);
142 CHECK_AND_RETURN_RET_LOG(mapIter != g_chainName2infoMap.end(), ERROR,
143 "create failed, no chain named %{public}s", chainName_.c_str());
144 auto model = InitEffectModel();
145 CHECK_AND_RETURN_RET_LOG(model, ERROR, "create failed, effectmodel is nullptr");
146
147 // second.first for libName, second.second for effectId, 1 for ioDirection
148 // do not need to release char* in info
149 struct EffectInfo info = {&mapIter->second.first[0], &mapIter->second.second[0], 1};
150
151 int32_t ret = model->CreateEffectController(model, &info, &controller_, &controllerId_);
152 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ERROR,
153 "create %{public}s effect controller failed, errCode is %{public}d", chainName_.c_str(), ret);
154
155 int8_t input[MAX_CMD_LEN] = {0};
156 int8_t output[MAX_REPLY_LEN] = {0};
157 uint32_t replyLen = MAX_REPLY_LEN;
158
159 std::lock_guard<std::mutex> lock(offlineChainMutex_);
160 CHECK_AND_RETURN_RET_LOG(controller_, ERROR, "enable failed, controller is nullptr");
161 ret = controller_->SendCommand(controller_, AUDIO_EFFECT_COMMAND_ENABLE,
162 static_cast<int8_t *>(input), MAX_CMD_LEN, output, &replyLen);
163 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ERROR,
164 "%{public}s effect COMMAND_ENABLE failed, errCode is %{public}d", chainName_.c_str(), ret);
165
166 InitDump();
167
168 AUDIO_INFO_LOG("Create %{public}s done", chainName_.c_str());
169 return SUCCESS;
170 }
171
SetParam(AudioStreamInfo inInfo,AudioStreamInfo outInfo)172 int32_t OfflineAudioEffectServerChain::SetParam(AudioStreamInfo inInfo, AudioStreamInfo outInfo)
173 {
174 AUDIO_INFO_LOG("%{public}d %{public}d %{public}hhu %{public}hhu %{public}" PRIu64 " InStreamInfo set",
175 inInfo.samplingRate, inInfo.encoding, inInfo.format, inInfo.channels, inInfo.channelLayout);
176 AUDIO_INFO_LOG("%{public}d %{public}d %{public}hhu %{public}hhu %{public}" PRIu64 " OutStreamInfo set",
177 outInfo.samplingRate, outInfo.encoding, outInfo.format, outInfo.channels, outInfo.channelLayout);
178
179 offlineConfig_.inputCfg = {inInfo.samplingRate, inInfo.channels, inInfo.format};
180 offlineConfig_.outputCfg = {outInfo.samplingRate, outInfo.channels, outInfo.format};
181
182 int8_t output[MAX_REPLY_LEN] = {0};
183 uint32_t replyLen = MAX_REPLY_LEN;
184
185 std::lock_guard<std::mutex> lock(offlineChainMutex_);
186 CHECK_AND_RETURN_RET_LOG(controller_, ERROR, "configure failed, controller is nullptr");
187 int32_t ret = controller_->SendCommand(controller_, AUDIO_EFFECT_COMMAND_SET_CONFIG,
188 reinterpret_cast<int8_t *>(&offlineConfig_), sizeof(offlineConfig_), output, &replyLen);
189 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ERROR,
190 "%{public}s effect COMMAND_SET_CONFIG failed, errCode is %{public}d", chainName_.c_str(), ret);
191
192 inBufferSize_ = static_cast<uint32_t>(GetByteSize(inInfo.format)) * inInfo.samplingRate * inInfo.channels *
193 MAX_TIME_INTERVAL_MS / AUDIO_MS_PER_SECOND;
194 outBufferSize_ = static_cast<uint32_t>(GetByteSize(outInfo.format)) * outInfo.samplingRate * outInfo.channels *
195 MAX_TIME_INTERVAL_MS / AUDIO_MS_PER_SECOND;
196 return SUCCESS;
197 }
198
GetEffectBufferSize(uint32_t & inBufferSize,uint32_t & outBufferSize)199 int32_t OfflineAudioEffectServerChain::GetEffectBufferSize(uint32_t &inBufferSize, uint32_t &outBufferSize)
200 {
201 CHECK_AND_RETURN_RET_LOG(inBufferSize_ != 0, ERROR, "inBufferSize_ do not init");
202 CHECK_AND_RETURN_RET_LOG(outBufferSize_ != 0, ERROR, "inBufferSize_ do not init");
203 inBufferSize = inBufferSize_;
204 outBufferSize = outBufferSize_;
205 AUDIO_INFO_LOG("GetEffectBufferSize in server done, inBufferSize_:%{public}u inBufferSize_:%{public}u",
206 inBufferSize_, outBufferSize_);
207 return SUCCESS;
208 }
209
Prepare(const std::shared_ptr<AudioSharedMemory> & bufferIn,const std::shared_ptr<AudioSharedMemory> & bufferOut)210 int32_t OfflineAudioEffectServerChain::Prepare(const std::shared_ptr<AudioSharedMemory> &bufferIn,
211 const std::shared_ptr<AudioSharedMemory> &bufferOut)
212 {
213 serverBufferIn_ = bufferIn;
214 serverBufferOut_ = bufferOut;
215 AUDIO_INFO_LOG("Prepare in server done");
216 return SUCCESS;
217 }
218
Process(uint32_t inSize,uint32_t outSize)219 int32_t OfflineAudioEffectServerChain::Process(uint32_t inSize, uint32_t outSize)
220 {
221 CHECK_AND_RETURN_RET_LOG(serverBufferIn_ && serverBufferIn_->GetBase(), ERROR, "serverBufferIn_ is nullptr");
222 CHECK_AND_RETURN_RET_LOG(serverBufferOut_ && serverBufferOut_->GetBase(), ERROR, "serverBufferOut_ is nullptr");
223
224 CHECK_AND_RETURN_RET_LOG(inSize <= inBufferSize_, ERROR,
225 "inSize %{public}u > serverInBufferSize %{public}u", inSize, inBufferSize_);
226 CHECK_AND_RETURN_RET_LOG(outSize <= outBufferSize_, ERROR,
227 "outSize %{public}u > serverOutBufferSize %{public}u", outSize, outBufferSize_);
228
229 DumpFileUtil::WriteDumpFile(dumpFileIn_, serverBufferIn_->GetBase(), inSize);
230
231 struct AudioEffectBuffer input;
232 struct AudioEffectBuffer output;
233
234 input = {static_cast<int32_t>(inSize) / GetFormatByteSize(offlineConfig_.inputCfg.format),
235 GetFormatByteSize(offlineConfig_.inputCfg.format),
236 reinterpret_cast<int8_t *>(serverBufferIn_->GetBase()), static_cast<int32_t>(inSize)};
237 output = {};
238
239 std::lock_guard<std::mutex> lock(offlineChainMutex_);
240 CHECK_AND_RETURN_RET_LOG(controller_, ERROR, "process failed, controller is nullptr");
241 int32_t ret = controller_->EffectProcess(controller_, &input, &output);
242 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ERROR, "EffectProcess failed ret:%{public}d", ret);
243 ret = memcpy_s(reinterpret_cast<int8_t *>(serverBufferOut_->GetBase()), outSize,
244 output.rawData, output.frameCount * GetFormatByteSize(offlineConfig_.outputCfg.format));
245 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ERROR, "memcpy failed, ret:%{public}d", ret);
246 FreeIfNotNull(output.rawData);
247
248 DumpFileUtil::WriteDumpFile(dumpFileOut_, serverBufferOut_->GetBase(), outSize);
249 return SUCCESS;
250 }
251
Release()252 int32_t OfflineAudioEffectServerChain::Release()
253 {
254 auto model = InitEffectModel();
255 CHECK_AND_RETURN_RET_LOG(model, ERROR, "model is nullptr");
256
257 std::lock_guard<std::mutex> lock(offlineChainMutex_);
258 int32_t ret = model->DestroyEffectController(model, &controllerId_);
259 controller_ = nullptr;
260 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, ERROR,
261 "chainId:%{public}s release failed, errCode is %{public}d", controllerId_.effectId, ret);
262
263 AUDIO_INFO_LOG("Release in server success");
264 return SUCCESS;
265 }
266 } // namespace AudioStandard
267 } // namespace OHOS
268