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 <iostream>
17 #include <cstddef>
18 #include <cstdint>
19 #include <vector>
20 #include <memory>
21 #include <queue>
22 #include <string>
23 #undef private
24 #include "audio_info.h"
25 #include "i_stream.h"
26 #include "hpae_capturer_manager.h"
27 #include "hpae_source_output_node.h"
28 #include "hpaecapturermanager_fuzzer.h"
29 #include "audio_engine_log.h"
30 using namespace std;
31 using namespace OHOS::AudioStandard::HPAE;
32
33 namespace OHOS {
34 namespace AudioStandard {
35 using namespace std;
36 const uint8_t TESTSIZE = 32;
37 static const uint8_t *RAW_DATA = nullptr;
38 static size_t g_dataSize = 0;
39 static size_t g_pos;
40 const size_t THRESHOLD = 10;
41 const uint32_t DEFAULT_FRAME_LENGTH = 960;
42 static std::string g_rootCapturerPath = "/data/source_file_io_48000_2_s16le.pcm";
43 const char* DEFAULT_TEST_DEVICE_CLASS = "file_io";
44 const char* DEFAULT_TEST_DEVICE_NETWORKID = "LocalDevice";
45 const uint32_t DEFAULT_SESSION_ID = 123456;
46 typedef void (*TestPtr)(const uint8_t *, size_t);
47
48 class DummyCapturerStreamCallback : public ICapturerStreamCallback {
49 public:
50 virtual ~DummyCapturerStreamCallback() = default;
OnStreamData(AudioCallBackCapturerStreamInfo & callBackStreamInfo)51 int32_t OnStreamData(AudioCallBackCapturerStreamInfo &callBackStreamInfo) override
52 {
53 return SUCCESS;
54 }
55 };
56
57 template<class T>
GetData()58 T GetData()
59 {
60 T object {};
61 size_t objectSize = sizeof(object);
62 if (RAW_DATA == nullptr || objectSize > g_dataSize - g_pos) {
63 return object;
64 }
65 errno_t ret = memcpy_s(&object, objectSize, RAW_DATA + g_pos, objectSize);
66 if (ret != EOK) {
67 return {};
68 }
69 g_pos += objectSize;
70 return object;
71 }
72
73 template<class T>
GetArrLength(T & arr)74 uint32_t GetArrLength(T& arr)
75 {
76 if (arr == nullptr) {
77 AUDIO_INFO_LOG("%{public}s: The array length is equal to 0", __func__);
78 return 0;
79 }
80 return sizeof(arr) / sizeof(arr[0]);
81 }
82
OnStreamData(AudioCallBackStreamInfo & callBackStremInfo)83 int32_t WriteFixedDataCb::OnStreamData(AudioCallBackStreamInfo& callBackStremInfo)
84 {
85 return SUCCESS;
86 }
87
ReadDataCb(const std::string & fileName)88 ReadDataCb::ReadDataCb(const std::string &fileName)
89 {
90 testFile_ = fopen(fileName.c_str(), "ab");
91 if (testFile_ == nullptr) {
92 AUDIO_ERR_LOG("Open file failed");
93 }
94 }
95
~ReadDataCb()96 ReadDataCb::~ReadDataCb()
97 {
98 if (testFile_) {
99 fclose(testFile_);
100 testFile_ = nullptr;
101 }
102 }
103
OnStreamData(AudioCallBackCapturerStreamInfo & callBackStreamInfo)104 int32_t ReadDataCb::OnStreamData(AudioCallBackCapturerStreamInfo &callBackStreamInfo)
105 {
106 return SUCCESS;
107 }
108
InitSourceInfo(HpaeSourceInfo & sourceInfo)109 void InitSourceInfo(HpaeSourceInfo &sourceInfo)
110 {
111 sourceInfo.deviceNetId = DEFAULT_TEST_DEVICE_NETWORKID;
112 sourceInfo.deviceClass = DEFAULT_TEST_DEVICE_CLASS;
113 sourceInfo.sourceType = SOURCE_TYPE_MIC;
114 sourceInfo.filePath = g_rootCapturerPath;
115
116 sourceInfo.samplingRate = SAMPLE_RATE_48000;
117 sourceInfo.channels = STEREO;
118 sourceInfo.format = SAMPLE_S16LE;
119 sourceInfo.frameLen = DEFAULT_FRAME_LENGTH;
120 sourceInfo.ecType = HPAE_EC_TYPE_NONE;
121 sourceInfo.micRef = HPAE_REF_OFF;
122 }
123
InitFuzzSourceInfo(HpaeSourceInfo & sourceInfo)124 void InitFuzzSourceInfo(HpaeSourceInfo &sourceInfo)
125 {
126 sourceInfo.deviceNetId = DEFAULT_TEST_DEVICE_NETWORKID;
127 sourceInfo.deviceClass = DEFAULT_TEST_DEVICE_CLASS;
128 sourceInfo.sourceType = SOURCE_TYPE_MIC;
129 sourceInfo.filePath = g_rootCapturerPath;
130
131 sourceInfo.samplingRate = SAMPLE_RATE_48000;
132 sourceInfo.channels = STEREO;
133 sourceInfo.format = SAMPLE_S16LE;
134 sourceInfo.frameLen = DEFAULT_FRAME_LENGTH;
135 sourceInfo.ecType = HPAE_EC_TYPE_NONE;
136 sourceInfo.micRef = HPAE_REF_OFF;
137 }
138
InitReloadStreamInfo(HpaeStreamInfo & streamInfo)139 void InitReloadStreamInfo(HpaeStreamInfo &streamInfo)
140 {
141 streamInfo.channels = STEREO;
142 streamInfo.samplingRate = SAMPLE_RATE_48000;
143 streamInfo.format = SAMPLE_S16LE;
144 streamInfo.frameLen = DEFAULT_FRAME_LENGTH;
145 streamInfo.sessionId = DEFAULT_SESSION_ID;
146 streamInfo.streamType = STREAM_MUSIC;
147 streamInfo.streamClassType = HPAE_STREAM_CLASS_TYPE_RECORD;
148 streamInfo.deviceName = "Built_in_mic";
149 }
150
InitReloadFuzzStreamInfo(HpaeStreamInfo & streamInfo)151 void InitReloadFuzzStreamInfo(HpaeStreamInfo &streamInfo)
152 {
153 streamInfo.channels = STEREO;
154 streamInfo.samplingRate = SAMPLE_RATE_48000;
155 streamInfo.format = SAMPLE_S16LE;
156 streamInfo.frameLen = DEFAULT_FRAME_LENGTH;
157 streamInfo.sessionId = GetData<uint32_t>();
158 streamInfo.streamType = STREAM_MUSIC;
159 streamInfo.streamClassType = HPAE_STREAM_CLASS_TYPE_RECORD;
160 streamInfo.deviceName = "Built_in_mic";
161 }
162
InitReloadSourceInfo(HpaeSourceInfo & sourceInfo,HpaeSourceInfo & newSourceInfo)163 void InitReloadSourceInfo(HpaeSourceInfo &sourceInfo, HpaeSourceInfo &newSourceInfo)
164 {
165 sourceInfo.deviceNetId = DEFAULT_TEST_DEVICE_NETWORKID;
166 sourceInfo.deviceClass = DEFAULT_TEST_DEVICE_CLASS;
167 sourceInfo.sourceType = SOURCE_TYPE_MIC;
168 sourceInfo.filePath = g_rootCapturerPath;
169
170 sourceInfo.samplingRate = SAMPLE_RATE_48000;
171 sourceInfo.channels = STEREO;
172 sourceInfo.format = SAMPLE_S16LE;
173 sourceInfo.frameLen = DEFAULT_FRAME_LENGTH;
174 sourceInfo.ecType = HPAE_EC_TYPE_NONE;
175 sourceInfo.micRef = HPAE_REF_OFF;
176
177 newSourceInfo.deviceNetId = DEFAULT_TEST_DEVICE_NETWORKID;
178 newSourceInfo.deviceClass = DEFAULT_TEST_DEVICE_CLASS;
179 newSourceInfo.sourceType = SOURCE_TYPE_VOICE_TRANSCRIPTION;
180 newSourceInfo.filePath = g_rootCapturerPath;
181
182 newSourceInfo.samplingRate = SAMPLE_RATE_48000;
183 newSourceInfo.channels = STEREO;
184 newSourceInfo.format = SAMPLE_S16LE;
185 newSourceInfo.frameLen = DEFAULT_FRAME_LENGTH;
186 newSourceInfo.ecType = HPAE_EC_TYPE_SAME_ADAPTER;
187 newSourceInfo.micRef = HPAE_REF_OFF;
188 }
189
InitReloadFuzzSourceInfo(HpaeSourceInfo & sourceInfo,HpaeSourceInfo & newSourceInfo)190 void InitReloadFuzzSourceInfo(HpaeSourceInfo &sourceInfo, HpaeSourceInfo &newSourceInfo)
191 {
192 sourceInfo.deviceNetId = DEFAULT_TEST_DEVICE_NETWORKID;
193 sourceInfo.deviceClass = DEFAULT_TEST_DEVICE_CLASS;
194 sourceInfo.sourceType = SOURCE_TYPE_MIC;
195 sourceInfo.filePath = g_rootCapturerPath;
196
197 sourceInfo.samplingRate = SAMPLE_RATE_48000;
198 sourceInfo.channels = STEREO;
199 sourceInfo.format = SAMPLE_S16LE;
200 sourceInfo.frameLen = DEFAULT_FRAME_LENGTH;
201 sourceInfo.ecType = HPAE_EC_TYPE_NONE;
202 sourceInfo.micRef = HPAE_REF_OFF;
203
204 newSourceInfo.deviceNetId = DEFAULT_TEST_DEVICE_NETWORKID;
205 newSourceInfo.deviceClass = DEFAULT_TEST_DEVICE_CLASS;
206 newSourceInfo.sourceType = SOURCE_TYPE_VOICE_TRANSCRIPTION;
207 newSourceInfo.filePath = g_rootCapturerPath;
208
209 newSourceInfo.samplingRate = SAMPLE_RATE_48000;
210 newSourceInfo.channels = STEREO;
211 newSourceInfo.format = SAMPLE_S16LE;
212 newSourceInfo.frameLen = DEFAULT_FRAME_LENGTH;
213 newSourceInfo.ecType = HPAE_EC_TYPE_SAME_ADAPTER;
214 newSourceInfo.micRef = HPAE_REF_OFF;
215 }
216
GetFuzzNodeInfo(HpaeNodeInfo & nodeInfo)217 void GetFuzzNodeInfo(HpaeNodeInfo &nodeInfo)
218 {
219 nodeInfo.nodeId = GetData<uint32_t>();
220 nodeInfo.frameLen = DEFAULT_FRAME_LENGTH;
221 nodeInfo.samplingRate = SAMPLE_RATE_48000;
222 nodeInfo.channels = STEREO;
223 nodeInfo.format = SAMPLE_S16LE;
224 nodeInfo.sceneType = HPAE_SCENE_RECORD;
225 nodeInfo.sourceBufferType = HPAE_SOURCE_BUFFER_TYPE_MIC;
226 }
227
GetHpaeCaptureMoveInfo()228 HpaeCaptureMoveInfo GetHpaeCaptureMoveInfo()
229 {
230 HpaeCaptureMoveInfo moveInfo;
231 HpaeNodeInfo nodeInfo;
232 GetFuzzNodeInfo(nodeInfo);
233 moveInfo.sessionId = GetData<uint32_t>();
234 moveInfo.sourceOutputNode = std::make_shared<HpaeSourceOutputNode>(nodeInfo);
235 return moveInfo;
236 }
237
WaitForMsgProcessing(std::shared_ptr<HpaeCapturerManager> & capturerManager)238 static void WaitForMsgProcessing(std::shared_ptr<HpaeCapturerManager> &capturerManager)
239 {
240 while (capturerManager->IsMsgProcessing()) {
241 std::this_thread::sleep_for(std::chrono::milliseconds(20)); // 20 for sleep
242 }
243 std::this_thread::sleep_for(std::chrono::milliseconds(40)); // 40 for sleep
244 }
245
StateControlFuzzTest(std::shared_ptr<HpaeCapturerManager> & capturerManager,HpaeStreamInfo & streamInfo,HpaeSourceOutputInfo & sourceOutputInfo)246 void StateControlFuzzTest(std::shared_ptr<HpaeCapturerManager> &capturerManager, HpaeStreamInfo &streamInfo,
247 HpaeSourceOutputInfo &sourceOutputInfo)
248 {
249 uint32_t sessionId = GetData<uint32_t>();
250 capturerManager->Start(sessionId);
251 WaitForMsgProcessing(capturerManager);
252 capturerManager->GetSourceOutputInfo(sessionId, sourceOutputInfo);
253 capturerManager->IsRunning();
254
255 capturerManager->Pause(sessionId);
256 WaitForMsgProcessing(capturerManager);
257 capturerManager->GetSourceOutputInfo(sessionId, sourceOutputInfo);
258 capturerManager->IsRunning();
259
260 capturerManager->Start(sessionId);
261 bool isMute = GetData<bool>();
262 capturerManager->SetMute(isMute);
263 WaitForMsgProcessing(capturerManager);
264 capturerManager->GetSourceOutputInfo(sessionId, sourceOutputInfo);
265 capturerManager->IsRunning();
266 capturerManager->Flush(sessionId);
267 capturerManager->Drain(sessionId);
268 capturerManager->Stop(sessionId);
269 capturerManager->OnNodeStatusUpdate(sessionId, OPERATION_STOPPED);
270 WaitForMsgProcessing(capturerManager);
271 capturerManager->GetSourceOutputInfo(sessionId, sourceOutputInfo);
272 capturerManager->IsRunning();
273
274 capturerManager->Release(sessionId);
275 WaitForMsgProcessing(capturerManager);
276
277 capturerManager->GetSourceOutputInfo(sessionId, sourceOutputInfo);
278 capturerManager->IsRunning();
279 }
280
StateControlTest(std::shared_ptr<HpaeCapturerManager> & capturerManager,HpaeStreamInfo & streamInfo,HpaeSourceOutputInfo & sourceOutputInfo)281 void StateControlTest(std::shared_ptr<HpaeCapturerManager> &capturerManager, HpaeStreamInfo &streamInfo,
282 HpaeSourceOutputInfo &sourceOutputInfo)
283 {
284 capturerManager->Start(streamInfo.sessionId);
285 WaitForMsgProcessing(capturerManager);
286 capturerManager->GetSourceOutputInfo(streamInfo.sessionId, sourceOutputInfo);
287 capturerManager->IsRunning();
288
289 capturerManager->Pause(streamInfo.sessionId);
290 WaitForMsgProcessing(capturerManager);
291 capturerManager->GetSourceOutputInfo(streamInfo.sessionId, sourceOutputInfo);
292 capturerManager->IsRunning();
293
294 capturerManager->Start(streamInfo.sessionId);
295 bool isMute = true;
296 capturerManager->SetMute(isMute);
297 WaitForMsgProcessing(capturerManager);
298 capturerManager->GetSourceOutputInfo(streamInfo.sessionId, sourceOutputInfo);
299 capturerManager->IsRunning();
300 capturerManager->Flush(streamInfo.sessionId);
301 capturerManager->Drain(streamInfo.sessionId);
302 capturerManager->Stop(streamInfo.sessionId);
303 capturerManager->OnNodeStatusUpdate(streamInfo.sessionId, OPERATION_STOPPED);
304 WaitForMsgProcessing(capturerManager);
305 capturerManager->GetSourceOutputInfo(streamInfo.sessionId, sourceOutputInfo);
306 capturerManager->IsRunning();
307
308 capturerManager->Release(streamInfo.sessionId);
309 WaitForMsgProcessing(capturerManager);
310
311 capturerManager->GetSourceOutputInfo(streamInfo.sessionId, sourceOutputInfo);
312 capturerManager->IsRunning();
313 }
314
HpaeCapturerManagerFuzzTest1()315 void HpaeCapturerManagerFuzzTest1()
316 {
317 HpaeSourceInfo sourceInfo;
318 InitSourceInfo(sourceInfo);
319 auto capturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
320 capturerManager->Init();
321 WaitForMsgProcessing(capturerManager);
322 capturerManager->IsInit();
323 HpaeStreamInfo streamInfo;
324 InitReloadStreamInfo(streamInfo);
325 capturerManager->CreateStream(streamInfo);
326 WaitForMsgProcessing(capturerManager);
327 HpaeSourceOutputInfo sourceOutputInfo;
328 capturerManager->GetSourceOutputInfo(streamInfo.sessionId, sourceOutputInfo);
329
330 StateControlTest(capturerManager, streamInfo, sourceOutputInfo);
331 capturerManager->OnNotifyQueue();
332 WaitForMsgProcessing(capturerManager);
333 capturerManager->DeInit();
334 }
335
HpaeCapturerManagerFuzzTest2()336 void HpaeCapturerManagerFuzzTest2()
337 {
338 HpaeSourceInfo sourceInfo;
339 InitFuzzSourceInfo(sourceInfo);
340 auto capturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
341 capturerManager->IsInit();
342 HpaeStreamInfo streamInfo;
343 InitReloadFuzzStreamInfo(streamInfo);
344 capturerManager->CreateStream(streamInfo);
345 WaitForMsgProcessing(capturerManager);
346 HpaeSourceOutputInfo sourceOutputInfo;
347 capturerManager->GetSourceOutputInfo(streamInfo.sessionId, sourceOutputInfo);
348 StateControlFuzzTest(capturerManager, streamInfo, sourceOutputInfo);
349 capturerManager->OnNotifyQueue();
350 WaitForMsgProcessing(capturerManager);
351 capturerManager->DeInit();
352 }
353
HpaeCapturerManagerFuzzTest3()354 void HpaeCapturerManagerFuzzTest3()
355 {
356 HpaeSourceInfo sourceInfo;
357 InitFuzzSourceInfo(sourceInfo);
358 auto capturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
359 capturerManager->Init();
360 WaitForMsgProcessing(capturerManager);
361 capturerManager->IsInit();
362 HpaeStreamInfo streamInfo;
363 InitReloadFuzzStreamInfo(streamInfo);
364 capturerManager->CreateStream(streamInfo);
365 WaitForMsgProcessing(capturerManager);
366 HpaeSourceOutputInfo sourceOutputInfo;
367 capturerManager->GetSourceOutputInfo(streamInfo.sessionId, sourceOutputInfo);
368
369 StateControlFuzzTest(capturerManager, streamInfo, sourceOutputInfo);
370 capturerManager->DeInit();
371 capturerManager->OnNotifyQueue();
372 WaitForMsgProcessing(capturerManager);
373 }
374
HpaeCapturerManagerReloadFuzzTest1()375 void HpaeCapturerManagerReloadFuzzTest1()
376 {
377 HpaeSourceInfo sourceInfo;
378 HpaeSourceInfo newSourceInfo;
379 InitReloadSourceInfo(sourceInfo, newSourceInfo);
380
381 auto capturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
382 capturerManager->Init();
383 WaitForMsgProcessing(capturerManager);
384 capturerManager->GetThreadName();
385 capturerManager->IsInit();
386 HpaeStreamInfo streamInfo;
387 InitReloadStreamInfo(streamInfo);
388 capturerManager->CreateStream(streamInfo);
389 WaitForMsgProcessing(capturerManager);
390 HpaeSourceOutputInfo sourceOutputInfo;
391 capturerManager->GetSourceOutputInfo(streamInfo.sessionId, sourceOutputInfo);
392 capturerManager->ReloadCaptureManager(newSourceInfo);
393 WaitForMsgProcessing(capturerManager);
394 capturerManager->GetSourceOutputInfo(streamInfo.sessionId, sourceOutputInfo);
395 WaitForMsgProcessing(capturerManager);
396 capturerManager->DeInit();
397 }
398
HpaeCapturerManagerReloadFuzzTest2()399 void HpaeCapturerManagerReloadFuzzTest2()
400 {
401 HpaeSourceInfo sourceInfo;
402 HpaeSourceInfo newSourceInfo;
403 InitReloadFuzzSourceInfo(sourceInfo, newSourceInfo);
404
405 auto capturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
406 capturerManager->GetThreadName();
407 capturerManager->IsInit();
408 HpaeStreamInfo streamInfo;
409 InitReloadFuzzStreamInfo(streamInfo);
410 capturerManager->CreateStream(streamInfo);
411 WaitForMsgProcessing(capturerManager);
412 HpaeSourceOutputInfo sourceOutputInfo;
413 capturerManager->GetSourceOutputInfo(streamInfo.sessionId, sourceOutputInfo);
414 capturerManager->ReloadCaptureManager(newSourceInfo);
415 WaitForMsgProcessing(capturerManager);
416 capturerManager->GetSourceOutputInfo(streamInfo.sessionId, sourceOutputInfo);
417 capturerManager->DeInit();
418 WaitForMsgProcessing(capturerManager);
419 }
420
HpaeCapturerManagerReloadFuzzTest3()421 void HpaeCapturerManagerReloadFuzzTest3()
422 {
423 HpaeSourceInfo sourceInfo;
424 HpaeSourceInfo newSourceInfo;
425 InitReloadFuzzSourceInfo(sourceInfo, newSourceInfo);
426
427 auto capturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
428 capturerManager->Init();
429 WaitForMsgProcessing(capturerManager);
430 capturerManager->GetThreadName();
431 capturerManager->IsInit();
432 HpaeStreamInfo streamInfo;
433 InitReloadFuzzStreamInfo(streamInfo);
434 capturerManager->CreateStream(streamInfo);
435 WaitForMsgProcessing(capturerManager);
436 HpaeSourceOutputInfo sourceOutputInfo;
437 capturerManager->GetSourceOutputInfo(streamInfo.sessionId, sourceOutputInfo);
438 capturerManager->ReloadCaptureManager(newSourceInfo);
439 WaitForMsgProcessing(capturerManager);
440 capturerManager->GetSourceOutputInfo(streamInfo.sessionId, sourceOutputInfo);
441 WaitForMsgProcessing(capturerManager);
442 capturerManager->DeInit();
443 }
444
MoveStreamFuzzTest()445 void MoveStreamFuzzTest()
446 {
447 HpaeSourceInfo sourceInfo;
448 InitFuzzSourceInfo(sourceInfo);
449 auto capturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
450 capturerManager->Init();
451 uint32_t sessionId = GetData<uint32_t>();
452 std::string sourceName = sourceInfo.sourceName;
453 capturerManager->MoveStream(sessionId, sourceName);
454 std::vector<uint32_t> sessionIds = {GetData<uint32_t>(), GetData<uint32_t>(), GetData<uint32_t>()};
455 capturerManager->MoveAllStream(sourceName, sessionIds);
456 WaitForMsgProcessing(capturerManager);
457 capturerManager->DeInit();
458 }
459
GetSourceInfoFuzzTest()460 void GetSourceInfoFuzzTest()
461 {
462 HpaeSourceInfo sourceInfo;
463 InitFuzzSourceInfo(sourceInfo);
464 auto capturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
465 capturerManager->Init();
466 capturerManager->GetSourceInfo();
467 capturerManager->GetAllSourceOutputsInfo();
468 WaitForMsgProcessing(capturerManager);
469 }
470
OnRequestLatencyFuzzTest()471 void OnRequestLatencyFuzzTest()
472 {
473 HpaeSourceInfo sourceInfo;
474 InitFuzzSourceInfo(sourceInfo);
475 auto capturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
476 capturerManager->Init();
477 uint32_t sessionId = GetData<uint32_t>();
478 uint64_t latency = GetData<uint64_t>();
479 capturerManager->OnRequestLatency(sessionId, latency);
480 WaitForMsgProcessing(capturerManager);
481 capturerManager->DeInit();
482 }
483
AddNodeToSourceFuzzTest1()484 void AddNodeToSourceFuzzTest1()
485 {
486 HpaeSourceInfo sourceInfo;
487 InitFuzzSourceInfo(sourceInfo);
488 auto capturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
489 capturerManager->Init();
490 HpaeCaptureMoveInfo moveInfo;
491 capturerManager->AddNodeToSource(moveInfo);
492 WaitForMsgProcessing(capturerManager);
493 capturerManager->DeInit();
494 }
495
AddNodeToSourceFuzzTest2()496 void AddNodeToSourceFuzzTest2()
497 {
498 HpaeSourceInfo sourceInfo;
499 InitFuzzSourceInfo(sourceInfo);
500 auto capturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
501 capturerManager->Init();
502 HpaeCaptureMoveInfo moveInfo = GetHpaeCaptureMoveInfo();
503 capturerManager->AddNodeToSource(moveInfo);
504 WaitForMsgProcessing(capturerManager);
505 capturerManager->DeInit();
506 }
507
AddAllNodesToSourceFuzzTest1()508 void AddAllNodesToSourceFuzzTest1()
509 {
510 HpaeSourceInfo sourceInfo;
511 InitFuzzSourceInfo(sourceInfo);
512 auto capturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
513 capturerManager->Init();
514 std::vector<HpaeCaptureMoveInfo> moveInfos;
515 bool isConnect = GetData<bool>();
516 capturerManager->AddAllNodesToSource(moveInfos, isConnect);
517 WaitForMsgProcessing(capturerManager);
518 capturerManager->DeInit();
519 }
520
AddAllNodesToSourceFuzzTest2()521 void AddAllNodesToSourceFuzzTest2()
522 {
523 HpaeSourceInfo sourceInfo;
524 InitFuzzSourceInfo(sourceInfo);
525 auto capturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
526 capturerManager->Init();
527 std::vector<HpaeCaptureMoveInfo> moveInfos = {GetHpaeCaptureMoveInfo(),
528 GetHpaeCaptureMoveInfo(), GetHpaeCaptureMoveInfo()};
529 bool isConnect = GetData<bool>();
530 capturerManager->AddAllNodesToSource(moveInfos, isConnect);
531 WaitForMsgProcessing(capturerManager);
532 capturerManager->DeInit();
533 }
534
GetDeviceHDFDumpInfoFuzzTest()535 void GetDeviceHDFDumpInfoFuzzTest()
536 {
537 HpaeSourceInfo sourceInfo;
538 InitFuzzSourceInfo(sourceInfo);
539 auto capturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
540 capturerManager->Init();
541 capturerManager->GetDeviceHDFDumpInfo();
542 WaitForMsgProcessing(capturerManager);
543 capturerManager->DeInit();
544 }
545
CaptureEffectCreateFuzzTest()546 void CaptureEffectCreateFuzzTest()
547 {
548 HpaeSourceInfo sourceInfo;
549 InitFuzzSourceInfo(sourceInfo);
550 auto capturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
551 CHECK_AND_RETURN(capturerManager != nullptr);
552 capturerManager->Init();
553 WaitForMsgProcessing(capturerManager);
554
555 std::vector<uint32_t> sessionIds;
556
557 HpaeStreamInfo streamInfo;
558 InitReloadFuzzStreamInfo(streamInfo);
559 streamInfo.sourceType = GetData<SourceType>();
560 streamInfo.sessionId = GetData<uint32_t>();
561 sessionIds.push_back(streamInfo.sessionId);
562
563 capturerManager->CreateStream(streamInfo);
564
565 for (uint32_t sessionId : sessionIds) {
566 capturerManager->DestroyStream(sessionId);
567 }
568 WaitForMsgProcessing(capturerManager);
569
570 capturerManager->DeInit();
571 }
572
StartWithEcAndMicRefFuzzTest()573 void StartWithEcAndMicRefFuzzTest()
574 {
575 HpaeSourceInfo sourceInfo;
576 InitFuzzSourceInfo(sourceInfo);
577
578 sourceInfo.ecType = GetData<HpaeEcType>();
579 sourceInfo.micRef = GetData<HpaeMicRefSwitch>();
580
581 auto capturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
582 CHECK_AND_RETURN(capturerManager != nullptr);
583 capturerManager->Init();
584 WaitForMsgProcessing(capturerManager);
585
586 HpaeStreamInfo streamInfo;
587 InitReloadFuzzStreamInfo(streamInfo);
588 streamInfo.sourceType = GetData<SourceType>();
589 streamInfo.sessionId = GetData<uint32_t>();
590
591 capturerManager->CreateStream(streamInfo);
592 WaitForMsgProcessing(capturerManager);
593
594 capturerManager->Start(streamInfo.sessionId);
595 WaitForMsgProcessing(capturerManager);
596
597 capturerManager->Stop(streamInfo.sessionId);
598 capturerManager->Release(streamInfo.sessionId);
599 WaitForMsgProcessing(capturerManager);
600 capturerManager->DeInit();
601 }
602
DeInitWithCapturerSourceStopForRemoteFuzzTest()603 void DeInitWithCapturerSourceStopForRemoteFuzzTest()
604 {
605 HpaeSourceInfo sourceInfo;
606 InitFuzzSourceInfo(sourceInfo);
607
608 sourceInfo.deviceClass = "remote";
609 sourceInfo.ecType = GetData<HpaeEcType>();
610 sourceInfo.micRef = GetData<HpaeMicRefSwitch>();
611
612 auto capturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
613 CHECK_AND_RETURN(capturerManager != nullptr);
614 capturerManager->Init();
615 WaitForMsgProcessing(capturerManager);
616
617 capturerManager->DeInit();
618 }
619
PrepareCapturerEcFuzzTest()620 void PrepareCapturerEcFuzzTest()
621 {
622 HpaeSourceInfo sourceInfo;
623 InitFuzzSourceInfo(sourceInfo);
624
625 sourceInfo.ecType = GetData<HpaeEcType>();
626 sourceInfo.micRef = GetData<HpaeMicRefSwitch>();
627
628 auto capturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
629 CHECK_AND_RETURN(capturerManager != nullptr);
630
631 capturerManager->Init();
632 WaitForMsgProcessing(capturerManager);
633
634 capturerManager->DeInit();
635 }
636
DeactivateThreadFuzzTest()637 void DeactivateThreadFuzzTest()
638 {
639 HpaeSourceInfo sourceInfo;
640 InitFuzzSourceInfo(sourceInfo);
641 auto capturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
642 CHECK_AND_RETURN(capturerManager != nullptr);
643
644 capturerManager->Init();
645 WaitForMsgProcessing(capturerManager);
646
647 capturerManager->DeactivateThread();
648 }
649
RegisterReadCallbackFuzzTest()650 void RegisterReadCallbackFuzzTest()
651 {
652 HpaeSourceInfo sourceInfo;
653 InitFuzzSourceInfo(sourceInfo);
654 auto capturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
655 CHECK_AND_RETURN(capturerManager != nullptr);
656
657 capturerManager->Init();
658 WaitForMsgProcessing(capturerManager);
659
660 HpaeStreamInfo streamInfo;
661 InitReloadFuzzStreamInfo(streamInfo);
662 capturerManager->CreateStream(streamInfo);
663 WaitForMsgProcessing(capturerManager);
664
665 auto callback = std::make_shared<DummyCapturerStreamCallback>();
666 CHECK_AND_RETURN(callback != nullptr);
667 capturerManager->RegisterReadCallback(streamInfo.sessionId, callback);
668 WaitForMsgProcessing(capturerManager);
669
670 uint32_t invalidSessionId = GetData<uint32_t>();
671 capturerManager->RegisterReadCallback(invalidSessionId, callback);
672 WaitForMsgProcessing(capturerManager);
673
674 capturerManager->DeInit();
675 }
676
CheckIfAnyStreamRunningFuzzTest()677 void CheckIfAnyStreamRunningFuzzTest()
678 {
679 HpaeSourceInfo sourceInfo;
680 InitFuzzSourceInfo(sourceInfo);
681 auto capturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
682 CHECK_AND_RETURN(capturerManager != nullptr);
683
684 capturerManager->Init();
685 WaitForMsgProcessing(capturerManager);
686
687 HpaeStreamInfo streamInfo;
688 InitReloadFuzzStreamInfo(streamInfo);
689 streamInfo.sessionId = GetData<uint32_t>();
690 capturerManager->CreateStream(streamInfo);
691 WaitForMsgProcessing(capturerManager);
692
693 capturerManager->Start(streamInfo.sessionId);
694 WaitForMsgProcessing(capturerManager);
695
696 HpaeSourceInfo newSourceInfo;
697 InitFuzzSourceInfo(newSourceInfo);
698 capturerManager->ReloadCaptureManager(newSourceInfo);
699 WaitForMsgProcessing(capturerManager);
700
701 capturerManager->DeInit();
702 }
703
DumpSourceInfoFuzzTest()704 void DumpSourceInfoFuzzTest()
705 {
706 HpaeSourceInfo sourceInfo;
707 InitFuzzSourceInfo(sourceInfo);
708 auto capturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
709 CHECK_AND_RETURN(capturerManager != nullptr);
710 capturerManager->Init();
711 WaitForMsgProcessing(capturerManager);
712 capturerManager->DumpSourceInfo();
713 WaitForMsgProcessing(capturerManager);
714 capturerManager->DeInit();
715 }
716
AddAllNodesToSourceAdvancedFuzzTest()717 void AddAllNodesToSourceAdvancedFuzzTest()
718 {
719 HpaeSourceInfo sourceInfo;
720 InitFuzzSourceInfo(sourceInfo);
721 auto capturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
722 CHECK_AND_RETURN(capturerManager != nullptr);
723
724 capturerManager->Init();
725 WaitForMsgProcessing(capturerManager);
726
727 std::vector<HpaeCaptureMoveInfo> moveInfos;
728
729 HpaeNodeInfo nodeInfo;
730 GetFuzzNodeInfo(nodeInfo);
731 nodeInfo.sceneType = GetData<HpaeProcessorType>();
732
733 HpaeCaptureMoveInfo moveInfo;
734 moveInfo.sessionId = GetData<uint32_t>();
735 moveInfo.sourceOutputNode = std::make_shared<HpaeSourceOutputNode>(nodeInfo);
736
737 moveInfo.sessionInfo.state = GetData<HpaeSessionState>();
738
739 moveInfos.push_back(moveInfo);
740
741 bool isConnect = GetData<bool>();
742 capturerManager->AddAllNodesToSource(moveInfos, isConnect);
743 WaitForMsgProcessing(capturerManager);
744
745 capturerManager->DeInit();
746 }
747
748 typedef void (*TestFuncs)();
749
750 TestFuncs g_testFuncs[] = {
751 HpaeCapturerManagerFuzzTest1,
752 HpaeCapturerManagerFuzzTest2,
753 HpaeCapturerManagerFuzzTest3,
754 HpaeCapturerManagerReloadFuzzTest1,
755 HpaeCapturerManagerReloadFuzzTest2,
756 HpaeCapturerManagerReloadFuzzTest3,
757 MoveStreamFuzzTest,
758 GetSourceInfoFuzzTest,
759 OnRequestLatencyFuzzTest,
760 AddNodeToSourceFuzzTest1,
761 AddNodeToSourceFuzzTest2,
762 AddAllNodesToSourceFuzzTest1,
763 AddAllNodesToSourceFuzzTest2,
764 GetDeviceHDFDumpInfoFuzzTest,
765 CaptureEffectCreateFuzzTest,
766 StartWithEcAndMicRefFuzzTest,
767 DeInitWithCapturerSourceStopForRemoteFuzzTest,
768 PrepareCapturerEcFuzzTest,
769 DeactivateThreadFuzzTest,
770 RegisterReadCallbackFuzzTest,
771 AddAllNodesToSourceAdvancedFuzzTest,
772 CheckIfAnyStreamRunningFuzzTest,
773 DumpSourceInfoFuzzTest,
774 };
775
FuzzTest(const uint8_t * rawData,size_t size)776 bool FuzzTest(const uint8_t* rawData, size_t size)
777 {
778 if (rawData == nullptr) {
779 return false;
780 }
781
782 // initialize data
783 RAW_DATA = rawData;
784 g_dataSize = size;
785 g_pos = 0;
786
787 uint32_t code = GetData<uint32_t>();
788 uint32_t len = GetArrLength(g_testFuncs);
789 if (len > 0) {
790 g_testFuncs[code % len]();
791 } else {
792 AUDIO_INFO_LOG("%{public}s: The len length is equal to 0", __func__);
793 }
794
795 return true;
796 }
797
798
799 } // namespace AudioStandard
800 } // namesapce OHOS
801
802 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)803 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
804 {
805 if (size < OHOS::AudioStandard::THRESHOLD) {
806 return 0;
807 }
808
809 OHOS::AudioStandard::FuzzTest(data, size);
810 return 0;
811 }