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 <iostream>
17 #include <cstddef>
18 #include <cstdint>
19
20 #include "audio_manager_base.h"
21 #include "audio_policy_manager_listener_stub_impl.h"
22 #include "audio_server.h"
23 #include "audio_service.h"
24 #include "sink/i_audio_render_sink.h"
25 #include "common/hdi_adapter_info.h"
26 #include "manager/hdi_adapter_manager.h"
27 #include "audio_endpoint.h"
28 #include "access_token.h"
29 #include "message_parcel.h"
30 #include "audio_process_in_client.h"
31 #include "audio_process_in_server.h"
32 #include "audio_param_parser.h"
33 #include "none_mix_engine.h"
34 #include "audio_playback_engine.h"
35 #include "pro_renderer_stream_impl.h"
36 #include "oh_audio_buffer.h"
37 using namespace std;
38
39 namespace OHOS {
40 namespace AudioStandard {
41 constexpr int32_t DEFAULT_STREAM_ID = 10;
42 static std::unique_ptr<NoneMixEngine> playbackEngine_ = nullptr;
43 static std::unique_ptr<AudioPlaybackEngine> audioPlaybackEngine_ = nullptr;
44 static const uint8_t* RAW_DATA = nullptr;
45 static size_t g_dataSize = 0;
46 static size_t g_pos;
47 const size_t THRESHOLD = 10;
48
49 /*
50 * describe: get data from outside untrusted data(g_data) which size is according to sizeof(T)
51 * tips: only support basic type
52 */
53 template<class T>
GetData()54 T GetData()
55 {
56 T object {};
57 size_t objectSize = sizeof(object);
58 if (RAW_DATA == nullptr || objectSize > g_dataSize - g_pos) {
59 return object;
60 }
61 errno_t ret = memcpy_s(&object, objectSize, RAW_DATA + g_pos, objectSize);
62 if (ret != EOK) {
63 return {};
64 }
65 g_pos += objectSize;
66 return object;
67 }
68
69 template<class T>
GetArrLength(T & arr)70 uint32_t GetArrLength(T& arr)
71 {
72 if (arr == nullptr) {
73 AUDIO_INFO_LOG("%{public}s: The array length is equal to 0", __func__);
74 return 0;
75 }
76 return sizeof(arr) / sizeof(arr[0]);
77 }
78
ReleaseNoneEngine()79 void ReleaseNoneEngine()
80 {
81 if (playbackEngine_ != nullptr) {
82 playbackEngine_->Stop();
83 playbackEngine_ = nullptr;
84 }
85 }
86
ReleaseAudioPlaybackEngine()87 void ReleaseAudioPlaybackEngine()
88 {
89 if (audioPlaybackEngine_ != nullptr) {
90 audioPlaybackEngine_->Stop();
91 audioPlaybackEngine_ = nullptr;
92 }
93 }
94
DeviceFuzzTestSetUp()95 void DeviceFuzzTestSetUp()
96 {
97 if (playbackEngine_ != nullptr) {
98 return;
99 }
100 AudioDeviceDescriptor deviceInfo(AudioDeviceDescriptor::DEVICE_INFO);
101 deviceInfo.deviceType_ = DEVICE_TYPE_USB_HEADSET;
102 playbackEngine_ = std::make_unique<NoneMixEngine>();
103 bool isVoip = GetData<bool>();
104 playbackEngine_->Init(deviceInfo, isVoip);
105 ReleaseNoneEngine();
106 }
107
InitProcessConfig()108 static AudioProcessConfig InitProcessConfig()
109 {
110 AudioProcessConfig config;
111 config.appInfo.appUid = DEFAULT_STREAM_ID;
112 config.appInfo.appPid = DEFAULT_STREAM_ID;
113 config.streamInfo.format = SAMPLE_S32LE;
114 config.streamInfo.samplingRate = SAMPLE_RATE_48000;
115 config.streamInfo.channels = STEREO;
116 config.streamInfo.channelLayout = AudioChannelLayout::CH_LAYOUT_STEREO;
117 config.audioMode = AudioMode::AUDIO_MODE_RECORD;
118 config.streamType = AudioStreamType::STREAM_MUSIC;
119 config.deviceType = DEVICE_TYPE_USB_HEADSET;
120 return config;
121 }
122
DirectAudioPlayBackEngineStateFuzzTest()123 void DirectAudioPlayBackEngineStateFuzzTest()
124 {
125 AudioProcessConfig config = InitProcessConfig();
126 std::shared_ptr<ProRendererStreamImpl> rendererStream = std::make_shared<ProRendererStreamImpl>(config, true);
127 rendererStream->InitParams();
128 uint32_t num = GetData<uint32_t>();
129 rendererStream->SetStreamIndex(num);
130 rendererStream->Start();
131 rendererStream->Pause();
132 rendererStream->Flush();
133 rendererStream->Stop();
134 rendererStream->Release();
135 }
136
NoneMixEngineStartFuzzTest()137 void NoneMixEngineStartFuzzTest()
138 {
139 playbackEngine_ = std::make_unique<NoneMixEngine>();
140 playbackEngine_->Start();
141 ReleaseNoneEngine();
142 }
143
NoneMixEngineStopFuzzTest()144 void NoneMixEngineStopFuzzTest()
145 {
146 playbackEngine_ = std::make_unique<NoneMixEngine>();
147 playbackEngine_->Stop();
148 ReleaseNoneEngine();
149 }
150
NoneMixEnginePauseFuzzTest()151 void NoneMixEnginePauseFuzzTest()
152 {
153 playbackEngine_ = std::make_unique<NoneMixEngine>();
154 playbackEngine_->Pause();
155 ReleaseNoneEngine();
156 }
157
NoneMixEngineFlushFuzzTest()158 void NoneMixEngineFlushFuzzTest()
159 {
160 playbackEngine_ = std::make_unique<NoneMixEngine>();
161 playbackEngine_->Flush();
162 ReleaseNoneEngine();
163 }
164
NoneMixEngineAddRendererFuzzTest()165 void NoneMixEngineAddRendererFuzzTest()
166 {
167 AudioProcessConfig config = InitProcessConfig();
168 std::shared_ptr<ProRendererStreamImpl> rendererStream = std::make_shared<ProRendererStreamImpl>(config, true);
169 rendererStream->InitParams();
170 uint32_t num = GetData<uint32_t>();
171 rendererStream->SetStreamIndex(num);
172 rendererStream->Start();
173 playbackEngine_ = std::make_unique<NoneMixEngine>();
174 playbackEngine_->AddRenderer(rendererStream);
175 ReleaseNoneEngine();
176 }
177
NoneMixEngineRemoveRendererFuzzTest()178 void NoneMixEngineRemoveRendererFuzzTest()
179 {
180 AudioProcessConfig config = InitProcessConfig();
181 std::shared_ptr<ProRendererStreamImpl> rendererStream = std::make_shared<ProRendererStreamImpl>(config, true);
182 rendererStream->InitParams();
183 uint32_t num = GetData<uint32_t>();
184 rendererStream->SetStreamIndex(num);
185 rendererStream->Start();
186 playbackEngine_ = std::make_unique<NoneMixEngine>();
187 playbackEngine_->AddRenderer(rendererStream);
188 playbackEngine_->RemoveRenderer(rendererStream);
189 ReleaseNoneEngine();
190 }
191
PlaybackEngineInitFuzzTest()192 void PlaybackEngineInitFuzzTest()
193 {
194 if (playbackEngine_ != nullptr) {
195 return;
196 }
197 AudioDeviceDescriptor deviceInfo(AudioDeviceDescriptor::DEVICE_INFO);
198 deviceInfo.deviceType_ = DEVICE_TYPE_USB_HEADSET;
199 audioPlaybackEngine_ = std::make_unique<AudioPlaybackEngine>();
200 bool isVoip = GetData<bool>();
201 audioPlaybackEngine_->Init(deviceInfo, isVoip);
202 ReleaseAudioPlaybackEngine();
203 }
204
PlaybackEngineStartFuzzTest()205 void PlaybackEngineStartFuzzTest()
206 {
207 audioPlaybackEngine_ = std::make_unique<AudioPlaybackEngine>();
208 audioPlaybackEngine_->Start();
209 ReleaseAudioPlaybackEngine();
210 }
211
PlaybackEngineStopFuzzTest()212 void PlaybackEngineStopFuzzTest()
213 {
214 audioPlaybackEngine_ = std::make_unique<AudioPlaybackEngine>();
215 audioPlaybackEngine_->Stop();
216 ReleaseAudioPlaybackEngine();
217 }
218
PlaybackEnginePauseFuzzTest()219 void PlaybackEnginePauseFuzzTest()
220 {
221 audioPlaybackEngine_ = std::make_unique<AudioPlaybackEngine>();
222 audioPlaybackEngine_->Pause();
223 ReleaseAudioPlaybackEngine();
224 }
225
PlaybackEngineFlushFuzzTest()226 void PlaybackEngineFlushFuzzTest()
227 {
228 audioPlaybackEngine_ = std::make_unique<AudioPlaybackEngine>();
229 audioPlaybackEngine_->Flush();
230 ReleaseAudioPlaybackEngine();
231 }
232
PlaybackEngineIsPlaybackEngineRunningFuzzTest()233 void PlaybackEngineIsPlaybackEngineRunningFuzzTest()
234 {
235 audioPlaybackEngine_ = std::make_unique<AudioPlaybackEngine>();
236 audioPlaybackEngine_->IsPlaybackEngineRunning();
237 ReleaseAudioPlaybackEngine();
238 }
239
PlaybackEngineGetLatencyFuzzTest()240 void PlaybackEngineGetLatencyFuzzTest()
241 {
242 audioPlaybackEngine_ = std::make_unique<AudioPlaybackEngine>();
243 audioPlaybackEngine_->GetLatency();
244 ReleaseAudioPlaybackEngine();
245 }
246
PlaybackEngineAddRendererFuzzTest()247 void PlaybackEngineAddRendererFuzzTest()
248 {
249 AudioProcessConfig config = InitProcessConfig();
250 std::shared_ptr<ProRendererStreamImpl> rendererStream = std::make_shared<ProRendererStreamImpl>(config, true);
251 rendererStream->InitParams();
252 uint32_t num = GetData<uint32_t>();
253 rendererStream->SetStreamIndex(num);
254 rendererStream->Start();
255 audioPlaybackEngine_ = std::make_unique<AudioPlaybackEngine>();
256 audioPlaybackEngine_->AddRenderer(rendererStream);
257 ReleaseAudioPlaybackEngine();
258 }
259
PlaybackEngineRemoveRendererFuzzTest()260 void PlaybackEngineRemoveRendererFuzzTest()
261 {
262 AudioProcessConfig config = InitProcessConfig();
263 std::shared_ptr<ProRendererStreamImpl> rendererStream = std::make_shared<ProRendererStreamImpl>(config, true);
264 rendererStream->InitParams();
265 uint32_t num = GetData<uint32_t>();
266 rendererStream->SetStreamIndex(num);
267 rendererStream->Start();
268 audioPlaybackEngine_ = std::make_unique<AudioPlaybackEngine>();
269 audioPlaybackEngine_->AddRenderer(rendererStream);
270 audioPlaybackEngine_->RemoveRenderer(rendererStream);
271 ReleaseAudioPlaybackEngine();
272 }
273
ResourceServiceAudioWorkgroupCheckFuzzTest()274 void ResourceServiceAudioWorkgroupCheckFuzzTest()
275 {
276 int32_t pid = GetData<int32_t>();
277 AudioResourceService::GetInstance()->AudioWorkgroupCheck(pid);
278 }
279
ResourceServiceCreateAudioWorkgroupFuzzTest()280 void ResourceServiceCreateAudioWorkgroupFuzzTest()
281 {
282 int32_t pid = GetData<int32_t>();
283 sptr<IRemoteObject> remoteObject = nullptr;
284 AudioResourceService::GetInstance()->CreateAudioWorkgroup(pid, remoteObject);
285 }
286
ResourceServiceReleaseAudioWorkgroupFuzzTest()287 void ResourceServiceReleaseAudioWorkgroupFuzzTest()
288 {
289 int32_t pid = GetData<int32_t>();
290 int32_t workgroupId = GetData<int32_t>();
291 AudioResourceService::GetInstance()->ReleaseAudioWorkgroup(pid, workgroupId);
292 }
293
ResourceServiceAddThreadToGroupFuzzTest()294 void ResourceServiceAddThreadToGroupFuzzTest()
295 {
296 int32_t pid = GetData<int32_t>();
297 int32_t workgroupId = GetData<int32_t>();
298 int32_t tokenId = GetData<int32_t>();
299 AudioResourceService::GetInstance()->AddThreadToGroup(pid, workgroupId, tokenId);
300 }
301
ResourceServiceRemoveThreadFromGroupFuzzTest()302 void ResourceServiceRemoveThreadFromGroupFuzzTest()
303 {
304 int32_t pid = GetData<int32_t>();
305 int32_t workgroupId = GetData<int32_t>();
306 int32_t tokenId = GetData<int32_t>();
307 AudioResourceService::GetInstance()->RemoveThreadFromGroup(pid, workgroupId, tokenId);
308 }
309
ResourceServiceStartGroupFuzzTest()310 void ResourceServiceStartGroupFuzzTest()
311 {
312 int32_t pid = GetData<int32_t>();
313 int32_t workgroupId = GetData<int32_t>();
314 uint64_t startTime = GetData<uint64_t>();
315 uint64_t deadlineTime = GetData<uint64_t>();
316 AudioResourceService::GetInstance()->StartGroup(pid, workgroupId, startTime, deadlineTime);
317 }
318
ResourceServiceStopGroupFuzzTest()319 void ResourceServiceStopGroupFuzzTest()
320 {
321 int32_t pid = GetData<int32_t>();
322 int32_t workgroupId = GetData<int32_t>();
323 AudioResourceService::GetInstance()->StopGroup(pid, workgroupId);
324 }
325
ResourceServiceGetAudioWorkgroupPtrFuzzTest()326 void ResourceServiceGetAudioWorkgroupPtrFuzzTest()
327 {
328 int32_t pid = GetData<int32_t>();
329 int32_t workgroupId = GetData<int32_t>();
330 AudioResourceService::GetInstance()->GetAudioWorkgroupPtr(pid, workgroupId);
331 }
332
ResourceServiceGetThreadsNumPerProcessFuzzTest()333 void ResourceServiceGetThreadsNumPerProcessFuzzTest()
334 {
335 int32_t pid = GetData<int32_t>();
336 AudioResourceService::GetInstance()->GetThreadsNumPerProcess(pid);
337 }
338
ResourceServiceIsProcessHasSystemPermissionFuzzTest()339 void ResourceServiceIsProcessHasSystemPermissionFuzzTest()
340 {
341 int32_t pid = GetData<int32_t>();
342 AudioResourceService::GetInstance()->IsProcessHasSystemPermission(pid);
343 }
344
ResourceServiceRegisterAudioWorkgroupMonitorFuzzTest()345 void ResourceServiceRegisterAudioWorkgroupMonitorFuzzTest()
346 {
347 int32_t pid = GetData<int32_t>();
348 int32_t groupId = GetData<int32_t>();
349 sptr<IRemoteObject> object = nullptr;
350 AudioResourceService::GetInstance()->RegisterAudioWorkgroupMonitor(pid, groupId, object);
351 }
352
RenderInServerGetLastAudioDurationFuzzTest()353 void RenderInServerGetLastAudioDurationFuzzTest()
354 {
355 AudioProcessConfig processConfig;
356 std::shared_ptr<StreamListenerHolder> streamListenerHolder =
357 std::make_shared<StreamListenerHolder>();
358 std::weak_ptr<IStreamListener> streamListener = streamListenerHolder;
359 std::shared_ptr<RendererInServer> rendererInServer =
360 std::make_shared<RendererInServer>(processConfig, streamListener);
361 std::shared_ptr<RendererInServer> renderer = rendererInServer;
362 renderer->GetLastAudioDuration();
363 }
364
RenderInServerHandleOperationStartedFuzzTest()365 void RenderInServerHandleOperationStartedFuzzTest()
366 {
367 AudioProcessConfig processConfig;
368 std::shared_ptr<StreamListenerHolder> streamListenerHolder =
369 std::make_shared<StreamListenerHolder>();
370 std::weak_ptr<IStreamListener> streamListener = streamListenerHolder;
371 std::shared_ptr<RendererInServer> rendererInServer =
372 std::make_shared<RendererInServer>(processConfig, streamListener);
373 std::shared_ptr<RendererInServer> renderer = rendererInServer;
374 renderer->HandleOperationStarted();
375 }
376
RenderInServerStandByCheckFuzzTest()377 void RenderInServerStandByCheckFuzzTest()
378 {
379 AudioProcessConfig processConfig;
380 std::shared_ptr<StreamListenerHolder> streamListenerHolder =
381 std::make_shared<StreamListenerHolder>();
382 std::weak_ptr<IStreamListener> streamListener = streamListenerHolder;
383 std::shared_ptr<RendererInServer> rendererInServer =
384 std::make_shared<RendererInServer>(processConfig, streamListener);
385 std::shared_ptr<RendererInServer> renderer = rendererInServer;
386 renderer->StandByCheck();
387 }
388
RenderInServerShouldEnableStandByFuzzTest()389 void RenderInServerShouldEnableStandByFuzzTest()
390 {
391 AudioProcessConfig processConfig;
392 std::shared_ptr<StreamListenerHolder> streamListenerHolder =
393 std::make_shared<StreamListenerHolder>();
394 std::weak_ptr<IStreamListener> streamListener = streamListenerHolder;
395 std::shared_ptr<RendererInServer> rendererInServer =
396 std::make_shared<RendererInServer>(processConfig, streamListener);
397 std::shared_ptr<RendererInServer> renderer = rendererInServer;
398 renderer->ShouldEnableStandBy();
399 }
400
RenderInServerGetStandbyStatusFuzzTest()401 void RenderInServerGetStandbyStatusFuzzTest()
402 {
403 AudioProcessConfig processConfig;
404 std::shared_ptr<StreamListenerHolder> streamListenerHolder =
405 std::make_shared<StreamListenerHolder>();
406 std::weak_ptr<IStreamListener> streamListener = streamListenerHolder;
407 std::shared_ptr<RendererInServer> rendererInServer =
408 std::make_shared<RendererInServer>(processConfig, streamListener);
409 std::shared_ptr<RendererInServer> renderer = rendererInServer;
410
411 bool isStandby = GetData<bool>();
412 int64_t enterStandbyTime = GetData<int64_t>();
413 renderer->GetStandbyStatus(isStandby, enterStandbyTime);
414 }
415
RenderInServerWriteMuteDataSysEventFuzzTest()416 void RenderInServerWriteMuteDataSysEventFuzzTest()
417 {
418 AudioProcessConfig processConfig;
419 std::shared_ptr<StreamListenerHolder> streamListenerHolder =
420 std::make_shared<StreamListenerHolder>();
421 std::weak_ptr<IStreamListener> streamListener = streamListenerHolder;
422 std::shared_ptr<RendererInServer> rendererInServer =
423 std::make_shared<RendererInServer>(processConfig, streamListener);
424 std::shared_ptr<RendererInServer> renderer = rendererInServer;
425 BufferDesc desc;
426 desc.buffer = nullptr;
427 desc.bufLength = 0;
428 desc.dataLength =0;
429 renderer->WriteMuteDataSysEvent(desc);
430 }
431
RenderInServerInnerCaptureEnqueueBufferFuzzTest()432 void RenderInServerInnerCaptureEnqueueBufferFuzzTest()
433 {
434 AudioProcessConfig processConfig;
435 std::shared_ptr<StreamListenerHolder> streamListenerHolder =
436 std::make_shared<StreamListenerHolder>();
437 std::weak_ptr<IStreamListener> streamListener = streamListenerHolder;
438 std::shared_ptr<RendererInServer> rendererInServer =
439 std::make_shared<RendererInServer>(processConfig, streamListener);
440 std::shared_ptr<RendererInServer> renderer = rendererInServer;
441 BufferDesc bufferDesc;
442 bufferDesc.buffer = nullptr;
443 bufferDesc.bufLength = 0;
444 bufferDesc.dataLength =0;
445 CaptureInfo captureInfo;
446 int32_t innerCapId = GetData<int32_t>();
447 renderer->InnerCaptureEnqueueBuffer(bufferDesc, captureInfo, innerCapId);
448 }
449
RenderInServerInnerCaptureOtherStreamFuzzTest()450 void RenderInServerInnerCaptureOtherStreamFuzzTest()
451 {
452 AudioProcessConfig processConfig;
453 std::shared_ptr<StreamListenerHolder> streamListenerHolder =
454 std::make_shared<StreamListenerHolder>();
455 std::weak_ptr<IStreamListener> streamListener = streamListenerHolder;
456 std::shared_ptr<RendererInServer> rendererInServer =
457 std::make_shared<RendererInServer>(processConfig, streamListener);
458 std::shared_ptr<RendererInServer> renderer = rendererInServer;
459 BufferDesc bufferDesc;
460 bufferDesc.buffer = nullptr;
461 bufferDesc.bufLength = 0;
462 bufferDesc.dataLength =0;
463 CaptureInfo captureInfo;
464 int32_t innerCapId = GetData<int32_t>();
465 renderer->InnerCaptureOtherStream(bufferDesc, captureInfo, innerCapId);
466 }
467
RenderInServerOtherStreamEnqueueFuzzTest()468 void RenderInServerOtherStreamEnqueueFuzzTest()
469 {
470 AudioProcessConfig processConfig;
471 std::shared_ptr<StreamListenerHolder> streamListenerHolder =
472 std::make_shared<StreamListenerHolder>();
473 std::weak_ptr<IStreamListener> streamListener = streamListenerHolder;
474 std::shared_ptr<RendererInServer> rendererInServer =
475 std::make_shared<RendererInServer>(processConfig, streamListener);
476 std::shared_ptr<RendererInServer> renderer = rendererInServer;
477
478 unsigned char inputData[] = "test";
479 BufferDesc bufferDesc;
480 bufferDesc.buffer = inputData;
481 bufferDesc.bufLength = 0;
482 bufferDesc.dataLength =0;
483 renderer->OtherStreamEnqueue(bufferDesc);
484 }
485
RenderInServerIsInvalidBufferFuzzTest()486 void RenderInServerIsInvalidBufferFuzzTest()
487 {
488 AudioProcessConfig processConfig;
489 std::shared_ptr<StreamListenerHolder> streamListenerHolder =
490 std::make_shared<StreamListenerHolder>();
491 std::weak_ptr<IStreamListener> streamListener = streamListenerHolder;
492 std::shared_ptr<RendererInServer> rendererInServer =
493 std::make_shared<RendererInServer>(processConfig, streamListener);
494 std::shared_ptr<RendererInServer> renderer = rendererInServer;
495
496 unsigned char inputData[] = "test";
497 BufferDesc bufferDesc;
498 bufferDesc.buffer = inputData;
499 bufferDesc.bufLength = 0;
500 bufferDesc.dataLength =0;
501 renderer->IsInvalidBuffer(bufferDesc.buffer, bufferDesc.bufLength);
502 }
503
RenderInServerDualToneStreamInStartFuzzTest()504 void RenderInServerDualToneStreamInStartFuzzTest()
505 {
506 AudioProcessConfig processConfig;
507 std::shared_ptr<StreamListenerHolder> streamListenerHolder =
508 std::make_shared<StreamListenerHolder>();
509 std::weak_ptr<IStreamListener> streamListener = streamListenerHolder;
510 std::shared_ptr<RendererInServer> rendererInServer =
511 std::make_shared<RendererInServer>(processConfig, streamListener);
512 std::shared_ptr<RendererInServer> renderer = rendererInServer;
513
514 renderer->dualToneStreamInStart();
515 }
516
RenderInServerRecordStandbyTimeFuzzTest()517 void RenderInServerRecordStandbyTimeFuzzTest()
518 {
519 AudioProcessConfig processConfig;
520 std::shared_ptr<StreamListenerHolder> streamListenerHolder =
521 std::make_shared<StreamListenerHolder>();
522 std::weak_ptr<IStreamListener> streamListener = streamListenerHolder;
523 std::shared_ptr<RendererInServer> rendererInServer =
524 std::make_shared<RendererInServer>(processConfig, streamListener);
525 std::shared_ptr<RendererInServer> renderer = rendererInServer;
526 bool isStandby = false;
527 bool isStandbyStart = GetData<bool>();
528 renderer->RecordStandbyTime(isStandby, isStandbyStart);
529 }
530
ProRendererGetStreamFramesWrittenFuzzTest()531 void ProRendererGetStreamFramesWrittenFuzzTest()
532 {
533 AudioProcessConfig config = InitProcessConfig();
534 std::shared_ptr<ProRendererStreamImpl> rendererStream = std::make_shared<ProRendererStreamImpl>(config, true);
535 uint64_t framesWritten = GetData<uint64_t>();
536 rendererStream->GetStreamFramesWritten(framesWritten);
537 }
538
ProRendererGetCurrentTimeStampFuzzTest()539 void ProRendererGetCurrentTimeStampFuzzTest()
540 {
541 AudioProcessConfig config = InitProcessConfig();
542 std::shared_ptr<ProRendererStreamImpl> rendererStream = std::make_shared<ProRendererStreamImpl>(config, true);
543 uint64_t timestamp = GetData<uint64_t>();
544 rendererStream->GetCurrentTimeStamp(timestamp);
545 }
546
ProRendererGetCurrentPositionFuzzTest()547 void ProRendererGetCurrentPositionFuzzTest()
548 {
549 AudioProcessConfig config = InitProcessConfig();
550 std::shared_ptr<ProRendererStreamImpl> rendererStream = std::make_shared<ProRendererStreamImpl>(config, true);
551 uint64_t framePosition = GetData<uint64_t>();
552 uint64_t timestamp = GetData<uint64_t>();
553 uint64_t latency = GetData<uint64_t>();
554 uint32_t base = GetData<uint32_t>();
555 rendererStream->GetCurrentPosition(framePosition, timestamp, latency, base);
556 }
557
ProRendererGetLatencyFuzzTest()558 void ProRendererGetLatencyFuzzTest()
559 {
560 AudioProcessConfig config = InitProcessConfig();
561 std::shared_ptr<ProRendererStreamImpl> rendererStream = std::make_shared<ProRendererStreamImpl>(config, true);
562 uint64_t latency = GetData<uint64_t>();
563 rendererStream->GetLatency(latency);
564 }
565
ProRendererSetAudioEffectModeFuzzTest()566 void ProRendererSetAudioEffectModeFuzzTest()
567 {
568 AudioProcessConfig config = InitProcessConfig();
569 std::shared_ptr<ProRendererStreamImpl> rendererStream = std::make_shared<ProRendererStreamImpl>(config, true);
570 int32_t effectMode = GetData<int32_t>();
571 rendererStream->SetAudioEffectMode(effectMode);
572 }
573
ProRendererGetAudioEffectModeFuzzTest()574 void ProRendererGetAudioEffectModeFuzzTest()
575 {
576 AudioProcessConfig config = InitProcessConfig();
577 std::shared_ptr<ProRendererStreamImpl> rendererStream = std::make_shared<ProRendererStreamImpl>(config, true);
578 int32_t effectMode = GetData<int32_t>();
579 rendererStream->GetAudioEffectMode(effectMode);
580 }
581
ProRendererSetPrivacyTypeFuzzTest()582 void ProRendererSetPrivacyTypeFuzzTest()
583 {
584 AudioProcessConfig config = InitProcessConfig();
585 std::shared_ptr<ProRendererStreamImpl> rendererStream = std::make_shared<ProRendererStreamImpl>(config, true);
586 int32_t privacyType = GetData<int32_t>();
587 rendererStream->SetPrivacyType(privacyType);
588 }
589
ProRendererGetPrivacyTypeFuzzTest()590 void ProRendererGetPrivacyTypeFuzzTest()
591 {
592 AudioProcessConfig config = InitProcessConfig();
593 std::shared_ptr<ProRendererStreamImpl> rendererStream = std::make_shared<ProRendererStreamImpl>(config, true);
594 int32_t privacyType = GetData<int32_t>();
595 rendererStream->GetPrivacyType(privacyType);
596 }
597
ProRendererSetSpeedFuzzTest()598 void ProRendererSetSpeedFuzzTest()
599 {
600 AudioProcessConfig config = InitProcessConfig();
601 std::shared_ptr<ProRendererStreamImpl> rendererStream = std::make_shared<ProRendererStreamImpl>(config, true);
602 float speed = GetData<float>();
603 rendererStream->SetSpeed(speed);
604 }
605
ProRendererDequeueBufferFuzzTest()606 void ProRendererDequeueBufferFuzzTest()
607 {
608 AudioProcessConfig config = InitProcessConfig();
609 std::shared_ptr<ProRendererStreamImpl> rendererStream = std::make_shared<ProRendererStreamImpl>(config, true);
610 size_t length = GetData<size_t>();
611 rendererStream->DequeueBuffer(length);
612 }
613
ProRendererEnqueueBufferFuzzTest()614 void ProRendererEnqueueBufferFuzzTest()
615 {
616 AudioProcessConfig config = InitProcessConfig();
617 std::shared_ptr<ProRendererStreamImpl> rendererStream = std::make_shared<ProRendererStreamImpl>(config, true);
618 BufferDesc bufferDesc;
619 bufferDesc.buffer = nullptr;
620 bufferDesc.bufLength = 0;
621 bufferDesc.dataLength =0;
622 rendererStream->EnqueueBuffer(bufferDesc);
623 }
624
ProRendererGetMinimumBufferSizeFuzzTest()625 void ProRendererGetMinimumBufferSizeFuzzTest()
626 {
627 AudioProcessConfig config = InitProcessConfig();
628 std::shared_ptr<ProRendererStreamImpl> rendererStream = std::make_shared<ProRendererStreamImpl>(config, true);
629 size_t minBufferSize = GetData<size_t>();
630 rendererStream->GetMinimumBufferSize(minBufferSize);
631 }
632
ProRendererGetByteSizePerFrameFuzzTest()633 void ProRendererGetByteSizePerFrameFuzzTest()
634 {
635 AudioProcessConfig config = InitProcessConfig();
636 std::shared_ptr<ProRendererStreamImpl> rendererStream = std::make_shared<ProRendererStreamImpl>(config, true);
637 size_t byteSizePerFrame = GetData<size_t>();
638 rendererStream->GetByteSizePerFrame(byteSizePerFrame);
639 }
640
ProRendererGetSpanSizePerFrameFuzzTest()641 void ProRendererGetSpanSizePerFrameFuzzTest()
642 {
643 AudioProcessConfig config = InitProcessConfig();
644 std::shared_ptr<ProRendererStreamImpl> rendererStream = std::make_shared<ProRendererStreamImpl>(config, true);
645 size_t spanSizeInFrame = GetData<size_t>();
646 rendererStream->GetSpanSizePerFrame(spanSizeInFrame);
647 }
648
ProRendererGetStreamIndexFuzzTest()649 void ProRendererGetStreamIndexFuzzTest()
650 {
651 AudioProcessConfig config = InitProcessConfig();
652 std::shared_ptr<ProRendererStreamImpl> rendererStream = std::make_shared<ProRendererStreamImpl>(config, true);
653 rendererStream->GetStreamIndex();
654 }
655
ProRendererOffloadSetVolumeFuzzTest()656 void ProRendererOffloadSetVolumeFuzzTest()
657 {
658 AudioProcessConfig config = InitProcessConfig();
659 std::shared_ptr<ProRendererStreamImpl> rendererStream = std::make_shared<ProRendererStreamImpl>(config, true);
660 float volume = GetData<float>();
661 rendererStream->OffloadSetVolume(volume);
662 }
663
ProRendererSetOffloadDataCallbackStateFuzzTest()664 void ProRendererSetOffloadDataCallbackStateFuzzTest()
665 {
666 AudioProcessConfig config = InitProcessConfig();
667 std::shared_ptr<ProRendererStreamImpl> rendererStream = std::make_shared<ProRendererStreamImpl>(config, true);
668 int32_t state = GetData<int32_t>();
669 rendererStream->SetOffloadDataCallbackState(state);
670 }
671
ProRendererUpdateSpatializationStateFuzzTest()672 void ProRendererUpdateSpatializationStateFuzzTest()
673 {
674 AudioProcessConfig config = InitProcessConfig();
675 std::shared_ptr<ProRendererStreamImpl> rendererStream = std::make_shared<ProRendererStreamImpl>(config, true);
676 bool spatializationEnabled = GetData<bool>();
677 bool headTrackingEnabled = GetData<bool>();
678 rendererStream->UpdateSpatializationState(spatializationEnabled, headTrackingEnabled);
679 }
680
ProRendererGetAudioTimeFuzzTest()681 void ProRendererGetAudioTimeFuzzTest()
682 {
683 AudioProcessConfig config = InitProcessConfig();
684 std::shared_ptr<ProRendererStreamImpl> rendererStream = std::make_shared<ProRendererStreamImpl>(config, true);
685 uint64_t framePos = GetData<uint64_t>();
686 int64_t sec = GetData<int64_t>();
687 int64_t nanoSec = GetData<int64_t>();
688 rendererStream->GetAudioTime(framePos, sec, nanoSec);
689 }
690
ProRendererPeekFuzzTest()691 void ProRendererPeekFuzzTest()
692 {
693 AudioProcessConfig config = InitProcessConfig();
694 std::shared_ptr<ProRendererStreamImpl> rendererStream = std::make_shared<ProRendererStreamImpl>(config, true);
695 int32_t index = GetData<int32_t>();
696 std::vector<char> audioBuffer = {0x01, 0x02, 0x03, 0x04, 0x05};
697 rendererStream->Peek(&audioBuffer, index);
698 }
699
ProRendererReturnIndexFuzzTest()700 void ProRendererReturnIndexFuzzTest()
701 {
702 AudioProcessConfig config = InitProcessConfig();
703 std::shared_ptr<ProRendererStreamImpl> rendererStream = std::make_shared<ProRendererStreamImpl>(config, true);
704 int32_t index = GetData<int32_t>();
705 rendererStream->ReturnIndex(index);
706 }
707
ProRendererSetClientVolumeFuzzTest()708 void ProRendererSetClientVolumeFuzzTest()
709 {
710 AudioProcessConfig config = InitProcessConfig();
711 std::shared_ptr<ProRendererStreamImpl> rendererStream = std::make_shared<ProRendererStreamImpl>(config, true);
712 float clientVolume = GetData<float>();
713 rendererStream->SetClientVolume(clientVolume);
714 }
715
ProRendererSetLoudnessGainFuzzTest()716 void ProRendererSetLoudnessGainFuzzTest()
717 {
718 AudioProcessConfig config = InitProcessConfig();
719 std::shared_ptr<ProRendererStreamImpl> rendererStream = std::make_shared<ProRendererStreamImpl>(config, true);
720 float loudnessGain = GetData<float>();
721 rendererStream->SetLoudnessGain(loudnessGain);
722 }
723
ProRendererUpdateMaxLengthFuzzTest()724 void ProRendererUpdateMaxLengthFuzzTest()
725 {
726 AudioProcessConfig config = InitProcessConfig();
727 std::shared_ptr<ProRendererStreamImpl> rendererStream = std::make_shared<ProRendererStreamImpl>(config, true);
728 uint32_t maxLength = GetData<uint32_t>();
729 rendererStream->UpdateMaxLength(maxLength);
730 }
731
ProRendererPopSinkBufferFuzzTest()732 void ProRendererPopSinkBufferFuzzTest()
733 {
734 AudioProcessConfig config = InitProcessConfig();
735 std::shared_ptr<ProRendererStreamImpl> rendererStream = std::make_shared<ProRendererStreamImpl>(config, true);
736 int32_t index = GetData<int32_t>();
737 std::vector<char> audioBuffer = {0x01, 0x02, 0x03, 0x04, 0x05};
738 rendererStream->PopSinkBuffer(&audioBuffer, index);
739 }
740
ProRendererGetStreamVolumeFuzzTest()741 void ProRendererGetStreamVolumeFuzzTest()
742 {
743 AudioProcessConfig config = InitProcessConfig();
744 std::shared_ptr<ProRendererStreamImpl> rendererStream = std::make_shared<ProRendererStreamImpl>(config, true);
745 rendererStream->GetStreamVolume();
746 }
747
748 typedef void (*TestFuncs[66])();
749
750 TestFuncs g_testFuncs = {
751 DeviceFuzzTestSetUp,
752 DirectAudioPlayBackEngineStateFuzzTest,
753 NoneMixEngineStartFuzzTest,
754 NoneMixEngineStopFuzzTest,
755 NoneMixEnginePauseFuzzTest,
756 NoneMixEngineFlushFuzzTest,
757 NoneMixEngineAddRendererFuzzTest,
758 NoneMixEngineRemoveRendererFuzzTest,
759 PlaybackEngineInitFuzzTest,
760 PlaybackEngineStartFuzzTest,
761 PlaybackEngineStopFuzzTest,
762 PlaybackEnginePauseFuzzTest,
763 PlaybackEngineFlushFuzzTest,
764 PlaybackEngineIsPlaybackEngineRunningFuzzTest,
765 PlaybackEngineGetLatencyFuzzTest,
766 PlaybackEngineAddRendererFuzzTest,
767 PlaybackEngineRemoveRendererFuzzTest,
768 ResourceServiceAudioWorkgroupCheckFuzzTest,
769 ResourceServiceCreateAudioWorkgroupFuzzTest,
770 ResourceServiceReleaseAudioWorkgroupFuzzTest,
771 ResourceServiceAddThreadToGroupFuzzTest,
772 ResourceServiceRemoveThreadFromGroupFuzzTest,
773 ResourceServiceStartGroupFuzzTest,
774 ResourceServiceStopGroupFuzzTest,
775 ResourceServiceGetAudioWorkgroupPtrFuzzTest,
776 ResourceServiceGetThreadsNumPerProcessFuzzTest,
777 ResourceServiceIsProcessHasSystemPermissionFuzzTest,
778 ResourceServiceRegisterAudioWorkgroupMonitorFuzzTest,
779 RenderInServerGetLastAudioDurationFuzzTest,
780 RenderInServerHandleOperationStartedFuzzTest,
781 RenderInServerStandByCheckFuzzTest,
782 RenderInServerShouldEnableStandByFuzzTest,
783 RenderInServerGetStandbyStatusFuzzTest,
784 RenderInServerWriteMuteDataSysEventFuzzTest,
785 RenderInServerInnerCaptureEnqueueBufferFuzzTest,
786 RenderInServerInnerCaptureOtherStreamFuzzTest,
787 RenderInServerOtherStreamEnqueueFuzzTest,
788 RenderInServerIsInvalidBufferFuzzTest,
789 RenderInServerDualToneStreamInStartFuzzTest,
790 RenderInServerRecordStandbyTimeFuzzTest,
791 ProRendererGetStreamFramesWrittenFuzzTest,
792 ProRendererGetCurrentTimeStampFuzzTest,
793 ProRendererGetCurrentPositionFuzzTest,
794 ProRendererGetLatencyFuzzTest,
795 ProRendererSetAudioEffectModeFuzzTest,
796 ProRendererGetAudioEffectModeFuzzTest,
797 ProRendererSetPrivacyTypeFuzzTest,
798 ProRendererGetPrivacyTypeFuzzTest,
799 ProRendererSetSpeedFuzzTest,
800 ProRendererDequeueBufferFuzzTest,
801 ProRendererEnqueueBufferFuzzTest,
802 ProRendererGetMinimumBufferSizeFuzzTest,
803 ProRendererGetByteSizePerFrameFuzzTest,
804 ProRendererGetSpanSizePerFrameFuzzTest,
805 ProRendererGetStreamIndexFuzzTest,
806 ProRendererOffloadSetVolumeFuzzTest,
807 ProRendererSetOffloadDataCallbackStateFuzzTest,
808 ProRendererUpdateSpatializationStateFuzzTest,
809 ProRendererGetAudioTimeFuzzTest,
810 ProRendererPeekFuzzTest,
811 ProRendererReturnIndexFuzzTest,
812 ProRendererSetClientVolumeFuzzTest,
813 ProRendererSetLoudnessGainFuzzTest,
814 ProRendererUpdateMaxLengthFuzzTest,
815 ProRendererPopSinkBufferFuzzTest,
816 ProRendererGetStreamVolumeFuzzTest,
817 };
818
FuzzTest(const uint8_t * rawData,size_t size)819 bool FuzzTest(const uint8_t* rawData, size_t size)
820 {
821 if (rawData == nullptr) {
822 return false;
823 }
824
825 // initialize data
826 RAW_DATA = rawData;
827 g_dataSize = size;
828 g_pos = 0;
829
830 uint32_t code = GetData<uint32_t>();
831 uint32_t len = GetArrLength(g_testFuncs);
832 if (len > 0) {
833 g_testFuncs[code % len]();
834 } else {
835 AUDIO_INFO_LOG("%{public}s: The len length is equal to 0", __func__);
836 }
837
838 return true;
839 }
840 } // namespace AudioStandard
841 } // namesapce OHOS
842
843 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)844 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
845 {
846 if (size < OHOS::AudioStandard::THRESHOLD) {
847 return 0;
848 }
849
850 OHOS::AudioStandard::FuzzTest(data, size);
851 return 0;
852 }
853