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