1 /*
2 * Copyright (c) 2025 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 "ipc_stream_in_server.h"
17 #include "audio_info.h"
18 #include "hpae_renderer_stream_impl.h"
19 #include "../fuzz_utils.h"
20
21 namespace OHOS {
22 namespace AudioStandard {
23 using namespace std;
24
25 FuzzUtils &g_fuzzUtils = FuzzUtils::GetInstance();
26 const size_t FUZZ_INPUT_SIZE_THRESHOLD = 10;
27
28 typedef void (*TestFuncs)();
29
CreateIpcStreamInServer()30 static shared_ptr<IpcStreamInServer> CreateIpcStreamInServer()
31 {
32 AudioProcessConfig configRet;
33 AudioMode modeRet = g_fuzzUtils.GetData<AudioMode>();
34 shared_ptr<IpcStreamInServer> ipcStreamInServerRet = make_shared<IpcStreamInServer>(configRet, modeRet);
35 if (ipcStreamInServerRet == nullptr) {
36 return nullptr;
37 }
38 ipcStreamInServerRet->streamListenerHolder_ = std::make_shared<StreamListenerHolder>();
39 ipcStreamInServerRet->ConfigRenderer();
40 if (ipcStreamInServerRet->rendererInServer_ == nullptr) {
41 return ipcStreamInServerRet;
42 }
43 bool isMoveAble = g_fuzzUtils.GetData<bool>();
44 ipcStreamInServerRet->rendererInServer_->stream_ = std::make_shared<HpaeRendererStreamImpl>(configRet, isMoveAble);
45 ipcStreamInServerRet->ConfigCapturer();
46 return ipcStreamInServerRet;
47 }
48
StreamListenerHolderIsWakeUpLaterNeededFuzzTest()49 void StreamListenerHolderIsWakeUpLaterNeededFuzzTest()
50 {
51 StreamListenerHolder streamListenerHolderRet;
52 Operation operation = g_fuzzUtils.GetData<Operation>();
53 streamListenerHolderRet.IsWakeUpLaterNeeded(operation);
54 }
55
StreamListenerHolderRegisterStreamListenerFuzzTest()56 void StreamListenerHolderRegisterStreamListenerFuzzTest()
57 {
58 StreamListenerHolder streamListenerHolderRet;
59 sptr<IIpcStreamListener> listener = nullptr;
60 streamListenerHolderRet.RegisterStreamListener(listener);
61 }
62
IpcStreamInServerConfigFuzzTest()63 void IpcStreamInServerConfigFuzzTest()
64 {
65 shared_ptr<IpcStreamInServer> ipcStreamInServerRet = CreateIpcStreamInServer();
66 CHECK_AND_RETURN(ipcStreamInServerRet != nullptr);
67 ipcStreamInServerRet->Config();
68 }
69
IpcStreamInServerGetRendererFuzzTest()70 void IpcStreamInServerGetRendererFuzzTest()
71 {
72 shared_ptr<IpcStreamInServer> ipcStreamInServerRet = CreateIpcStreamInServer();
73 CHECK_AND_RETURN(ipcStreamInServerRet != nullptr);
74 ipcStreamInServerRet->GetRenderer();
75 }
76
IpcStreamInServerGetCapturerFuzzTest()77 void IpcStreamInServerGetCapturerFuzzTest()
78 {
79 shared_ptr<IpcStreamInServer> ipcStreamInServerRet = CreateIpcStreamInServer();
80 CHECK_AND_RETURN(ipcStreamInServerRet != nullptr);
81 ipcStreamInServerRet->GetCapturer();
82 }
83
IpcStreamInServerResolveBufferFuzzTest()84 void IpcStreamInServerResolveBufferFuzzTest()
85 {
86 shared_ptr<IpcStreamInServer> ipcStreamInServerRet = CreateIpcStreamInServer();
87 CHECK_AND_RETURN(ipcStreamInServerRet != nullptr);
88 std::shared_ptr<OHAudioBuffer> buffer;
89 ipcStreamInServerRet->ResolveBuffer(buffer);
90 }
91
IpcStreamInServerGetAudioSessionIDFuzzTest()92 void IpcStreamInServerGetAudioSessionIDFuzzTest()
93 {
94 shared_ptr<IpcStreamInServer> ipcStreamInServerRet = CreateIpcStreamInServer();
95 CHECK_AND_RETURN(ipcStreamInServerRet != nullptr);
96 uint32_t sessionId = g_fuzzUtils.GetData<uint32_t>();
97 ipcStreamInServerRet->GetAudioSessionID(sessionId);
98 }
99
IpcStreamInServerStartFuzzTest()100 void IpcStreamInServerStartFuzzTest()
101 {
102 shared_ptr<IpcStreamInServer> ipcStreamInServerRet = CreateIpcStreamInServer();
103 CHECK_AND_RETURN(ipcStreamInServerRet != nullptr);
104 ipcStreamInServerRet->Start();
105 }
106
IpcStreamInServerPauseFuzzTest()107 void IpcStreamInServerPauseFuzzTest()
108 {
109 shared_ptr<IpcStreamInServer> ipcStreamInServerRet = CreateIpcStreamInServer();
110 CHECK_AND_RETURN(ipcStreamInServerRet != nullptr);
111 ipcStreamInServerRet->Pause();
112 }
113
IpcStreamInServerStopFuzzTest()114 void IpcStreamInServerStopFuzzTest()
115 {
116 shared_ptr<IpcStreamInServer> ipcStreamInServerRet = CreateIpcStreamInServer();
117 CHECK_AND_RETURN(ipcStreamInServerRet != nullptr);
118 ipcStreamInServerRet->Stop();
119 }
120
IpcStreamInServerReleaseFuzzTest()121 void IpcStreamInServerReleaseFuzzTest()
122 {
123 shared_ptr<IpcStreamInServer> ipcStreamInServerRet = CreateIpcStreamInServer();
124 CHECK_AND_RETURN(ipcStreamInServerRet != nullptr);
125 bool isSwitchStream = g_fuzzUtils.GetData<bool>();
126 ipcStreamInServerRet->Release(isSwitchStream);
127 }
128
IpcStreamInServerFlushFuzzTest()129 void IpcStreamInServerFlushFuzzTest()
130 {
131 shared_ptr<IpcStreamInServer> ipcStreamInServerRet = CreateIpcStreamInServer();
132 CHECK_AND_RETURN(ipcStreamInServerRet != nullptr);
133 ipcStreamInServerRet->Flush();
134 }
135
IpcStreamInServerDrainFuzzTest()136 void IpcStreamInServerDrainFuzzTest()
137 {
138 shared_ptr<IpcStreamInServer> ipcStreamInServerRet = CreateIpcStreamInServer();
139 CHECK_AND_RETURN(ipcStreamInServerRet != nullptr);
140 bool stopFlag = g_fuzzUtils.GetData<bool>();
141 ipcStreamInServerRet->Drain(stopFlag);
142 }
143
IpcStreamInServerUpdatePlaybackCaptureConfigFuzzTest()144 void IpcStreamInServerUpdatePlaybackCaptureConfigFuzzTest()
145 {
146 shared_ptr<IpcStreamInServer> ipcStreamInServerRet = CreateIpcStreamInServer();
147 CHECK_AND_RETURN(ipcStreamInServerRet != nullptr);
148 AudioPlaybackCaptureConfig config;
149 ipcStreamInServerRet->UpdatePlaybackCaptureConfig(config);
150 }
151
IpcStreamInServerGetAudioTimeFuzzTest()152 void IpcStreamInServerGetAudioTimeFuzzTest()
153 {
154 shared_ptr<IpcStreamInServer> ipcStreamInServerRet = CreateIpcStreamInServer();
155 CHECK_AND_RETURN(ipcStreamInServerRet != nullptr);
156 uint64_t framePos = g_fuzzUtils.GetData<uint64_t>();
157 uint64_t timestamp = g_fuzzUtils.GetData<uint64_t>();
158 ipcStreamInServerRet->GetAudioTime(framePos, timestamp);
159 }
160
IpcStreamInServerGetAudioPositionFuzzTest()161 void IpcStreamInServerGetAudioPositionFuzzTest()
162 {
163 shared_ptr<IpcStreamInServer> ipcStreamInServerRet = CreateIpcStreamInServer();
164 CHECK_AND_RETURN(ipcStreamInServerRet != nullptr);
165 uint64_t framePos = g_fuzzUtils.GetData<uint64_t>();
166 uint64_t timestamp = g_fuzzUtils.GetData<uint64_t>();
167 uint64_t latency = g_fuzzUtils.GetData<uint64_t>();
168 int32_t base = g_fuzzUtils.GetData<int32_t>();
169 ipcStreamInServerRet->GetAudioPosition(framePos, timestamp, latency, base);
170 }
171
IpcStreamInServerGetSpeedPositionFuzzTest()172 void IpcStreamInServerGetSpeedPositionFuzzTest()
173 {
174 shared_ptr<IpcStreamInServer> ipcStreamInServerRet = CreateIpcStreamInServer();
175 CHECK_AND_RETURN(ipcStreamInServerRet != nullptr);
176 uint64_t framePos = g_fuzzUtils.GetData<uint64_t>();
177 uint64_t timestamp = g_fuzzUtils.GetData<uint64_t>();
178 uint64_t latency = g_fuzzUtils.GetData<uint64_t>();
179 int32_t base = g_fuzzUtils.GetData<int32_t>();
180 ipcStreamInServerRet->GetSpeedPosition(framePos, timestamp, latency, base);
181 }
182
IpcStreamInServerGetLatencyFuzzTest()183 void IpcStreamInServerGetLatencyFuzzTest()
184 {
185 shared_ptr<IpcStreamInServer> ipcStreamInServerRet = CreateIpcStreamInServer();
186 CHECK_AND_RETURN(ipcStreamInServerRet != nullptr);
187 uint64_t latency = g_fuzzUtils.GetData<uint64_t>();
188 ipcStreamInServerRet->GetLatency(latency);
189 }
190
IpcStreamInServerSetRateFuzzTest()191 void IpcStreamInServerSetRateFuzzTest()
192 {
193 shared_ptr<IpcStreamInServer> ipcStreamInServerRet = CreateIpcStreamInServer();
194 CHECK_AND_RETURN(ipcStreamInServerRet != nullptr);
195 int32_t rate = g_fuzzUtils.GetData<int32_t>();
196 ipcStreamInServerRet->SetRate(rate);
197 }
198
IpcStreamInServerGetRateFuzzTest()199 void IpcStreamInServerGetRateFuzzTest()
200 {
201 shared_ptr<IpcStreamInServer> ipcStreamInServerRet = CreateIpcStreamInServer();
202 CHECK_AND_RETURN(ipcStreamInServerRet != nullptr);
203 int32_t rate = g_fuzzUtils.GetData<int32_t>();
204 ipcStreamInServerRet->GetRate(rate);
205 }
206
IpcStreamInServerSetLowPowerVolumeFuzzTest()207 void IpcStreamInServerSetLowPowerVolumeFuzzTest()
208 {
209 shared_ptr<IpcStreamInServer> ipcStreamInServerRet = CreateIpcStreamInServer();
210 CHECK_AND_RETURN(ipcStreamInServerRet != nullptr);
211 float volume = g_fuzzUtils.GetData<float>();
212 ipcStreamInServerRet->SetLowPowerVolume(volume);
213 }
214
IpcStreamInServerGetLowPowerVolumeFuzzTest()215 void IpcStreamInServerGetLowPowerVolumeFuzzTest()
216 {
217 shared_ptr<IpcStreamInServer> ipcStreamInServerRet = CreateIpcStreamInServer();
218 CHECK_AND_RETURN(ipcStreamInServerRet != nullptr);
219 float volume = g_fuzzUtils.GetData<float>();
220 ipcStreamInServerRet->GetLowPowerVolume(volume);
221 }
222
IpcStreamInServerSetAudioEffectModeFuzzTest()223 void IpcStreamInServerSetAudioEffectModeFuzzTest()
224 {
225 shared_ptr<IpcStreamInServer> ipcStreamInServerRet = CreateIpcStreamInServer();
226 CHECK_AND_RETURN(ipcStreamInServerRet != nullptr);
227 int32_t effectMode = g_fuzzUtils.GetData<int32_t>();
228 ipcStreamInServerRet->SetAudioEffectMode(effectMode);
229 }
230
IpcStreamInServerGetAudioEffectModeFuzzTest()231 void IpcStreamInServerGetAudioEffectModeFuzzTest()
232 {
233 shared_ptr<IpcStreamInServer> ipcStreamInServerRet = CreateIpcStreamInServer();
234 CHECK_AND_RETURN(ipcStreamInServerRet != nullptr);
235 int32_t effectMode = g_fuzzUtils.GetData<int32_t>();
236 ipcStreamInServerRet->GetAudioEffectMode(effectMode);
237 }
238
IpcStreamInServerSetPrivacyTypeFuzzTest()239 void IpcStreamInServerSetPrivacyTypeFuzzTest()
240 {
241 shared_ptr<IpcStreamInServer> ipcStreamInServerRet = CreateIpcStreamInServer();
242 CHECK_AND_RETURN(ipcStreamInServerRet != nullptr);
243 int32_t privacyType = g_fuzzUtils.GetData<int32_t>();
244 ipcStreamInServerRet->SetPrivacyType(privacyType);
245 }
246
IpcStreamInServerGetPrivacyTypeFuzzTest()247 void IpcStreamInServerGetPrivacyTypeFuzzTest()
248 {
249 shared_ptr<IpcStreamInServer> ipcStreamInServerRet = CreateIpcStreamInServer();
250 CHECK_AND_RETURN(ipcStreamInServerRet != nullptr);
251 int32_t privacyType = g_fuzzUtils.GetData<int32_t>();
252 ipcStreamInServerRet->GetPrivacyType(privacyType);
253 }
254
IpcStreamInServerSetOffloadModeFuzzTest()255 void IpcStreamInServerSetOffloadModeFuzzTest()
256 {
257 shared_ptr<IpcStreamInServer> ipcStreamInServerRet = CreateIpcStreamInServer();
258 CHECK_AND_RETURN(ipcStreamInServerRet != nullptr);
259 int32_t state = g_fuzzUtils.GetData<int32_t>();
260 bool isAppBack = g_fuzzUtils.GetData<bool>();
261 ipcStreamInServerRet->SetOffloadMode(state, isAppBack);
262 }
263
IpcStreamInServerUnsetOffloadModeFuzzTest()264 void IpcStreamInServerUnsetOffloadModeFuzzTest()
265 {
266 shared_ptr<IpcStreamInServer> ipcStreamInServerRet = CreateIpcStreamInServer();
267 CHECK_AND_RETURN(ipcStreamInServerRet != nullptr);
268 ipcStreamInServerRet->UnsetOffloadMode();
269 }
270
IpcStreamInServerGetOffloadApproximatelyCacheTimeFuzzTest()271 void IpcStreamInServerGetOffloadApproximatelyCacheTimeFuzzTest()
272 {
273 shared_ptr<IpcStreamInServer> ipcStreamInServerRet = CreateIpcStreamInServer();
274 CHECK_AND_RETURN(ipcStreamInServerRet != nullptr);
275 uint64_t timestamp = g_fuzzUtils.GetData<uint64_t>();
276 uint64_t paWriteIndex = g_fuzzUtils.GetData<uint64_t>();
277 uint64_t cacheTimeDsp = g_fuzzUtils.GetData<uint64_t>();
278 uint64_t cacheTimePa = g_fuzzUtils.GetData<uint64_t>();
279 ipcStreamInServerRet->GetOffloadApproximatelyCacheTime(timestamp, paWriteIndex, cacheTimeDsp, cacheTimePa);
280 }
281
IpcStreamInServerUpdateSpatializationStateFuzzTest()282 void IpcStreamInServerUpdateSpatializationStateFuzzTest()
283 {
284 shared_ptr<IpcStreamInServer> ipcStreamInServerRet = CreateIpcStreamInServer();
285 CHECK_AND_RETURN(ipcStreamInServerRet != nullptr);
286 bool spatializationEnabled = g_fuzzUtils.GetData<bool>();
287 bool headTrackingEnabled = g_fuzzUtils.GetData<bool>();
288 ipcStreamInServerRet->UpdateSpatializationState(spatializationEnabled, headTrackingEnabled);
289 }
290
IpcStreamInServerGetStreamManagerTypeFuzzTest()291 void IpcStreamInServerGetStreamManagerTypeFuzzTest()
292 {
293 shared_ptr<IpcStreamInServer> ipcStreamInServerRet = CreateIpcStreamInServer();
294 CHECK_AND_RETURN(ipcStreamInServerRet != nullptr);
295 ipcStreamInServerRet->GetStreamManagerType();
296 }
297
IpcStreamInServerSetSilentModeAndMixWithOthersFuzzTest()298 void IpcStreamInServerSetSilentModeAndMixWithOthersFuzzTest()
299 {
300 shared_ptr<IpcStreamInServer> ipcStreamInServerRet = CreateIpcStreamInServer();
301 CHECK_AND_RETURN(ipcStreamInServerRet != nullptr);
302 bool on = g_fuzzUtils.GetData<bool>();
303 ipcStreamInServerRet->SetClientVolume();
304 ipcStreamInServerRet->SetSilentModeAndMixWithOthers(on);
305 }
306
IpcStreamInServerSetLoudnessGainFuzzTest()307 void IpcStreamInServerSetLoudnessGainFuzzTest()
308 {
309 shared_ptr<IpcStreamInServer> ipcStreamInServerRet = CreateIpcStreamInServer();
310 CHECK_AND_RETURN(ipcStreamInServerRet != nullptr);
311 float loudnessGain = g_fuzzUtils.GetData<float>();
312 ipcStreamInServerRet->SetLoudnessGain(loudnessGain);
313 }
314
IpcStreamInServerSetMuteFuzzTest()315 void IpcStreamInServerSetMuteFuzzTest()
316 {
317 shared_ptr<IpcStreamInServer> ipcStreamInServerRet = CreateIpcStreamInServer();
318 CHECK_AND_RETURN(ipcStreamInServerRet != nullptr);
319 bool isMute = g_fuzzUtils.GetData<bool>();
320 ipcStreamInServerRet->SetMute(isMute);
321 }
322
IpcStreamInServerSetDuckFactorFuzzTest()323 void IpcStreamInServerSetDuckFactorFuzzTest()
324 {
325 shared_ptr<IpcStreamInServer> ipcStreamInServerRet = CreateIpcStreamInServer();
326 CHECK_AND_RETURN(ipcStreamInServerRet != nullptr);
327 float duckFactor = g_fuzzUtils.GetData<float>();
328 ipcStreamInServerRet->SetDuckFactor(duckFactor);
329 }
330
IpcStreamInServerRegisterThreadPriorityFuzzTest()331 void IpcStreamInServerRegisterThreadPriorityFuzzTest()
332 {
333 shared_ptr<IpcStreamInServer> ipcStreamInServerRet = CreateIpcStreamInServer();
334 CHECK_AND_RETURN(ipcStreamInServerRet != nullptr);
335 int32_t tid = g_fuzzUtils.GetData<int32_t>();
336 std::string bundleName = "testBundleName";
337 uint32_t method = g_fuzzUtils.GetData<uint32_t>();
338 ipcStreamInServerRet->RegisterThreadPriority(tid, bundleName, method);
339 }
340
IpcStreamInServerSetDefaultOutputDeviceFuzzTest()341 void IpcStreamInServerSetDefaultOutputDeviceFuzzTest()
342 {
343 shared_ptr<IpcStreamInServer> ipcStreamInServerRet = CreateIpcStreamInServer();
344 CHECK_AND_RETURN(ipcStreamInServerRet != nullptr);
345 int32_t defaultOutputDevice = g_fuzzUtils.GetData<int32_t>();
346 ipcStreamInServerRet->SetDefaultOutputDevice(defaultOutputDevice);
347 }
348
IpcStreamInServerSetSourceDurationFuzzTest()349 void IpcStreamInServerSetSourceDurationFuzzTest()
350 {
351 shared_ptr<IpcStreamInServer> ipcStreamInServerRet = CreateIpcStreamInServer();
352 CHECK_AND_RETURN(ipcStreamInServerRet != nullptr);
353 int64_t duration = g_fuzzUtils.GetData<int64_t>();
354 ipcStreamInServerRet->SetSourceDuration(duration);
355 }
356
IpcStreamInServerSetSpeedFuzzTest()357 void IpcStreamInServerSetSpeedFuzzTest()
358 {
359 shared_ptr<IpcStreamInServer> ipcStreamInServerRet = CreateIpcStreamInServer();
360 CHECK_AND_RETURN(ipcStreamInServerRet != nullptr);
361 float speed = g_fuzzUtils.GetData<float>();
362 ipcStreamInServerRet->SetSpeed(speed);
363 }
364
IpcStreamInServerSetOffloadDataCallbackStateFuzzTest()365 void IpcStreamInServerSetOffloadDataCallbackStateFuzzTest()
366 {
367 shared_ptr<IpcStreamInServer> ipcStreamInServerRet = CreateIpcStreamInServer();
368 CHECK_AND_RETURN(ipcStreamInServerRet != nullptr);
369 int32_t state = g_fuzzUtils.GetData<int32_t>();
370 ipcStreamInServerRet->SetOffloadDataCallbackState(state);
371 }
372
IpcStreamInServerResolveBufferBaseAndGetServerSpanSizeFuzzTest()373 void IpcStreamInServerResolveBufferBaseAndGetServerSpanSizeFuzzTest()
374 {
375 shared_ptr<IpcStreamInServer> ipcStreamInServerRet = CreateIpcStreamInServer();
376 CHECK_AND_RETURN(ipcStreamInServerRet != nullptr);
377 uint32_t totalSizeInFrame = 1;
378 uint32_t byteSizePerFrame = 1;
379 uint32_t spanSizeInFrame = g_fuzzUtils.GetData<uint32_t>();
380 uint64_t engineTotalSizeInFrame = g_fuzzUtils.GetData<uint64_t>();
381 std::shared_ptr<OHAudioBufferBase> buffer = OHAudioBufferBase::CreateFromLocal(totalSizeInFrame, byteSizePerFrame);
382
383 ipcStreamInServerRet->ResolveBufferBaseAndGetServerSpanSize(buffer, spanSizeInFrame, engineTotalSizeInFrame);
384 }
385
IpcStreamInServerSetAudioHapticsSyncIdFuzzTest()386 void IpcStreamInServerSetAudioHapticsSyncIdFuzzTest()
387 {
388 shared_ptr<IpcStreamInServer> ipcStreamInServerRet = CreateIpcStreamInServer();
389 CHECK_AND_RETURN(ipcStreamInServerRet != nullptr);
390 int32_t audioHapticsSyncId = g_fuzzUtils.GetData<int32_t>();
391
392 ipcStreamInServerRet->SetAudioHapticsSyncId(audioHapticsSyncId);
393 }
394
395 vector<TestFuncs> g_testFuncs = {
396 StreamListenerHolderIsWakeUpLaterNeededFuzzTest,
397 StreamListenerHolderRegisterStreamListenerFuzzTest,
398 IpcStreamInServerConfigFuzzTest,
399 IpcStreamInServerGetRendererFuzzTest,
400 IpcStreamInServerGetCapturerFuzzTest,
401 IpcStreamInServerResolveBufferFuzzTest,
402 IpcStreamInServerGetAudioSessionIDFuzzTest,
403 IpcStreamInServerStartFuzzTest,
404 IpcStreamInServerPauseFuzzTest,
405 IpcStreamInServerStopFuzzTest,
406 IpcStreamInServerReleaseFuzzTest,
407 IpcStreamInServerFlushFuzzTest,
408 IpcStreamInServerDrainFuzzTest,
409 IpcStreamInServerUpdatePlaybackCaptureConfigFuzzTest,
410 IpcStreamInServerGetAudioTimeFuzzTest,
411 IpcStreamInServerGetAudioPositionFuzzTest,
412 IpcStreamInServerGetSpeedPositionFuzzTest,
413 IpcStreamInServerGetLatencyFuzzTest,
414 IpcStreamInServerSetRateFuzzTest,
415 IpcStreamInServerGetRateFuzzTest,
416 IpcStreamInServerSetLowPowerVolumeFuzzTest,
417 IpcStreamInServerGetLowPowerVolumeFuzzTest,
418 IpcStreamInServerSetAudioEffectModeFuzzTest,
419 IpcStreamInServerGetAudioEffectModeFuzzTest,
420 IpcStreamInServerSetPrivacyTypeFuzzTest,
421 IpcStreamInServerGetPrivacyTypeFuzzTest,
422 IpcStreamInServerSetOffloadModeFuzzTest,
423 IpcStreamInServerUnsetOffloadModeFuzzTest,
424 IpcStreamInServerGetOffloadApproximatelyCacheTimeFuzzTest,
425 IpcStreamInServerUpdateSpatializationStateFuzzTest,
426 IpcStreamInServerGetStreamManagerTypeFuzzTest,
427 IpcStreamInServerSetSilentModeAndMixWithOthersFuzzTest,
428 IpcStreamInServerSetLoudnessGainFuzzTest,
429 IpcStreamInServerSetMuteFuzzTest,
430 IpcStreamInServerSetDuckFactorFuzzTest,
431 IpcStreamInServerRegisterThreadPriorityFuzzTest,
432 IpcStreamInServerSetDefaultOutputDeviceFuzzTest,
433 IpcStreamInServerSetSourceDurationFuzzTest,
434 IpcStreamInServerSetSpeedFuzzTest,
435 IpcStreamInServerSetOffloadDataCallbackStateFuzzTest,
436 IpcStreamInServerResolveBufferBaseAndGetServerSpanSizeFuzzTest,
437 IpcStreamInServerSetAudioHapticsSyncIdFuzzTest,
438 };
439 } // namespace AudioStandard
440 } // namesapce OHOS
441
442 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)443 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
444 {
445 if (size < OHOS::AudioStandard::FUZZ_INPUT_SIZE_THRESHOLD) {
446 return 0;
447 }
448
449 OHOS::AudioStandard::g_fuzzUtils.fuzzTest(data, size, OHOS::AudioStandard::g_testFuncs);
450 return 0;
451 }