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 #include <cstddef>
17 #include <cstdint>
18 #include "securec.h"
19
20 #include "audio_effect.h"
21 #include "audio_effect_chain.h"
22 #include "audio_effect_log.h"
23 #include "audio_effect_chain_manager.h"
24 #ifdef SUPPORT_OLD_ENGINE
25 #include "audio_effect_chain_adapter.h"
26 #include "audio_enhance_chain_adapter.h"
27 #endif
28 #include "audio_enhance_chain_manager.h"
29 #include "audio_enhance_chain_manager_impl.h"
30 #include "audio_errors.h"
31 #include "audio_head_tracker.h"
32
33 namespace OHOS {
34 namespace AudioStandard {
35 using namespace std;
36
37 constexpr uint32_t INFOCHANNELS = 2;
38 constexpr uint64_t INFOCHANNELLAYOUT = 0x3;
39 const char* SCENETYPEMUSIC = "SCENE_MUSIC";
40 const char* SESSIONIDDEFAULT = "123456";
41 const char* EFFECTDEFAULT = "EFFECT_DEFAULT";
42 const uint32_t AUDIOEFFECTSCENE_LENGTH = 6;
43 const uint32_t AUDIOENCODINGTYPE_LENGTH = 3;
44 const string EXTRASCENETYPE = "2";
45 const int32_t DEFAULT_RATE = 48000;
46 const int32_t DEFAULT_CHANNEL = 4;
47 const int32_t DEFAULT_FORMAT = 1;
48 const int32_t MAX_EXTRA_NUM = 3;
49 const float SYSTEM_VOLINFO = 0.75f;
50 static const uint8_t *RAW_DATA = nullptr;
51 static size_t g_dataSize = 0;
52 static size_t g_pos;
53 const size_t THRESHOLD = 10;
54 const int32_t NUM_2 = 2;
55 const int32_t TEST_HANDLE_SIZE = 10;
56
57 vector<EffectChain> DEFAULT_EFFECT_CHAINS = {{"EFFECTCHAIN_SPK_MUSIC", {}, ""}, {"EFFECTCHAIN_BT_MUSIC", {}, ""}};
58 vector<shared_ptr<AudioEffectLibEntry>> DEFAULT_EFFECT_LIBRARY_LIST = {};
59 EffectChainManagerParam DEFAULT_MAP{
60 3,
61 "SCENE_DEFAULT",
62 {},
63 {{"SCENE_MOVIE_&_EFFECT_DEFAULT_&_DEVICE_TYPE_SPEAKER", "EFFECTCHAIN_SPK_MUSIC"},
64 {"SCENE_MOVIE_&_EFFECT_DEFAULT_&_DEVICE_TYPE_BLUETOOTH_A2DP", "EFFECTCHAIN_BT_MUSIC"}},
65 {{"effect1", "property1"}, {"effect4", "property5"}, {"effect1", "property4"}}
66 };
67
68 EffectChainManagerParam DEFAULT_EFFECT_CHAIN_MANAGER_PARAM{
69 3,
70 "SCENE_DEFAULT",
71 {},
72 {{"SCENE_MOVIE_&_EFFECT_DEFAULT_&_DEVICE_TYPE_SPEAKER", "EFFECTCHAIN_SPK_MUSIC"},
73 {"SCENE_MOVIE_&_EFFECT_DEFAULT_&_DEVICE_TYPE_BLUETOOTH_A2DP", "EFFECTCHAIN_BT_MUSIC"}},
74 {{"effect1", "property1"}, {"effect4", "property5"}, {"effect1", "property4"}}
75 };
76
77 SessionEffectInfo DEFAULT_INFO = {
78 "EFFECT_DEFAULT",
79 "SCENE_MOVIE",
80 INFOCHANNELS,
81 INFOCHANNELLAYOUT,
82 };
83
84 #define DEFAULT_NUM_CHANNEL 2
85 #define DEFAULT_CHANNELLAYOUT 3
86
87 const vector<DeviceType> g_testDeviceTypes = {
88 DEVICE_TYPE_NONE,
89 DEVICE_TYPE_INVALID,
90 DEVICE_TYPE_EARPIECE,
91 DEVICE_TYPE_SPEAKER,
92 DEVICE_TYPE_WIRED_HEADSET,
93 DEVICE_TYPE_WIRED_HEADPHONES,
94 DEVICE_TYPE_BLUETOOTH_SCO,
95 DEVICE_TYPE_BLUETOOTH_A2DP,
96 DEVICE_TYPE_BLUETOOTH_A2DP_IN,
97 DEVICE_TYPE_MIC,
98 DEVICE_TYPE_WAKEUP,
99 DEVICE_TYPE_USB_HEADSET,
100 DEVICE_TYPE_DP,
101 DEVICE_TYPE_REMOTE_CAST,
102 DEVICE_TYPE_USB_DEVICE,
103 DEVICE_TYPE_ACCESSORY,
104 DEVICE_TYPE_REMOTE_DAUDIO,
105 DEVICE_TYPE_HDMI,
106 DEVICE_TYPE_LINE_DIGITAL,
107 DEVICE_TYPE_NEARLINK,
108 DEVICE_TYPE_NEARLINK_IN,
109 DEVICE_TYPE_FILE_SINK,
110 DEVICE_TYPE_FILE_SOURCE,
111 DEVICE_TYPE_EXTERN_CABLE,
112 DEVICE_TYPE_DEFAULT,
113 DEVICE_TYPE_USB_ARM_HEADSET,
114 DEVICE_TYPE_MAX,
115 };
116
117 /*
118 * describe: get data from outside untrusted data(RAW_DATA) which size is according to sizeof(T)
119 * tips: only support basic type
120 */
121 template<class T>
GetData()122 T GetData()
123 {
124 T object {};
125 size_t objectSize = sizeof(object);
126 if (RAW_DATA == nullptr || objectSize > g_dataSize - g_pos) {
127 return object;
128 }
129 errno_t ret = memcpy_s(&object, objectSize, RAW_DATA + g_pos, objectSize);
130 if (ret != EOK) {
131 return {};
132 }
133 g_pos += objectSize;
134 return object;
135 }
136
137 template<class T>
GetArrLength(T & arr)138 uint32_t GetArrLength(T& arr)
139 {
140 if (arr == nullptr) {
141 AUDIO_INFO_LOG("%{public}s: The array length is equal to 0", __func__);
142 return 0;
143 }
144 return sizeof(arr) / sizeof(arr[0]);
145 }
146
EffectChainManagerInitCbFuzzTest()147 void EffectChainManagerInitCbFuzzTest()
148 {
149 #ifdef SUPPORT_OLD_ENGINE
150 AudioEffectChainManager::GetInstance()->InitAudioEffectChainManager(DEFAULT_EFFECT_CHAINS, DEFAULT_MAP,
151 DEFAULT_EFFECT_LIBRARY_LIST);
152
153 const char *sceneType = SCENETYPEMUSIC;
154 EffectChainManagerInitCb(sceneType);
155 sceneType = nullptr;
156 EffectChainManagerInitCb(sceneType);
157 sceneType = "";
158 EffectChainManagerInitCb(sceneType);
159 #endif
160 }
161
EffectChainManagerCreateCbFuzzTest()162 void EffectChainManagerCreateCbFuzzTest()
163 {
164 #ifdef SUPPORT_OLD_ENGINE
165 const char *sceneType = SCENETYPEMUSIC;
166 EffectChainManagerInitCb(sceneType);
167
168 const char *sessionid = SESSIONIDDEFAULT;
169 EffectChainManagerCreateCb(sceneType, sessionid);
170 EffectChainManagerReleaseCb(sceneType, sessionid);
171 sessionid = "";
172 EffectChainManagerCreateCb(sceneType, sessionid);
173 EffectChainManagerReleaseCb(sceneType, sessionid);
174 #endif
175 }
176
EffectChainManagerCheckEffectOffloadFuzzTest()177 void EffectChainManagerCheckEffectOffloadFuzzTest()
178 {
179 #ifdef SUPPORT_OLD_ENGINE
180 const char *sceneType = "";
181 EffectChainManagerInitCb(sceneType);
182 EffectChainManagerCheckEffectOffload();
183 #endif
184 }
185
EffectChainManagerAddSessionInfoFuzzTest()186 void EffectChainManagerAddSessionInfoFuzzTest()
187 {
188 #ifdef SUPPORT_OLD_ENGINE
189 EffectChainManagerInitCb(SCENETYPEMUSIC);
190
191 SessionInfoPack pack = {2, "3", EFFECTDEFAULT, "true"};
192 EffectChainManagerAddSessionInfo(SCENETYPEMUSIC, SESSIONIDDEFAULT, pack);
193 #endif
194 }
195
EffectChainManagerDeleteSessionInfoFuzzTest()196 void EffectChainManagerDeleteSessionInfoFuzzTest()
197 {
198 #ifdef SUPPORT_OLD_ENGINE
199 EffectChainManagerInitCb(SCENETYPEMUSIC);
200
201 SessionInfoPack pack = {2, "3", SESSIONIDDEFAULT, "true"};
202 EffectChainManagerAddSessionInfo(SCENETYPEMUSIC, SESSIONIDDEFAULT, pack);
203 EffectChainManagerDeleteSessionInfo(SCENETYPEMUSIC, SESSIONIDDEFAULT);
204 #endif
205 }
206
EffectChainManagerReturnEffectChannelInfoFuzzTest()207 void EffectChainManagerReturnEffectChannelInfoFuzzTest()
208 {
209 #ifdef SUPPORT_OLD_ENGINE
210 EffectChainManagerInitCb(SCENETYPEMUSIC);
211
212 SessionInfoPack pack = {2, "3", SESSIONIDDEFAULT, "true"};
213 EffectChainManagerAddSessionInfo(SCENETYPEMUSIC, SESSIONIDDEFAULT, pack);
214
215 uint32_t processChannels = GetData<uint32_t>();
216 uint64_t processChannelLayout = GetData<uint64_t>();
217 EffectChainManagerReturnEffectChannelInfo(SCENETYPEMUSIC, &processChannels, &processChannelLayout);
218 #endif
219 }
220
EffectChainManagerReturnMultiChannelInfoFuzzTest()221 void EffectChainManagerReturnMultiChannelInfoFuzzTest()
222 {
223 #ifdef SUPPORT_OLD_ENGINE
224 EffectChainManagerInitCb(SCENETYPEMUSIC);
225
226 uint32_t processChannels = GetData<uint32_t>();
227 uint64_t processChannelLayout = GetData<uint64_t>();
228 EffectChainManagerReturnMultiChannelInfo(&processChannels, &processChannelLayout);
229 #endif
230 }
231
EffectChainManagerSceneCheckFuzzTest()232 void EffectChainManagerSceneCheckFuzzTest()
233 {
234 #ifdef SUPPORT_OLD_ENGINE
235 EffectChainManagerInitCb("SCENE_MUSIC");
236 EffectChainManagerSceneCheck("SCENE_MUSIC", "SCENE_MUSIC");
237 #endif
238 }
239
EffectChainManagerProcessFuzzTest()240 void EffectChainManagerProcessFuzzTest()
241 {
242 #ifdef SUPPORT_OLD_ENGINE
243 EffectChainManagerInitCb(SCENETYPEMUSIC);
244 #endif
245 }
246
EffectChainManagerMultichannelUpdateFuzzTest()247 void EffectChainManagerMultichannelUpdateFuzzTest()
248 {
249 #ifdef SUPPORT_OLD_ENGINE
250 EffectChainManagerInitCb(SCENETYPEMUSIC);
251 EffectChainManagerMultichannelUpdate(nullptr);
252 EffectChainManagerMultichannelUpdate(SCENETYPEMUSIC);
253 #endif
254 }
255
EffectChainManagerExistFuzzTest()256 void EffectChainManagerExistFuzzTest()
257 {
258 #ifdef SUPPORT_OLD_ENGINE
259 EffectChainManagerInitCb(SCENETYPEMUSIC);
260 #endif
261 }
262
EffectChainManagerVolumeUpdateFuzzTest()263 void EffectChainManagerVolumeUpdateFuzzTest()
264 {
265 #ifdef SUPPORT_OLD_ENGINE
266 EffectChainManagerInitCb(SCENETYPEMUSIC);
267 EffectChainManagerVolumeUpdate(SESSIONIDDEFAULT);
268 #endif
269 }
270
AudioEffectChainManagerFirst(std::shared_ptr<AudioEffectChain> audioEffectChain)271 void AudioEffectChainManagerFirst(std::shared_ptr<AudioEffectChain> audioEffectChain)
272 {
273 audioEffectChain->IsEmptyEffectHandles();
274 const uint32_t channels = GetData<uint32_t>();
275 const uint64_t channelLayout = GetData<uint64_t>();
276 audioEffectChain->UpdateMultichannelIoBufferConfig(channels, channelLayout);
277 std::string sceneMode = "EFFECT_DEFAULT";
278 AudioEffectConfig ioBufferConfig;
279 AudioBufferConfig inputCfg;
280 uint32_t samplingRate = GetData<uint32_t>();
281 uint32_t channel = GetData<uint32_t>();
282 uint8_t format = GetData<uint8_t>();
283 uint64_t channelLayouts = GetData<uint64_t>();
284 uint32_t encoding_int = GetData<uint32_t>();
285 encoding_int = (encoding_int%AUDIOENCODINGTYPE_LENGTH)-1;
286 AudioEncodingType encoding = static_cast<AudioEncodingType>(encoding_int);
287 inputCfg.samplingRate = samplingRate;
288 inputCfg.channels = channel;
289 inputCfg.format = format;
290 inputCfg.channelLayout = channelLayouts;
291 inputCfg.encoding = encoding;
292 ioBufferConfig.inputCfg = inputCfg;
293 ioBufferConfig.outputCfg = inputCfg;
294 audioEffectChain->StoreOldEffectChainInfo(sceneMode, ioBufferConfig);
295 }
296
AudioEffectChainFuzzTest()297 void AudioEffectChainFuzzTest()
298 {
299 std::shared_ptr<AudioEffectChain> audioEffectChain = nullptr;
300 std::string sceneType = "SCENE_MUSIC";
301 #ifdef SENSOR_ENABLE
302 std::shared_ptr<HeadTracker> headTracker = nullptr;
303 headTracker = std::make_shared<HeadTracker>();
304 audioEffectChain = std::make_shared<AudioEffectChain>(sceneType, headTracker);
305 #else
306 audioEffectChain = std::make_shared<AudioEffectChain>(sceneType);
307 #endif
308 audioEffectChain->SetEffectMode("EFFECT_DEFAULT");
309 audioEffectChain->SetExtraSceneType(EXTRASCENETYPE);
310 uint32_t currSceneType_int = GetData<uint32_t>();
311 currSceneType_int = (currSceneType_int % AUDIOEFFECTSCENE_LENGTH);
312 AudioEffectScene currSceneType = GetData<AudioEffectScene>();
313 audioEffectChain->SetEffectCurrSceneType(currSceneType);
314 AudioEffectChainManagerFirst(audioEffectChain);
315 }
316
AudioEnhanceChainManagerFuzzTest(AudioEnhanceChainManager * audioEnhanceChainMananger)317 void AudioEnhanceChainManagerFuzzTest(AudioEnhanceChainManager *audioEnhanceChainMananger)
318 {
319 AudioEnhancePropertyArray propertyArray;
320 AudioVolumeType volumeType = GetData<AudioVolumeType>();
321 audioEnhanceChainMananger->SetVolumeInfo(volumeType, SYSTEM_VOLINFO);
322 bool isMute = true;
323 audioEnhanceChainMananger->SetMicrophoneMuteInfo(isMute);
324 isMute = false;
325 audioEnhanceChainMananger->SetMicrophoneMuteInfo(isMute);
326 uint32_t renderId = GetData<uint32_t>();
327 DeviceType newDeviceType = GetData<DeviceType>();
328 audioEnhanceChainMananger->SetOutputDevice(renderId, newDeviceType);
329 audioEnhanceChainMananger->GetAudioEnhanceProperty(propertyArray);
330 audioEnhanceChainMananger->ResetInfo();
331 audioEnhanceChainMananger->SetInputDevice(DEFAULT_CHANNEL, newDeviceType);
332 uint32_t sessionId = GetData<uint32_t>();
333 audioEnhanceChainMananger->SetStreamVolumeInfo(sessionId, 0);
334 std::string mainKey = "mainKey";
335 std::string subKey = "subKey";
336 std::string extraSceneType = "extraSceneType";
337 audioEnhanceChainMananger->UpdateExtraSceneType(mainKey, subKey, extraSceneType);
338 audioEnhanceChainMananger->SendInitCommand();
339 }
340
AudioEnhanceChainManagerCreateFuzzTest(AudioEnhanceChainManager * manager)341 void AudioEnhanceChainManagerCreateFuzzTest(AudioEnhanceChainManager *manager)
342 {
343 uint64_t sceneKeyCode = GetData<uint64_t>();
344 AudioEnhanceDeviceAttr deviceAttr = {};
345 manager->CreateAudioEnhanceChainDynamic(sceneKeyCode, deviceAttr);
346
347 AudioBufferConfig micConfig = {};
348 AudioBufferConfig ecConfig = {};
349 AudioBufferConfig micRefConfig = {};
350 manager->AudioEnhanceChainGetAlgoConfig(sceneKeyCode, micConfig, ecConfig, micRefConfig);
351
352 const uint32_t bufLen = 128;
353 std::vector<uint8_t> input(bufLen);
354 std::vector<uint8_t> output(bufLen);
355 EnhanceTransBuffer transBuf = {};
356 transBuf.micData = input.data();
357 transBuf.micDataLen = input.size();
358 manager->ApplyEnhanceChainById(sceneKeyCode, transBuf);
359 manager->GetChainOutputDataById(sceneKeyCode, output.data(), output.size());
360
361 manager->ReleaseAudioEnhanceChainDynamic(sceneKeyCode);
362 }
363
AudioEnhanceChainManagerPropertyFuzzTest(AudioEnhanceChainManager * manager)364 void AudioEnhanceChainManagerPropertyFuzzTest(AudioEnhanceChainManager *manager)
365 {
366 uint32_t temp = GetData<uint32_t>();
367 DeviceType deviceType = static_cast<DeviceType>(temp);
368
369 AudioEffectPropertyArrayV3 propV3Array = {};
370 manager->SetAudioEnhanceProperty(propV3Array, deviceType);
371 manager->GetAudioEnhanceProperty(propV3Array, deviceType);
372
373 AudioEnhancePropertyArray propArray = {};
374 manager->SetAudioEnhanceProperty(propArray, deviceType);
375 manager->GetAudioEnhanceProperty(propArray, deviceType);
376 }
377
AudioEnhanceChainFuzzTest()378 void AudioEnhanceChainFuzzTest()
379 {
380 #ifdef SUPPORT_OLD_ENGINE
381 EffectChainManagerParam managerParam;
382 managerParam.maxExtraNum = MAX_EXTRA_NUM;
383 managerParam.defaultSceneName = "SCENE_DEFAULT";
384 managerParam.priorSceneList = {};
385 managerParam.sceneTypeToChainNameMap = {{"SCENE_RECORD_&_ENHANCE_DEFAULT_&_DEVICE_TYPE_MIC", "EFFECTCHAIN_RECORD"}};
386 managerParam.effectDefaultProperty = {
387 {"effect1", "property1"}, {"effect2", "property2"}, {"effect3", "property3"}
388 };
389 std::vector<std::shared_ptr<AudioEffectLibEntry>> enhanceLibraryList;
390 enhanceLibraryList = {};
391 AudioEnhanceChainManager *audioEnhanceChainMananger = AudioEnhanceChainManager::GetInstance();
392 EffectChain testChain;
393 testChain.name = "EFFECTCHAIN_RECORD";
394 testChain.apply = {"record"};
395 std::vector<EffectChain> enhanceChains;
396 enhanceChains.emplace_back(testChain);
397 audioEnhanceChainMananger->InitAudioEnhanceChainManager(enhanceChains, managerParam, enhanceLibraryList);
398 DeviceAttrAdapter validAdapter = {DEFAULT_RATE, DEFAULT_CHANNEL, DEFAULT_FORMAT, true,
399 DEFAULT_RATE, DEFAULT_CHANNEL, DEFAULT_FORMAT, true, DEFAULT_RATE, DEFAULT_CHANNEL, DEFAULT_FORMAT};
400 EnhanceChainManagerCreateCb(AUDIOEFFECTSCENE_LENGTH, &validAdapter);
401 EnhanceChainManagerReleaseCb(AUDIOEFFECTSCENE_LENGTH);
402 EnhanceChainManagerExist(AUDIOEFFECTSCENE_LENGTH);
403 pa_sample_spec micSpec;
404 pa_sample_spec ecSpec;
405 pa_sample_spec micRefSpec;
406 pa_sample_spec_init(&micSpec);
407 pa_sample_spec_init(&ecSpec);
408 pa_sample_spec_init(&micRefSpec);
409 EnhanceChainManagerCreateCb(AUDIOEFFECTSCENE_LENGTH, &validAdapter);
410 EnhanceChainManagerGetAlgoConfig(AUDIOEFFECTSCENE_LENGTH, &micSpec, &ecSpec, &micRefSpec);
411 EnhanceChainManagerIsEmptyEnhanceChain();
412 EnhanceChainManagerInitEnhanceBuffer();
413 const char *invalidScene = "SCENE_RECORD";
414 uint64_t sceneTypeCode = GetData<uint64_t>();
415 GetSceneTypeCode(invalidScene, &sceneTypeCode);
416 AudioEnhanceChainManagerFuzzTest(audioEnhanceChainMananger);
417 AudioEnhanceChainManagerCreateFuzzTest(audioEnhanceChainMananger);
418 AudioEnhanceChainManagerPropertyFuzzTest(audioEnhanceChainMananger);
419 #endif
420 }
421
AudioEffectChainGetOutputChannelInfoFuzzTest()422 void AudioEffectChainGetOutputChannelInfoFuzzTest()
423 {
424 AudioEffectChainManager *audioEffectChainManager = AudioEffectChainManager::GetInstance();
425 if (audioEffectChainManager == nullptr) {
426 return;
427 }
428 std::string sceneType = "SCENE_MUSIC";
429 std::string sceneTypeAndDeviceKey = sceneType + "_&_" + "DEVICE_TYPE_SPEAKER";
430 std::shared_ptr<AudioEffectChain> audioEffectChain = nullptr;
431 #ifdef SENSOR_ENABLE
432 std::shared_ptr<HeadTracker> headTracker = nullptr;
433 headTracker = std::make_shared<HeadTracker>();
434 audioEffectChain = std::make_shared<AudioEffectChain>(sceneType, headTracker);
435 #else
436 audioEffectChain = std::make_shared<AudioEffectChain>(sceneType);
437 #endif
438 audioEffectChainManager->sceneTypeToEffectChainMap_.insert({sceneTypeAndDeviceKey, audioEffectChain});
439 uint32_t channels;
440 uint64_t channelLayout;
441 audioEffectChainManager->GetOutputChannelInfo(sceneType, channels, channelLayout);
442 }
443
AudioEffectChainStreamVolumeUpdateFuzzTest()444 void AudioEffectChainStreamVolumeUpdateFuzzTest()
445 {
446 AudioEffectChainManager *audioEffectChainManager = AudioEffectChainManager::GetInstance();
447 if (audioEffectChainManager == nullptr) {
448 return;
449 }
450
451 const std::string sessionIDString = "12345";
452 const float streamVolume = GetData<float>();
453 audioEffectChainManager->StreamVolumeUpdate(sessionIDString, streamVolume);
454 }
455
AudioEffectChainQueryHdiSupportedChannelInfoFuzzTest()456 void AudioEffectChainQueryHdiSupportedChannelInfoFuzzTest()
457 {
458 AudioEffectChainManager *audioEffectChainManager = AudioEffectChainManager::GetInstance();
459 if (audioEffectChainManager == nullptr) {
460 return;
461 }
462
463 uint32_t channels = GetData<uint32_t>();
464 uint64_t channelLayout = GetData<uint64_t>();
465 SessionEffectInfo sessionEffectInfo;
466 sessionEffectInfo.channelLayout = GetData<uint64_t>();
467 sessionEffectInfo.channels = GetData<uint32_t>();
468 std::set<std::string> sceneType = {"123"};
469 audioEffectChainManager->isInitialized_ = GetData<bool>();
470 audioEffectChainManager->sceneTypeToSessionIDMap_.insert({"test", sceneType});
471 audioEffectChainManager->sessionIDToEffectInfoMap_.insert({"123", sessionEffectInfo});
472
473 audioEffectChainManager->QueryHdiSupportedChannelInfo(channels, channelLayout);
474 audioEffectChainManager->ResetInfo();
475 }
476
AudioEffectChainUpdateEffectBtOffloadSupportedFuzzTest()477 void AudioEffectChainUpdateEffectBtOffloadSupportedFuzzTest()
478 {
479 AudioEffectChainManager *audioEffectChainManager = AudioEffectChainManager::GetInstance();
480 if (audioEffectChainManager == nullptr) {
481 return;
482 }
483
484 audioEffectChainManager->InitAudioEffectChainManager(DEFAULT_EFFECT_CHAINS,
485 DEFAULT_EFFECT_CHAIN_MANAGER_PARAM, DEFAULT_EFFECT_LIBRARY_LIST);
486 audioEffectChainManager->btOffloadSupported_ = GetData<bool>();
487 audioEffectChainManager->spatializationEnabled_ = GetData<bool>();
488 bool isSupported = GetData<bool>();
489 audioEffectChainManager->UpdateEffectBtOffloadSupported(isSupported);
490 audioEffectChainManager->ResetInfo();
491 }
492
AudioEffectChainLoadEffectPropertiesFuzzTest()493 void AudioEffectChainLoadEffectPropertiesFuzzTest()
494 {
495 AudioEffectChainManager *audioEffectChainManager = AudioEffectChainManager::GetInstance();
496 if (audioEffectChainManager == nullptr) {
497 return;
498 }
499
500 audioEffectChainManager->InitAudioEffectChainManager(DEFAULT_EFFECT_CHAINS,
501 DEFAULT_EFFECT_CHAIN_MANAGER_PARAM, DEFAULT_EFFECT_LIBRARY_LIST);
502 audioEffectChainManager->LoadEffectProperties();
503 }
504
AudioEffectChainSetAudioEffectPropertyFuzzTest()505 void AudioEffectChainSetAudioEffectPropertyFuzzTest()
506 {
507 AudioEffectChainManager *audioEffectChainManager = AudioEffectChainManager::GetInstance();
508 if (audioEffectChainManager == nullptr) {
509 return;
510 }
511 AudioEffectProperty audioEffectProperty1 = {
512 .effectClass = "testClass1",
513 .effectProp = "testProp1",
514 };
515 AudioEffectProperty audioEffectProperty2 = {
516 .effectClass = "testClass2",
517 .effectProp = "testProp2",
518 };
519
520 AudioEffectPropertyArray audioEffectPropertyArray = {};
521 audioEffectPropertyArray.property.push_back(audioEffectProperty1);
522 audioEffectPropertyArray.property.push_back(audioEffectProperty2);
523 audioEffectChainManager->InitAudioEffectChainManager(DEFAULT_EFFECT_CHAINS,
524 DEFAULT_EFFECT_CHAIN_MANAGER_PARAM, DEFAULT_EFFECT_LIBRARY_LIST);
525 const char *sceneType = "SCENE_MUSIC";
526 std::string sceneTypeAndDeviceKey = "SCENE_MUSIC_&_DEVICE_TYPE_SPEAKER";
527 std::shared_ptr<AudioEffectChain> audioEffectChain =
528 audioEffectChainManager->CreateAudioEffectChain(sceneType, GetData<bool>());
529 audioEffectChainManager->sceneTypeToEffectChainMap_.insert({sceneTypeAndDeviceKey, audioEffectChain});
530 audioEffectChainManager->InitAudioEffectChainDynamic(sceneType);
531 audioEffectChainManager->SetAudioEffectProperty(audioEffectPropertyArray);
532 }
533
AudioEffectChainGetAudioEffectPropertyFuzzTest()534 void AudioEffectChainGetAudioEffectPropertyFuzzTest()
535 {
536 AudioEffectChainManager *audioEffectChainManager = AudioEffectChainManager::GetInstance();
537 if (audioEffectChainManager == nullptr) {
538 return;
539 }
540
541 AudioEffectPropertyArrayV3 audioEffectPropertyArrayV3 = {};
542 audioEffectChainManager->InitAudioEffectChainManager(DEFAULT_EFFECT_CHAINS,
543 DEFAULT_EFFECT_CHAIN_MANAGER_PARAM, DEFAULT_EFFECT_LIBRARY_LIST);
544 const char *sceneType = "SCENE_MUSIC";
545 std::string sceneTypeAndDeviceKey = "SCENE_MUSIC_&_DEVICE_TYPE_SPEAKER";
546 std::shared_ptr<AudioEffectChain> audioEffectChain =
547 audioEffectChainManager->CreateAudioEffectChain(sceneType, GetData<bool>());
548
549 audioEffectChainManager->sceneTypeToEffectChainMap_.insert({sceneTypeAndDeviceKey, audioEffectChain});
550 audioEffectChainManager->InitAudioEffectChainDynamic(sceneType);
551 audioEffectChainManager->effectPropertyMap_.insert(std::make_pair("SCENE_MUSIC", "property"));
552 audioEffectChainManager->GetAudioEffectProperty(audioEffectPropertyArrayV3);
553 }
554
AudioEffectChainWaitAndReleaseEffectChainFuzzTest()555 void AudioEffectChainWaitAndReleaseEffectChainFuzzTest()
556 {
557 AudioEffectChainManager *audioEffectChainManager = AudioEffectChainManager::GetInstance();
558 if (audioEffectChainManager == nullptr) {
559 return;
560 }
561
562 std::string sceneType = "SCENE_MUSIC";
563 std::string sceneTypeAndDeviceKey = "SCENE_MUSIC_&_DEVICE_TYPE_SPEAKER";
564 std::string defaultSceneTypeAndDeviceKey = "SCENE_DEFAULT_&_DEVICE_TYPE_SPEAKER";
565 audioEffectChainManager->InitAudioEffectChainManager(DEFAULT_EFFECT_CHAINS,
566 DEFAULT_EFFECT_CHAIN_MANAGER_PARAM, DEFAULT_EFFECT_LIBRARY_LIST);
567 std::shared_ptr<AudioEffectChain> audioEffectChain =
568 audioEffectChainManager->CreateAudioEffectChain(sceneType, GetData<bool>());
569 audioEffectChainManager->sceneTypeToEffectChainMap_.insert({sceneTypeAndDeviceKey, audioEffectChain});
570 audioEffectChainManager->sceneTypeToEffectChainCountMap_.insert({defaultSceneTypeAndDeviceKey, GetData<int32_t>()});
571 audioEffectChainManager->sceneTypeToEffectChainCountMap_.insert({sceneTypeAndDeviceKey, GetData<int32_t>()});
572 int32_t ret = GetData<int32_t>();
573 audioEffectChainManager->WaitAndReleaseEffectChain(sceneType, sceneTypeAndDeviceKey,
574 defaultSceneTypeAndDeviceKey, ret);
575 audioEffectChainManager->ResetInfo();
576 }
577
AudioEffectChainInitEffectBufferFuzzTest()578 void AudioEffectChainInitEffectBufferFuzzTest()
579 {
580 AudioEffectChainManager *audioEffectChainManager = AudioEffectChainManager::GetInstance();
581 if (audioEffectChainManager == nullptr || g_testDeviceTypes.size() == 0) {
582 return;
583 }
584
585 audioEffectChainManager->InitAudioEffectChainManager(DEFAULT_EFFECT_CHAINS,
586 DEFAULT_EFFECT_CHAIN_MANAGER_PARAM, DEFAULT_EFFECT_LIBRARY_LIST);
587 std::string sceneType = "SCENE_MOVIE";
588 std::string sceneTypeAndDeviceKey = "SCENE_MOVIE_&_DEVICE_TYPE_SPEAKER";
589 std::shared_ptr<AudioEffectChain> audioEffectChain =
590 audioEffectChainManager->CreateAudioEffectChain(sceneType, GetData<bool>());
591 audioEffectChainManager->sessionIDToEffectInfoMap_.clear();
592 string sessionID1 = "123456";
593 audioEffectChainManager->deviceType_ =
594 g_testDeviceTypes[GetData<uint32_t>() % g_testDeviceTypes.size()];
595 audioEffectChainManager->sceneTypeToEffectChainMap_.insert({sceneTypeAndDeviceKey, audioEffectChain});
596 audioEffectChainManager->SessionInfoMapAdd(sessionID1, DEFAULT_INFO);
597 audioEffectChainManager->InitEffectBuffer(sessionID1);
598 }
599
AudioEffectChainCheckProcessClusterInstancesFuzzTest()600 void AudioEffectChainCheckProcessClusterInstancesFuzzTest()
601 {
602 AudioEffectChainManager *audioEffectChainManager = AudioEffectChainManager::GetInstance();
603 if (audioEffectChainManager == nullptr) {
604 return;
605 }
606
607 std::string sceneType = "test";
608 std::string scene = "SCENE_DEFAULT";
609 std::string effect = sceneType + "_&_" + audioEffectChainManager->GetDeviceTypeName();
610 std::string defaultScene = scene + "_&_" + audioEffectChainManager->GetDeviceTypeName();
611 auto headTracker = std::make_shared<HeadTracker>();
612 std::shared_ptr<AudioEffectChain> audioEffectChain = std::make_shared<AudioEffectChain>("123", headTracker);
613 audioEffectChainManager->sceneTypeToEffectChainMap_.insert({effect, audioEffectChain});
614 audioEffectChainManager->sceneTypeToEffectChainMap_.insert({defaultScene, audioEffectChain});
615
616 audioEffectChainManager->maxEffectChainCount_ = GetData<int32_t>();
617 audioEffectChainManager->isDefaultEffectChainExisted_ = GetData<bool>();
618 audioEffectChainManager->CheckProcessClusterInstances(sceneType);
619 }
620
AudioEffectChainUpdateDeviceInfoFuzzTest()621 void AudioEffectChainUpdateDeviceInfoFuzzTest()
622 {
623 AudioEffectChainManager *audioEffectChainManager = AudioEffectChainManager::GetInstance();
624 if (audioEffectChainManager == nullptr) {
625 return;
626 }
627
628 int32_t device = GetData<int32_t>();
629 string sinkName = "Speaker";
630
631 audioEffectChainManager->InitAudioEffectChainManager(DEFAULT_EFFECT_CHAINS,
632 DEFAULT_EFFECT_CHAIN_MANAGER_PARAM, DEFAULT_EFFECT_LIBRARY_LIST);
633 if (g_testDeviceTypes.size() != 0) {
634 audioEffectChainManager->deviceType_ = g_testDeviceTypes[GetData<uint32_t>() % g_testDeviceTypes.size()];
635 }
636 audioEffectChainManager->isInitialized_ = static_cast<bool>(GetData<uint32_t>() % NUM_2);
637 audioEffectChainManager->UpdateDeviceInfo(device, sinkName);
638 }
639
AudioEffectChainInitHdiStateFuzzTest()640 void AudioEffectChainInitHdiStateFuzzTest()
641 {
642 AudioEffectChainManager audioEffectChainManager;
643
644 if (g_testDeviceTypes.size() != 0) {
645 audioEffectChainManager.deviceType_ = g_testDeviceTypes[GetData<uint32_t>() % g_testDeviceTypes.size()];
646 }
647 audioEffectChainManager.GetOffloadEnabled();
648 audioEffectChainManager.audioEffectHdiParam_ = nullptr;
649 audioEffectChainManager.InitHdiState();
650 }
651
AudioEffectChainEffectDspVolumeUpdateFuzzTest()652 void AudioEffectChainEffectDspVolumeUpdateFuzzTest()
653 {
654 AudioEffectChainManager *audioEffectChainManager = AudioEffectChainManager::GetInstance();
655 if (audioEffectChainManager == nullptr) {
656 return;
657 }
658
659 audioEffectChainManager->InitAudioEffectChainManager(DEFAULT_EFFECT_CHAINS,
660 DEFAULT_EFFECT_CHAIN_MANAGER_PARAM, DEFAULT_EFFECT_LIBRARY_LIST);
661 const char *sceneType = "SCENE_MUSIC";
662 std::string sceneTypeAndDeviceKey = "SCENE_MUSIC_&_DEVICE_TYPE_SPEAKER";
663 std::shared_ptr<AudioEffectChain> audioEffectChain =
664 audioEffectChainManager->CreateAudioEffectChain(sceneType, GetData<bool>());
665 audioEffectChainManager->sceneTypeToEffectChainMap_.insert({sceneTypeAndDeviceKey, audioEffectChain});
666 audioEffectChainManager->InitAudioEffectChainDynamic(sceneType);
667 const std::string sessionID = "12345";
668 audioEffectChainManager->SessionInfoMapAdd(sessionID, DEFAULT_INFO);
669 std::shared_ptr<AudioEffectVolume> audioEffectVolume = std::make_shared<AudioEffectVolume>();
670 audioEffectChainManager->EffectDspVolumeUpdate(audioEffectVolume);
671 }
672
AudioEffectChainEffectApVolumeUpdateFuzzTest()673 void AudioEffectChainEffectApVolumeUpdateFuzzTest()
674 {
675 AudioEffectChainManager *audioEffectChainManager = AudioEffectChainManager::GetInstance();
676 if (audioEffectChainManager == nullptr) {
677 return;
678 }
679
680 audioEffectChainManager->ResetInfo();
681 SessionEffectInfo sessionEffectInfo;
682 audioEffectChainManager->sessionIDSet_.insert("test");
683 audioEffectChainManager->sessionIDSet_.insert("test1");
684 audioEffectChainManager->sessionIDToEffectInfoMap_.insert({"test", sessionEffectInfo});
685 std::shared_ptr<AudioEffectVolume> audioEffectVolume = std::make_shared<AudioEffectVolume>();
686 audioEffectChainManager->EffectApVolumeUpdate(audioEffectVolume);
687 audioEffectChainManager->ResetInfo();
688 }
689
AudioEffectChainSendEffectApVolumeFuzzTest()690 void AudioEffectChainSendEffectApVolumeFuzzTest()
691 {
692 AudioEffectChainManager *audioEffectChainManager = AudioEffectChainManager::GetInstance();
693
694 std::string scene = "test";
695 auto headTracker = std::make_shared<HeadTracker>();
696 std::shared_ptr<AudioEffectChain> audioEffectChain = std::make_shared<AudioEffectChain>(scene, headTracker);
697 if (audioEffectChainManager == nullptr || audioEffectChain == nullptr) {
698 return;
699 }
700 audioEffectChain->SetCurrVolume(GetData<float>());
701 audioEffectChain->SetFinalVolume(GetData<float>());
702
703 audioEffectChainManager->sceneTypeToEffectChainMap_.insert({"test", nullptr});
704 audioEffectChainManager->sceneTypeToEffectChainMap_.insert({"test1", audioEffectChain});
705 std::shared_ptr<AudioEffectVolume> audioEffectVolume = std::make_shared<AudioEffectVolume>();
706 audioEffectChainManager->SendEffectApVolume(audioEffectVolume);
707 audioEffectChainManager->ResetInfo();
708 }
709
AudioEffectChainEffectRotationUpdateFuzzTest()710 void AudioEffectChainEffectRotationUpdateFuzzTest()
711 {
712 AudioEffectChainManager *audioEffectChainManager = AudioEffectChainManager::GetInstance();
713 if (audioEffectChainManager == nullptr) {
714 return;
715 }
716 uint32_t rotationState = GetData<uint32_t>();
717 std::set<std::string> sceneType = {"123"};
718 audioEffectChainManager->sceneTypeToSessionIDMap_.insert({"test", sceneType});
719
720 audioEffectChainManager->EffectRotationUpdate(rotationState);
721 audioEffectChainManager->ResetInfo();
722 }
723
AudioEffectChainUpdateSensorStateFuzzTest()724 void AudioEffectChainUpdateSensorStateFuzzTest()
725 {
726 AudioEffectChainManager *audioEffectChainManager = AudioEffectChainManager::GetInstance();
727 if (audioEffectChainManager == nullptr) {
728 return;
729 }
730 audioEffectChainManager->InitAudioEffectChainManager(DEFAULT_EFFECT_CHAINS,
731 DEFAULT_EFFECT_CHAIN_MANAGER_PARAM, DEFAULT_EFFECT_LIBRARY_LIST);
732 audioEffectChainManager->headTrackingEnabled_ = GetData<bool>();
733 audioEffectChainManager->btOffloadEnabled_ = GetData<bool>();
734 audioEffectChainManager->btOffloadEnabled_ = GetData<bool>();
735 audioEffectChainManager->UpdateSensorState();
736 audioEffectChainManager->ResetInfo();
737 }
738
AudioEffectChainSetSpatializationSceneTypeFuzzTest()739 void AudioEffectChainSetSpatializationSceneTypeFuzzTest()
740 {
741 static const vector<AudioSpatializationSceneType> testSpatializationSceneTypes = {
742 SPATIALIZATION_SCENE_TYPE_DEFAULT,
743 SPATIALIZATION_SCENE_TYPE_MUSIC,
744 SPATIALIZATION_SCENE_TYPE_MOVIE,
745 SPATIALIZATION_SCENE_TYPE_AUDIOBOOK,
746 SPATIALIZATION_SCENE_TYPE_MAX,
747 };
748 AudioEffectChainManager *audioEffectChainManager = AudioEffectChainManager::GetInstance();
749 if (audioEffectChainManager == nullptr) {
750 return;
751 }
752 AudioSpatializationSceneType spatializationSceneType = SPATIALIZATION_SCENE_TYPE_DEFAULT;
753 if (testSpatializationSceneTypes.size() != 0) {
754 spatializationSceneType = testSpatializationSceneTypes[
755 GetData<uint32_t>() % testSpatializationSceneTypes.size()];
756 }
757
758 audioEffectChainManager->InitAudioEffectChainManager(DEFAULT_EFFECT_CHAINS,
759 DEFAULT_EFFECT_CHAIN_MANAGER_PARAM, DEFAULT_EFFECT_LIBRARY_LIST);
760 audioEffectChainManager->spatializationEnabled_ = GetData<bool>();
761 audioEffectChainManager->deviceType_ = DEVICE_TYPE_BLUETOOTH_A2DP;
762 audioEffectChainManager->SetSpatializationSceneType(spatializationSceneType);
763 audioEffectChainManager->ResetInfo();
764 }
765
AudioEffectChainSendAudioParamToARMFuzzTest()766 void AudioEffectChainSendAudioParamToARMFuzzTest()
767 {
768 static const vector<HdiSetParamCommandCode> testHdiSetParamCommandCode = {
769 HDI_INIT,
770 HDI_BYPASS,
771 HDI_HEAD_MODE,
772 HDI_ROOM_MODE,
773 HDI_BLUETOOTH_MODE,
774 HDI_DESTROY,
775 HDI_UPDATE_SPATIAL_DEVICE_TYPE,
776 HDI_VOLUME,
777 HDI_ROTATION,
778 HDI_EXTRA_SCENE_TYPE,
779 HDI_SPATIALIZATION_SCENE_TYPE,
780 HDI_STREAM_USAGE,
781 HDI_FOLD_STATE,
782 HDI_LID_STATE,
783 HDI_QUERY_CHANNELLAYOUT,
784 };
785 AudioEffectChainManager *audioEffectChainManager = AudioEffectChainManager::GetInstance();
786 if (audioEffectChainManager == nullptr) {
787 return;
788 }
789 HdiSetParamCommandCode code;
790 if (testHdiSetParamCommandCode.size() != 0) {
791 code = testHdiSetParamCommandCode[GetData<uint32_t>() % testHdiSetParamCommandCode.size()];
792 } else {
793 code = HDI_INIT;
794 }
795 std::string value = "test";
796 std::string scene = "123";
797 auto headTracker = std::make_shared<HeadTracker>();
798 std::shared_ptr<AudioEffectChain> audioEffectChain = std::make_shared<AudioEffectChain>(scene, headTracker);
799
800 audioEffectChainManager->sceneTypeToEffectChainMap_.insert({scene, audioEffectChain});
801 audioEffectChainManager->SendAudioParamToARM(code, value);
802 audioEffectChainManager->ResetInfo();
803 }
804
AudioEffectChainUpdateParamExtraFuzzTest()805 void AudioEffectChainUpdateParamExtraFuzzTest()
806 {
807 static const vector<std::string> testSubKeys = {
808 "update_audio_effect_type",
809 "fold_state",
810 "lid_state",
811 };
812 AudioEffectChainManager *audioEffectChainManager = AudioEffectChainManager::GetInstance();
813 if (audioEffectChainManager == nullptr || testSubKeys.size() == 0) {
814 return;
815 }
816
817 bool mainKeyType = GetData<bool>();
818 std::string mainkey = "audio_effect";
819 std::string subkey = testSubKeys[GetData<uint32_t>() % testSubKeys.size()];
820 if (mainKeyType) {
821 mainkey = "device_status";
822 }
823 std::string value = "test";
824 audioEffectChainManager->UpdateParamExtra(mainkey, subkey, value);
825 audioEffectChainManager->ResetInfo();
826 }
827
AudioEffectChainSetSpatializationSceneTypeToChainsFuzzTest()828 void AudioEffectChainSetSpatializationSceneTypeToChainsFuzzTest()
829 {
830 AudioEffectChainManager *audioEffectChainManager = AudioEffectChainManager::GetInstance();
831 if (audioEffectChainManager == nullptr) {
832 return;
833 }
834
835 audioEffectChainManager->InitAudioEffectChainManager(DEFAULT_EFFECT_CHAINS,
836 DEFAULT_EFFECT_CHAIN_MANAGER_PARAM, DEFAULT_EFFECT_LIBRARY_LIST);
837 const char *sceneType = "SCENE_MUSIC";
838 std::string sceneTypeAndDeviceKey = "SCENE_MUSIC_&_DEVICE_TYPE_SPEAKER";
839 std::shared_ptr<AudioEffectChain> audioEffectChain =
840 audioEffectChainManager->CreateAudioEffectChain(sceneType, GetData<bool>());
841
842 audioEffectChainManager->sceneTypeToEffectChainMap_[sceneTypeAndDeviceKey] = audioEffectChain;
843 audioEffectChainManager->InitAudioEffectChainDynamic(sceneType);
844 audioEffectChainManager->SetSpatializationSceneTypeToChains();
845 audioEffectChainManager->ResetInfo();
846 }
847
AudioEffectChainUpdateDefaultAudioEffectFuzzTest()848 void AudioEffectChainUpdateDefaultAudioEffectFuzzTest()
849 {
850 AudioEffectChainManager *audioEffectChainManager = AudioEffectChainManager::GetInstance();
851 if (audioEffectChainManager == nullptr) {
852 return;
853 }
854
855 audioEffectChainManager->InitAudioEffectChainManager(DEFAULT_EFFECT_CHAINS,
856 DEFAULT_EFFECT_CHAIN_MANAGER_PARAM, DEFAULT_EFFECT_LIBRARY_LIST);
857 std::set<std::string> sceneType = {"123"};
858 audioEffectChainManager->sceneTypeToSessionIDMap_.insert({"test", sceneType});
859 audioEffectChainManager->UpdateDefaultAudioEffect();
860 audioEffectChainManager->ResetInfo();
861 }
862
AudioEffectChainUpdateStreamUsageFuzzTest()863 void AudioEffectChainUpdateStreamUsageFuzzTest()
864 {
865 AudioEffectChainManager *audioEffectChainManager = AudioEffectChainManager::GetInstance();
866 if (audioEffectChainManager == nullptr) {
867 return;
868 }
869
870 audioEffectChainManager->InitAudioEffectChainManager(DEFAULT_EFFECT_CHAINS,
871 DEFAULT_EFFECT_CHAIN_MANAGER_PARAM, DEFAULT_EFFECT_LIBRARY_LIST);
872 const std::string sessionID = "12345";
873 audioEffectChainManager->SessionInfoMapAdd(sessionID, DEFAULT_INFO);
874 const char *sceneType = "SCENE_MUSIC";
875 std::string sceneTypeAndDeviceKey = "SCENE_MUSIC_&_DEVICE_TYPE_SPEAKER";
876 audioEffectChainManager->sceneTypeToSpecialEffectSet_.insert(sceneType);
877 audioEffectChainManager->isDefaultEffectChainExisted_ = GetData<bool>();
878 std::shared_ptr<AudioEffectChain> audioEffectChain =
879 audioEffectChainManager->CreateAudioEffectChain(sceneType, GetData<bool>());
880 audioEffectChainManager->sceneTypeToEffectChainMap_.insert({sceneTypeAndDeviceKey, audioEffectChain});
881 audioEffectChainManager->InitAudioEffectChainDynamic(sceneType);
882 audioEffectChainManager->UpdateStreamUsage();
883 }
884
AudioEffectChainCheckSceneTypeMatchFuzzTest()885 void AudioEffectChainCheckSceneTypeMatchFuzzTest()
886 {
887 AudioEffectChainManager *audioEffectChainManager = AudioEffectChainManager::GetInstance();
888 if (audioEffectChainManager == nullptr) {
889 return;
890 }
891
892 const std::string sceneType = "SCENE_MUSIC";
893 const std::string sinkSceneType = "SCENE_MUSIC";
894
895 audioEffectChainManager->deviceType_ = DEVICE_TYPE_SPEAKER;
896 std::string sceneTypeAndDeviceKey = "SCENE_MUSIC_&_DEVICE_TYPE_SPEAKER";
897 std::shared_ptr<AudioEffectChain> audioEffectChain =
898 audioEffectChainManager->CreateAudioEffectChain(sceneType, GetData<bool>());
899 audioEffectChainManager->sceneTypeToEffectChainMap_.insert({sceneTypeAndDeviceKey, audioEffectChain});
900 audioEffectChainManager->sceneTypeToSpecialEffectSet_.insert(sceneType);
901 audioEffectChainManager->CheckSceneTypeMatch(sinkSceneType, sceneType);
902 }
903
AudioEffectChainCheckAndReleaseCommonEffectChainFuzzTest()904 void AudioEffectChainCheckAndReleaseCommonEffectChainFuzzTest()
905 {
906 AudioEffectChainManager *audioEffectChainManager = AudioEffectChainManager::GetInstance();
907 if (audioEffectChainManager == nullptr) {
908 return;
909 }
910
911 std::string sceneType = "test";
912 std::string scene = "SCENE_DEFAULT";
913 audioEffectChainManager->isDefaultEffectChainExisted_ = GetData<bool>();
914
915 std::string deviceTypeName = audioEffectChainManager->GetDeviceTypeName();
916 std::string effectChain0 = scene + "_&_" + deviceTypeName;
917 std::string effectChain1 = sceneType + "_&_" + deviceTypeName;
918 auto headTracker = std::make_shared<HeadTracker>();
919 std::shared_ptr<AudioEffectChain> audioEffectChain = std::make_shared<AudioEffectChain>(scene, headTracker);
920 audioEffectChainManager->sceneTypeToEffectChainMap_.insert({effectChain0, audioEffectChain});
921 audioEffectChainManager->sceneTypeToEffectChainMap_.insert({effectChain1, audioEffectChain});
922
923 audioEffectChainManager->defaultEffectChainCount_ = GetData<int32_t>();
924 audioEffectChainManager->CheckAndReleaseCommonEffectChain(sceneType);
925 audioEffectChainManager->ResetInfo();
926 }
927
AudioEffectChainNotifyAndCreateAudioEffectChainFuzzTest()928 void AudioEffectChainNotifyAndCreateAudioEffectChainFuzzTest()
929 {
930 AudioEffectChainManager *audioEffectChainManager = AudioEffectChainManager::GetInstance();
931 if (audioEffectChainManager == nullptr) {
932 return;
933 }
934
935 std::string sceneType = "SCENE_MUSIC";
936 std::string sceneTypeAndDeviceKey = "SCENE_MUSIC_&_DEVICE_TYPE_SPEAKER";
937 audioEffectChainManager->InitAudioEffectChainManager(DEFAULT_EFFECT_CHAINS,
938 DEFAULT_EFFECT_CHAIN_MANAGER_PARAM, DEFAULT_EFFECT_LIBRARY_LIST);
939 int32_t count = GetData<int32_t>();
940 audioEffectChainManager->sceneTypeToEffectChainCountMap_.insert({sceneTypeAndDeviceKey, count});
941 audioEffectChainManager->NotifyAndCreateAudioEffectChain(sceneType);
942 audioEffectChainManager->ResetInfo();
943 }
944
AudioEffectChainCreateAudioEffectChainDynamicInnerFuzzTest()945 void AudioEffectChainCreateAudioEffectChainDynamicInnerFuzzTest()
946 {
947 AudioEffectChainManager *audioEffectChainManager = AudioEffectChainManager::GetInstance();
948 if (audioEffectChainManager == nullptr) {
949 return;
950 }
951
952 audioEffectChainManager->InitAudioEffectChainManager(DEFAULT_EFFECT_CHAINS,
953 DEFAULT_EFFECT_CHAIN_MANAGER_PARAM, DEFAULT_EFFECT_LIBRARY_LIST);
954 std::string sceneType = "SCENE_MOVIE";
955 std::string sceneTypeAndDeviceKey = "SCENE_MOVIE_&_DEVICE_TYPE_SPEAKER";
956 std::shared_ptr<AudioEffectChain> audioEffectChain =
957 audioEffectChainManager->CreateAudioEffectChain(sceneType, GetData<bool>());
958 audioEffectChainManager->sessionIDToEffectInfoMap_.clear();
959 string sessionID1 = "123456";
960 audioEffectChainManager->deviceType_ = DeviceType::DEVICE_TYPE_SPEAKER;
961 audioEffectChainManager->sceneTypeToEffectChainMap_.insert({sceneTypeAndDeviceKey, audioEffectChain});
962 audioEffectChainManager->SessionInfoMapAdd(sessionID1, DEFAULT_INFO);
963 audioEffectChainManager->CreateAudioEffectChainDynamicInner(sceneType);
964 }
965
AudioEnhanceChainSetRelateWithDevicePropForEnhanceFuzzTest()966 void AudioEnhanceChainSetRelateWithDevicePropForEnhanceFuzzTest()
967 {
968 AudioEnhanceChainManagerImpl audioEnhanceChainManagerImpl;
969 std::string sceneAndMode = "SCENE_VOIP_UP_&_ENHANCE_DEFAULT";
970 EnhanceChainConfigInfo enhanceChainConfigInfo;
971 enhanceChainConfigInfo.chainName = "ENHANCE_DEFAULT";
972 enhanceChainConfigInfo.chainLabel = "SCENE_VOIP_UP";
973 audioEnhanceChainManagerImpl.chainConfigInfoMap_.insert({sceneAndMode, enhanceChainConfigInfo});
974 audioEnhanceChainManagerImpl.SetRelateWithDevicePropForEnhance();
975 }
976
AudioEnhanceChainUpdateEnhancePropertyMapFromDbFuzzTest()977 void AudioEnhanceChainUpdateEnhancePropertyMapFromDbFuzzTest()
978 {
979 if (g_testDeviceTypes.size() == 0) {
980 return;
981 }
982 DeviceType deviceType = g_testDeviceTypes[GetData<uint32_t>() % g_testDeviceTypes.size()];
983 AudioEnhanceChainManagerImpl audioEnhanceChainManagerImpl;
984 audioEnhanceChainManagerImpl.enhancePropertyMap_.insert({"SCENE_VOIP_UP_&_DEVICE_TYPE_MIC", "ENHANCE_DEFAULT"});
985 audioEnhanceChainManagerImpl.UpdateEnhancePropertyMapFromDb(deviceType);
986 }
987
AudioEnhanceChainGetThreadHandlerBySceneFuzzTest()988 void AudioEnhanceChainGetThreadHandlerBySceneFuzzTest()
989 {
990 static const vector<AudioEnhanceScene> testAudioEnhanceScenes = {
991 SCENE_VOIP_UP,
992 SCENE_RECORD,
993 SCENE_PRE_ENHANCE,
994 SCENE_ASR,
995 SCENE_VOICE_MESSAGE,
996 SCENE_NONE,
997 };
998 if (testAudioEnhanceScenes.size() == 0) {
999 return;
1000 }
1001 uint32_t sceneIndex = GetData<uint32_t>() % testAudioEnhanceScenes.size();
1002 AudioEnhanceScene scene = testAudioEnhanceScenes[GetData<uint32_t>() % testAudioEnhanceScenes.size()];
1003 AudioEnhanceChainManagerImpl audioEnhanceChainManagerImpl;
1004 std::shared_ptr<ThreadHandler> threadHandler = ThreadHandler::NewInstance("testThreadHandler");
1005 std::pair<std::shared_ptr<ThreadHandler>, uint32_t> threadHandlerPair =
1006 std::make_pair(threadHandler, GetData<uint32_t>());
1007 audioEnhanceChainManagerImpl.threadHandlerMap_.insert({sceneIndex, threadHandlerPair});
1008 audioEnhanceChainManagerImpl.threadHandlerMap_.insert({sceneIndex, threadHandlerPair});
1009 audioEnhanceChainManagerImpl.GetThreadHandlerByScene(scene);
1010 }
1011
AudioEnhanceChainCreateAudioEnhanceChainDynamicFuzzTest()1012 void AudioEnhanceChainCreateAudioEnhanceChainDynamicFuzzTest()
1013 {
1014 AudioEnhanceChainManagerImpl audioEnhanceChainManagerImpl;
1015 AudioEnhanceDeviceAttr deviceAttr;
1016 uint64_t sceneKeyCode = GetData<uint64_t>();
1017 audioEnhanceChainManagerImpl.CreateAudioEnhanceChainDynamic(sceneKeyCode, deviceAttr);
1018 }
1019
AudioEnhanceChainGetEnhanceNamesBySceneCodeFuzzTest()1020 void AudioEnhanceChainGetEnhanceNamesBySceneCodeFuzzTest()
1021 {
1022 AudioEnhanceChainManagerImpl audioEnhanceChainManagerImpl;
1023 uint64_t sceneKeyCode = GetData<uint64_t>();
1024 bool defaultFlag = GetData<bool>();
1025 audioEnhanceChainManagerImpl.GetEnhanceNamesBySceneCode(sceneKeyCode, defaultFlag);
1026 }
1027
AudioEnhanceChainCreateEnhanceChainInnerFuzzTest()1028 void AudioEnhanceChainCreateEnhanceChainInnerFuzzTest()
1029 {
1030 AudioEnhanceChainManagerImpl audioEnhanceChainManagerImpl;
1031 AudioEnhanceDeviceAttr deviceAttr;
1032 deviceAttr.ecChannels = GetData<uint32_t>();
1033 deviceAttr.micRate = GetData<uint64_t>();
1034 deviceAttr.needEc = GetData<bool>();
1035 deviceAttr.needMicRef = GetData<bool>();
1036 uint64_t sceneKeyCode = GetData<uint64_t>();
1037 audioEnhanceChainManagerImpl.CreateEnhanceChainInner(sceneKeyCode, deviceAttr);
1038 }
1039
AudioEnhanceChainAddAudioEnhanceChainHandlesFuzzTest()1040 void AudioEnhanceChainAddAudioEnhanceChainHandlesFuzzTest()
1041 {
1042 AudioEnhanceChainManagerImpl audioEnhanceChainManagerImpl;
1043 std::string scene = "scene";
1044 AudioEnhanceParamAdapter algoParam;
1045 AudioEnhanceDeviceAttr deviceAttr;
1046 uint64_t chainId = GetData<uint64_t>();
1047 std::shared_ptr<AudioEnhanceChain> audioEnhanceChain =
1048 std::make_shared<AudioEnhanceChain>(chainId, scene, ScenePriority::PRIOR_SCENE, algoParam, deviceAttr);
1049 if (audioEnhanceChain == nullptr) {
1050 return;
1051 }
1052 std::vector<std::string> enhanceNames;
1053 enhanceNames.push_back("enhance1");
1054 enhanceNames.push_back("enhance2");
1055 audioEnhanceChainManagerImpl.AddAudioEnhanceChainHandles(audioEnhanceChain, enhanceNames);
1056 }
1057
AudioEnhanceChainSetAudioEnhancePropertyToChainsFuzzTest()1058 void AudioEnhanceChainSetAudioEnhancePropertyToChainsFuzzTest()
1059 {
1060 AudioEnhanceChainManagerImpl audioEnhanceChainManagerImpl;
1061 AudioEffectPropertyV3 property;
1062 audioEnhanceChainManagerImpl.SetAudioEnhancePropertyToChains(property);
1063 }
1064
AudioEnhanceChainApplyEnhanceChainByIdFuzzTest()1065 void AudioEnhanceChainApplyEnhanceChainByIdFuzzTest()
1066 {
1067 AudioEnhanceChainManagerImpl audioEnhanceChainManagerImpl;
1068 uint64_t sceneKeyCode = GetData<uint64_t>();
1069 EnhanceTransBuffer transBuf;
1070 audioEnhanceChainManagerImpl.ApplyEnhanceChainById(sceneKeyCode, transBuf);
1071 }
1072
AudioEnhanceChainUpdateExtraSceneTypeFuzzTest()1073 void AudioEnhanceChainUpdateExtraSceneTypeFuzzTest()
1074 {
1075 AudioEnhanceChainManagerImpl audioEnhanceChainManagerImpl;
1076 std::string mainkey = "audio_effect";
1077 std::string subkey = "update_audio_effect_type";
1078 std::string extraSceneType = "SCENE_VOIP_UP";
1079 audioEnhanceChainManagerImpl.UpdateExtraSceneType(mainkey, subkey, extraSceneType);
1080 }
1081
SetAbsVolumeStateToEffectFuzzTest()1082 void SetAbsVolumeStateToEffectFuzzTest()
1083 {
1084 std::string scene = "SCENE_MUSIC";
1085 auto headTracker = std::make_shared<HeadTracker>();
1086 std::shared_ptr<AudioEffectChain> audioEffectChain = std::make_shared<AudioEffectChain>(scene, headTracker);
1087 AudioEffectChainManager *audioEffectChainManager = AudioEffectChainManager::GetInstance();
1088 if (audioEffectChain == nullptr || audioEffectChainManager == nullptr) {
1089 return;
1090 }
1091 audioEffectChainManager->sceneTypeToEffectChainMap_.insert({scene, audioEffectChain});
1092 audioEffectChainManager->sceneTypeToEffectChainMap_.insert({"1", nullptr});
1093 bool absVolumeState = GetData<bool>();
1094 audioEffectChainManager->SetAbsVolumeStateToEffect(absVolumeState);
1095 audioEffectChainManager->EffectDspAbsVolumeStateUpdate(absVolumeState);
1096 audioEffectChainManager->EffectApAbsVolumeStateUpdate(absVolumeState);
1097 }
1098
ReleaseAudioEffectChainDynamicInnerFuzzTest()1099 void ReleaseAudioEffectChainDynamicInnerFuzzTest()
1100 {
1101 AudioEffectChainManager *audioEffectChainManager = AudioEffectChainManager::GetInstance();
1102 if (audioEffectChainManager == nullptr) {
1103 return;
1104 }
1105 audioEffectChainManager->ResetInfo();
1106 std::string sceneType = "test";
1107 std::string deviceKey = sceneType + "_&_" + audioEffectChainManager->GetDeviceTypeName();
1108 std::shared_ptr<AudioEffectChain> audioEffectChain =
1109 audioEffectChainManager->CreateAudioEffectChain(sceneType, GetData<bool>());
1110
1111 audioEffectChainManager->sceneTypeToEffectChainMap_[deviceKey] = audioEffectChain;
1112 audioEffectChainManager->sceneTypeToEffectChainCountMap_[deviceKey] = GetData<int32_t>();
1113
1114 audioEffectChainManager->isInitialized_ = GetData<bool>();
1115 audioEffectChainManager->ReleaseAudioEffectChainDynamicInner(sceneType);
1116 }
1117
EnhanceChainManagerGetAlgoConfigFuzzTest()1118 void EnhanceChainManagerGetAlgoConfigFuzzTest()
1119 {
1120 struct DeviceAttrAdapter validAdapter;
1121 EnhanceChainManagerCreateCb(0, &validAdapter);
1122 EnhanceChainManagerSendInitCommand();
1123 }
1124
QueryEffectChannelInfoInnerFuzzTest()1125 void QueryEffectChannelInfoInnerFuzzTest()
1126 {
1127 AudioEffectChainManager *audioEffectChainManager = AudioEffectChainManager::GetInstance();
1128 if (audioEffectChainManager == nullptr) {
1129 return;
1130 }
1131 audioEffectChainManager->InitAudioEffectChainManager(DEFAULT_EFFECT_CHAINS,
1132 DEFAULT_EFFECT_CHAIN_MANAGER_PARAM, DEFAULT_EFFECT_LIBRARY_LIST);
1133 std::string sceneType = "SCENE_MOVIE";
1134 uint32_t channels = GetData<uint32_t>();
1135 uint64_t channelLayout = GetData<uint64_t>();
1136 audioEffectChainManager->QueryEffectChannelInfoInner(sceneType, channels, channelLayout);
1137 }
1138
EffectChainManagerExistAudioEffectChainInnerFuzzTest1()1139 void EffectChainManagerExistAudioEffectChainInnerFuzzTest1()
1140 {
1141 AudioEffectChainManager *audioEffectChainManager = AudioEffectChainManager::GetInstance();
1142 if (audioEffectChainManager == nullptr) {
1143 return;
1144 }
1145 audioEffectChainManager->InitAudioEffectChainManager(DEFAULT_EFFECT_CHAINS,
1146 DEFAULT_EFFECT_CHAIN_MANAGER_PARAM, DEFAULT_EFFECT_LIBRARY_LIST);
1147 std::string sceneType = "SCENE_MOVIE";
1148 std::string effectMode = "EFFECT_MODE_NORMAL";
1149 audioEffectChainManager->ExistAudioEffectChainInner(sceneType, effectMode);
1150 audioEffectChainManager->deviceType_ = DeviceType::DEVICE_TYPE_SPEAKER;
1151 audioEffectChainManager->ExistAudioEffectChainInner(sceneType, effectMode);
1152 }
1153
EffectChainManagerExistAudioEffectChainInnerFuzzTest2()1154 void EffectChainManagerExistAudioEffectChainInnerFuzzTest2()
1155 {
1156 AudioEffectChainManager *audioEffectChainManager = AudioEffectChainManager::GetInstance();
1157 if (audioEffectChainManager == nullptr) {
1158 return;
1159 }
1160 std::string sceneType = "test";
1161 std::string effectMode = "123";
1162
1163 audioEffectChainManager->ResetInfo();
1164 audioEffectChainManager->isInitialized_ = true;
1165 audioEffectChainManager->ExistAudioEffectChainInner(sceneType, effectMode);
1166
1167 std::string sceneTypeAndMode = sceneType + "_&_" + effectMode + "_&_" +
1168 audioEffectChainManager->GetDeviceTypeName();
1169 audioEffectChainManager->sceneTypeAndModeToEffectChainNameMap_[sceneTypeAndMode] = "123456";
1170
1171 std::shared_ptr<AudioEffectChain> audioEffectChain =
1172 audioEffectChainManager->CreateAudioEffectChain(sceneType, true);
1173 CHECK_AND_RETURN(audioEffectChain != nullptr);
1174 std::string sceneTypeAndDeviceKey = sceneType + "_&_" + audioEffectChainManager->GetDeviceTypeName();
1175 audioEffectChainManager->sceneTypeToEffectChainMap_[sceneTypeAndDeviceKey] = audioEffectChain;
1176 audioEffectChainManager->ExistAudioEffectChainInner(sceneType, effectMode);
1177 }
1178
EffectChainManagerExistAudioEffectChainInnerFuzzTest3()1179 void EffectChainManagerExistAudioEffectChainInnerFuzzTest3()
1180 {
1181 AudioEffectChainManager *audioEffectChainManager = AudioEffectChainManager::GetInstance();
1182 if (audioEffectChainManager == nullptr) {
1183 return;
1184 }
1185 std::string sceneType = "test";
1186 std::string effectMode = "123";
1187
1188 audioEffectChainManager->ResetInfo();
1189 audioEffectChainManager->isInitialized_ = true;
1190 std::string sceneTypeAndMode = sceneType + "_&_" + effectMode + "_&_" +
1191 audioEffectChainManager->GetDeviceTypeName();
1192 audioEffectChainManager->sceneTypeAndModeToEffectChainNameMap_[sceneTypeAndMode] = "123456";
1193 audioEffectChainManager->ExistAudioEffectChainInner(sceneType, effectMode);
1194
1195 std::string sceneTypeAndDeviceKey = sceneType + "_&_" + audioEffectChainManager->GetDeviceTypeName();
1196 audioEffectChainManager->sceneTypeToEffectChainMap_[sceneTypeAndDeviceKey] = nullptr;
1197 audioEffectChainManager->ExistAudioEffectChainInner(sceneType, effectMode);
1198 }
1199
EnhanceChainManagerUpdatePropertyAndSendToAlgoFuzzTest()1200 void EnhanceChainManagerUpdatePropertyAndSendToAlgoFuzzTest()
1201 {
1202 AudioEnhanceChainManagerImpl audioEnhanceChainManagerImpl;
1203 audioEnhanceChainManagerImpl.enhancePropertyMap_.insert({"SCENE_VOIP_UP_&_DEVICE_TYPE_MIC", "ENHANCE_DEFAULT"});
1204 DeviceType deviceType = GetData<DeviceType>();
1205 audioEnhanceChainManagerImpl.UpdatePropertyAndSendToAlgo(deviceType);
1206 }
1207
1208 typedef void (*TestFuncs[59])();
1209
1210 TestFuncs g_testFuncs = {
1211 EffectChainManagerInitCbFuzzTest,
1212 EffectChainManagerCreateCbFuzzTest,
1213 EffectChainManagerCheckEffectOffloadFuzzTest,
1214 EffectChainManagerAddSessionInfoFuzzTest,
1215 EffectChainManagerDeleteSessionInfoFuzzTest,
1216 EffectChainManagerReturnEffectChannelInfoFuzzTest,
1217 EffectChainManagerReturnMultiChannelInfoFuzzTest,
1218 EffectChainManagerSceneCheckFuzzTest,
1219 EffectChainManagerProcessFuzzTest,
1220 EffectChainManagerMultichannelUpdateFuzzTest,
1221 EffectChainManagerExistFuzzTest,
1222 EffectChainManagerVolumeUpdateFuzzTest,
1223 AudioEffectChainFuzzTest,
1224 AudioEnhanceChainFuzzTest,
1225 AudioEffectChainGetOutputChannelInfoFuzzTest,
1226 AudioEffectChainStreamVolumeUpdateFuzzTest,
1227 AudioEffectChainQueryHdiSupportedChannelInfoFuzzTest,
1228 AudioEffectChainUpdateEffectBtOffloadSupportedFuzzTest,
1229 AudioEffectChainLoadEffectPropertiesFuzzTest,
1230 AudioEffectChainSetAudioEffectPropertyFuzzTest,
1231 AudioEffectChainGetAudioEffectPropertyFuzzTest,
1232 AudioEffectChainWaitAndReleaseEffectChainFuzzTest,
1233 AudioEffectChainInitEffectBufferFuzzTest,
1234 AudioEffectChainCheckProcessClusterInstancesFuzzTest,
1235 AudioEffectChainUpdateDeviceInfoFuzzTest,
1236 AudioEffectChainInitHdiStateFuzzTest,
1237 AudioEffectChainEffectDspVolumeUpdateFuzzTest,
1238 AudioEffectChainEffectApVolumeUpdateFuzzTest,
1239 AudioEffectChainSendEffectApVolumeFuzzTest,
1240 AudioEffectChainEffectRotationUpdateFuzzTest,
1241 AudioEffectChainUpdateSensorStateFuzzTest,
1242 AudioEffectChainSetSpatializationSceneTypeFuzzTest,
1243 AudioEffectChainSendAudioParamToARMFuzzTest,
1244 AudioEffectChainUpdateParamExtraFuzzTest,
1245 AudioEffectChainSetSpatializationSceneTypeToChainsFuzzTest,
1246 AudioEffectChainUpdateDefaultAudioEffectFuzzTest,
1247 AudioEffectChainUpdateStreamUsageFuzzTest,
1248 AudioEffectChainCheckSceneTypeMatchFuzzTest,
1249 AudioEffectChainCheckAndReleaseCommonEffectChainFuzzTest,
1250 AudioEffectChainNotifyAndCreateAudioEffectChainFuzzTest,
1251 AudioEffectChainCreateAudioEffectChainDynamicInnerFuzzTest,
1252 AudioEnhanceChainSetRelateWithDevicePropForEnhanceFuzzTest,
1253 AudioEnhanceChainUpdateEnhancePropertyMapFromDbFuzzTest,
1254 AudioEnhanceChainGetThreadHandlerBySceneFuzzTest,
1255 AudioEnhanceChainCreateAudioEnhanceChainDynamicFuzzTest,
1256 AudioEnhanceChainGetEnhanceNamesBySceneCodeFuzzTest,
1257 AudioEnhanceChainCreateEnhanceChainInnerFuzzTest,
1258 AudioEnhanceChainAddAudioEnhanceChainHandlesFuzzTest,
1259 AudioEnhanceChainSetAudioEnhancePropertyToChainsFuzzTest,
1260 AudioEnhanceChainApplyEnhanceChainByIdFuzzTest,
1261 AudioEnhanceChainUpdateExtraSceneTypeFuzzTest,
1262 SetAbsVolumeStateToEffectFuzzTest,
1263 ReleaseAudioEffectChainDynamicInnerFuzzTest,
1264 EnhanceChainManagerGetAlgoConfigFuzzTest,
1265 QueryEffectChannelInfoInnerFuzzTest,
1266 EffectChainManagerExistAudioEffectChainInnerFuzzTest1,
1267 EffectChainManagerExistAudioEffectChainInnerFuzzTest2,
1268 EffectChainManagerExistAudioEffectChainInnerFuzzTest3,
1269 EnhanceChainManagerUpdatePropertyAndSendToAlgoFuzzTest,
1270 };
1271
FuzzTest(const uint8_t * rawData,size_t size)1272 bool FuzzTest(const uint8_t* rawData, size_t size)
1273 {
1274 if (rawData == nullptr) {
1275 return false;
1276 }
1277
1278 // initialize data
1279 RAW_DATA = rawData;
1280 g_dataSize = size;
1281 g_pos = 0;
1282
1283 uint32_t code = GetData<uint32_t>();
1284 uint32_t len = GetArrLength(g_testFuncs);
1285 if (len > 0) {
1286 g_testFuncs[code % len]();
1287 } else {
1288 AUDIO_INFO_LOG("%{public}s: The len length is equal to 0", __func__);
1289 }
1290
1291 return true;
1292 }
1293 } // namespace AudioStandard
1294 } // namespace OHOS
1295
1296 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)1297 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
1298 {
1299 if (size < OHOS::AudioStandard::THRESHOLD) {
1300 return 0;
1301 }
1302
1303 OHOS::AudioStandard::FuzzTest(data, size);
1304 return 0;
1305 }
1306