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 "hpaeoffloadrenderermanager_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_offload_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 = "offload";
54 const char* DEFAULT_TEST_DEVICE_NETWORKID = "LocalDevice";
55 constexpr size_t THRESHOLD = 10;
56 constexpr uint8_t TESTSIZE = 42;
57 constexpr int32_t TEST_SLEEP_TIME_20 = 20;
58 constexpr int32_t TEST_SLEEP_TIME_40 = 40;
59 constexpr int32_t FRAME_LENGTH_960 = 960;
60 constexpr int32_t TEST_STREAM_SESSION_ID = 123456;
61 constexpr int32_t DEFAULT_NODE_ID = 1;
62
63 template<class T>
GetData()64 T GetData()
65 {
66 T object {};
67 size_t objectSize = sizeof(object);
68 if (RAW_DATA == nullptr || objectSize > g_dataSize - g_pos) {
69 return object;
70 }
71 errno_t ret = memcpy_s(&object, objectSize, RAW_DATA + g_pos, objectSize);
72 if (ret != EOK) {
73 return {};
74 }
75 g_pos += objectSize;
76 return object;
77 }
78
79 template<class T>
GetArrLength(T & arr)80 uint32_t GetArrLength(T& arr)
81 {
82 if (arr == nullptr) {
83 AUDIO_INFO_LOG("%{public}s: The array length is equal to 0", __func__);
84 return 0;
85 }
86 return sizeof(arr) / sizeof(arr[0]);
87 }
88
InitHpaeSinkInfo(HpaeSinkInfo & sinkInfo)89 static void InitHpaeSinkInfo(HpaeSinkInfo &sinkInfo)
90 {
91 sinkInfo.deviceNetId = DEFAULT_TEST_DEVICE_NETWORKID;
92 sinkInfo.deviceClass = DEFAULT_TEST_DEVICE_CLASS;
93 sinkInfo.adapterName = DEFAULT_TEST_DEVICE_CLASS;
94 sinkInfo.filePath = "g_rootCapturerPath";
95 sinkInfo.frameLen = FRAME_LENGTH_960;
96 sinkInfo.samplingRate = SAMPLE_RATE_48000;
97 sinkInfo.format = SAMPLE_F32LE;
98 sinkInfo.channels = STEREO;
99 sinkInfo.deviceType = DEVICE_TYPE_SPEAKER;
100 }
101
InitRenderStreamInfo(HpaeStreamInfo & streamInfo)102 static void InitRenderStreamInfo(HpaeStreamInfo &streamInfo)
103 {
104 streamInfo.channels = STEREO;
105 streamInfo.samplingRate = SAMPLE_RATE_44100;
106 streamInfo.format = SAMPLE_S16LE;
107 streamInfo.frameLen = FRAME_LENGTH_960;
108 streamInfo.sessionId = TEST_STREAM_SESSION_ID;
109 streamInfo.streamType = STREAM_MUSIC;
110 streamInfo.streamClassType = HPAE_STREAM_CLASS_TYPE_PLAY;
111 }
112
InitNodeInfo(HpaeNodeInfo & nodeInfo)113 static void InitNodeInfo(HpaeNodeInfo &nodeInfo)
114 {
115 nodeInfo.nodeId = DEFAULT_NODE_ID;
116 nodeInfo.frameLen = FRAME_LENGTH_960;
117 nodeInfo.samplingRate = SAMPLE_RATE_48000;
118 nodeInfo.channels = STEREO;
119 nodeInfo.format = SAMPLE_S16LE;
120 nodeInfo.sceneType = HPAE_SCENE_RECORD;
121 nodeInfo.sourceBufferType = HPAE_SOURCE_BUFFER_TYPE_MIC;
122 }
123
WaitForMsgProcessing(std::shared_ptr<IHpaeRendererManager> & hpaeRendererManager)124 void WaitForMsgProcessing(std::shared_ptr<IHpaeRendererManager> &hpaeRendererManager)
125 {
126 while (hpaeRendererManager->IsMsgProcessing()) {
127 std::this_thread::sleep_for(std::chrono::milliseconds(TEST_SLEEP_TIME_20));
128 }
129 std::this_thread::sleep_for(std::chrono::milliseconds(TEST_SLEEP_TIME_40));
130 }
131
OnStreamData(AudioCallBackStreamInfo & callBackStremInfo)132 int32_t WriteFixedDataCb::OnStreamData(AudioCallBackStreamInfo& callBackStremInfo)
133 {
134 return SUCCESS;
135 }
136
ReadDataCb(const std::string & fileName)137 ReadDataCb::ReadDataCb(const std::string &fileName)
138 {
139 testFile_ = fopen(fileName.c_str(), "ab");
140 if (testFile_ == nullptr) {
141 AUDIO_ERR_LOG("Open file failed");
142 }
143 }
144
~ReadDataCb()145 ReadDataCb::~ReadDataCb()
146 {
147 if (testFile_) {
148 fclose(testFile_);
149 testFile_ = nullptr;
150 }
151 }
152
OnStreamData(AudioCallBackCapturerStreamInfo & callBackStreamInfo)153 int32_t ReadDataCb::OnStreamData(AudioCallBackCapturerStreamInfo &callBackStreamInfo)
154 {
155 return SUCCESS;
156 }
157
CreateRendererManagerFuzzTest()158 void CreateRendererManagerFuzzTest()
159 {
160 HpaeSinkInfo sinkInfo;
161 InitHpaeSinkInfo(sinkInfo);
162 IHpaeRendererManager::CreateRendererManager(sinkInfo);
163 }
164
UploadDumpSinkInfoFuzzTest()165 void UploadDumpSinkInfoFuzzTest()
166 {
167 HpaeSinkInfo sinkInfo;
168 InitHpaeSinkInfo(sinkInfo);
169 std::shared_ptr<IHpaeRendererManager> offloadRendererManager =
170 IHpaeRendererManager::CreateRendererManager(sinkInfo);
171 offloadRendererManager->Init();
172 string deviceName = "";
173 offloadRendererManager->UploadDumpSinkInfo(deviceName);
174 WaitForMsgProcessing(offloadRendererManager);
175 offloadRendererManager->DeInit();
176 }
177
OnNotifyDfxNodeInfoFuzzTest()178 void OnNotifyDfxNodeInfoFuzzTest()
179 {
180 HpaeSinkInfo sinkInfo;
181 InitHpaeSinkInfo(sinkInfo);
182 auto offloadRendererManager = IHpaeRendererManager::CreateRendererManager(sinkInfo);
183 offloadRendererManager->Init();
184 bool isConnect = false;
185 uint32_t preNodeId = GetData<uint32_t>();
186 HpaeDfxNodeInfo nodeInfo = {};
187 offloadRendererManager->OnNotifyDfxNodeInfo(isConnect, preNodeId, nodeInfo);
188 WaitForMsgProcessing(offloadRendererManager);
189 offloadRendererManager->DeInit();
190 }
191
HpaeOffloadRendererManagerConstructFuzzTest()192 void HpaeOffloadRendererManagerConstructFuzzTest()
193 {
194 HpaeSinkInfo sinkInfo;
195 InitHpaeSinkInfo(sinkInfo);
196 HpaeOffloadRendererManager offloadRendererManager(sinkInfo);
197 }
198
HpaeOffloadRendererManagerFlushFuzzTest()199 void HpaeOffloadRendererManagerFlushFuzzTest()
200 {
201 HpaeSinkInfo sinkInfo;
202 InitHpaeSinkInfo(sinkInfo);
203 auto offloadRendererManager = IHpaeRendererManager::CreateRendererManager(sinkInfo);
204 offloadRendererManager->Init();
205 uint32_t sessionId = GetData<uint32_t>();
206 offloadRendererManager->Flush(sessionId);
207 WaitForMsgProcessing(offloadRendererManager);
208 offloadRendererManager->DeInit();
209 }
210
HpaeOffloadRendererManagerDrainFuzzTest()211 void HpaeOffloadRendererManagerDrainFuzzTest()
212 {
213 HpaeSinkInfo sinkInfo;
214 InitHpaeSinkInfo(sinkInfo);
215 auto offloadRendererManager = IHpaeRendererManager::CreateRendererManager(sinkInfo);
216 offloadRendererManager->Init();
217 uint32_t sessionId = GetData<uint32_t>();
218 offloadRendererManager->Drain(sessionId);
219 WaitForMsgProcessing(offloadRendererManager);
220 offloadRendererManager->DeInit();
221 }
222
HpaeOffloadRendererManagerReleaseFuzzTest()223 void HpaeOffloadRendererManagerReleaseFuzzTest()
224 {
225 HpaeSinkInfo sinkInfo;
226 InitHpaeSinkInfo(sinkInfo);
227 auto offloadRendererManager = IHpaeRendererManager::CreateRendererManager(sinkInfo);
228 offloadRendererManager->Init();
229 uint32_t sessionId = GetData<uint32_t>();
230 offloadRendererManager->Release(sessionId);
231 WaitForMsgProcessing(offloadRendererManager);
232 offloadRendererManager->DeInit();
233 }
234
HpaeOffloadRendererManagerMoveStreamFuzzTest()235 void HpaeOffloadRendererManagerMoveStreamFuzzTest()
236 {
237 HpaeSinkInfo sinkInfo;
238 InitHpaeSinkInfo(sinkInfo);
239 auto offloadRendererManager = IHpaeRendererManager::CreateRendererManager(sinkInfo);
240 offloadRendererManager->Init();
241 uint32_t sessionId = GetData<uint32_t>();
242 string sinkName = "";
243 offloadRendererManager->MoveStream(sessionId, sinkName);
244 WaitForMsgProcessing(offloadRendererManager);
245 offloadRendererManager->DeInit();
246 }
247
HpaeOffloadRendererManagerMoveAllStreamFuzzTest()248 void HpaeOffloadRendererManagerMoveAllStreamFuzzTest()
249 {
250 HpaeSinkInfo sinkInfo;
251 InitHpaeSinkInfo(sinkInfo);
252 auto offloadRendererManager = IHpaeRendererManager::CreateRendererManager(sinkInfo);
253 offloadRendererManager->Init();
254 string sinkName = "";
255 vector<uint32_t> sessionIds;
256 MoveSessionType moveSessionType = MOVE_ALL;
257 offloadRendererManager->MoveAllStream(sinkName, sessionIds, moveSessionType);
258 WaitForMsgProcessing(offloadRendererManager);
259 offloadRendererManager->DeInit();
260 }
261
HpaeOffloadRendererManagerSuspendStreamManagerFuzzTest()262 void HpaeOffloadRendererManagerSuspendStreamManagerFuzzTest()
263 {
264 HpaeSinkInfo sinkInfo;
265 InitHpaeSinkInfo(sinkInfo);
266 auto offloadRendererManager = IHpaeRendererManager::CreateRendererManager(sinkInfo);
267 offloadRendererManager->Init();
268 bool isSuspend = false;
269 offloadRendererManager->SuspendStreamManager(isSuspend);
270 WaitForMsgProcessing(offloadRendererManager);
271 offloadRendererManager->DeInit();
272 }
273
HpaeOffloadRendererManagerSetMuteFuzzTest()274 void HpaeOffloadRendererManagerSetMuteFuzzTest()
275 {
276 HpaeSinkInfo sinkInfo;
277 InitHpaeSinkInfo(sinkInfo);
278 auto offloadRendererManager = IHpaeRendererManager::CreateRendererManager(sinkInfo);
279 offloadRendererManager->Init();
280 bool isMute = false;
281 offloadRendererManager->SetMute(isMute);
282 WaitForMsgProcessing(offloadRendererManager);
283 offloadRendererManager->DeInit();
284 }
285
HpaeOffloadRendererManagerProcessFuzzTest()286 void HpaeOffloadRendererManagerProcessFuzzTest()
287 {
288 HpaeSinkInfo sinkInfo;
289 InitHpaeSinkInfo(sinkInfo);
290 auto offloadRendererManager = IHpaeRendererManager::CreateRendererManager(sinkInfo);
291 offloadRendererManager->Init();
292 offloadRendererManager->Process();
293 WaitForMsgProcessing(offloadRendererManager);
294 offloadRendererManager->DeInit();
295 }
296
HpaeOffloadRendererManagerHandleMsgFuzzTest()297 void HpaeOffloadRendererManagerHandleMsgFuzzTest()
298 {
299 HpaeSinkInfo sinkInfo;
300 InitHpaeSinkInfo(sinkInfo);
301 auto offloadRendererManager = IHpaeRendererManager::CreateRendererManager(sinkInfo);
302 offloadRendererManager->Init();
303 offloadRendererManager->HandleMsg();
304 WaitForMsgProcessing(offloadRendererManager);
305 offloadRendererManager->DeInit();
306 }
307
HpaeOffloadRendererManagerIsMsgProcessingFuzzTest()308 void HpaeOffloadRendererManagerIsMsgProcessingFuzzTest()
309 {
310 HpaeSinkInfo sinkInfo;
311 InitHpaeSinkInfo(sinkInfo);
312 auto offloadRendererManager = IHpaeRendererManager::CreateRendererManager(sinkInfo);
313 offloadRendererManager->Init();
314 offloadRendererManager->IsMsgProcessing();
315 WaitForMsgProcessing(offloadRendererManager);
316 offloadRendererManager->DeInit();
317 }
318
HpaeOffloadRendererManagerDeactivateThreadFuzzTest()319 void HpaeOffloadRendererManagerDeactivateThreadFuzzTest()
320 {
321 HpaeSinkInfo sinkInfo;
322 InitHpaeSinkInfo(sinkInfo);
323 auto offloadRendererManager = IHpaeRendererManager::CreateRendererManager(sinkInfo);
324 offloadRendererManager->Init();
325 offloadRendererManager->DeactivateThread();
326 WaitForMsgProcessing(offloadRendererManager);
327 offloadRendererManager->DeInit();
328 }
329
HpaeOffloadRendererManagerSetClientVolumeFuzzTest()330 void HpaeOffloadRendererManagerSetClientVolumeFuzzTest()
331 {
332 HpaeSinkInfo sinkInfo;
333 InitHpaeSinkInfo(sinkInfo);
334 auto offloadRendererManager = IHpaeRendererManager::CreateRendererManager(sinkInfo);
335 offloadRendererManager->Init();
336 uint32_t sessionId = GetData<uint32_t>();
337 float volume = GetData<float>();
338 offloadRendererManager->SetClientVolume(sessionId, volume);
339 WaitForMsgProcessing(offloadRendererManager);
340 offloadRendererManager->DeInit();
341 }
342
HpaeOffloadRendererManagerSetRateFuzzTest()343 void HpaeOffloadRendererManagerSetRateFuzzTest()
344 {
345 HpaeSinkInfo sinkInfo;
346 InitHpaeSinkInfo(sinkInfo);
347 auto offloadRendererManager = IHpaeRendererManager::CreateRendererManager(sinkInfo);
348 offloadRendererManager->Init();
349 uint32_t sessionId = GetData<uint32_t>();
350 int32_t rate = GetData<int32_t>();
351 offloadRendererManager->SetRate(sessionId, rate);
352 WaitForMsgProcessing(offloadRendererManager);
353 offloadRendererManager->DeInit();
354 }
355
HpaeOffloadRendererManagerSetAudioEffectModeFuzzTest()356 void HpaeOffloadRendererManagerSetAudioEffectModeFuzzTest()
357 {
358 HpaeSinkInfo sinkInfo;
359 InitHpaeSinkInfo(sinkInfo);
360 auto offloadRendererManager = IHpaeRendererManager::CreateRendererManager(sinkInfo);
361 offloadRendererManager->Init();
362 uint32_t sessionId = GetData<uint32_t>();
363 int32_t effectMode = GetData<int32_t>();
364 offloadRendererManager->SetAudioEffectMode(sessionId, effectMode);
365 WaitForMsgProcessing(offloadRendererManager);
366 offloadRendererManager->DeInit();
367 }
368
HpaeOffloadRendererManagerGetAudioEffectModeFuzzTest()369 void HpaeOffloadRendererManagerGetAudioEffectModeFuzzTest()
370 {
371 HpaeSinkInfo sinkInfo;
372 InitHpaeSinkInfo(sinkInfo);
373 auto offloadRendererManager = IHpaeRendererManager::CreateRendererManager(sinkInfo);
374 offloadRendererManager->Init();
375 uint32_t sessionId = GetData<uint32_t>();
376 int32_t effectMode = GetData<int32_t>();
377 offloadRendererManager->GetAudioEffectMode(sessionId, effectMode);
378 WaitForMsgProcessing(offloadRendererManager);
379 offloadRendererManager->DeInit();
380 }
381
HpaeOffloadRendererManagerSetPrivacyTypeFuzzTest()382 void HpaeOffloadRendererManagerSetPrivacyTypeFuzzTest()
383 {
384 HpaeSinkInfo sinkInfo;
385 InitHpaeSinkInfo(sinkInfo);
386 auto offloadRendererManager = IHpaeRendererManager::CreateRendererManager(sinkInfo);
387 offloadRendererManager->Init();
388 uint32_t sessionId = GetData<uint32_t>();
389 int32_t privacyType = GetData<int32_t>();
390 offloadRendererManager->SetPrivacyType(sessionId, privacyType);
391 WaitForMsgProcessing(offloadRendererManager);
392 offloadRendererManager->DeInit();
393 }
394
HpaeOffloadRendererManagerGetPrivacyTypeFuzzTest()395 void HpaeOffloadRendererManagerGetPrivacyTypeFuzzTest()
396 {
397 HpaeSinkInfo sinkInfo;
398 InitHpaeSinkInfo(sinkInfo);
399 auto offloadRendererManager = IHpaeRendererManager::CreateRendererManager(sinkInfo);
400 offloadRendererManager->Init();
401 uint32_t sessionId = GetData<uint32_t>();
402 int32_t privacyType = GetData<int32_t>();
403 offloadRendererManager->GetPrivacyType(sessionId, privacyType);
404 WaitForMsgProcessing(offloadRendererManager);
405 offloadRendererManager->DeInit();
406 }
407
HpaeOffloadRendererManagerGetWritableSizeFuzzTest()408 void HpaeOffloadRendererManagerGetWritableSizeFuzzTest()
409 {
410 HpaeSinkInfo sinkInfo;
411 InitHpaeSinkInfo(sinkInfo);
412 auto offloadRendererManager = IHpaeRendererManager::CreateRendererManager(sinkInfo);
413 offloadRendererManager->Init();
414 uint32_t sessionId = GetData<uint32_t>();
415 offloadRendererManager->GetWritableSize(sessionId);
416 WaitForMsgProcessing(offloadRendererManager);
417 offloadRendererManager->DeInit();
418 }
419
HpaeOffloadRendererManagerUpdateSpatializationStateFuzzTest()420 void HpaeOffloadRendererManagerUpdateSpatializationStateFuzzTest()
421 {
422 HpaeSinkInfo sinkInfo;
423 InitHpaeSinkInfo(sinkInfo);
424 auto offloadRendererManager = IHpaeRendererManager::CreateRendererManager(sinkInfo);
425 offloadRendererManager->Init();
426 uint32_t sessionId = GetData<uint32_t>();
427 bool spatializationEnabled = false;
428 bool headTrackingEnabled = false;
429 offloadRendererManager->UpdateSpatializationState(sessionId, spatializationEnabled, headTrackingEnabled);
430 WaitForMsgProcessing(offloadRendererManager);
431 offloadRendererManager->DeInit();
432 }
433
HpaeOffloadRendererManagerUpdateMaxLengthFuzzTest()434 void HpaeOffloadRendererManagerUpdateMaxLengthFuzzTest()
435 {
436 HpaeSinkInfo sinkInfo;
437 InitHpaeSinkInfo(sinkInfo);
438 auto offloadRendererManager = IHpaeRendererManager::CreateRendererManager(sinkInfo);
439 offloadRendererManager->Init();
440 uint32_t sessionId = GetData<uint32_t>();
441 uint32_t maxLength = GetData<uint32_t>();
442 offloadRendererManager->UpdateMaxLength(sessionId, maxLength);
443 WaitForMsgProcessing(offloadRendererManager);
444 offloadRendererManager->DeInit();
445 }
446
HpaeOffloadRendererManagerGetAllSinkInputsInfoFuzzTest()447 void HpaeOffloadRendererManagerGetAllSinkInputsInfoFuzzTest()
448 {
449 HpaeSinkInfo sinkInfo;
450 InitHpaeSinkInfo(sinkInfo);
451 auto offloadRendererManager = IHpaeRendererManager::CreateRendererManager(sinkInfo);
452 offloadRendererManager->Init();
453 offloadRendererManager->GetAllSinkInputsInfo();
454 WaitForMsgProcessing(offloadRendererManager);
455 offloadRendererManager->DeInit();
456 }
457
HpaeOffloadRendererManagerGetSinkInfoFuzzTest()458 void HpaeOffloadRendererManagerGetSinkInfoFuzzTest()
459 {
460 HpaeSinkInfo sinkInfo;
461 InitHpaeSinkInfo(sinkInfo);
462 auto offloadRendererManager = IHpaeRendererManager::CreateRendererManager(sinkInfo);
463 offloadRendererManager->Init();
464 offloadRendererManager->GetSinkInfo();
465 WaitForMsgProcessing(offloadRendererManager);
466 offloadRendererManager->DeInit();
467 }
468
HpaeOffloadRendererManagerAddNodeToSinkFuzzTest()469 void HpaeOffloadRendererManagerAddNodeToSinkFuzzTest()
470 {
471 HpaeSinkInfo sinkInfo;
472 InitHpaeSinkInfo(sinkInfo);
473 auto offloadRendererManager = IHpaeRendererManager::CreateRendererManager(sinkInfo);
474 offloadRendererManager->Init();
475 HpaeNodeInfo nodeInfo;
476 InitNodeInfo(nodeInfo);
477 auto node = std::make_shared<HpaeSinkInputNode>(nodeInfo);
478 offloadRendererManager->AddNodeToSink(node);
479 WaitForMsgProcessing(offloadRendererManager);
480 offloadRendererManager->DeInit();
481 }
482
HpaeOffloadRendererManagerAddAllNodesToSinkFuzzTest()483 void HpaeOffloadRendererManagerAddAllNodesToSinkFuzzTest()
484 {
485 HpaeSinkInfo sinkInfo;
486 InitHpaeSinkInfo(sinkInfo);
487 auto offloadRendererManager = IHpaeRendererManager::CreateRendererManager(sinkInfo);
488 offloadRendererManager->Init();
489 HpaeNodeInfo nodeInfo;
490 InitNodeInfo(nodeInfo);
491 auto node = std::make_shared<HpaeSinkInputNode>(nodeInfo);
492 vector<std::shared_ptr<HpaeSinkInputNode>> sinkInputs;
493 sinkInputs.emplace_back(node);
494 bool isConnect = false;
495 offloadRendererManager->AddAllNodesToSink(sinkInputs, isConnect);
496 WaitForMsgProcessing(offloadRendererManager);
497 offloadRendererManager->DeInit();
498 }
499
HpaeOffloadRendererManagerRegisterReadCallbackFuzzTest()500 void HpaeOffloadRendererManagerRegisterReadCallbackFuzzTest()
501 {
502 HpaeSinkInfo sinkInfo;
503 InitHpaeSinkInfo(sinkInfo);
504 auto offloadRendererManager = IHpaeRendererManager::CreateRendererManager(sinkInfo);
505 offloadRendererManager->Init();
506 uint32_t sessionId = GetData<uint32_t>();
507 std::shared_ptr<ReadDataCb> readDataCb = std::make_shared<ReadDataCb>(g_rootCapturerPath);
508 offloadRendererManager->RegisterReadCallback(sessionId, readDataCb);
509 WaitForMsgProcessing(offloadRendererManager);
510 offloadRendererManager->DeInit();
511 }
512
HpaeOffloadRendererManagerOnNodeStatusUpdateFuzzTest()513 void HpaeOffloadRendererManagerOnNodeStatusUpdateFuzzTest()
514 {
515 HpaeSinkInfo sinkInfo;
516 InitHpaeSinkInfo(sinkInfo);
517 auto offloadRendererManager = IHpaeRendererManager::CreateRendererManager(sinkInfo);
518 offloadRendererManager->Init();
519 uint32_t sessionId = GetData<uint32_t>();
520 IOperation operation = OPERATION_INVALID;
521 offloadRendererManager->OnNodeStatusUpdate(sessionId, operation);
522 WaitForMsgProcessing(offloadRendererManager);
523 offloadRendererManager->DeInit();
524 }
525
HpaeOffloadRendererManagerOnFadeDoneFuzzTest()526 void HpaeOffloadRendererManagerOnFadeDoneFuzzTest()
527 {
528 HpaeSinkInfo sinkInfo;
529 InitHpaeSinkInfo(sinkInfo);
530 auto offloadRendererManager = IHpaeRendererManager::CreateRendererManager(sinkInfo);
531 offloadRendererManager->Init();
532 uint32_t sessionId = GetData<uint32_t>();
533 IOperation operation = OPERATION_INVALID;
534 offloadRendererManager->OnFadeDone(sessionId, operation);
535 WaitForMsgProcessing(offloadRendererManager);
536 offloadRendererManager->DeInit();
537 }
538
HpaeOffloadRendererManagerOnNotifyQueueFuzzTest()539 void HpaeOffloadRendererManagerOnNotifyQueueFuzzTest()
540 {
541 HpaeSinkInfo sinkInfo;
542 InitHpaeSinkInfo(sinkInfo);
543 auto offloadRendererManager = IHpaeRendererManager::CreateRendererManager(sinkInfo);
544 offloadRendererManager->Init();
545 offloadRendererManager->OnNotifyQueue();
546 WaitForMsgProcessing(offloadRendererManager);
547 offloadRendererManager->DeInit();
548 }
549
HpaeOffloadRendererManagerGetThreadNameFuzzTest()550 void HpaeOffloadRendererManagerGetThreadNameFuzzTest()
551 {
552 HpaeSinkInfo sinkInfo;
553 InitHpaeSinkInfo(sinkInfo);
554 auto offloadRendererManager = IHpaeRendererManager::CreateRendererManager(sinkInfo);
555 offloadRendererManager->Init();
556 offloadRendererManager->GetThreadName();
557 WaitForMsgProcessing(offloadRendererManager);
558 offloadRendererManager->DeInit();
559 }
560
HpaeOffloadRendererManagerDumpSinkInfoFuzzTest()561 void HpaeOffloadRendererManagerDumpSinkInfoFuzzTest()
562 {
563 HpaeSinkInfo sinkInfo;
564 InitHpaeSinkInfo(sinkInfo);
565 auto offloadRendererManager = IHpaeRendererManager::CreateRendererManager(sinkInfo);
566 offloadRendererManager->Init();
567 offloadRendererManager->DumpSinkInfo();
568 WaitForMsgProcessing(offloadRendererManager);
569 offloadRendererManager->DeInit();
570 }
571
HpaeOffloadRendererManagerReloadRenderManagerFuzzTest()572 void HpaeOffloadRendererManagerReloadRenderManagerFuzzTest()
573 {
574 HpaeSinkInfo sinkInfo;
575 InitHpaeSinkInfo(sinkInfo);
576 auto offloadRendererManager = IHpaeRendererManager::CreateRendererManager(sinkInfo);
577 offloadRendererManager->Init();
578 HpaeSinkInfo newSinkInfo;
579 InitHpaeSinkInfo(newSinkInfo);
580 newSinkInfo.samplingRate = SAMPLE_RATE_16000;
581 offloadRendererManager->ReloadRenderManager(newSinkInfo);
582 WaitForMsgProcessing(offloadRendererManager);
583 offloadRendererManager->DeInit();
584 }
585
HpaeOffloadRendererManagerGetDeviceHDFDumpInfoFuzzTest()586 void HpaeOffloadRendererManagerGetDeviceHDFDumpInfoFuzzTest()
587 {
588 HpaeSinkInfo sinkInfo;
589 InitHpaeSinkInfo(sinkInfo);
590 auto offloadRendererManager = IHpaeRendererManager::CreateRendererManager(sinkInfo);
591 offloadRendererManager->Init();
592 offloadRendererManager->GetDeviceHDFDumpInfo();
593 WaitForMsgProcessing(offloadRendererManager);
594 offloadRendererManager->DeInit();
595 }
596
HpaeOffloadRendererManagerSetLoudnessGainFuzzTest()597 void HpaeOffloadRendererManagerSetLoudnessGainFuzzTest()
598 {
599 HpaeSinkInfo sinkInfo;
600 InitHpaeSinkInfo(sinkInfo);
601 auto offloadRendererManager = IHpaeRendererManager::CreateRendererManager(sinkInfo);
602 offloadRendererManager->Init();
603 uint32_t sessionId = GetData<uint32_t>();
604 float loudnessGain = GetData<float>();
605 offloadRendererManager->SetLoudnessGain(sessionId, loudnessGain);
606 WaitForMsgProcessing(offloadRendererManager);
607 offloadRendererManager->DeInit();
608 }
609
HpaeOffloadRendererManagerSetOffloadRenderCallbackTypeFuzzTest()610 void HpaeOffloadRendererManagerSetOffloadRenderCallbackTypeFuzzTest()
611 {
612 HpaeSinkInfo sinkInfo;
613 InitHpaeSinkInfo(sinkInfo);
614 auto offloadRendererManager = IHpaeRendererManager::CreateRendererManager(sinkInfo);
615 offloadRendererManager->Init();
616 uint32_t sessionId = GetData<uint32_t>();
617 int32_t type = GetData<int32_t>();
618 offloadRendererManager->SetOffloadRenderCallbackType(sessionId, type);
619 WaitForMsgProcessing(offloadRendererManager);
620 offloadRendererManager->DeInit();
621 }
622
IRendererManagerReloadFuzzTest()623 void IRendererManagerReloadFuzzTest()
624 {
625 HpaeSinkInfo sinkInfo;
626 InitHpaeSinkInfo(sinkInfo);
627 auto rendererManager = IHpaeRendererManager::CreateRendererManager(sinkInfo);
628 rendererManager->Init();
629 WaitForMsgProcessing(rendererManager);
630 rendererManager->IsInit();
631
632 HpaeStreamInfo streamInfo;
633 InitRenderStreamInfo(streamInfo);
634 rendererManager->CreateStream(streamInfo);
635 WaitForMsgProcessing(rendererManager);
636 HpaeSinkInputInfo sinkInputInfo;
637 uint32_t sessionId = GetData<uint32_t>();
638 rendererManager->GetSinkInputInfo(sessionId, sinkInputInfo);
639
640 rendererManager->ReloadRenderManager(sinkInfo, true);
641 WaitForMsgProcessing(rendererManager);
642 rendererManager->IsInit();
643
644 rendererManager->Start(sessionId);
645 rendererManager->SetOffloadPolicy(sessionId, 0);
646 WaitForMsgProcessing(rendererManager);
647
648 rendererManager->SetSpeed(sessionId, 1.0f);
649 WaitForMsgProcessing(rendererManager);
650
651 rendererManager->DeInit();
652 rendererManager->IsInit();
653
654 rendererManager->ReloadRenderManager(sinkInfo, true);
655 WaitForMsgProcessing(rendererManager);
656 rendererManager->DeInit();
657 }
658
IRendererManagerCreateDestoryStreamFuzzTest()659 void IRendererManagerCreateDestoryStreamFuzzTest()
660 {
661 HpaeSinkInfo sinkInfo;
662 InitHpaeSinkInfo(sinkInfo);
663 auto hpaeRendererManager = IHpaeRendererManager::CreateRendererManager(sinkInfo);
664 hpaeRendererManager->Init();
665 WaitForMsgProcessing(hpaeRendererManager);
666 hpaeRendererManager->IsInit();
667 HpaeStreamInfo streamInfo;
668
669 uint32_t sessionId = GetData<uint32_t>();
670 hpaeRendererManager->DestroyStream(sessionId);
671 WaitForMsgProcessing(hpaeRendererManager);
672 HpaeSinkInputInfo sinkInputInfo;
673 hpaeRendererManager->GetSinkInputInfo(sessionId, sinkInputInfo);
674
675 InitRenderStreamInfo(streamInfo);
676 hpaeRendererManager->CreateStream(streamInfo);
677 WaitForMsgProcessing(hpaeRendererManager);
678
679 hpaeRendererManager->GetSinkInputInfo(sessionId, sinkInputInfo);
680 hpaeRendererManager->DestroyStream(sessionId);
681 WaitForMsgProcessing(hpaeRendererManager);
682 hpaeRendererManager->GetSinkInputInfo(sessionId, sinkInputInfo);
683 hpaeRendererManager->DeInit();
684 }
685
IRendererManagerStartPuaseStreamFuzzTest()686 void IRendererManagerStartPuaseStreamFuzzTest()
687 {
688 HpaeSinkInfo sinkInfo;
689 InitHpaeSinkInfo(sinkInfo);
690 auto hpaeRendererManager = IHpaeRendererManager::CreateRendererManager(sinkInfo);
691 hpaeRendererManager->Init();
692 WaitForMsgProcessing(hpaeRendererManager);
693 hpaeRendererManager->IsInit();
694 HpaeStreamInfo streamInfo;
695 HpaeSinkInputInfo sinkInputInfo;
696 std::shared_ptr<WriteFixedDataCb> writeIncDataCb = std::make_shared<WriteFixedDataCb>(SAMPLE_S16LE);
697
698 uint32_t sessionId = GetData<uint32_t>();
699 hpaeRendererManager->RegisterWriteCallback(sessionId, writeIncDataCb);
700 hpaeRendererManager->Start(sessionId);
701
702 hpaeRendererManager->SetOffloadPolicy(sessionId, 0);
703 hpaeRendererManager->SetSpeed(sessionId, 1.0f);
704 WaitForMsgProcessing(hpaeRendererManager);
705 hpaeRendererManager->GetSinkInputInfo(sessionId, sinkInputInfo);
706
707 hpaeRendererManager->IsRunning();
708 hpaeRendererManager->Pause(sessionId);
709 WaitForMsgProcessing(hpaeRendererManager);
710 hpaeRendererManager->GetSinkInputInfo(sessionId, sinkInputInfo);
711
712 hpaeRendererManager->Stop(sessionId);
713 WaitForMsgProcessing(hpaeRendererManager);
714
715 hpaeRendererManager->DestroyStream(sessionId);
716 WaitForMsgProcessing(hpaeRendererManager);
717
718 hpaeRendererManager->DeInit();
719 }
720
UpdateCollaborativeStateFuzzTest()721 void UpdateCollaborativeStateFuzzTest()
722 {
723 HpaeSinkInfo sinkInfo;
724 InitHpaeSinkInfo(sinkInfo);
725 auto hpaeRendererManager = IHpaeRendererManager::CreateRendererManager(sinkInfo);
726 hpaeRendererManager->Init();
727 WaitForMsgProcessing(hpaeRendererManager);
728 hpaeRendererManager->IsInit();
729 hpaeRendererManager->UpdateCollaborativeState(true);
730
731 HpaeStreamInfo streamInfo;
732 InitRenderStreamInfo(streamInfo);
733 std::shared_ptr<WriteFixedDataCb> writeIncDataCb = std::make_shared<WriteFixedDataCb>(SAMPLE_S16LE);
734 uint32_t sessionId = GetData<uint32_t>();
735 hpaeRendererManager->RegisterWriteCallback(sessionId, writeIncDataCb);
736
737 hpaeRendererManager->Start(sessionId);
738 WaitForMsgProcessing(hpaeRendererManager);
739 HpaeSinkInputInfo sinkInputInfo;
740 hpaeRendererManager->GetSinkInputInfo(sessionId, sinkInputInfo);
741
742 hpaeRendererManager->IsRunning();
743 hpaeRendererManager->Pause(sessionId);
744 WaitForMsgProcessing(hpaeRendererManager);
745 hpaeRendererManager->Stop(sessionId);
746 WaitForMsgProcessing(hpaeRendererManager);
747
748 hpaeRendererManager->DestroyStream(sessionId);
749 WaitForMsgProcessing(hpaeRendererManager);
750 hpaeRendererManager->GetSinkInputInfo(sessionId, sinkInputInfo);
751 hpaeRendererManager->UpdateCollaborativeState(false);
752 WaitForMsgProcessing(hpaeRendererManager);
753 hpaeRendererManager->DeInit();
754 }
755
756 typedef void (*TestFuncs)();
757 TestFuncs g_testFuncs[TESTSIZE] = {
758 CreateRendererManagerFuzzTest,
759 UploadDumpSinkInfoFuzzTest,
760 OnNotifyDfxNodeInfoFuzzTest,
761 HpaeOffloadRendererManagerConstructFuzzTest,
762 HpaeOffloadRendererManagerFlushFuzzTest,
763 HpaeOffloadRendererManagerDrainFuzzTest,
764 HpaeOffloadRendererManagerReleaseFuzzTest,
765 HpaeOffloadRendererManagerMoveStreamFuzzTest,
766 HpaeOffloadRendererManagerMoveAllStreamFuzzTest,
767 HpaeOffloadRendererManagerSuspendStreamManagerFuzzTest,
768 HpaeOffloadRendererManagerSetMuteFuzzTest,
769 HpaeOffloadRendererManagerProcessFuzzTest,
770 HpaeOffloadRendererManagerHandleMsgFuzzTest,
771 HpaeOffloadRendererManagerIsMsgProcessingFuzzTest,
772 HpaeOffloadRendererManagerDeactivateThreadFuzzTest,
773 HpaeOffloadRendererManagerSetClientVolumeFuzzTest,
774 HpaeOffloadRendererManagerSetRateFuzzTest,
775 HpaeOffloadRendererManagerSetAudioEffectModeFuzzTest,
776 HpaeOffloadRendererManagerGetAudioEffectModeFuzzTest,
777 HpaeOffloadRendererManagerSetPrivacyTypeFuzzTest,
778 HpaeOffloadRendererManagerGetPrivacyTypeFuzzTest,
779 HpaeOffloadRendererManagerGetWritableSizeFuzzTest,
780 HpaeOffloadRendererManagerUpdateSpatializationStateFuzzTest,
781 HpaeOffloadRendererManagerUpdateMaxLengthFuzzTest,
782 HpaeOffloadRendererManagerGetAllSinkInputsInfoFuzzTest,
783 HpaeOffloadRendererManagerGetSinkInfoFuzzTest,
784 HpaeOffloadRendererManagerAddNodeToSinkFuzzTest,
785 HpaeOffloadRendererManagerAddAllNodesToSinkFuzzTest,
786 HpaeOffloadRendererManagerRegisterReadCallbackFuzzTest,
787 HpaeOffloadRendererManagerOnNodeStatusUpdateFuzzTest,
788 HpaeOffloadRendererManagerOnFadeDoneFuzzTest,
789 HpaeOffloadRendererManagerOnNotifyQueueFuzzTest,
790 HpaeOffloadRendererManagerGetThreadNameFuzzTest,
791 HpaeOffloadRendererManagerDumpSinkInfoFuzzTest,
792 HpaeOffloadRendererManagerReloadRenderManagerFuzzTest,
793 HpaeOffloadRendererManagerGetDeviceHDFDumpInfoFuzzTest,
794 HpaeOffloadRendererManagerSetLoudnessGainFuzzTest,
795 HpaeOffloadRendererManagerSetOffloadRenderCallbackTypeFuzzTest,
796 IRendererManagerReloadFuzzTest,
797 IRendererManagerCreateDestoryStreamFuzzTest,
798 IRendererManagerStartPuaseStreamFuzzTest,
799 UpdateCollaborativeStateFuzzTest,
800 };
801
FuzzTest(const uint8_t * rawData,size_t size)802 bool FuzzTest(const uint8_t* rawData, size_t size)
803 {
804 if (rawData == nullptr) {
805 return false;
806 }
807
808 // initialize data
809 RAW_DATA = rawData;
810 g_dataSize = size;
811 g_pos = 0;
812
813 uint32_t code = GetData<uint32_t>();
814 uint32_t len = GetArrLength(g_testFuncs);
815 if (len > 0) {
816 g_testFuncs[code % len]();
817 } else {
818 AUDIO_INFO_LOG("%{public}s: The len length is equal to 0", __func__);
819 }
820
821 return true;
822 }
823 } // namespace AudioStandard
824 } // namesapce OHOS
825
826 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)827 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
828 {
829 if (size < OHOS::AudioStandard::THRESHOLD) {
830 return 0;
831 }
832
833 OHOS::AudioStandard::FuzzTest(data, size);
834 return 0;
835 }
836