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 #ifndef LOG_TAG
16 #define LOG_TAG "AudioEffectChain"
17 #endif
18
19 #include "audio_effect_chain.h"
20 #include "audio_effect_chain_adapter.h"
21 #include "audio_effect.h"
22 #include "audio_errors.h"
23 #include "audio_effect_log.h"
24 #include "audio_utils.h"
25 #include "securec.h"
26 #include "media_monitor_manager.h"
27
28 namespace OHOS {
29 namespace AudioStandard {
30
31 const uint32_t NUM_SET_EFFECT_PARAM = 10;
32 const uint32_t DEFAULT_SAMPLE_RATE = 48000;
33 const uint32_t MAX_UINT_VOLUME = 65535;
34 const uint32_t DEFAULT_NUM_CHANNEL = STEREO;
35 const uint64_t DEFAULT_NUM_CHANNELLAYOUT = CH_LAYOUT_STEREO;
36
37 template <typename T>
Swap(T & a,T & b)38 static void Swap(T &a, T &b)
39 {
40 T temp = a;
41 a = b;
42 b = temp;
43 }
44
45 #ifdef SENSOR_ENABLE
AudioEffectChain(std::string scene,std::shared_ptr<HeadTracker> headTracker)46 AudioEffectChain::AudioEffectChain(std::string scene, std::shared_ptr<HeadTracker> headTracker)
47 {
48 sceneType_ = scene;
49 effectMode_ = AUDIO_SUPPORTED_SCENE_MODES.find(EFFECT_DEFAULT)->second;
50 audioBufIn_.frameLength = 0;
51 audioBufOut_.frameLength = 0;
52 ioBufferConfig_.inputCfg.samplingRate = DEFAULT_SAMPLE_RATE;
53 ioBufferConfig_.inputCfg.channels = DEFAULT_NUM_CHANNEL;
54 ioBufferConfig_.inputCfg.format = DATA_FORMAT_F32;
55 ioBufferConfig_.inputCfg.channelLayout = DEFAULT_NUM_CHANNELLAYOUT;
56 ioBufferConfig_.outputCfg.samplingRate = DEFAULT_SAMPLE_RATE;
57 ioBufferConfig_.outputCfg.channels = DEFAULT_NUM_CHANNEL;
58 ioBufferConfig_.outputCfg.format = DATA_FORMAT_F32;
59 ioBufferConfig_.outputCfg.channelLayout = DEFAULT_NUM_CHANNELLAYOUT;
60 headTracker_ = headTracker;
61 dumpNameIn_ = "dump_effect_in_" + scene + "_"
62 + std::to_string(ioBufferConfig_.inputCfg.samplingRate) + "_"
63 + std::to_string(ioBufferConfig_.inputCfg.channels) + "_4_"
64 + GetTime() + ".pcm";
65 dumpNameOut_ = "dump_effect_out_" + scene + "_"
66 + std::to_string(ioBufferConfig_.outputCfg.samplingRate) + "_"
67 + std::to_string(ioBufferConfig_.outputCfg.channels) + "_4_"
68 + GetTime() + ".pcm";
69 DumpFileUtil::OpenDumpFile(DUMP_SERVER_PARA, dumpNameIn_, &dumpFileInput_);
70 DumpFileUtil::OpenDumpFile(DUMP_SERVER_PARA, dumpNameOut_, &dumpFileOutput_);
71 }
72 #else
AudioEffectChain(std::string scene)73 AudioEffectChain::AudioEffectChain(std::string scene)
74 {
75 sceneType_ = scene;
76 effectMode_ = AUDIO_SUPPORTED_SCENE_MODES.find(EFFECT_DEFAULT)->second;
77 audioBufIn_.frameLength = 0;
78 audioBufOut_.frameLength = 0;
79 ioBufferConfig_.inputCfg.samplingRate = DEFAULT_SAMPLE_RATE;
80 ioBufferConfig_.inputCfg.channels = DEFAULT_NUM_CHANNEL;
81 ioBufferConfig_.inputCfg.format = DATA_FORMAT_F32;
82 ioBufferConfig_.inputCfg.channelLayout = DEFAULT_NUM_CHANNELLAYOUT;
83 ioBufferConfig_.outputCfg.samplingRate = DEFAULT_SAMPLE_RATE;
84 ioBufferConfig_.outputCfg.channels = DEFAULT_NUM_CHANNEL;
85 ioBufferConfig_.outputCfg.format = DATA_FORMAT_F32;
86 ioBufferConfig_.outputCfg.channelLayout = DEFAULT_NUM_CHANNELLAYOUT;
87 dumpNameIn_ = "dump_effect_in_" + scene + "_"
88 + std::to_string(ioBufferConfig_.inputCfg.samplingRate) + "_"
89 + std::to_string(ioBufferConfig_.inputCfg.channels) + "_4_"
90 + GetTime() + ".pcm";
91 dumpNameOut_ = "dump_effect_out_" + scene + "_"
92 + std::to_string(ioBufferConfig_.outputCfg.samplingRate) + "_"
93 + std::to_string(ioBufferConfig_.outputCfg.channels) + "_4_"
94 + GetTime() + ".pcm";
95 DumpFileUtil::OpenDumpFile(DUMP_SERVER_PARA, dumpNameIn_, &dumpFileInput_);
96 DumpFileUtil::OpenDumpFile(DUMP_SERVER_PARA, dumpNameOut_, &dumpFileOutput_);
97 }
98 #endif
99
~AudioEffectChain()100 AudioEffectChain::~AudioEffectChain()
101 {
102 ReleaseEffectChain();
103 DumpFileUtil::CloseDumpFile(&dumpFileInput_);
104 DumpFileUtil::CloseDumpFile(&dumpFileOutput_);
105 }
106
SetEffectMode(const std::string & mode)107 void AudioEffectChain::SetEffectMode(const std::string &mode)
108 {
109 effectMode_ = mode;
110 }
111
SetExtraSceneType(const std::string & extraSceneType)112 void AudioEffectChain::SetExtraSceneType(const std::string &extraSceneType)
113 {
114 extraEffectChainType_ = static_cast<uint32_t>(std::stoi(extraSceneType));
115 }
116
SetEffectCurrSceneType(AudioEffectScene currSceneType)117 void AudioEffectChain::SetEffectCurrSceneType(AudioEffectScene currSceneType)
118 {
119 currSceneType_ = currSceneType;
120 }
121
SetSpatializationSceneType(AudioSpatializationSceneType spatializationSceneType)122 void AudioEffectChain::SetSpatializationSceneType(AudioSpatializationSceneType spatializationSceneType)
123 {
124 spatializationSceneType_ = spatializationSceneType;
125 }
126
SetSpatializationEnabled(bool enabled)127 void AudioEffectChain::SetSpatializationEnabled(bool enabled)
128 {
129 spatializationEnabled_ = enabled;
130 }
131
SetStreamUsage(const int32_t streamUsage)132 void AudioEffectChain::SetStreamUsage(const int32_t streamUsage)
133 {
134 streamUsage_ = static_cast<StreamUsage>(streamUsage);
135 }
136
ReleaseEffectChain()137 void AudioEffectChain::ReleaseEffectChain()
138 {
139 std::lock_guard<std::mutex> lock(reloadMutex_);
140 for (uint32_t i = 0; i < standByEffectHandles_.size() && i < libHandles_.size(); ++i) {
141 if (!libHandles_[i]) {
142 continue;
143 }
144 if (!standByEffectHandles_[i]) {
145 continue;
146 }
147 if (!libHandles_[i]->releaseEffect) {
148 continue;
149 }
150 libHandles_[i]->releaseEffect(standByEffectHandles_[i]);
151 }
152 standByEffectHandles_.clear();
153 libHandles_.clear();
154 }
155
SetEffectParamToHandle(AudioEffectHandle handle,int32_t & replyData)156 int32_t AudioEffectChain::SetEffectParamToHandle(AudioEffectHandle handle, int32_t &replyData)
157 {
158 AudioEffectTransInfo cmdInfo = {sizeof(AudioEffectConfig), &ioBufferConfig_};
159 AudioEffectTransInfo replyInfo = {sizeof(int32_t), &replyData};
160 // Set param
161 AudioEffectParam *effectParam =
162 new AudioEffectParam[sizeof(AudioEffectParam) + NUM_SET_EFFECT_PARAM * sizeof(int32_t)];
163 effectParam->status = 0;
164 effectParam->paramSize = sizeof(int32_t);
165 effectParam->valueSize = 0;
166 int32_t *data = &(effectParam->data[0]);
167 data[COMMAND_CODE_INDEX] = EFFECT_SET_PARAM;
168 data[SCENE_TYPE_INDEX] = static_cast<int32_t>(currSceneType_);
169 data[EFFECT_MODE_INDEX] = GetKeyFromValue(AUDIO_SUPPORTED_SCENE_MODES, effectMode_);
170 #ifdef WINDOW_MANAGER_ENABLE
171 std::shared_ptr<AudioEffectRotation> audioEffectRotation = AudioEffectRotation::GetInstance();
172 if (audioEffectRotation == nullptr) {
173 data[ROTATION_INDEX] = 0;
174 } else {
175 data[ROTATION_INDEX] = static_cast<int32_t>(audioEffectRotation->GetRotation());
176 }
177 #else
178 data[ROTATION_INDEX] = 0;
179 #endif
180 data[VOLUME_INDEX] = static_cast<int32_t>(finalVolume_ * MAX_UINT_VOLUME);
181 data[EXTRA_SCENE_TYPE_INDEX] = static_cast<int32_t>(extraEffectChainType_);
182 data[SPATIAL_DEVICE_TYPE_INDEX] = spatialDeviceType_;
183 data[SPATIALIZATION_SCENE_TYPE_INDEX] = spatializationSceneType_;
184 data[SPATIALIZATION_ENABLED_INDEX] = spatializationEnabled_;
185 data[STREAM_USAGE_INDEX] = streamUsage_;
186 AUDIO_DEBUG_LOG("set param to handle, sceneType: %{public}d, effectMode: %{public}d, rotation: %{public}d, "
187 "volume: %{public}d, extraSceneType: %{public}d, spatialDeviceType: %{public}d, "
188 "spatializationSceneType: %{public}d, spatializationEnabled: %{public}d, streamUsage: %{public}d",
189 data[SCENE_TYPE_INDEX], data[EFFECT_MODE_INDEX], data[ROTATION_INDEX], data[VOLUME_INDEX],
190 data[EXTRA_SCENE_TYPE_INDEX], data[SPATIAL_DEVICE_TYPE_INDEX], data[SPATIALIZATION_SCENE_TYPE_INDEX],
191 data[SPATIALIZATION_ENABLED_INDEX], data[STREAM_USAGE_INDEX]);
192 cmdInfo = {sizeof(AudioEffectParam) + sizeof(int32_t) * NUM_SET_EFFECT_PARAM, effectParam};
193 int32_t ret = (*handle)->command(handle, EFFECT_CMD_SET_PARAM, &cmdInfo, &replyInfo);
194 delete[] effectParam;
195 return ret;
196 }
197
AddEffectHandle(AudioEffectHandle handle,AudioEffectLibrary * libHandle,AudioEffectScene currSceneType)198 void AudioEffectChain::AddEffectHandle(AudioEffectHandle handle, AudioEffectLibrary *libHandle,
199 AudioEffectScene currSceneType)
200 {
201 int32_t ret;
202 int32_t replyData = 0;
203 currSceneType_ = currSceneType;
204 AudioEffectTransInfo cmdInfo = {sizeof(AudioEffectConfig), &ioBufferConfig_};
205 AudioEffectTransInfo replyInfo = {sizeof(int32_t), &replyData};
206 ret = (*handle)->command(handle, EFFECT_CMD_INIT, &cmdInfo, &replyInfo);
207 CHECK_AND_RETURN_LOG(ret == 0, "[%{public}s] with mode [%{public}s], %{public}s lib EFFECT_CMD_INIT fail",
208 sceneType_.c_str(), effectMode_.c_str(), libHandle->name);
209 ret = (*handle)->command(handle, EFFECT_CMD_ENABLE, &cmdInfo, &replyInfo);
210 CHECK_AND_RETURN_LOG(ret == 0, "[%{public}s] with mode [%{public}s], %{public}s lib EFFECT_CMD_ENABLE fail",
211 sceneType_.c_str(), effectMode_.c_str(), libHandle->name);
212
213 CHECK_AND_RETURN_LOG(SetEffectParamToHandle(handle, replyData) == 0,
214 "[%{public}s] with mode [%{public}s], %{public}s lib EFFECT_CMD_SET_PARAM fail", sceneType_.c_str(),
215 effectMode_.c_str(), libHandle->name);
216
217 cmdInfo = {sizeof(AudioEffectConfig), &ioBufferConfig_};
218 ret = (*handle)->command(handle, EFFECT_CMD_SET_CONFIG, &cmdInfo, &replyInfo);
219 CHECK_AND_RETURN_LOG(ret == 0, "[%{public}s] with mode [%{public}s], %{public}s lib EFFECT_CMD_SET_CONFIG fail",
220 sceneType_.c_str(), effectMode_.c_str(), libHandle->name);
221
222 ret = (*handle)->command(handle, EFFECT_CMD_GET_CONFIG, &cmdInfo, &cmdInfo);
223 CHECK_AND_RETURN_LOG(ret == 0, "[%{public}s] with mode [%{public}s], %{public}s lib EFFECT_CMD_GET_CONFIG fail",
224 sceneType_.c_str(), effectMode_.c_str(), libHandle->name);
225 Swap(ioBufferConfig_.inputCfg, ioBufferConfig_.outputCfg); // pass outputCfg to next algo as inputCfg
226
227 standByEffectHandles_.emplace_back(handle);
228 libHandles_.emplace_back(libHandle);
229 latency_ += static_cast<uint32_t>(replyData);
230 }
231
UpdateEffectParam()232 int32_t AudioEffectChain::UpdateEffectParam()
233 {
234 std::lock_guard<std::mutex> lock(reloadMutex_);
235 latency_ = 0;
236 for (AudioEffectHandle handle : standByEffectHandles_) {
237 int32_t replyData;
238 int32_t ret = SetEffectParamToHandle(handle, replyData);
239 CHECK_AND_RETURN_RET_LOG(ret == 0, ret, "set EFFECT_CMD_SET_PARAM fail");
240 AUDIO_DEBUG_LOG("Set Effect Param Scene Type: %{public}d Success", currSceneType_);
241 latency_ += static_cast<uint32_t>(replyData);
242 }
243 return SUCCESS;
244 }
245
ApplyEffectChain(float * bufIn,float * bufOut,uint32_t frameLen,AudioEffectProcInfo procInfo)246 void AudioEffectChain::ApplyEffectChain(float *bufIn, float *bufOut, uint32_t frameLen, AudioEffectProcInfo procInfo)
247 {
248 size_t inTotlen = frameLen * ioBufferConfig_.inputCfg.channels * sizeof(float);
249 size_t outTotlen = frameLen * ioBufferConfig_.outputCfg.channels * sizeof(float);
250 DumpFileUtil::WriteDumpFile(dumpFileInput_, static_cast<void *>(bufIn), inTotlen);
251 DumpEffectProcessData(dumpNameIn_, static_cast<void *>(bufIn), inTotlen);
252
253 if (IsEmptyEffectHandles()) {
254 CHECK_AND_RETURN_LOG(memcpy_s(bufOut, outTotlen, bufIn, outTotlen) == 0, "memcpy error in apply effect");
255 DumpFileUtil::WriteDumpFile(dumpFileOutput_, static_cast<void *>(bufOut), outTotlen);
256 DumpEffectProcessData(dumpNameOut_, static_cast<void *>(bufOut), outTotlen);
257 return;
258 }
259
260 #ifdef SENSOR_ENABLE
261 int32_t replyData = 0;
262 auto imuData = headTracker_->GetHeadPostureData();
263 AudioEffectTransInfo cmdInfo = {sizeof(HeadPostureData), &imuData};
264 AudioEffectTransInfo replyInfo = {sizeof(int32_t), &replyData};
265 #endif
266
267 audioBufIn_.frameLength = frameLen;
268 audioBufOut_.frameLength = frameLen;
269 uint32_t count = 0;
270 std::lock_guard<std::mutex> lock(reloadMutex_);
271 for (AudioEffectHandle handle : standByEffectHandles_) {
272 #ifdef SENSOR_ENABLE
273 if ((!procInfo.btOffloadEnabled) && procInfo.headTrackingEnabled) {
274 (*handle)->command(handle, EFFECT_CMD_SET_IMU, &cmdInfo, &replyInfo);
275 }
276 #endif
277 if ((count & 1) == 0) {
278 audioBufIn_.raw = bufIn;
279 audioBufOut_.raw = bufOut;
280 } else {
281 audioBufOut_.raw = bufIn;
282 audioBufIn_.raw = bufOut;
283 }
284 int32_t ret = (*handle)->process(handle, &audioBufIn_, &audioBufOut_);
285 CHECK_AND_CONTINUE_LOG(ret == 0, "[%{public}s] with mode [%{public}s], either one of libs process fail",
286 sceneType_.c_str(), effectMode_.c_str());
287 count++;
288 }
289 if ((count & 1) == 0) {
290 CHECK_AND_RETURN_LOG(memcpy_s(bufOut, outTotlen, bufIn, outTotlen) == 0, "memcpy error when last copy");
291 }
292
293 DumpFileUtil::WriteDumpFile(dumpFileOutput_, static_cast<void *>(bufOut), outTotlen);
294 DumpEffectProcessData(dumpNameOut_, static_cast<void *>(bufOut), outTotlen);
295 }
296
IsEmptyEffectHandles()297 bool AudioEffectChain::IsEmptyEffectHandles()
298 {
299 std::lock_guard<std::mutex> lock(reloadMutex_);
300 return standByEffectHandles_.size() == 0;
301 }
302
UpdateMultichannelIoBufferConfig(const uint32_t & channels,const uint64_t & channelLayout)303 int32_t AudioEffectChain::UpdateMultichannelIoBufferConfig(const uint32_t &channels, const uint64_t &channelLayout)
304 {
305 if (ioBufferConfig_.inputCfg.channels == channels && ioBufferConfig_.inputCfg.channelLayout == channelLayout) {
306 return SUCCESS;
307 }
308 ioBufferConfig_.inputCfg.channels = channels;
309 ioBufferConfig_.inputCfg.channelLayout = channelLayout;
310 if (IsEmptyEffectHandles()) {
311 return SUCCESS;
312 }
313 std::lock_guard<std::mutex> lock(reloadMutex_);
314 int32_t replyData = 0;
315 AudioEffectTransInfo cmdInfo = {sizeof(AudioEffectConfig), &ioBufferConfig_};
316 AudioEffectTransInfo replyInfo = {sizeof(int32_t), &replyData};
317 AudioEffectHandle preHandle = nullptr;
318 ioBufferConfig_.outputCfg.channels = 0;
319 ioBufferConfig_.outputCfg.channelLayout = 0;
320 for (AudioEffectHandle handle : standByEffectHandles_) {
321 if (preHandle != nullptr) {
322 int32_t ret = (*preHandle)->command(preHandle, EFFECT_CMD_SET_CONFIG, &cmdInfo, &replyInfo);
323 CHECK_AND_RETURN_RET_LOG(ret == 0, ERROR, "Multichannel effect chain update EFFECT_CMD_SET_CONFIG fail");
324
325 ret = (*preHandle)->command(preHandle, EFFECT_CMD_GET_CONFIG, &cmdInfo, &cmdInfo);
326 CHECK_AND_RETURN_RET_LOG(ret == 0, ERROR, "Multichannel effect chain update EFFECT_CMD_GET_CONFIG fail");
327 Swap(ioBufferConfig_.inputCfg, ioBufferConfig_.outputCfg); // pass outputCfg to next algo as inputCfg
328 }
329 preHandle = handle;
330 }
331 ioBufferConfig_.outputCfg.channels = DEFAULT_NUM_CHANNEL;
332 ioBufferConfig_.outputCfg.channelLayout = DEFAULT_NUM_CHANNELLAYOUT;
333 if (preHandle == nullptr) {
334 AUDIO_ERR_LOG("The preHandle is nullptr!");
335 return ERROR;
336 }
337 int32_t ret = (*preHandle)->command(preHandle, EFFECT_CMD_SET_CONFIG, &cmdInfo, &replyInfo);
338 CHECK_AND_RETURN_RET_LOG(ret == 0, ERROR, "last effect update EFFECT_CMD_SET_CONFIG fail");
339 // recover bufferconfig
340 ioBufferConfig_.inputCfg.channels = channels;
341 ioBufferConfig_.inputCfg.channelLayout = channelLayout;
342 dumpNameIn_ = "dump_effect_in_" + sceneType_ + "_"
343 + std::to_string(ioBufferConfig_.inputCfg.samplingRate) + "_"
344 + std::to_string(ioBufferConfig_.inputCfg.channels) + "_4.pcm";
345 dumpNameOut_ = "dump_effect_out_" + sceneType_ + "_"
346 + std::to_string(ioBufferConfig_.outputCfg.samplingRate) + "_"
347 + std::to_string(ioBufferConfig_.outputCfg.channels) + "_4.pcm";
348 return SUCCESS;
349 }
350
ResetIoBufferConfig()351 void AudioEffectChain::ResetIoBufferConfig()
352 {
353 ioBufferConfig_.inputCfg.channels = DEFAULT_NUM_CHANNEL;
354 ioBufferConfig_.inputCfg.channelLayout = DEFAULT_NUM_CHANNELLAYOUT;
355 ioBufferConfig_.outputCfg.channels = DEFAULT_NUM_CHANNEL;
356 ioBufferConfig_.outputCfg.channelLayout = DEFAULT_NUM_CHANNELLAYOUT;
357 dumpNameIn_ = "dump_effect_in_" + sceneType_ + "_"
358 + std::to_string(ioBufferConfig_.inputCfg.samplingRate) + "_"
359 + std::to_string(ioBufferConfig_.inputCfg.channels) + "_4.pcm";
360 dumpNameOut_ = "dump_effect_out_" + sceneType_ + "_"
361 + std::to_string(ioBufferConfig_.outputCfg.samplingRate) + "_"
362 + std::to_string(ioBufferConfig_.outputCfg.channels) + "_4.pcm";
363 }
364
GetIoBufferConfig()365 AudioEffectConfig AudioEffectChain::GetIoBufferConfig()
366 {
367 return ioBufferConfig_;
368 }
369
StoreOldEffectChainInfo(std::string & sceneMode,AudioEffectConfig & ioBufferConfig)370 void AudioEffectChain::StoreOldEffectChainInfo(std::string &sceneMode, AudioEffectConfig &ioBufferConfig)
371 {
372 sceneMode = effectMode_;
373 ioBufferConfig = GetIoBufferConfig();
374 return;
375 }
376
GetLatency()377 uint32_t AudioEffectChain::GetLatency()
378 {
379 return latency_;
380 }
381
DumpEffectProcessData(std::string fileName,void * buffer,size_t len)382 void AudioEffectChain::DumpEffectProcessData(std::string fileName, void *buffer, size_t len)
383 {
384 if (AudioDump::GetInstance().GetVersionType() == BETA_VERSION) {
385 Media::MediaMonitor::MediaMonitorManager::GetInstance().WriteAudioBuffer(fileName, buffer, len);
386 }
387 }
388
389 #ifdef SENSOR_ENABLE
SetHeadTrackingDisabled()390 void AudioEffectChain::SetHeadTrackingDisabled()
391 {
392 if (IsEmptyEffectHandles()) {
393 return;
394 }
395
396 std::lock_guard<std::mutex> lock(reloadMutex_);
397 for (AudioEffectHandle handle : standByEffectHandles_) {
398 int32_t replyData = 0;
399 HeadPostureData imuDataDisabled = {1, 1.0, 0.0, 0.0, 0.0};
400 AudioEffectTransInfo cmdInfo = {sizeof(HeadPostureData), &imuDataDisabled};
401 AudioEffectTransInfo replyInfo = {sizeof(int32_t), &replyData};
402 int32_t ret = (*handle)->command(handle, EFFECT_CMD_SET_IMU, &cmdInfo, &replyInfo);
403 if (ret != SUCCESS) {
404 AUDIO_WARNING_LOG("SetHeadTrackingDisabled failed");
405 }
406 }
407 }
408 #endif
409
InitEffectChain()410 void AudioEffectChain::InitEffectChain()
411 {
412 if (IsEmptyEffectHandles()) {
413 return;
414 }
415 std::lock_guard<std::mutex> lock(reloadMutex_);
416 for (AudioEffectHandle handle : standByEffectHandles_) {
417 int32_t replyData = 0;
418 AudioEffectTransInfo cmdInfo = {sizeof(int32_t), &replyData};
419 AudioEffectTransInfo replyInfo = {sizeof(int32_t), &replyData};
420 int32_t ret = (*handle)->command(handle, EFFECT_CMD_ENABLE, &cmdInfo, &replyInfo);
421 CHECK_AND_RETURN_LOG(ret == 0, "[%{public}s] with mode [%{public}s], either one of libs EFFECT_CMD_ENABLE fail",
422 sceneType_.c_str(), effectMode_.c_str());
423 }
424 }
425
SetFinalVolume(const float volume)426 void AudioEffectChain::SetFinalVolume(const float volume)
427 {
428 finalVolume_ = volume;
429 }
430
GetFinalVolume()431 float AudioEffectChain::GetFinalVolume()
432 {
433 return finalVolume_;
434 }
435
SetCurrVolume(const float volume)436 void AudioEffectChain::SetCurrVolume(const float volume)
437 {
438 currVolume_ = volume;
439 }
440
GetCurrVolume()441 float AudioEffectChain::GetCurrVolume()
442 {
443 return currVolume_;
444 }
445
SetFinalVolumeState(const bool state)446 void AudioEffectChain::SetFinalVolumeState(const bool state)
447 {
448 sendFinalVolumeState_ = state;
449 }
450
GetFinalVolumeState()451 bool AudioEffectChain::GetFinalVolumeState()
452 {
453 return sendFinalVolumeState_;
454 }
455
SetSpatialDeviceType(AudioSpatialDeviceType spatialDeviceType)456 void AudioEffectChain::SetSpatialDeviceType(AudioSpatialDeviceType spatialDeviceType)
457 {
458 spatialDeviceType_ = spatialDeviceType;
459
460 return;
461 }
462 } // namespace AudioStandard
463 } // namespace OHOS
464