1 /*
2 * Copyright (c) 2024-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 "audio_endpoint.h"
17 #include "audio_endpoint_private.h"
18 #include "audio_service.h"
19
20 using namespace std;
21
22 namespace OHOS {
23 namespace AudioStandard {
24
25 const int32_t NUM_2 = 2;
26 const int32_t AUDIOCHANNELSIZE = 17;
27 const int32_t ENDPOINTTYPESIZE = 4;
28 const int32_t SAVE_FOREGROUND_LIST_NUM = 11;
29 static const uint8_t* RAW_DATA = nullptr;
30 static size_t g_dataSize = 0;
31 static size_t g_pos;
32 const size_t THRESHOLD = 10;
33 typedef void (*TestPtr)();
34
35 const vector<AudioStreamType> g_testAudioStreamTypes = {
36 STREAM_DEFAULT,
37 STREAM_MUSIC,
38 STREAM_RING,
39 STREAM_MEDIA,
40 STREAM_VOICE_ASSISTANT,
41 STREAM_SYSTEM,
42 STREAM_ALARM,
43 STREAM_NOTIFICATION,
44 STREAM_BLUETOOTH_SCO,
45 STREAM_ENFORCED_AUDIBLE,
46 STREAM_DTMF,
47 STREAM_TTS,
48 STREAM_ACCESSIBILITY,
49 STREAM_RECORDING,
50 STREAM_MOVIE,
51 STREAM_GAME,
52 STREAM_SPEECH,
53 STREAM_SYSTEM_ENFORCED,
54 STREAM_ULTRASONIC,
55 STREAM_WAKEUP,
56 STREAM_VOICE_MESSAGE,
57 STREAM_NAVIGATION,
58 STREAM_INTERNAL_FORCE_STOP,
59 STREAM_SOURCE_VOICE_CALL,
60 STREAM_VOICE_RING,
61 STREAM_VOICE_CALL_ASSISTANT,
62 STREAM_CAMCORDER,
63 STREAM_APP,
64 STREAM_TYPE_MAX,
65 STREAM_ALL,
66 };
67
68 const vector<AudioSamplingRate> g_testAudioSamplingRates = {
69 SAMPLE_RATE_8000,
70 SAMPLE_RATE_11025,
71 SAMPLE_RATE_12000,
72 SAMPLE_RATE_16000,
73 SAMPLE_RATE_22050,
74 SAMPLE_RATE_24000,
75 SAMPLE_RATE_32000,
76 SAMPLE_RATE_44100,
77 SAMPLE_RATE_48000,
78 SAMPLE_RATE_64000,
79 SAMPLE_RATE_88200,
80 SAMPLE_RATE_96000,
81 SAMPLE_RATE_176400,
82 SAMPLE_RATE_192000,
83 };
84
85 const vector<AudioSampleFormat> g_testAudioSampleFormats = {
86 SAMPLE_U8,
87 SAMPLE_S16LE,
88 SAMPLE_S24LE,
89 SAMPLE_S32LE,
90 SAMPLE_F32LE,
91 INVALID_WIDTH,
92 };
93
94 const vector<DeviceType> g_testDeviceTypes = {
95 DEVICE_TYPE_NONE,
96 DEVICE_TYPE_INVALID,
97 DEVICE_TYPE_EARPIECE,
98 DEVICE_TYPE_SPEAKER,
99 DEVICE_TYPE_WIRED_HEADSET,
100 DEVICE_TYPE_WIRED_HEADPHONES,
101 DEVICE_TYPE_BLUETOOTH_SCO,
102 DEVICE_TYPE_BLUETOOTH_A2DP,
103 DEVICE_TYPE_BLUETOOTH_A2DP_IN,
104 DEVICE_TYPE_MIC,
105 DEVICE_TYPE_WAKEUP,
106 DEVICE_TYPE_USB_HEADSET,
107 DEVICE_TYPE_DP,
108 DEVICE_TYPE_REMOTE_CAST,
109 DEVICE_TYPE_USB_DEVICE,
110 DEVICE_TYPE_ACCESSORY,
111 DEVICE_TYPE_REMOTE_DAUDIO,
112 DEVICE_TYPE_HDMI,
113 DEVICE_TYPE_LINE_DIGITAL,
114 DEVICE_TYPE_NEARLINK,
115 DEVICE_TYPE_NEARLINK_IN,
116 DEVICE_TYPE_FILE_SINK,
117 DEVICE_TYPE_FILE_SOURCE,
118 DEVICE_TYPE_EXTERN_CABLE,
119 DEVICE_TYPE_DEFAULT,
120 DEVICE_TYPE_USB_ARM_HEADSET,
121 DEVICE_TYPE_MAX
122 };
123
124 const vector<SourceType> g_testSourceTypes = {
125 SOURCE_TYPE_INVALID,
126 SOURCE_TYPE_MIC,
127 SOURCE_TYPE_VOICE_RECOGNITION,
128 SOURCE_TYPE_PLAYBACK_CAPTURE,
129 SOURCE_TYPE_WAKEUP,
130 SOURCE_TYPE_VOICE_CALL,
131 SOURCE_TYPE_VOICE_COMMUNICATION,
132 SOURCE_TYPE_ULTRASONIC,
133 SOURCE_TYPE_VIRTUAL_CAPTURE,
134 SOURCE_TYPE_VOICE_MESSAGE,
135 SOURCE_TYPE_REMOTE_CAST,
136 SOURCE_TYPE_VOICE_TRANSCRIPTION,
137 SOURCE_TYPE_CAMCORDER,
138 SOURCE_TYPE_UNPROCESSED,
139 SOURCE_TYPE_EC,
140 SOURCE_TYPE_MIC_REF,
141 SOURCE_TYPE_LIVE,
142 SOURCE_TYPE_MAX,
143 };
144
145 template<class T>
GetArrLength(T & arr)146 uint32_t GetArrLength(T& arr)
147 {
148 if (arr == nullptr) {
149 AUDIO_INFO_LOG("%{public}s: The array length is equal to 0", __func__);
150 return 0;
151 }
152 return sizeof(arr) / sizeof(arr[0]);
153 }
154
155 template<class T>
GetData()156 T GetData()
157 {
158 T object {};
159 size_t objectSize = sizeof(object);
160 if (RAW_DATA == nullptr || objectSize > g_dataSize - g_pos) {
161 return object;
162 }
163 errno_t ret = memcpy_s(&object, objectSize, RAW_DATA + g_pos, objectSize);
164 if (ret != EOK) {
165 return {};
166 }
167 g_pos += objectSize;
168 return object;
169 }
170
171 #ifdef HAS_FEATURE_INNERCAPTURER
AudioServiceOnProcessReleaseFuzzTest()172 void AudioServiceOnProcessReleaseFuzzTest()
173 {
174 shared_ptr<AudioService> audioService = make_shared<AudioService>();
175 if (audioService == nullptr) {
176 return;
177 }
178 static const vector<AudioEncodingType> testAudioEncodingTypes = {
179 ENCODING_INVALID,
180 ENCODING_PCM,
181 ENCODING_AUDIOVIVID,
182 ENCODING_EAC3,
183 };
184 AudioProcessConfig config = {};
185 config.privacyType = static_cast<AudioPrivacyType>(GetData<uint32_t>() % NUM_2);
186 config.audioMode = static_cast<AudioMode>(GetData<uint32_t>() % NUM_2);
187 config.streamType = g_testAudioStreamTypes[GetData<uint32_t>() % g_testAudioStreamTypes.size()];
188 config.streamInfo.channels = static_cast<AudioChannel>(GetData<uint32_t>() % AUDIOCHANNELSIZE);
189 config.streamInfo.samplingRate = g_testAudioSamplingRates[GetData<uint32_t>() % g_testAudioSamplingRates.size()];
190 config.streamInfo.format = g_testAudioSampleFormats[GetData<uint32_t>() % g_testAudioSampleFormats.size()];
191 config.streamInfo.encoding = testAudioEncodingTypes[GetData<uint32_t>() % testAudioEncodingTypes.size()];
192 auto audioProcess = audioService->GetAudioProcess(config);
193 bool isSwitchStream = GetData<bool>();
194 audioService->OnProcessRelease(audioProcess, isSwitchStream);
195 }
196
AudioServiceCheckInnerCapForRendererFuzzTest()197 void AudioServiceCheckInnerCapForRendererFuzzTest()
198 {
199 shared_ptr<AudioService> audioService = make_shared<AudioService>();
200 if (audioService == nullptr) {
201 return;
202 }
203 AudioProcessConfig processConfig;
204 uint32_t sessionId = GetData<uint32_t>();
205 std::shared_ptr<StreamListenerHolder> streamListenerHolder =
206 std::make_shared<StreamListenerHolder>();
207 std::weak_ptr<IStreamListener> streamListener = streamListenerHolder;
208 std::shared_ptr<RendererInServer> rendererInServer =
209 std::make_shared<RendererInServer>(processConfig, streamListener);
210 std::shared_ptr<RendererInServer> renderer = rendererInServer;
211 audioService->CheckInnerCapForRenderer(sessionId, renderer);
212 }
213
AudioServiceResetAudioEndpointFuzzTest()214 void AudioServiceResetAudioEndpointFuzzTest()
215 {
216 shared_ptr<AudioService> audioService = make_shared<AudioService>();
217 if (audioService == nullptr) {
218 return;
219 }
220 audioService->ResetAudioEndpoint();
221 }
222
AudioServiceReLinkProcessToEndpointFuzzTest()223 void AudioServiceReLinkProcessToEndpointFuzzTest()
224 {
225 AudioProcessConfig config = {};
226 AudioDeviceDescriptor deviceInfo(AudioDeviceDescriptor::DEVICE_INFO);
227 deviceInfo.deviceRole_ = DeviceRole::OUTPUT_DEVICE;
228 AudioStreamInfo audioStreamInfo = { SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO, CH_LAYOUT_STEREO };
229 deviceInfo.networkId_ = LOCAL_NETWORK_ID;
230 std::shared_ptr<AudioEndpoint> audioEndpointPtr = AudioEndpoint::CreateEndpoint(
231 AudioEndpoint::TYPE_MMAP, 0, config, deviceInfo, audioStreamInfo);
232 AudioProcessConfig configProcess = {};
233 sptr<AudioProcessInServer> audioProcess = AudioProcessInServer::Create(configProcess,
234 AudioService::GetInstance());
235 shared_ptr<AudioService> audioService = make_shared<AudioService>();
236 if (audioProcess == nullptr || audioEndpointPtr == nullptr || audioService == nullptr) {
237 return;
238 }
239
240 audioService->linkedPairedList_.clear();
241 audioService->linkedPairedList_.push_back(make_pair(audioProcess, audioEndpointPtr));
242 audioService->ReLinkProcessToEndpoint();
243 }
244
AudioServiceCheckInnerCapForProcessFuzzTest()245 void AudioServiceCheckInnerCapForProcessFuzzTest()
246 {
247 AudioProcessConfig config = {};
248 AudioDeviceDescriptor deviceInfo(AudioDeviceDescriptor::DEVICE_INFO);
249 deviceInfo.deviceRole_ = DeviceRole::OUTPUT_DEVICE;
250 AudioStreamInfo audioStreamInfo = { SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO, CH_LAYOUT_STEREO };
251 deviceInfo.networkId_ = LOCAL_NETWORK_ID;
252 std::shared_ptr<AudioEndpoint> audioEndpointPtr = AudioEndpoint::CreateEndpoint(
253 AudioEndpoint::TYPE_MMAP, 0, config, deviceInfo, audioStreamInfo);
254 AudioProcessConfig configProcess = {};
255 sptr<AudioProcessInServer> audioProcess = AudioProcessInServer::Create(configProcess,
256 AudioService::GetInstance());
257 shared_ptr<AudioService> audioService = make_shared<AudioService>();
258 if (audioProcess == nullptr || audioEndpointPtr == nullptr || audioService == nullptr) {
259 return;
260 }
261 audioService->CheckInnerCapForProcess(audioProcess, audioEndpointPtr);
262 }
263
AudioServiceLinkProcessToEndpointFuzzTest()264 void AudioServiceLinkProcessToEndpointFuzzTest()
265 {
266 AudioProcessConfig config = {};
267 AudioDeviceDescriptor deviceInfo(AudioDeviceDescriptor::DEVICE_INFO);
268 deviceInfo.deviceRole_ = DeviceRole::OUTPUT_DEVICE;
269 AudioStreamInfo audioStreamInfo = { SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO, CH_LAYOUT_STEREO };
270 deviceInfo.networkId_ = LOCAL_NETWORK_ID;
271 std::shared_ptr<AudioEndpoint> audioEndpointPtr = AudioEndpoint::CreateEndpoint(
272 AudioEndpoint::TYPE_MMAP, 0, config, deviceInfo, audioStreamInfo);
273 AudioProcessConfig configProcess = {};
274 sptr<AudioProcessInServer> audioProcess = AudioProcessInServer::Create(configProcess,
275 AudioService::GetInstance());
276 shared_ptr<AudioService> audioService = make_shared<AudioService>();
277 if (audioProcess == nullptr || audioEndpointPtr == nullptr || audioService == nullptr) {
278 return;
279 }
280 audioService->LinkProcessToEndpoint(audioProcess, audioEndpointPtr);
281 }
282
AudioServiceUnlinkProcessToEndpointFuzzTest()283 void AudioServiceUnlinkProcessToEndpointFuzzTest()
284 {
285 AudioProcessConfig config = {};
286 AudioDeviceDescriptor deviceInfo(AudioDeviceDescriptor::DEVICE_INFO);
287 deviceInfo.deviceRole_ = DeviceRole::OUTPUT_DEVICE;
288 AudioStreamInfo audioStreamInfo = { SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO, CH_LAYOUT_STEREO };
289 deviceInfo.networkId_ = LOCAL_NETWORK_ID;
290 std::shared_ptr<AudioEndpoint> audioEndpointPtr = AudioEndpoint::CreateEndpoint(
291 AudioEndpoint::TYPE_MMAP, 0, config, deviceInfo, audioStreamInfo);
292 AudioProcessConfig configProcess = {};
293 sptr<AudioProcessInServer> audioProcess = AudioProcessInServer::Create(configProcess,
294 AudioService::GetInstance());
295 shared_ptr<AudioService> audioService = make_shared<AudioService>();
296 if (audioProcess == nullptr || audioEndpointPtr == nullptr || audioService == nullptr) {
297 return;
298 }
299 audioService->UnlinkProcessToEndpoint(audioProcess, audioEndpointPtr);
300 }
301
AudioServiceGetDeviceInfoForProcessFuzzTest()302 void AudioServiceGetDeviceInfoForProcessFuzzTest()
303 {
304 shared_ptr<AudioService> audioService = make_shared<AudioService>();
305 if (audioService == nullptr) {
306 return;
307 }
308 AudioProcessConfig config = {};
309 config.originalSessionId = GetData<uint32_t>() / NUM_2;
310 config.privacyType = static_cast<AudioPrivacyType>(GetData<uint32_t>() % NUM_2);
311 config.capturerInfo.sourceType = g_testSourceTypes[GetData<uint32_t>() % g_testSourceTypes.size()];
312 config.streamInfo.channels = static_cast<AudioChannel>(GetData<uint32_t>() % AUDIOCHANNELSIZE);
313 config.streamInfo.samplingRate = g_testAudioSamplingRates[GetData<uint32_t>() % g_testAudioSamplingRates.size()];
314 config.streamInfo.format = g_testAudioSampleFormats[GetData<uint32_t>() % g_testAudioSampleFormats.size()];
315
316 AudioStreamInfo info;
317 audioService->GetDeviceInfoForProcess(config, info);
318 }
319
AudioServiceGetMaxAmplitudeFuzzTest()320 void AudioServiceGetMaxAmplitudeFuzzTest()
321 {
322 AudioProcessConfig config = {};
323 AudioDeviceDescriptor deviceInfo(AudioDeviceDescriptor::DEVICE_INFO);
324 deviceInfo.deviceRole_ = DeviceRole::OUTPUT_DEVICE;
325 AudioStreamInfo audioStreamInfo = { SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO, CH_LAYOUT_STEREO };
326 deviceInfo.networkId_ = LOCAL_NETWORK_ID;
327 std::shared_ptr<AudioEndpoint> audioEndpointPtr = AudioEndpoint::CreateEndpoint(
328 AudioEndpoint::TYPE_MMAP, 0, config, deviceInfo, audioStreamInfo);
329 AudioProcessConfig configProcess = {};
330 sptr<AudioProcessInServer> audioProcess = AudioProcessInServer::Create(configProcess,
331 AudioService::GetInstance());
332 shared_ptr<AudioService> audioService = make_shared<AudioService>();
333 if (audioProcess == nullptr || audioEndpointPtr == nullptr || audioService == nullptr) {
334 return;
335 }
336 bool isOutputDevice = GetData<bool>();
337
338 audioService->linkedPairedList_.clear();
339 audioService->linkedPairedList_.push_back(make_pair(audioProcess, audioEndpointPtr));
340 audioService->GetMaxAmplitude(isOutputDevice);
341 }
342
AudioServiceGetCapturerBySessionIDFuzzTest()343 void AudioServiceGetCapturerBySessionIDFuzzTest()
344 {
345 shared_ptr<AudioService> audioService = make_shared<AudioService>();
346 if (audioService == nullptr) {
347 return;
348 }
349 uint32_t sessionID = GetData<uint32_t>();
350 audioService->allRendererMap_.clear();
351 audioService->allCapturerMap_.insert(make_pair(
352 sessionID, std::make_shared<CapturerInServer>(AudioProcessConfig(), std::weak_ptr<IStreamListener>())));
353 audioService->GetCapturerBySessionID(sessionID);
354 }
355
AudioServiceSetOffloadModeFuzzTest()356 void AudioServiceSetOffloadModeFuzzTest()
357 {
358 shared_ptr<AudioService> audioService = make_shared<AudioService>();
359 if (audioService == nullptr) {
360 return;
361 }
362 uint32_t sessionId = GetData<uint32_t>();
363 int32_t state = GetData<int32_t>();
364 bool isAppBack = GetData<bool>();
365 std::shared_ptr<CapturerInServer> capturer = nullptr;
366 audioService->InsertCapturer(state, capturer);
367 audioService->SetOffloadMode(sessionId, state, isAppBack);
368 }
369
370 #endif // HAS_FEATURE_INNERCAPTURER
371
AudioServiceGetReleaseDelayTimeFuzzTest()372 void AudioServiceGetReleaseDelayTimeFuzzTest()
373 {
374 shared_ptr<AudioService> audioService = make_shared<AudioService>();
375 if (audioService == nullptr) {
376 return;
377 }
378 AudioProcessConfig clientConfig = {};
379 std::shared_ptr<AudioEndpointInner> endpoint = std::make_shared<AudioEndpointInner>(
380 static_cast<AudioEndpoint::EndpointType>(GetData<uint32_t>() % ENDPOINTTYPESIZE),
381 GetData<uint64_t>(), clientConfig);
382 endpoint->deviceInfo_.deviceType_ = g_testDeviceTypes[GetData<uint32_t>() % g_testDeviceTypes.size()];
383 bool isSwitchStream = GetData<bool>();
384 bool isRecord = GetData<bool>();
385 audioService->GetReleaseDelayTime(endpoint, isSwitchStream, isRecord);
386 }
387
AudioServiceRemoveIdFromMuteControlSetFuzzTest()388 void AudioServiceRemoveIdFromMuteControlSetFuzzTest()
389 {
390 shared_ptr<AudioService> audioService = make_shared<AudioService>();
391 if (audioService == nullptr) {
392 return;
393 }
394 uint32_t sessionId = GetData<uint32_t>();
395 audioService->RemoveIdFromMuteControlSet(sessionId);
396 }
397
AudioServiceCheckRenderSessionMuteStateFuzzTest()398 void AudioServiceCheckRenderSessionMuteStateFuzzTest()
399 {
400 AudioProcessConfig processConfig;
401 uint32_t sessionId = GetData<uint32_t>();
402 shared_ptr<AudioService> audioService = make_shared<AudioService>();
403 if (audioService == nullptr) {
404 return;
405 }
406 audioService->UpdateMuteControlSet(sessionId, true);
407
408 std::shared_ptr<StreamListenerHolder> streamListenerHolder =
409 std::make_shared<StreamListenerHolder>();
410 std::weak_ptr<IStreamListener> streamListener = streamListenerHolder;
411 std::shared_ptr<RendererInServer> rendererInServer =
412 std::make_shared<RendererInServer>(processConfig, streamListener);
413 std::shared_ptr<RendererInServer> renderer = rendererInServer;
414 audioService->CheckRenderSessionMuteState(sessionId, renderer);
415 }
416
AudioServiceCheckCaptureSessionMuteStateFuzzTest()417 void AudioServiceCheckCaptureSessionMuteStateFuzzTest()
418 {
419 AudioProcessConfig processConfig;
420 uint32_t sessionId = GetData<uint32_t>();
421 shared_ptr<AudioService> audioService = make_shared<AudioService>();
422 if (audioService == nullptr) {
423 return;
424 }
425 audioService->UpdateMuteControlSet(sessionId, true);
426
427 std::shared_ptr<StreamListenerHolder> streamListenerHolder =
428 std::make_shared<StreamListenerHolder>();
429 std::weak_ptr<IStreamListener> streamListener = streamListenerHolder;
430 std::shared_ptr<CapturerInServer> capturerInServer =
431 std::make_shared<CapturerInServer>(processConfig, streamListener);
432 std::shared_ptr<CapturerInServer> capturer = capturerInServer;
433 audioService->CheckCaptureSessionMuteState(sessionId, capturer);
434 }
435
AudioServiceCheckFastSessionMuteStateFuzzTest()436 void AudioServiceCheckFastSessionMuteStateFuzzTest()
437 {
438 AudioProcessConfig processConfig;
439 uint32_t sessionId = GetData<uint32_t>();
440 shared_ptr<AudioService> audioService = make_shared<AudioService>();
441 if (audioService == nullptr) {
442 return;
443 }
444 audioService->UpdateMuteControlSet(sessionId, true);
445
446 sptr<AudioProcessInServer> audioprocess = AudioProcessInServer::Create(processConfig, audioService.get());
447 audioService->CheckFastSessionMuteState(sessionId, audioprocess);
448 }
449
AudioServiceIsMuteSwitchStreamFuzzTest()450 void AudioServiceIsMuteSwitchStreamFuzzTest()
451 {
452 AudioProcessConfig processConfig;
453 uint32_t sessionId = GetData<uint32_t>();
454 shared_ptr<AudioService> audioService = make_shared<AudioService>();
455 if (audioService == nullptr) {
456 return;
457 }
458 audioService->muteSwitchStreams_.insert(sessionId);
459 audioService->IsMuteSwitchStream(sessionId);
460 }
461
AudioServiceInsertRendererFuzzTest()462 void AudioServiceInsertRendererFuzzTest()
463 {
464 shared_ptr<AudioService> audioService = make_shared<AudioService>();
465 if (audioService == nullptr) {
466 return;
467 }
468 uint32_t sessionId = GetData<uint32_t>();
469 AudioProcessConfig processConfig;
470 std::shared_ptr<StreamListenerHolder> streamListenerHolder =
471 std::make_shared<StreamListenerHolder>();
472 std::weak_ptr<IStreamListener> streamListener = streamListenerHolder;
473 std::shared_ptr<RendererInServer> rendererInServer =
474 std::make_shared<RendererInServer>(processConfig, streamListener);
475 std::shared_ptr<RendererInServer> renderer = rendererInServer;
476
477 audioService->InsertRenderer(sessionId, renderer);
478 }
479
AudioServiceSaveForegroundListFuzzTest()480 void AudioServiceSaveForegroundListFuzzTest()
481 {
482 shared_ptr<AudioService> audioService = make_shared<AudioService>();
483 if (audioService == nullptr) {
484 return;
485 }
486 std::vector<std::string> list;
487 bool isTestError = GetData<bool>();
488 if (isTestError) {
489 list.assign(SAVE_FOREGROUND_LIST_NUM, "example_string");
490 } else {
491 list.push_back("test_string");
492 }
493
494 audioService->SaveForegroundList(list);
495 }
496
AudioServiceMatchForegroundListFuzzTest()497 void AudioServiceMatchForegroundListFuzzTest()
498 {
499 shared_ptr<AudioService> audioService = make_shared<AudioService>();
500 if (audioService == nullptr) {
501 return;
502 }
503 uint32_t uid = GetData<uint32_t>();
504 string bundleName = "test_bundle";
505 audioService->foregroundSet_.insert(bundleName);
506
507 audioService->MatchForegroundList(bundleName, uid);
508 audioService->InForegroundList(uid);
509 }
510
AudioServiceUpdateForegroundStateFuzzTest()511 void AudioServiceUpdateForegroundStateFuzzTest()
512 {
513 shared_ptr<AudioService> audioService = make_shared<AudioService>();
514 if (audioService == nullptr) {
515 return;
516 }
517 uint32_t appTokenId = GetData<uint32_t>();
518 bool isActive = GetData<bool>();
519
520 audioService->UpdateForegroundState(appTokenId, isActive);
521 }
522
AudioServiceDumpForegroundListFuzzTest()523 void AudioServiceDumpForegroundListFuzzTest()
524 {
525 shared_ptr<AudioService> audioService = make_shared<AudioService>();
526 if (audioService == nullptr) {
527 return;
528 }
529 std::string dumpString = "test_dump_string";
530 audioService->foregroundSet_.insert("_success");
531 audioService->DumpForegroundList(dumpString);
532 }
533
AudioServiceRemoveRendererFuzzTest()534 void AudioServiceRemoveRendererFuzzTest()
535 {
536 shared_ptr<AudioService> audioService = make_shared<AudioService>();
537 if (audioService == nullptr) {
538 return;
539 }
540 uint32_t sessionId = GetData<uint32_t>();
541 audioService->allRendererMap_.clear();
542 audioService->allCapturerMap_.insert(make_pair(
543 sessionId, std::make_shared<CapturerInServer>(AudioProcessConfig(), std::weak_ptr<IStreamListener>())));
544 audioService->RemoveRenderer(sessionId);
545 }
546
AudioServiceInsertCapturerFuzzTest()547 void AudioServiceInsertCapturerFuzzTest()
548 {
549 uint32_t sessionId = GetData<uint32_t>();
550 AudioProcessConfig processConfig;
551
552 std::shared_ptr<StreamListenerHolder> streamListenerHolder =
553 std::make_shared<StreamListenerHolder>();
554 std::weak_ptr<IStreamListener> streamListener = streamListenerHolder;
555 std::shared_ptr<CapturerInServer> capturerInServer =
556 std::make_shared<CapturerInServer>(processConfig, streamListener);
557 std::shared_ptr<CapturerInServer> capturer = capturerInServer;
558 shared_ptr<AudioService> audioService = make_shared<AudioService>();
559 if (audioService == nullptr) {
560 return;
561 }
562 audioService->InsertCapturer(sessionId, capturer);
563 }
564
AudioServiceAddFilteredRenderFuzzTest()565 void AudioServiceAddFilteredRenderFuzzTest()
566 {
567 shared_ptr<AudioService> audioService = make_shared<AudioService>();
568 if (audioService == nullptr) {
569 return;
570 }
571 audioService->filteredRendererMap_.clear();
572
573 int32_t innerCapId = GetData<int32_t>();
574 std::shared_ptr<RendererInServer> renderer = nullptr;
575 audioService->AddFilteredRender(innerCapId, renderer);
576 audioService->filteredRendererMap_.clear();
577 }
578
AudioServiceShouldBeInnerCapFuzzTest()579 void AudioServiceShouldBeInnerCapFuzzTest()
580 {
581 shared_ptr<AudioService> audioService = make_shared<AudioService>();
582 if (audioService == nullptr) {
583 return;
584 }
585
586 AudioProcessConfig rendererConfig;
587 rendererConfig.privacyType = static_cast<AudioPrivacyType>(GetData<uint32_t>() % NUM_2);
588 std::set<int32_t> beCapIds;
589 audioService->ShouldBeInnerCap(rendererConfig, beCapIds);
590 }
591
AudioServiceCheckDisableFastInnerFuzzTest()592 void AudioServiceCheckDisableFastInnerFuzzTest()
593 {
594 shared_ptr<AudioService> audioService = make_shared<AudioService>();
595 if (audioService == nullptr) {
596 return;
597 }
598
599 AudioProcessConfig clientConfig = {};
600 std::shared_ptr<AudioEndpointInner> endpoint = std::make_shared<AudioEndpointInner>(AudioEndpoint::TYPE_VOIP_MMAP,
601 GetData<uint64_t>(), clientConfig);
602 audioService->CheckDisableFastInner(endpoint);
603 }
604
AudioServiceFilterAllFastProcessFuzzTest()605 void AudioServiceFilterAllFastProcessFuzzTest()
606 {
607 static const vector<DeviceRole> g_testDeviceTypes = {
608 DEVICE_ROLE_NONE,
609 INPUT_DEVICE,
610 OUTPUT_DEVICE,
611 DEVICE_ROLE_MAX,
612 };
613 shared_ptr<AudioService> audioService = make_shared<AudioService>();
614 if (audioService == nullptr) {
615 return;
616 }
617 AudioProcessConfig config = {};
618 config.audioMode = static_cast<AudioMode>(GetData<uint32_t>() % NUM_2);
619 sptr<AudioProcessInServer> audioprocess = AudioProcessInServer::Create(config, audioService.get());
620 AudioProcessConfig clientConfig = {};
621 std::shared_ptr<AudioEndpointInner> endpoint = std::make_shared<AudioEndpointInner>(AudioEndpoint::TYPE_VOIP_MMAP,
622 GetData<uint64_t>(), clientConfig);
623 endpoint->deviceInfo_.deviceRole_ = g_testDeviceTypes[GetData<uint32_t>() % g_testDeviceTypes.size()];
624 audioService->linkedPairedList_.clear();
625 audioService->linkedPairedList_.push_back(std::make_pair(audioprocess, endpoint));
626
627 audioService->endpointList_.clear();
628 audioService->endpointList_.insert(std::make_pair("endpoint", endpoint));
629 audioService->FilterAllFastProcess();
630 }
631
AudioServiceHandleFastCaptureFuzzTest()632 void AudioServiceHandleFastCaptureFuzzTest()
633 {
634 shared_ptr<AudioService> audioService = make_shared<AudioService>();
635 if (audioService == nullptr) {
636 return;
637 }
638 audioService->filteredRendererMap_.clear();
639
640 std::set<int32_t> captureIds = {1};
641 AudioProcessConfig config = {};
642 sptr<AudioProcessInServer> audioprocess = AudioProcessInServer::Create(config, audioService.get());
643
644 AudioProcessConfig clientConfig = {};
645 std::shared_ptr<AudioEndpointInner> endpoint = std::make_shared<AudioEndpointInner>(AudioEndpoint::TYPE_VOIP_MMAP,
646 GetData<uint64_t>(), clientConfig);
647
648 audioService->HandleFastCapture(captureIds, audioprocess, endpoint);
649 }
650
AudioServiceOnUpdateInnerCapListFuzzTest()651 void AudioServiceOnUpdateInnerCapListFuzzTest()
652 {
653 shared_ptr<AudioService> audioService = make_shared<AudioService>();
654 if (audioService == nullptr) {
655 return;
656 }
657 bool isTestError = GetData<bool>();
658 std::shared_ptr<RendererInServer> renderer;
659 AudioProcessConfig processConfig;
660 std::shared_ptr<StreamListenerHolder> streamListenerHolder =
661 std::make_shared<StreamListenerHolder>();
662 std::weak_ptr<IStreamListener> streamListener = streamListenerHolder;
663 if (isTestError) {
664 renderer = nullptr;
665 } else {
666 renderer = std::make_shared<RendererInServer>(processConfig, streamListener);
667 }
668 std::vector<std::weak_ptr<RendererInServer>> rendererVector;
669 rendererVector.push_back(renderer);
670 int32_t innerCapId = GetData<int32_t>();
671 audioService->filteredRendererMap_.clear();
672 audioService->endpointList_.clear();
673 audioService->filteredRendererMap_.insert(std::make_pair(innerCapId, rendererVector));
674 audioService->OnUpdateInnerCapList(innerCapId);
675 }
676
AudioServiceEnableDualToneListFuzzTest()677 void AudioServiceEnableDualToneListFuzzTest()
678 {
679 shared_ptr<AudioService> audioService = make_shared<AudioService>();
680 if (audioService == nullptr) {
681 return;
682 }
683 bool isTestError = GetData<bool>();
684 std::shared_ptr<RendererInServer> renderer;
685 AudioProcessConfig processConfig;
686 std::shared_ptr<StreamListenerHolder> streamListenerHolder =
687 std::make_shared<StreamListenerHolder>();
688 std::weak_ptr<IStreamListener> streamListener = streamListenerHolder;
689 if (isTestError) {
690 renderer = nullptr;
691 } else {
692 renderer = std::make_shared<RendererInServer>(processConfig, streamListener);
693 }
694
695 int32_t sessionId = GetData<int32_t>();
696 audioService->allRendererMap_.clear();
697 audioService->allRendererMap_.insert(std::make_pair(sessionId, renderer));
698 audioService->EnableDualToneList(sessionId);
699 }
700
AudioServiceDisableDualToneListFuzzTest()701 void AudioServiceDisableDualToneListFuzzTest()
702 {
703 shared_ptr<AudioService> audioService = make_shared<AudioService>();
704 if (audioService == nullptr) {
705 return;
706 }
707 bool isTestError = GetData<bool>();
708 std::shared_ptr<RendererInServer> renderer;
709 AudioProcessConfig processConfig;
710 std::shared_ptr<StreamListenerHolder> streamListenerHolder =
711 std::make_shared<StreamListenerHolder>();
712 std::weak_ptr<IStreamListener> streamListener = streamListenerHolder;
713 if (isTestError) {
714 renderer = nullptr;
715 } else {
716 renderer = std::make_shared<RendererInServer>(processConfig, streamListener);
717 }
718
719 audioService->filteredDualToneRendererMap_.clear();
720 audioService->filteredDualToneRendererMap_.push_back(renderer);
721 int32_t sessionId = GetData<int32_t>();
722 audioService->DisableDualToneList(sessionId);
723 }
724
AudioServiceNotifyStreamVolumeChangedFuzzTest()725 void AudioServiceNotifyStreamVolumeChangedFuzzTest()
726 {
727 AudioProcessConfig config = {};
728 AudioDeviceDescriptor deviceInfo(AudioDeviceDescriptor::DEVICE_INFO);
729 deviceInfo.deviceRole_ = DeviceRole::OUTPUT_DEVICE;
730 AudioStreamInfo audioStreamInfo = { SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO, CH_LAYOUT_STEREO };
731 deviceInfo.networkId_ = LOCAL_NETWORK_ID;
732 std::shared_ptr<AudioEndpoint> audioEndpointPtr = AudioEndpoint::CreateEndpoint(
733 AudioEndpoint::TYPE_MMAP, 0, config, deviceInfo, audioStreamInfo);
734 AudioProcessConfig configProcess = {};
735 sptr<AudioProcessInServer> audioProcess = AudioProcessInServer::Create(configProcess,
736 AudioService::GetInstance());
737 shared_ptr<AudioService> audioService = make_shared<AudioService>();
738 if (audioEndpointPtr == nullptr || audioService == nullptr) {
739 return;
740 }
741 float volume = GetData<float>();
742
743 audioService->endpointList_.insert(make_pair("testendpoint", audioEndpointPtr));
744 AudioStreamType streamType = g_testAudioStreamTypes[GetData<uint32_t>() % g_testAudioStreamTypes.size()];
745 audioService->NotifyStreamVolumeChanged(streamType, volume);
746 }
747
AudioServiceDumpFuzzTest()748 void AudioServiceDumpFuzzTest()
749 {
750 AudioProcessConfig config = {};
751 AudioDeviceDescriptor deviceInfo(AudioDeviceDescriptor::DEVICE_INFO);
752 deviceInfo.deviceRole_ = DeviceRole::OUTPUT_DEVICE;
753 AudioStreamInfo audioStreamInfo = { SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO, CH_LAYOUT_STEREO };
754 deviceInfo.networkId_ = LOCAL_NETWORK_ID;
755 std::shared_ptr<AudioEndpoint> audioEndpointPtr = AudioEndpoint::CreateEndpoint(
756 AudioEndpoint::TYPE_MMAP, 0, config, deviceInfo, audioStreamInfo);
757 AudioProcessConfig configProcess = {};
758 sptr<AudioProcessInServer> audioProcess = AudioProcessInServer::Create(configProcess,
759 AudioService::GetInstance());
760 shared_ptr<AudioService> audioService = make_shared<AudioService>();
761 if (audioProcess == nullptr || audioEndpointPtr == nullptr || audioService == nullptr) {
762 return;
763 }
764 std::string dumpString = "abcdefg";
765 AudioPlaybackCaptureConfig playbackCaptureConfig;
766 audioService->workingConfigs_.insert(make_pair(GetData<int32_t>(), playbackCaptureConfig));
767 config.audioMode = static_cast<AudioMode>(GetData<uint32_t>() % NUM_2);
768 std::shared_ptr<AudioEndpointInner> endpointInner = std::make_shared<AudioEndpointInner>(
769 AudioEndpoint::TYPE_VOIP_MMAP, GetData<uint64_t>(), config);
770 audioService->linkedPairedList_.clear();
771 audioService->linkedPairedList_.push_back(std::make_pair(audioProcess, endpointInner));
772 audioService->endpointList_.clear();
773 audioService->endpointList_.insert(make_pair("testendpoint", audioEndpointPtr));
774 std::shared_ptr<StreamListenerHolder> streamListenerHolder =
775 std::make_shared<StreamListenerHolder>();
776 std::weak_ptr<IStreamListener> streamListener = streamListenerHolder;
777 std::shared_ptr<RendererInServer> renderer = std::make_shared<RendererInServer>(config, streamListener);
778 audioService->allRendererMap_.insert(std::make_pair(GetData<int32_t>(), renderer));
779 audioService->Dump(dumpString);
780 }
781
AudioServiceGetCreatedAudioStreamMostUidFuzzTest()782 void AudioServiceGetCreatedAudioStreamMostUidFuzzTest()
783 {
784 shared_ptr<AudioService> audioService = make_shared<AudioService>();
785 if (audioService == nullptr) {
786 return;
787 }
788 int32_t mostAppUid = GetData<int32_t>();
789 int32_t mostAppNum = GetData<int32_t>();
790 audioService->appUseNumMap_.clear();
791 audioService->appUseNumMap_.insert(make_pair(mostAppUid, mostAppNum));
792 audioService->GetCreatedAudioStreamMostUid(mostAppUid, mostAppNum);
793 }
794
795 TestPtr g_testPtrs[] = {
796 #ifdef HAS_FEATURE_INNERCAPTURER
797 AudioServiceOnProcessReleaseFuzzTest,
798 AudioServiceCheckInnerCapForRendererFuzzTest,
799 AudioServiceResetAudioEndpointFuzzTest,
800 AudioServiceReLinkProcessToEndpointFuzzTest,
801 AudioServiceCheckInnerCapForProcessFuzzTest,
802 AudioServiceLinkProcessToEndpointFuzzTest,
803 AudioServiceUnlinkProcessToEndpointFuzzTest,
804 AudioServiceGetDeviceInfoForProcessFuzzTest,
805 AudioServiceGetMaxAmplitudeFuzzTest,
806 AudioServiceGetCapturerBySessionIDFuzzTest,
807 AudioServiceSetOffloadModeFuzzTest,
808 #endif
809 AudioServiceGetReleaseDelayTimeFuzzTest,
810 AudioServiceRemoveIdFromMuteControlSetFuzzTest,
811 AudioServiceCheckRenderSessionMuteStateFuzzTest,
812 AudioServiceCheckCaptureSessionMuteStateFuzzTest,
813 AudioServiceCheckFastSessionMuteStateFuzzTest,
814 AudioServiceIsMuteSwitchStreamFuzzTest,
815 AudioServiceInsertRendererFuzzTest,
816 AudioServiceSaveForegroundListFuzzTest,
817 AudioServiceMatchForegroundListFuzzTest,
818 AudioServiceUpdateForegroundStateFuzzTest,
819 AudioServiceDumpForegroundListFuzzTest,
820 AudioServiceRemoveRendererFuzzTest,
821 AudioServiceInsertCapturerFuzzTest,
822 AudioServiceAddFilteredRenderFuzzTest,
823 AudioServiceShouldBeInnerCapFuzzTest,
824 AudioServiceCheckDisableFastInnerFuzzTest,
825 AudioServiceFilterAllFastProcessFuzzTest,
826 AudioServiceHandleFastCaptureFuzzTest,
827 AudioServiceOnUpdateInnerCapListFuzzTest,
828 AudioServiceEnableDualToneListFuzzTest,
829 AudioServiceDisableDualToneListFuzzTest,
830 AudioServiceNotifyStreamVolumeChangedFuzzTest,
831 AudioServiceDumpFuzzTest,
832 AudioServiceGetCreatedAudioStreamMostUidFuzzTest,
833 };
834
FuzzTest(const uint8_t * rawData,size_t size)835 bool FuzzTest(const uint8_t* rawData, size_t size)
836 {
837 if (rawData == nullptr) {
838 return false;
839 }
840
841 RAW_DATA = rawData;
842 g_dataSize = size;
843 g_pos = 0;
844
845 uint32_t code = GetData<uint32_t>();
846 uint32_t len = GetArrLength(g_testPtrs);
847 if (len > 0) {
848 g_testPtrs[code % len]();
849 } else {
850 AUDIO_INFO_LOG("%{public}s: The len length is equal to 0", __func__);
851 }
852 return true;
853 }
854
855 } // namespace AudioStandard
856 } // namesapce OHOS
857
858 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)859 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
860 {
861 if (size < OHOS::AudioStandard::THRESHOLD) {
862 return 0;
863 }
864 OHOS::AudioStandard::FuzzTest(data, size);
865 return 0;
866 }