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 "hpaerenderermanager_fuzzer.h"
17
18 #include <iostream>
19 #include <cstddef>
20 #include <cstdint>
21 #include <cstring>
22 #include "audio_info.h"
23 #include "audio_policy_server.h"
24 #include "audio_policy_service.h"
25 #include "audio_device_info.h"
26 #include "audio_utils.h"
27 #include "accesstoken_kit.h"
28 #include "nativetoken_kit.h"
29 #include "token_setproc.h"
30 #include "access_token.h"
31 #include "audio_channel_blend.h"
32 #include "volume_ramp.h"
33 #include "audio_speed.h"
34
35 #include "audio_policy_utils.h"
36 #include "audio_stream_descriptor.h"
37 #include "audio_limiter_manager.h"
38 #include "dfx_msg_manager.h"
39 #include "hpae_define.h"
40 #include "hpae_renderer_manager.h"
41 #include "hpae_sink_input_node.h"
42 #include "i_hpae_renderer_manager.h"
43
44 namespace OHOS {
45 namespace AudioStandard {
46 using namespace std;
47 using namespace HPAE;
48
49 static const uint8_t* RAW_DATA = nullptr;
50 static size_t g_dataSize = 0;
51 static size_t g_pos;
52 static std::string g_rootCapturerPath = "/data/source_file_io_48000_2_s16le.pcm";
53 const char* DEFAULT_TEST_DEVICE_CLASS = "file_io";
54 const char* DEFAULT_TEST_DEVICE_NETWORKID = "LocalDevice";
55 constexpr size_t THRESHOLD = 10;
56 constexpr int32_t TEST_SLEEP_TIME_20 = 20;
57 constexpr int32_t TEST_SLEEP_TIME_40 = 40;
58 constexpr int32_t FRAME_LENGTH_960 = 960;
59 constexpr int32_t TEST_STREAM_SESSION_ID = 123456;
60 constexpr int32_t DEFAULT_NODE_ID = 1;
61
62 template<class T>
GetData()63 T GetData()
64 {
65 T object {};
66 size_t objectSize = sizeof(object);
67 if (RAW_DATA == nullptr || objectSize > g_dataSize - g_pos) {
68 return object;
69 }
70 errno_t ret = memcpy_s(&object, objectSize, RAW_DATA + g_pos, objectSize);
71 if (ret != EOK) {
72 return {};
73 }
74 g_pos += objectSize;
75 return object;
76 }
77
78 template<class T>
GetArrLength(T & arr)79 uint32_t GetArrLength(T& arr)
80 {
81 if (arr == nullptr) {
82 AUDIO_INFO_LOG("%{public}s: The array length is equal to 0", __func__);
83 return 0;
84 }
85 return sizeof(arr) / sizeof(arr[0]);
86 }
87
InitHpaeSinkInfo(HpaeSinkInfo & sinkInfo)88 static void InitHpaeSinkInfo(HpaeSinkInfo &sinkInfo)
89 {
90 sinkInfo.deviceNetId = DEFAULT_TEST_DEVICE_NETWORKID;
91 sinkInfo.deviceClass = DEFAULT_TEST_DEVICE_CLASS;
92 sinkInfo.adapterName = DEFAULT_TEST_DEVICE_CLASS;
93 sinkInfo.filePath = "g_rootCapturerPath";
94 sinkInfo.frameLen = FRAME_LENGTH_960;
95 sinkInfo.samplingRate = SAMPLE_RATE_48000;
96 sinkInfo.format = SAMPLE_F32LE;
97 sinkInfo.channels = STEREO;
98 sinkInfo.deviceType = DEVICE_TYPE_SPEAKER;
99 }
100
InitRenderStreamInfo(HpaeStreamInfo & streamInfo)101 static void InitRenderStreamInfo(HpaeStreamInfo &streamInfo)
102 {
103 streamInfo.channels = STEREO;
104 streamInfo.samplingRate = SAMPLE_RATE_44100;
105 streamInfo.format = SAMPLE_S16LE;
106 streamInfo.frameLen = FRAME_LENGTH_960;
107 streamInfo.sessionId = TEST_STREAM_SESSION_ID;
108 streamInfo.streamType = STREAM_MUSIC;
109 streamInfo.streamClassType = HPAE_STREAM_CLASS_TYPE_PLAY;
110 }
111
InitNodeInfo(HpaeNodeInfo & nodeInfo)112 static void InitNodeInfo(HpaeNodeInfo &nodeInfo)
113 {
114 nodeInfo.nodeId = DEFAULT_NODE_ID;
115 nodeInfo.frameLen = FRAME_LENGTH_960;
116 nodeInfo.samplingRate = SAMPLE_RATE_48000;
117 nodeInfo.channels = STEREO;
118 nodeInfo.format = SAMPLE_S16LE;
119 nodeInfo.sceneType = HPAE_SCENE_RECORD;
120 nodeInfo.sourceBufferType = HPAE_SOURCE_BUFFER_TYPE_MIC;
121 }
122
WaitForMsgProcessing(std::shared_ptr<IHpaeRendererManager> & hpaeRendererManager)123 void WaitForMsgProcessing(std::shared_ptr<IHpaeRendererManager> &hpaeRendererManager)
124 {
125 while (hpaeRendererManager->IsMsgProcessing()) {
126 std::this_thread::sleep_for(std::chrono::milliseconds(TEST_SLEEP_TIME_20));
127 }
128 std::this_thread::sleep_for(std::chrono::milliseconds(TEST_SLEEP_TIME_40));
129 }
130
OnStreamData(AudioCallBackStreamInfo & callBackStremInfo)131 int32_t WriteFixedDataCb::OnStreamData(AudioCallBackStreamInfo& callBackStremInfo)
132 {
133 return SUCCESS;
134 }
135
ReadDataCb(const std::string & fileName)136 ReadDataCb::ReadDataCb(const std::string &fileName)
137 {
138 testFile_ = fopen(fileName.c_str(), "ab");
139 if (testFile_ == nullptr) {
140 AUDIO_ERR_LOG("Open file failed");
141 }
142 }
143
~ReadDataCb()144 ReadDataCb::~ReadDataCb()
145 {
146 if (testFile_) {
147 fclose(testFile_);
148 testFile_ = nullptr;
149 }
150 }
151
OnStreamData(AudioCallBackCapturerStreamInfo & callBackStreamInfo)152 int32_t ReadDataCb::OnStreamData(AudioCallBackCapturerStreamInfo &callBackStreamInfo)
153 {
154 return SUCCESS;
155 }
156
CreateRendererManagerFuzzTest()157 void CreateRendererManagerFuzzTest()
158 {
159 HpaeSinkInfo sinkInfo;
160 InitHpaeSinkInfo(sinkInfo);
161 IHpaeRendererManager::CreateRendererManager(sinkInfo);
162 }
163
UploadDumpSinkInfoFuzzTest()164 void UploadDumpSinkInfoFuzzTest()
165 {
166 HpaeSinkInfo sinkInfo;
167 InitHpaeSinkInfo(sinkInfo);
168 std::shared_ptr<IHpaeRendererManager> rendererManager = IHpaeRendererManager::CreateRendererManager(sinkInfo);
169 std::shared_ptr<HpaeRendererManager> hpaeRendererManager = std::make_shared<HpaeRendererManager>(sinkInfo);
170 hpaeRendererManager->sinkInfo_ = sinkInfo;
171 rendererManager->Init();
172 string deviceName = "";
173 rendererManager->UploadDumpSinkInfo(deviceName);
174 WaitForMsgProcessing(rendererManager);
175 rendererManager->DeInit();
176 }
177
OnNotifyDfxNodeInfoFuzzTest()178 void OnNotifyDfxNodeInfoFuzzTest()
179 {
180 HpaeSinkInfo sinkInfo;
181 InitHpaeSinkInfo(sinkInfo);
182 auto rendererManager = IHpaeRendererManager::CreateRendererManager(sinkInfo);
183 rendererManager->Init();
184 bool isConnect = false;
185 uint32_t preNodeId = GetData<uint32_t>();
186 HpaeDfxNodeInfo nodeInfo = {};
187 rendererManager->OnNotifyDfxNodeInfo(isConnect, preNodeId, nodeInfo);
188 WaitForMsgProcessing(rendererManager);
189 rendererManager->DeInit();
190 }
191
HpaeRendererManagerConstructFuzzTest()192 void HpaeRendererManagerConstructFuzzTest()
193 {
194 HpaeSinkInfo sinkInfo;
195 InitHpaeSinkInfo(sinkInfo);
196 HpaeRendererManager rendererManager(sinkInfo);
197 }
198
HpaeRendererManagerFlushFuzzTest()199 void HpaeRendererManagerFlushFuzzTest()
200 {
201 HpaeSinkInfo sinkInfo;
202 InitHpaeSinkInfo(sinkInfo);
203 auto rendererManager = IHpaeRendererManager::CreateRendererManager(sinkInfo);
204 rendererManager->Init();
205 uint32_t sessionId = GetData<uint32_t>();
206 rendererManager->Flush(sessionId);
207 rendererManager->DeInit();
208 }
209
HpaeRendererManagerDrainFuzzTest()210 void HpaeRendererManagerDrainFuzzTest()
211 {
212 HpaeSinkInfo sinkInfo;
213 InitHpaeSinkInfo(sinkInfo);
214 auto rendererManager = IHpaeRendererManager::CreateRendererManager(sinkInfo);
215 rendererManager->Init();
216 uint32_t sessionId = GetData<uint32_t>();
217 rendererManager->Drain(sessionId);
218 rendererManager->DeInit();
219 }
220
HpaeRendererManagerReleaseFuzzTest()221 void HpaeRendererManagerReleaseFuzzTest()
222 {
223 HpaeSinkInfo sinkInfo;
224 InitHpaeSinkInfo(sinkInfo);
225 auto rendererManager = IHpaeRendererManager::CreateRendererManager(sinkInfo);
226 rendererManager->Init();
227 uint32_t sessionId = GetData<uint32_t>();
228 rendererManager->Release(sessionId);
229 rendererManager->DeInit();
230 }
231
HpaeRendererManagerMoveStreamFuzzTest()232 void HpaeRendererManagerMoveStreamFuzzTest()
233 {
234 HpaeSinkInfo sinkInfo;
235 InitHpaeSinkInfo(sinkInfo);
236 auto rendererManager = IHpaeRendererManager::CreateRendererManager(sinkInfo);
237 rendererManager->Init();
238 uint32_t sessionId = GetData<uint32_t>();
239 string sinkName = "";
240 rendererManager->MoveStream(sessionId, sinkName);
241 WaitForMsgProcessing(rendererManager);
242 rendererManager->DeInit();
243 }
244
HpaeRendererManagerMoveAllStreamFuzzTest()245 void HpaeRendererManagerMoveAllStreamFuzzTest()
246 {
247 HpaeSinkInfo sinkInfo;
248 InitHpaeSinkInfo(sinkInfo);
249 auto rendererManager = IHpaeRendererManager::CreateRendererManager(sinkInfo);
250 rendererManager->Init();
251 string sinkName = "";
252 vector<uint32_t> sessionIds;
253 MoveSessionType moveSessionType = MOVE_ALL;
254 rendererManager->MoveAllStream(sinkName, sessionIds, moveSessionType);
255 WaitForMsgProcessing(rendererManager);
256 rendererManager->DeInit();
257 }
258
HpaeRendererManagerSuspendStreamManagerFuzzTest()259 void HpaeRendererManagerSuspendStreamManagerFuzzTest()
260 {
261 HpaeSinkInfo sinkInfo;
262 InitHpaeSinkInfo(sinkInfo);
263 auto rendererManager = IHpaeRendererManager::CreateRendererManager(sinkInfo);
264 rendererManager->Init();
265 bool isSuspend = false;
266 rendererManager->SuspendStreamManager(isSuspend);
267 WaitForMsgProcessing(rendererManager);
268 rendererManager->DeInit();
269 }
270
HpaeRendererManagerSetMuteFuzzTest()271 void HpaeRendererManagerSetMuteFuzzTest()
272 {
273 HpaeSinkInfo sinkInfo;
274 InitHpaeSinkInfo(sinkInfo);
275 auto rendererManager = IHpaeRendererManager::CreateRendererManager(sinkInfo);
276 rendererManager->Init();
277 bool isMute = false;
278 rendererManager->SetMute(isMute);
279 WaitForMsgProcessing(rendererManager);
280 rendererManager->DeInit();
281 }
282
HpaeRendererManagerProcessFuzzTest()283 void HpaeRendererManagerProcessFuzzTest()
284 {
285 HpaeSinkInfo sinkInfo;
286 InitHpaeSinkInfo(sinkInfo);
287 auto rendererManager = IHpaeRendererManager::CreateRendererManager(sinkInfo);
288 rendererManager->Init();
289 rendererManager->Process();
290 WaitForMsgProcessing(rendererManager);
291 rendererManager->DeInit();
292 }
293
HpaeRendererManagerHandleMsgFuzzTest()294 void HpaeRendererManagerHandleMsgFuzzTest()
295 {
296 HpaeSinkInfo sinkInfo;
297 InitHpaeSinkInfo(sinkInfo);
298 auto rendererManager = IHpaeRendererManager::CreateRendererManager(sinkInfo);
299 rendererManager->Init();
300 rendererManager->HandleMsg();
301 WaitForMsgProcessing(rendererManager);
302 rendererManager->DeInit();
303 }
304
HpaeRendererManagerIsMsgProcessingFuzzTest()305 void HpaeRendererManagerIsMsgProcessingFuzzTest()
306 {
307 HpaeSinkInfo sinkInfo;
308 InitHpaeSinkInfo(sinkInfo);
309 auto rendererManager = IHpaeRendererManager::CreateRendererManager(sinkInfo);
310 rendererManager->Init();
311 rendererManager->IsMsgProcessing();
312 WaitForMsgProcessing(rendererManager);
313 rendererManager->DeInit();
314 }
315
HpaeRendererManagerDeactivateThreadFuzzTest()316 void HpaeRendererManagerDeactivateThreadFuzzTest()
317 {
318 HpaeSinkInfo sinkInfo;
319 InitHpaeSinkInfo(sinkInfo);
320 auto rendererManager = IHpaeRendererManager::CreateRendererManager(sinkInfo);
321 rendererManager->Init();
322 rendererManager->DeactivateThread();
323 WaitForMsgProcessing(rendererManager);
324 rendererManager->DeInit();
325 }
326
HpaeRendererManagerSetClientVolumeFuzzTest()327 void HpaeRendererManagerSetClientVolumeFuzzTest()
328 {
329 HpaeSinkInfo sinkInfo;
330 InitHpaeSinkInfo(sinkInfo);
331 auto rendererManager = IHpaeRendererManager::CreateRendererManager(sinkInfo);
332 rendererManager->Init();
333 uint32_t sessionId = GetData<uint32_t>();
334 float volume = GetData<float>();
335 rendererManager->SetClientVolume(sessionId, volume);
336 WaitForMsgProcessing(rendererManager);
337 rendererManager->DeInit();
338 }
339
HpaeRendererManagerSetRateFuzzTest()340 void HpaeRendererManagerSetRateFuzzTest()
341 {
342 HpaeSinkInfo sinkInfo;
343 InitHpaeSinkInfo(sinkInfo);
344 auto rendererManager = IHpaeRendererManager::CreateRendererManager(sinkInfo);
345 rendererManager->Init();
346 uint32_t sessionId = GetData<uint32_t>();
347 int32_t rate = GetData<int32_t>();
348 rendererManager->SetRate(sessionId, rate);
349 WaitForMsgProcessing(rendererManager);
350 rendererManager->DeInit();
351 }
352
HpaeRendererManagerSetAudioEffectModeFuzzTest()353 void HpaeRendererManagerSetAudioEffectModeFuzzTest()
354 {
355 HpaeSinkInfo sinkInfo;
356 InitHpaeSinkInfo(sinkInfo);
357 auto rendererManager = IHpaeRendererManager::CreateRendererManager(sinkInfo);
358 rendererManager->Init();
359 uint32_t sessionId = GetData<uint32_t>();
360 int32_t effectMode = GetData<int32_t>();
361 rendererManager->SetAudioEffectMode(sessionId, effectMode);
362 WaitForMsgProcessing(rendererManager);
363 rendererManager->DeInit();
364 }
365
HpaeRendererManagerGetAudioEffectModeFuzzTest()366 void HpaeRendererManagerGetAudioEffectModeFuzzTest()
367 {
368 HpaeSinkInfo sinkInfo;
369 InitHpaeSinkInfo(sinkInfo);
370 auto rendererManager = IHpaeRendererManager::CreateRendererManager(sinkInfo);
371 rendererManager->Init();
372 uint32_t sessionId = GetData<uint32_t>();
373 int32_t effectMode = GetData<int32_t>();
374 rendererManager->GetAudioEffectMode(sessionId, effectMode);
375 rendererManager->DeInit();
376 }
377
IRendererManagerReloadFuzzTest()378 void IRendererManagerReloadFuzzTest()
379 {
380 HpaeSinkInfo sinkInfo;
381 InitHpaeSinkInfo(sinkInfo);
382 auto rendererManager = IHpaeRendererManager::CreateRendererManager(sinkInfo);
383 rendererManager->Init();
384 WaitForMsgProcessing(rendererManager);
385 rendererManager->IsInit();
386
387 HpaeStreamInfo streamInfo;
388 InitRenderStreamInfo(streamInfo);
389 rendererManager->CreateStream(streamInfo);
390 WaitForMsgProcessing(rendererManager);
391 HpaeSinkInputInfo sinkInputInfo;
392 uint32_t sessionId = GetData<uint32_t>();
393 rendererManager->GetSinkInputInfo(sessionId, sinkInputInfo);
394
395 rendererManager->ReloadRenderManager(sinkInfo, true);
396 WaitForMsgProcessing(rendererManager);
397 rendererManager->IsInit();
398
399 rendererManager->Start(sessionId);
400 rendererManager->SetOffloadPolicy(sessionId, 0);
401 WaitForMsgProcessing(rendererManager);
402
403 rendererManager->SetSpeed(sessionId, 1.0f);
404 WaitForMsgProcessing(rendererManager);
405
406 rendererManager->DeInit();
407 rendererManager->IsInit();
408
409 rendererManager->ReloadRenderManager(sinkInfo, true);
410 WaitForMsgProcessing(rendererManager);
411 rendererManager->DeInit();
412 }
413
IRendererManagerCreateDestoryStreamFuzzTest()414 void IRendererManagerCreateDestoryStreamFuzzTest()
415 {
416 HpaeSinkInfo sinkInfo;
417 InitHpaeSinkInfo(sinkInfo);
418 auto hpaeRendererManager = IHpaeRendererManager::CreateRendererManager(sinkInfo);
419 hpaeRendererManager->Init();
420 WaitForMsgProcessing(hpaeRendererManager);
421 hpaeRendererManager->IsInit();
422 HpaeStreamInfo streamInfo;
423
424 uint32_t sessionId = GetData<uint32_t>();
425 hpaeRendererManager->DestroyStream(sessionId);
426 WaitForMsgProcessing(hpaeRendererManager);
427 HpaeSinkInputInfo sinkInputInfo;
428 hpaeRendererManager->GetSinkInputInfo(sessionId, sinkInputInfo);
429
430 InitRenderStreamInfo(streamInfo);
431 hpaeRendererManager->CreateStream(streamInfo);
432 WaitForMsgProcessing(hpaeRendererManager);
433
434 hpaeRendererManager->GetSinkInputInfo(sessionId, sinkInputInfo);
435 hpaeRendererManager->DestroyStream(sessionId);
436 WaitForMsgProcessing(hpaeRendererManager);
437 hpaeRendererManager->GetSinkInputInfo(sessionId, sinkInputInfo);
438 hpaeRendererManager->DeInit();
439 }
440
IRendererManagerStartPuaseStreamFuzzTest()441 void IRendererManagerStartPuaseStreamFuzzTest()
442 {
443 HpaeSinkInfo sinkInfo;
444 InitHpaeSinkInfo(sinkInfo);
445 auto hpaeRendererManager = IHpaeRendererManager::CreateRendererManager(sinkInfo);
446 hpaeRendererManager->Init();
447 WaitForMsgProcessing(hpaeRendererManager);
448 hpaeRendererManager->IsInit();
449 HpaeStreamInfo streamInfo;
450 HpaeSinkInputInfo sinkInputInfo;
451 std::shared_ptr<WriteFixedDataCb> writeIncDataCb = std::make_shared<WriteFixedDataCb>(SAMPLE_S16LE);
452
453 uint32_t sessionId = GetData<uint32_t>();
454 hpaeRendererManager->RegisterWriteCallback(sessionId, writeIncDataCb);
455 hpaeRendererManager->Start(sessionId);
456
457 hpaeRendererManager->SetOffloadPolicy(sessionId, 0);
458 hpaeRendererManager->SetSpeed(sessionId, 1.0f);
459 WaitForMsgProcessing(hpaeRendererManager);
460 hpaeRendererManager->GetSinkInputInfo(sessionId, sinkInputInfo);
461
462 hpaeRendererManager->IsRunning();
463 hpaeRendererManager->Pause(sessionId);
464 WaitForMsgProcessing(hpaeRendererManager);
465 hpaeRendererManager->GetSinkInputInfo(sessionId, sinkInputInfo);
466
467 hpaeRendererManager->Stop(sessionId);
468 WaitForMsgProcessing(hpaeRendererManager);
469
470 hpaeRendererManager->DestroyStream(sessionId);
471 WaitForMsgProcessing(hpaeRendererManager);
472 hpaeRendererManager->DeInit();
473 }
474
UpdateCollaborativeStateFuzzTest()475 void UpdateCollaborativeStateFuzzTest()
476 {
477 HpaeSinkInfo sinkInfo;
478 InitHpaeSinkInfo(sinkInfo);
479 auto hpaeRendererManager = IHpaeRendererManager::CreateRendererManager(sinkInfo);
480 hpaeRendererManager->Init();
481 WaitForMsgProcessing(hpaeRendererManager);
482 hpaeRendererManager->IsInit();
483 hpaeRendererManager->UpdateCollaborativeState(true);
484
485 HpaeStreamInfo streamInfo;
486 InitRenderStreamInfo(streamInfo);
487 std::shared_ptr<WriteFixedDataCb> writeIncDataCb = std::make_shared<WriteFixedDataCb>(SAMPLE_S16LE);
488 uint32_t sessionId = GetData<uint32_t>();
489 hpaeRendererManager->RegisterWriteCallback(sessionId, writeIncDataCb);
490
491 hpaeRendererManager->Start(sessionId);
492 WaitForMsgProcessing(hpaeRendererManager);
493 HpaeSinkInputInfo sinkInputInfo;
494 hpaeRendererManager->GetSinkInputInfo(sessionId, sinkInputInfo);
495
496 hpaeRendererManager->IsRunning();
497 hpaeRendererManager->Pause(sessionId);
498 WaitForMsgProcessing(hpaeRendererManager);
499 hpaeRendererManager->Stop(sessionId);
500 WaitForMsgProcessing(hpaeRendererManager);
501
502 hpaeRendererManager->DestroyStream(sessionId);
503 WaitForMsgProcessing(hpaeRendererManager);
504 hpaeRendererManager->GetSinkInputInfo(sessionId, sinkInputInfo);
505 hpaeRendererManager->UpdateCollaborativeState(false);
506 WaitForMsgProcessing(hpaeRendererManager);
507 hpaeRendererManager->DeInit();
508 }
509
AddSingleNodeToSinkAndCreateEffectAndConnectFuzzTest()510 void AddSingleNodeToSinkAndCreateEffectAndConnectFuzzTest()
511 {
512 HpaeSinkInfo sinkInfo;
513 InitHpaeSinkInfo(sinkInfo);
514 HpaeNodeInfo nodeinfo;
515 InitNodeInfo(nodeinfo);
516 auto rendererManager = HpaeRendererManager(sinkInfo);
517 auto node = std::make_shared<HpaeSinkInputNode>(nodeinfo);
518 CHECK_AND_RETURN(node != nullptr);
519 bool isConnect = GetData<bool>();
520 rendererManager.AddSingleNodeToSink(node, isConnect);
521 }
522
CreateDefaultProcessClusterFuzzTest()523 void CreateDefaultProcessClusterFuzzTest()
524 {
525 HpaeSinkInfo sinkInfo;
526 InitHpaeSinkInfo(sinkInfo);
527 auto rendererManager = HpaeRendererManager(sinkInfo);
528 HpaeNodeInfo nodeinfo;
529 InitNodeInfo(nodeinfo);
530 rendererManager.CreateDefaultProcessCluster(nodeinfo);
531 }
532
CreateProcessClusterInnerSwitchCaseFuzzTest()533 void CreateProcessClusterInnerSwitchCaseFuzzTest()
534 {
535 HpaeSinkInfo sinkInfo;
536 InitHpaeSinkInfo(sinkInfo);
537 auto rendererManager = HpaeRendererManager(sinkInfo);
538 HpaeNodeInfo nodeinfo;
539 InitNodeInfo(nodeinfo);
540 int32_t processClusterDecision = GetData<int32_t>();
541 rendererManager.CreateProcessClusterInner(nodeinfo, processClusterDecision);
542 }
543
RefreshProcessClusterByDeviceFuzzTest()544 void RefreshProcessClusterByDeviceFuzzTest()
545 {
546 HpaeSinkInfo sinkInfo;
547 InitHpaeSinkInfo(sinkInfo);
548 auto rendererManager = IHpaeRendererManager::CreateRendererManager(sinkInfo);
549 CHECK_AND_RETURN(rendererManager != nullptr);
550 rendererManager->RefreshProcessClusterByDevice();
551 }
552
DeleteInputSessionForMoveFuzzTest()553 void DeleteInputSessionForMoveFuzzTest()
554 {
555 HpaeSinkInfo sinkInfo;
556 InitHpaeSinkInfo(sinkInfo);
557 auto rendererManager = HpaeRendererManager(sinkInfo);
558 uint32_t sessionId = GetData<uint32_t>();
559 rendererManager.DeleteInputSessionForMove(sessionId);
560 }
561
DeleteProcessClusterFuzzTest()562 void DeleteProcessClusterFuzzTest()
563 {
564 HpaeSinkInfo sinkInfo;
565 InitHpaeSinkInfo(sinkInfo);
566 auto rendererManager = HpaeRendererManager(sinkInfo);
567 HpaeProcessorType sceneType = GetData<HpaeProcessorType>();
568 rendererManager.DeleteProcessCluster(sceneType);
569 }
570
ConnectInputSessionFuzzTest()571 void ConnectInputSessionFuzzTest()
572 {
573 HpaeSinkInfo sinkInfo;
574 InitHpaeSinkInfo(sinkInfo);
575 auto rendererManager = HpaeRendererManager(sinkInfo);
576 uint32_t sessionId = GetData<uint32_t>();
577 HpaeNodeInfo nodeInfo;
578 nodeInfo.nodeId = sessionId;
579 auto node = std::make_shared<HpaeSinkInputNode>(nodeInfo);
580 CHECK_AND_RETURN(node != nullptr);
581 rendererManager.sinkInputNodeMap_[sessionId] = node;
582 rendererManager.ConnectInputSession(sessionId);
583 }
584
DisConnectInputSessionFuzzTest()585 void DisConnectInputSessionFuzzTest()
586 {
587 HpaeSinkInfo sinkInfo;
588 InitHpaeSinkInfo(sinkInfo);
589 auto rendererManager = HpaeRendererManager(sinkInfo);
590 uint32_t sessionId = GetData<uint32_t>();
591 rendererManager.DisConnectInputSession(sessionId);
592 }
593
CheckIsStreamRunningFuzzTest()594 void CheckIsStreamRunningFuzzTest()
595 {
596 HpaeSinkInfo sinkInfo;
597 InitHpaeSinkInfo(sinkInfo);
598 auto rendererManager = HpaeRendererManager(sinkInfo);
599 rendererManager.CheckIsStreamRunning();
600 }
601
CreateOutputClusterNodeInfoFuzzTest()602 void CreateOutputClusterNodeInfoFuzzTest()
603 {
604 HpaeSinkInfo sinkInfo;
605 InitHpaeSinkInfo(sinkInfo);
606 auto rendererManager = HpaeRendererManager(sinkInfo);
607 HpaeNodeInfo nodeinfo;
608 InitNodeInfo(nodeinfo);
609 rendererManager.CreateOutputClusterNodeInfo(nodeinfo);
610 }
611
StartRenderSinkFuzzTest()612 void StartRenderSinkFuzzTest()
613 {
614 HpaeSinkInfo sinkInfo;
615 InitHpaeSinkInfo(sinkInfo);
616 auto rendererManager = HpaeRendererManager(sinkInfo);
617 rendererManager.StartRenderSink();
618 }
619
SetSpeedFuzzTest()620 void SetSpeedFuzzTest()
621 {
622 HpaeSinkInfo sinkInfo;
623 InitHpaeSinkInfo(sinkInfo);
624 auto rendererManager = IHpaeRendererManager::CreateRendererManager(sinkInfo);
625 CHECK_AND_RETURN(rendererManager != nullptr);
626 uint32_t sessionId = GetData<uint32_t>();
627 float speed = GetData<float>();
628 rendererManager->SetSpeed(sessionId, speed);
629 }
630
ReConnectNodeForCollaborationFuzzTest()631 void ReConnectNodeForCollaborationFuzzTest()
632 {
633 HpaeSinkInfo sinkInfo;
634 InitHpaeSinkInfo(sinkInfo);
635 auto rendererManager = HpaeRendererManager(sinkInfo);
636 uint32_t sessionId = GetData<uint32_t>();
637 rendererManager.ReConnectNodeForCollaboration(sessionId);
638 }
639
EnableAndDisableCollaborationFuzzTest()640 void EnableAndDisableCollaborationFuzzTest()
641 {
642 HpaeSinkInfo sinkInfo;
643 InitHpaeSinkInfo(sinkInfo);
644 auto rendererManager = HpaeRendererManager(sinkInfo);
645 rendererManager.EnableCollaboration();
646 rendererManager.DisableCollaboration();
647 }
648
649 typedef void (*TestFuncs)();
650 TestFuncs g_testFuncs[] = {
651 CreateRendererManagerFuzzTest,
652 UploadDumpSinkInfoFuzzTest,
653 OnNotifyDfxNodeInfoFuzzTest,
654 HpaeRendererManagerConstructFuzzTest,
655 HpaeRendererManagerFlushFuzzTest,
656 HpaeRendererManagerDrainFuzzTest,
657 HpaeRendererManagerReleaseFuzzTest,
658 HpaeRendererManagerMoveStreamFuzzTest,
659 HpaeRendererManagerMoveAllStreamFuzzTest,
660 HpaeRendererManagerSuspendStreamManagerFuzzTest,
661 HpaeRendererManagerSetMuteFuzzTest,
662 HpaeRendererManagerProcessFuzzTest,
663 HpaeRendererManagerHandleMsgFuzzTest,
664 HpaeRendererManagerIsMsgProcessingFuzzTest,
665 HpaeRendererManagerDeactivateThreadFuzzTest,
666 HpaeRendererManagerSetClientVolumeFuzzTest,
667 HpaeRendererManagerSetRateFuzzTest,
668 HpaeRendererManagerSetAudioEffectModeFuzzTest,
669 HpaeRendererManagerGetAudioEffectModeFuzzTest,
670 IRendererManagerReloadFuzzTest,
671 IRendererManagerCreateDestoryStreamFuzzTest,
672 IRendererManagerStartPuaseStreamFuzzTest,
673 UpdateCollaborativeStateFuzzTest,
674 AddSingleNodeToSinkAndCreateEffectAndConnectFuzzTest,
675 CreateDefaultProcessClusterFuzzTest,
676 CreateProcessClusterInnerSwitchCaseFuzzTest,
677 RefreshProcessClusterByDeviceFuzzTest,
678 DeleteInputSessionForMoveFuzzTest,
679 DeleteProcessClusterFuzzTest,
680 ConnectInputSessionFuzzTest,
681 DisConnectInputSessionFuzzTest,
682 CheckIsStreamRunningFuzzTest,
683 CreateOutputClusterNodeInfoFuzzTest,
684 StartRenderSinkFuzzTest,
685 SetSpeedFuzzTest,
686 ReConnectNodeForCollaborationFuzzTest,
687 EnableAndDisableCollaborationFuzzTest,
688 };
689
FuzzTest(const uint8_t * rawData,size_t size)690 bool FuzzTest(const uint8_t* rawData, size_t size)
691 {
692 if (rawData == nullptr) {
693 return false;
694 }
695
696 // initialize data
697 RAW_DATA = rawData;
698 g_dataSize = size;
699 g_pos = 0;
700
701 uint32_t code = GetData<uint32_t>();
702 uint32_t len = GetArrLength(g_testFuncs);
703 if (len > 0) {
704 g_testFuncs[code % len]();
705 } else {
706 AUDIO_INFO_LOG("%{public}s: The len length is equal to 0", __func__);
707 }
708
709 return true;
710 }
711 } // namespace AudioStandard
712 } // namesapce OHOS
713
714 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)715 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
716 {
717 if (size < OHOS::AudioStandard::THRESHOLD) {
718 return 0;
719 }
720
721 OHOS::AudioStandard::FuzzTest(data, size);
722 return 0;
723 }
724