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 #include <chrono>
16 #include <thread>
17 #include <fstream>
18 
19 #include "audio_effect.h"
20 #include "audio_utils.h"
21 #include "audio_effect_log.h"
22 #include "audio_effect_chain_manager.h"
23 #include "audio_errors.h"
24 
25 namespace OHOS {
26 namespace AudioStandard {
27 using namespace std;
28 constexpr uint32_t INFOCHANNELS = 2;
29 constexpr uint64_t INFOCHANNELLAYOUT = 0x3;
30 const int32_t LIMITSIZE = 4;
31 const string SCENETYPEDEFAULT = "SCENE_MOVIE";
32 const string SCENETYPEMUSIC = "SCENE_MUSIC";
33 bool g_hasPermission = false;
34 const uint64_t COMMON_UINT64_NUM = 2;
35 vector<EffectChain> DEFAULT_EFFECT_CHAINS = {{"EFFECTCHAIN_SPK_MUSIC", {}, ""}, {"EFFECTCHAIN_BT_MUSIC", {}, ""}};
36 EffectChainManagerParam DEFAULT_MAP{
37     3,
38     "SCENE_DEFAULT",
39     {},
40     {{"SCENE_MOVIE_&_EFFECT_DEFAULT_&_DEVICE_TYPE_SPEAKER", "EFFECTCHAIN_SPK_MUSIC"},
41         {"SCENE_MOVIE_&_EFFECT_DEFAULT_&_DEVICE_TYPE_BLUETOOTH_A2DP", "EFFECTCHAIN_BT_MUSIC"}},
42     {{"effect1", "property1"}, {"effect4", "property5"}, {"effect1", "property4"}}
43 };
44 
45 vector<shared_ptr<AudioEffectLibEntry>> DEFAULT_EFFECT_LIBRARY_LIST = {};
46 SessionEffectInfo DEFAULT_INFO = {
47     "EFFECT_DEFAULT",
48     SCENETYPEDEFAULT,
49     INFOCHANNELS,
50     INFOCHANNELLAYOUT,
51     "0",
52 };
53 
InitAudioEffectChainManagerFuzzTest(const uint8_t *rawData, size_t size)54 void InitAudioEffectChainManagerFuzzTest(const uint8_t *rawData, size_t size)
55 {
56     if (rawData == nullptr || size < LIMITSIZE) {
57         return;
58     }
59     string effectMode = "EFFECT_DEFAULT";
60     string sceneType = "SCENE_MOVIE";
61     string spatializationEnabled = "0";
62     AudioEffectScene currSceneType = SCENE_MUSIC;
63     AudioEffectChainManager::GetInstance()->InitAudioEffectChainManager(DEFAULT_EFFECT_CHAINS, DEFAULT_MAP,
64         DEFAULT_EFFECT_LIBRARY_LIST);
65     AudioEffectChainManager::GetInstance()->CreateAudioEffectChainDynamic(sceneType);
66     AudioEffectChainManager::GetInstance()->ExistAudioEffectChain(sceneType, effectMode,
67         spatializationEnabled);
68     AudioEffectChainManager::GetInstance()->SetHdiParam(currSceneType);
69     AudioEffectChainManager::GetInstance()->ResetInfo();
70 }
71 
CheckAndAddSessionIDFuzzTest(const uint8_t *rawData, size_t size)72 void CheckAndAddSessionIDFuzzTest(const uint8_t *rawData, size_t size)
73 {
74     if (rawData == nullptr || size < LIMITSIZE) {
75         return;
76     }
77     std::string sessionID = "123456";
78     AudioEffectChainManager::GetInstance()->CheckAndAddSessionID(sessionID);
79     AudioEffectChainManager::GetInstance()->CheckAndRemoveSessionID(sessionID);
80     AudioEffectChainManager::GetInstance()->ResetInfo();
81 }
82 
CheckAndRemoveSessionIDFuzzTest(const uint8_t *rawData, size_t size)83 void CheckAndRemoveSessionIDFuzzTest(const uint8_t *rawData, size_t size)
84 {
85     if (rawData == nullptr || size < LIMITSIZE) {
86         return;
87     }
88     const std::string sessionID = "123456";
89     AudioEffectChainManager::GetInstance()->CheckAndRemoveSessionID(sessionID);
90     AudioEffectChainManager::GetInstance()->ResetInfo();
91 }
92 
ReleaseAudioEffectChainDynamicFuzzTest(const uint8_t *rawData, size_t size)93 void ReleaseAudioEffectChainDynamicFuzzTest(const uint8_t *rawData, size_t size)
94 {
95     if (rawData == nullptr || size < LIMITSIZE) {
96         return;
97     }
98     AudioEffectChainManager::GetInstance()->InitAudioEffectChainManager(DEFAULT_EFFECT_CHAINS, DEFAULT_MAP,
99         DEFAULT_EFFECT_LIBRARY_LIST);
100     const std::string sceneType = "SCENE_MOVIE";
101     AudioEffectChainManager::GetInstance()->CreateAudioEffectChainDynamic(sceneType);
102     AudioEffectChainManager::GetInstance()->ReleaseAudioEffectChainDynamic(sceneType);
103     AudioEffectChainManager::GetInstance()->ResetInfo();
104 }
105 
ApplyAudioEffectChainFuzzTest(const uint8_t *rawData, size_t size)106 void ApplyAudioEffectChainFuzzTest(const uint8_t *rawData, size_t size)
107 {
108     if (rawData == nullptr || size < LIMITSIZE) {
109         return;
110     }
111     AudioEffectChainManager::GetInstance()->InitAudioEffectChainManager(DEFAULT_EFFECT_CHAINS, DEFAULT_MAP,
112         DEFAULT_EFFECT_LIBRARY_LIST);
113     int numChans = *reinterpret_cast<const int*>(rawData);
114     int frameLen = *reinterpret_cast<const int*>(rawData);
115     float* bufIn = const_cast<float *>(reinterpret_cast<const float*>(rawData));
116     float* bufOut = const_cast<float *>(reinterpret_cast<const float*>(rawData));
117     auto eBufferAttr = make_unique<EffectBufferAttr>(bufIn, bufOut, numChans, frameLen);
118     const std::string sceneType = "SCENE_MOVIE";
119     AudioEffectChainManager::GetInstance()->CreateAudioEffectChainDynamic(sceneType);
120     AudioEffectChainManager::GetInstance()->ApplyAudioEffectChain(sceneType, eBufferAttr);
121     AudioEffectChainManager::GetInstance()->ResetInfo();
122 }
123 
SetOutputDeviceSinkFuzzTest(const uint8_t *rawData, size_t size)124 void SetOutputDeviceSinkFuzzTest(const uint8_t *rawData, size_t size)
125 {
126     if (rawData == nullptr || size < LIMITSIZE) {
127         return;
128     }
129     AudioEffectChainManager::GetInstance()->InitAudioEffectChainManager(DEFAULT_EFFECT_CHAINS, DEFAULT_MAP,
130         DEFAULT_EFFECT_LIBRARY_LIST);
131     int32_t device = *reinterpret_cast<const int32_t *>(rawData);
132     const std::string sinkName = "123456";
133     AudioEffectChainManager::GetInstance()->SetOutputDeviceSink(device, sinkName);
134     AudioEffectChainManager::GetInstance()->ResetInfo();
135 }
136 
GetDeviceSinkNameFuzzTest(const uint8_t *rawData, size_t size)137 void GetDeviceSinkNameFuzzTest(const uint8_t *rawData, size_t size)
138 {
139     if (rawData == nullptr || size < LIMITSIZE) {
140         return;
141     }
142     AudioEffectChainManager::GetInstance()->GetDeviceTypeName();
143     AudioEffectChainManager::GetInstance()->ResetInfo();
144 }
145 
GetOffloadEnabledFuzzTest(const uint8_t *rawData, size_t size)146 void GetOffloadEnabledFuzzTest(const uint8_t *rawData, size_t size)
147 {
148     if (rawData == nullptr || size < LIMITSIZE) {
149         return;
150     }
151     AudioEffectChainManager::GetInstance()->InitAudioEffectChainManager(DEFAULT_EFFECT_CHAINS, DEFAULT_MAP,
152         DEFAULT_EFFECT_LIBRARY_LIST);
153     AudioEffectChainManager::GetInstance()->deviceType_ = DEVICE_TYPE_SPEAKER;
154 
155     AudioEffectChainManager::GetInstance()->spkOffloadEnabled_ = false;
156     AudioEffectChainManager::GetInstance()->SetSpkOffloadState();
157     AudioEffectChainManager::GetInstance()->GetOffloadEnabled();
158     AudioEffectChainManager::GetInstance()->ResetInfo();
159 }
160 
DumpFuzzTest(const uint8_t *rawData, size_t size)161 void DumpFuzzTest(const uint8_t *rawData, size_t size)
162 {
163     if (rawData == nullptr || size < LIMITSIZE) {
164         return;
165     }
166     AudioEffectChainManager::GetInstance()->Dump();
167 }
168 
UpdateMultichannelConfigFuzzTest(const uint8_t *rawData, size_t size)169 void UpdateMultichannelConfigFuzzTest(const uint8_t *rawData, size_t size)
170 {
171     if (rawData == nullptr || size < LIMITSIZE) {
172         return;
173     }
174     AudioEffectChainManager::GetInstance()->InitAudioEffectChainManager(DEFAULT_EFFECT_CHAINS, DEFAULT_MAP,
175         DEFAULT_EFFECT_LIBRARY_LIST);
176     AudioEffectChainManager::GetInstance()->CreateAudioEffectChainDynamic(SCENETYPEDEFAULT);
177     const std::string sceneType = "SCENE_MOVIE";
178     AudioEffectChainManager::GetInstance()->UpdateMultichannelConfig(sceneType);
179     AudioEffectChainManager::GetInstance()->ResetInfo();
180 }
181 
UpdateSpatializationStateFuzzTest(const uint8_t *rawData, size_t size)182 void UpdateSpatializationStateFuzzTest(const uint8_t *rawData, size_t size)
183 {
184     if (rawData == nullptr || size < LIMITSIZE) {
185         return;
186     }
187     bool spatializationEnabled = *reinterpret_cast<const bool*>(rawData);
188     bool headTrackingEnabled = *reinterpret_cast<const bool*>(rawData + sizeof(bool));
189     AudioSpatializationState spatializationState = {spatializationEnabled, headTrackingEnabled};
190 
191     AudioEffectChainManager::GetInstance()->UpdateSpatializationState(spatializationState);
192     AudioEffectChainManager::GetInstance()->ResetInfo();
193 }
194 
SetHdiParamFuzzTest(const uint8_t *rawData, size_t size)195 void SetHdiParamFuzzTest(const uint8_t *rawData, size_t size)
196 {
197     if (rawData == nullptr || size < LIMITSIZE) {
198         return;
199     }
200     AudioEffectScene currSceneType = SCENE_MUSIC;
201     AudioEffectChainManager::GetInstance()->SetHdiParam(currSceneType);
202     AudioEffectChainManager::GetInstance()->ResetInfo();
203 }
204 
SessionInfoMapAddFuzzTest(const uint8_t *rawData, size_t size)205 void SessionInfoMapAddFuzzTest(const uint8_t *rawData, size_t size)
206 {
207     if (rawData == nullptr || size < LIMITSIZE) {
208         return;
209     }
210     const std::string sessionID = "123456";
211     AudioEffectChainManager::GetInstance()->SessionInfoMapAdd(sessionID, DEFAULT_INFO);
212     AudioEffectChainManager::GetInstance()->SessionInfoMapDelete(SCENETYPEDEFAULT, sessionID);
213     AudioEffectChainManager::GetInstance()->ResetInfo();
214 }
215 
SessionInfoMapDeleteFuzzTest(const uint8_t *rawData, size_t size)216 void SessionInfoMapDeleteFuzzTest(const uint8_t *rawData, size_t size)
217 {
218     if (rawData == nullptr || size < LIMITSIZE) {
219         return;
220     }
221     const std::string sessionID = "123456";
222     AudioEffectChainManager::GetInstance()->SessionInfoMapDelete(SCENETYPEDEFAULT, sessionID);
223     AudioEffectChainManager::GetInstance()->ResetInfo();
224 }
225 
ReturnEffectChannelInfoFuzzTest(const uint8_t *rawData, size_t size)226 void ReturnEffectChannelInfoFuzzTest(const uint8_t *rawData, size_t size)
227 {
228     if (rawData == nullptr || size < LIMITSIZE) {
229         return;
230     }
231 
232     uint32_t channels = *reinterpret_cast<const uint32_t*>(rawData);
233     uint64_t channelLayout = COMMON_UINT64_NUM;
234     const std::string sessionID = "123456";
235 
236     AudioEffectChainManager::GetInstance()->InitAudioEffectChainManager(DEFAULT_EFFECT_CHAINS, DEFAULT_MAP,
237         DEFAULT_EFFECT_LIBRARY_LIST);
238     AudioEffectChainManager::GetInstance()->CreateAudioEffectChainDynamic(SCENETYPEDEFAULT);
239     AudioEffectChainManager::GetInstance()->SessionInfoMapAdd(sessionID, DEFAULT_INFO);
240 
241     AudioEffectChainManager::GetInstance()->ReturnEffectChannelInfo(SCENETYPEDEFAULT, channels,
242         channelLayout);
243 
244     AudioEffectChainManager::GetInstance()->ResetInfo();
245 }
246 
ReturnMultiChannelInfoFuzzTest(const uint8_t *rawData, size_t size)247 void ReturnMultiChannelInfoFuzzTest(const uint8_t *rawData, size_t size)
248 {
249     if (rawData == nullptr || size < LIMITSIZE) {
250         return;
251     }
252 
253     uint32_t channels = *reinterpret_cast<const uint32_t*>(rawData);
254     uint64_t channelLayout = COMMON_UINT64_NUM;
255     const std::string sessionID = "123456";
256 
257     AudioEffectChainManager::GetInstance()->SessionInfoMapAdd(sessionID, DEFAULT_INFO);
258     AudioEffectChainManager::GetInstance()->ReturnMultiChannelInfo(&channels, &channelLayout);
259     AudioEffectChainManager::GetInstance()->ResetInfo();
260 }
261 
EffectRotationUpdateFuzzTest(const uint8_t *rawData, size_t size)262 void EffectRotationUpdateFuzzTest(const uint8_t *rawData, size_t size)
263 {
264     if (rawData == nullptr || size < LIMITSIZE) {
265         return;
266     }
267     uint32_t rotationState = *reinterpret_cast<const uint32_t*>(rawData);
268     AudioEffectChainManager::GetInstance()->EffectRotationUpdate(rotationState);
269     AudioEffectChainManager::GetInstance()->ResetInfo();
270 }
271 
GetLatencyFuzzTest(const uint8_t *rawData, size_t size)272 void GetLatencyFuzzTest(const uint8_t *rawData, size_t size)
273 {
274     if (rawData == nullptr || size < LIMITSIZE) {
275         return;
276     }
277     const std::string sessionID = "123456";
278     AudioEffectChainManager::GetInstance()->SessionInfoMapAdd(sessionID, DEFAULT_INFO);
279     AudioEffectChainManager::GetInstance()->GetLatency(sessionID);
280     AudioEffectChainManager::GetInstance()->ResetInfo();
281 }
282 
SetSpatializationSceneTypeFuzzTest(const uint8_t *rawData, size_t size)283 void SetSpatializationSceneTypeFuzzTest(const uint8_t *rawData, size_t size)
284 {
285     if (rawData == nullptr || size < LIMITSIZE || size < sizeof(AudioSpatializationSceneType)) {
286         return;
287     }
288     AudioSpatializationSceneType spatializationSceneType =
289         *reinterpret_cast<const AudioSpatializationSceneType*>(rawData);
290 
291     AudioEffectChainManager::GetInstance()->SetSpatializationSceneType(spatializationSceneType);
292     AudioEffectChainManager::GetInstance()->ResetInfo();
293 }
294 
GetCurSpatializationEnabledFuzzTest(const uint8_t *rawData, size_t size)295 void GetCurSpatializationEnabledFuzzTest(const uint8_t *rawData, size_t size)
296 {
297     if (rawData == nullptr || size < LIMITSIZE) {
298         return;
299     }
300     AudioEffectChainManager::GetInstance()->GetCurSpatializationEnabled();
301     AudioEffectChainManager::GetInstance()->ResetInfo();
302 }
303 
ResetEffectBufferFuzzTest(const uint8_t *rawData, size_t size)304 void ResetEffectBufferFuzzTest(const uint8_t *rawData, size_t size)
305 {
306     if (rawData == nullptr || size < LIMITSIZE) {
307         return;
308     }
309     AudioEffectChainManager::GetInstance()->ResetEffectBuffer();
310 }
311 
UpdateSpkOffloadEnabledFuzzTest(const uint8_t* rawData, size_t size)312 void UpdateSpkOffloadEnabledFuzzTest(const uint8_t* rawData, size_t size)
313 {
314     if (rawData == nullptr || size < LIMITSIZE) {
315         return;
316     }
317     AudioEffectChainManager::GetInstance()->InitAudioEffectChainManager(DEFAULT_EFFECT_CHAINS, DEFAULT_MAP,
318         DEFAULT_EFFECT_LIBRARY_LIST);
319     bool spkOffloadEnabled = *reinterpret_cast<const bool*>(rawData);
320     AudioEffectChainManager::GetInstance()->spkOffloadEnabled_ = spkOffloadEnabled;
321     AudioEffectChainManager::GetInstance()->UpdateDefaultAudioEffect();
322     AudioEffectChainManager::GetInstance()->deviceType_ = DEVICE_TYPE_SPEAKER;
323     AudioEffectChainManager::GetInstance()->GetOffloadEnabled();
324     AudioEffectChainManager::GetInstance()->ResetInfo();
325 }
326 
UpdateDeviceInfoFuzzTest(const uint8_t* rawData, size_t size)327 void UpdateDeviceInfoFuzzTest(const uint8_t* rawData, size_t size)
328 {
329     if (rawData == nullptr || size < LIMITSIZE) {
330         return;
331     }
332 
333     int32_t device = *reinterpret_cast<const int32_t*>(rawData);
334     string sinkName = "Speaker";
335 
336     AudioEffectChainManager::GetInstance()->InitAudioEffectChainManager(DEFAULT_EFFECT_CHAINS, DEFAULT_MAP,
337         DEFAULT_EFFECT_LIBRARY_LIST);
338     bool isInitialized = *reinterpret_cast<const bool*>(rawData);
339     AudioEffectChainManager::GetInstance()->isInitialized_ = isInitialized;
340     AudioEffectChainManager::GetInstance()->deviceType_ = DEVICE_TYPE_SPEAKER;
341     AudioEffectChainManager::GetInstance()->InitAudioEffectChainManager(DEFAULT_EFFECT_CHAINS, DEFAULT_MAP,
342         DEFAULT_EFFECT_LIBRARY_LIST);
343     AudioEffectChainManager::GetInstance()->UpdateDeviceInfo(device, sinkName);
344     AudioEffectChainManager::GetInstance()->ResetInfo();
345 }
346 
CheckAndReleaseCommonEffectChainFuzzTest(const uint8_t* rawData, size_t size)347 void CheckAndReleaseCommonEffectChainFuzzTest(const uint8_t* rawData, size_t size)
348 {
349     if (rawData == nullptr || size < LIMITSIZE) {
350         return;
351     }
352 
353     AudioEffectChainManager::GetInstance()->InitAudioEffectChainManager(DEFAULT_EFFECT_CHAINS, DEFAULT_MAP,
354         DEFAULT_EFFECT_LIBRARY_LIST);
355     bool isCommonEffectChainExisted = *reinterpret_cast<const bool*>(rawData);
356     AudioEffectChainManager::GetInstance()->isDefaultEffectChainExisted_ = isCommonEffectChainExisted;
357     AudioEffectChainManager::GetInstance()->CheckAndReleaseCommonEffectChain(SCENETYPEMUSIC);
358     AudioEffectChainManager::GetInstance()->ResetInfo();
359 }
360 
UpdateCurrSceneTypeFuzzTest(const uint8_t* rawData, size_t size)361 void UpdateCurrSceneTypeFuzzTest(const uint8_t* rawData, size_t size)
362 {
363     if (rawData == nullptr || size < LIMITSIZE || size < sizeof(AudioEffectScene)) {
364         return;
365     }
366     AudioEffectScene currSceneType = *reinterpret_cast<const AudioEffectScene*>(rawData);
367     bool spatializationEnabled = *reinterpret_cast<const bool*>(rawData);
368 
369     std::string sceneType = SCENETYPEMUSIC;
370     AudioEffectChainManager::GetInstance()->InitAudioEffectChainManager(DEFAULT_EFFECT_CHAINS, DEFAULT_MAP,
371         DEFAULT_EFFECT_LIBRARY_LIST);
372     AudioEffectChainManager::GetInstance()->spatializationEnabled_ = spatializationEnabled;
373     AudioEffectChainManager::GetInstance()->UpdateCurrSceneType(currSceneType, sceneType);
374     AudioEffectChainManager::GetInstance()->ResetInfo();
375 }
376 
CheckSceneTypeMatchFuzzTest(const uint8_t* rawData, size_t size)377 void CheckSceneTypeMatchFuzzTest(const uint8_t* rawData, size_t size)
378 {
379     if (rawData == nullptr || size < LIMITSIZE) {
380         return;
381     }
382 
383     const std::string sinkSceneType = SCENETYPEMUSIC;
384     const std::string sceneType = SCENETYPEMUSIC;
385 
386     AudioEffectChainManager::GetInstance()->InitAudioEffectChainManager(DEFAULT_EFFECT_CHAINS, DEFAULT_MAP,
387         DEFAULT_EFFECT_LIBRARY_LIST);
388     AudioEffectChainManager::GetInstance()->CheckSceneTypeMatch(sinkSceneType, sceneType);
389     AudioEffectChainManager::GetInstance()->ResetInfo();
390 }
391 
UpdateSpatialDeviceTypeFuzzTest(const uint8_t* rawData, size_t size)392 void UpdateSpatialDeviceTypeFuzzTest(const uint8_t* rawData, size_t size)
393 {
394     if (rawData == nullptr || size < LIMITSIZE) {
395         return;
396     }
397 
398     AudioSpatialDeviceType spatialDeviceType = *reinterpret_cast<const AudioSpatialDeviceType*>(rawData);
399 
400     AudioEffectChainManager::GetInstance()->InitAudioEffectChainManager(DEFAULT_EFFECT_CHAINS, DEFAULT_MAP,
401         DEFAULT_EFFECT_LIBRARY_LIST);
402     AudioEffectChainManager::GetInstance()->UpdateSpatialDeviceType(spatialDeviceType);
403     AudioEffectChainManager::GetInstance()->ResetInfo();
404 }
405 } // namespace AudioStandard
406 } // namespace OHOS
407 
LLVMFuzzerTestOneInput(const uint8_t *rawData, size_t size)408 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *rawData, size_t size)
409 {
410     /* Run your code on data */
411     OHOS::AudioStandard::InitAudioEffectChainManagerFuzzTest(rawData, size);
412     OHOS::AudioStandard::CheckAndAddSessionIDFuzzTest(rawData, size);
413     OHOS::AudioStandard::CheckAndRemoveSessionIDFuzzTest(rawData, size);
414     OHOS::AudioStandard::ReleaseAudioEffectChainDynamicFuzzTest(rawData, size);
415     OHOS::AudioStandard::ApplyAudioEffectChainFuzzTest(rawData, size);
416     OHOS::AudioStandard::SetOutputDeviceSinkFuzzTest(rawData, size);
417     OHOS::AudioStandard::GetDeviceSinkNameFuzzTest(rawData, size);
418     OHOS::AudioStandard::GetOffloadEnabledFuzzTest(rawData, size);
419     OHOS::AudioStandard::DumpFuzzTest(rawData, size);
420     OHOS::AudioStandard::UpdateMultichannelConfigFuzzTest(rawData, size);
421     OHOS::AudioStandard::UpdateSpatializationStateFuzzTest(rawData, size);
422     OHOS::AudioStandard::SetHdiParamFuzzTest(rawData, size);
423     OHOS::AudioStandard::SessionInfoMapAddFuzzTest(rawData, size);
424     OHOS::AudioStandard::SessionInfoMapDeleteFuzzTest(rawData, size);
425     OHOS::AudioStandard::ReturnEffectChannelInfoFuzzTest(rawData, size);
426     OHOS::AudioStandard::ReturnMultiChannelInfoFuzzTest(rawData, size);
427     OHOS::AudioStandard::EffectRotationUpdateFuzzTest(rawData, size);
428     OHOS::AudioStandard::GetLatencyFuzzTest(rawData, size);
429     OHOS::AudioStandard::SetSpatializationSceneTypeFuzzTest(rawData, size);
430     OHOS::AudioStandard::GetCurSpatializationEnabledFuzzTest(rawData, size);
431     OHOS::AudioStandard::ResetEffectBufferFuzzTest(rawData, size);
432     OHOS::AudioStandard::UpdateSpkOffloadEnabledFuzzTest(rawData, size);
433     OHOS::AudioStandard::UpdateDeviceInfoFuzzTest(rawData, size);
434     OHOS::AudioStandard::CheckAndReleaseCommonEffectChainFuzzTest(rawData, size);
435     OHOS::AudioStandard::UpdateCurrSceneTypeFuzzTest(rawData, size);
436     OHOS::AudioStandard::CheckSceneTypeMatchFuzzTest(rawData, size);
437     OHOS::AudioStandard::UpdateSpatialDeviceTypeFuzzTest(rawData, size);
438     return 0;
439 }
440