• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 #include "hpaeinnercapturermanager_fuzzer.h"
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 "hpae_inner_capturer_manager.h"
26 #include "i_hpae_renderer_manager.h"
27 #include "audio_engine_log.h"
28 
29 using namespace std;
30 using namespace OHOS::AudioStandard::HPAE;
31 
32 
33 namespace OHOS {
34 namespace AudioStandard {
35 static const uint8_t *RAW_DATA = nullptr;
36 static size_t g_dataSize = 0;
37 static size_t g_pos;
38 const size_t THRESHOLD = 10;
39 const uint32_t DEFAULT_FRAME_LENGTH1 = 960;
40 const uint32_t DEFAULT_FRAME_LENGTH2 = 882;
41 static std::string g_rootPath = "/data/";
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 template<class T>
GetData()49 T GetData()
50 {
51     T object {};
52     size_t objectSize = sizeof(object);
53     if (RAW_DATA == nullptr || objectSize > g_dataSize - g_pos) {
54         return object;
55     }
56     errno_t ret = memcpy_s(&object, objectSize, RAW_DATA + g_pos, objectSize);
57     if (ret != EOK) {
58         return {};
59     }
60     g_pos += objectSize;
61     return object;
62 }
63 
64 template<class T>
GetArrLength(T & arr)65 uint32_t GetArrLength(T& arr)
66 {
67     if (arr == nullptr) {
68         AUDIO_INFO_LOG("%{public}s: The array length is equal to 0", __func__);
69         return 0;
70     }
71     return sizeof(arr) / sizeof(arr[0]);
72 }
73 
OnStreamData(AudioCallBackStreamInfo & callBackStremInfo)74 int32_t WriteFixedDataCb::OnStreamData(AudioCallBackStreamInfo& callBackStremInfo)
75 {
76     return SUCCESS;
77 }
78 
ReadDataCb(const std::string & fileName)79 ReadDataCb::ReadDataCb(const std::string &fileName)
80 {
81     testFile_ = fopen(fileName.c_str(), "ab");
82     if (testFile_ == nullptr) {
83         AUDIO_ERR_LOG("Open file failed");
84     }
85 }
86 
~ReadDataCb()87 ReadDataCb::~ReadDataCb()
88 {
89     if (testFile_) {
90         fclose(testFile_);
91         testFile_ = nullptr;
92     }
93 }
94 
OnStreamData(AudioCallBackCapturerStreamInfo & callBackStreamInfo)95 int32_t ReadDataCb::OnStreamData(AudioCallBackCapturerStreamInfo &callBackStreamInfo)
96 {
97     return SUCCESS;
98 }
99 
GetInCapSinkInfo()100 HpaeSinkInfo GetInCapSinkInfo()
101 {
102     HpaeSinkInfo sinkInfo;
103     sinkInfo.deviceNetId = DEFAULT_TEST_DEVICE_NETWORKID;
104     sinkInfo.deviceClass = DEFAULT_TEST_DEVICE_CLASS;
105     sinkInfo.adapterName = DEFAULT_TEST_DEVICE_CLASS;
106     sinkInfo.filePath = g_rootPath + "constructHpaeInnerCapturerManagerTest.pcm";
107     sinkInfo.samplingRate = SAMPLE_RATE_48000;
108     sinkInfo.frameLen = DEFAULT_FRAME_LENGTH1;
109     sinkInfo.format = SAMPLE_F32LE;
110     sinkInfo.channels = STEREO;
111     sinkInfo.deviceType = DEVICE_TYPE_SPEAKER;
112     return sinkInfo;
113 }
114 
GetInCapFuzzSinkInfo()115 HpaeSinkInfo GetInCapFuzzSinkInfo()
116 {
117     HpaeSinkInfo sinkInfo;
118     sinkInfo.deviceNetId = DEFAULT_TEST_DEVICE_NETWORKID;
119     sinkInfo.deviceClass = DEFAULT_TEST_DEVICE_CLASS;
120     sinkInfo.adapterName = DEFAULT_TEST_DEVICE_CLASS;
121     sinkInfo.filePath = g_rootPath + "constructHpaeInnerCapturerManagerTest.pcm";
122     sinkInfo.samplingRate = SAMPLE_RATE_48000;
123     sinkInfo.frameLen = GetData<size_t>();
124     sinkInfo.format = SAMPLE_F32LE;
125     sinkInfo.channels = STEREO;
126     sinkInfo.deviceType = DEVICE_TYPE_SPEAKER;
127     return sinkInfo;
128 }
129 
GetInCapPlayStreamInfo()130 HpaeStreamInfo GetInCapPlayStreamInfo()
131 {
132     HpaeStreamInfo streamInfo;
133     streamInfo.channels = STEREO;
134     streamInfo.samplingRate = SAMPLE_RATE_44100;
135     streamInfo.frameLen = GetData<size_t>();
136     streamInfo.format = SAMPLE_S16LE;
137     streamInfo.sessionId = DEFAULT_SESSION_ID;
138     streamInfo.streamType = STREAM_MUSIC;
139     streamInfo.streamClassType = HPAE_STREAM_CLASS_TYPE_PLAY;
140     streamInfo.sourceType = SOURCE_TYPE_PLAYBACK_CAPTURE;
141     return streamInfo;
142 }
143 
GetInCapPlayFuzzStreamInfo()144 HpaeStreamInfo GetInCapPlayFuzzStreamInfo()
145 {
146     HpaeStreamInfo streamInfo;
147     streamInfo.channels = STEREO;
148     streamInfo.samplingRate = SAMPLE_RATE_44100;
149     streamInfo.frameLen = GetData<size_t>();
150     streamInfo.format = SAMPLE_S16LE;
151     streamInfo.sessionId = GetData<uint32_t>();
152     streamInfo.streamType = STREAM_MUSIC;
153     streamInfo.streamClassType = HPAE_STREAM_CLASS_TYPE_PLAY;
154     streamInfo.sourceType = SOURCE_TYPE_PLAYBACK_CAPTURE;
155     return streamInfo;
156 }
157 
GetInCapRecordStreamInfo()158 static HpaeStreamInfo GetInCapRecordStreamInfo()
159 {
160     HpaeStreamInfo streamInfo;
161     streamInfo.channels = STEREO;
162     streamInfo.samplingRate = SAMPLE_RATE_44100;
163     streamInfo.frameLen = DEFAULT_FRAME_LENGTH2;
164     streamInfo.format = SAMPLE_S16LE;
165     streamInfo.sessionId = DEFAULT_SESSION_ID + 1;
166     streamInfo.streamType = STREAM_MUSIC;
167     streamInfo.streamClassType = HPAE_STREAM_CLASS_TYPE_RECORD;
168     streamInfo.sourceType = SOURCE_TYPE_PLAYBACK_CAPTURE;
169     return streamInfo;
170 }
171 
GetInCapRecordFuzzStreamInfo()172 static HpaeStreamInfo GetInCapRecordFuzzStreamInfo()
173 {
174     HpaeStreamInfo streamInfo;
175     streamInfo.channels = STEREO;
176     streamInfo.samplingRate = SAMPLE_RATE_44100;
177     streamInfo.frameLen = DEFAULT_FRAME_LENGTH2;
178     streamInfo.format = SAMPLE_S16LE;
179     streamInfo.sessionId = GetData<uint32_t>();
180     streamInfo.streamType = STREAM_MUSIC;
181     streamInfo.streamClassType = HPAE_STREAM_CLASS_TYPE_RECORD;
182     streamInfo.sourceType = SOURCE_TYPE_PLAYBACK_CAPTURE;
183     return streamInfo;
184 }
185 
WaitForMsgProcessing(std::shared_ptr<HpaeInnerCapturerManager> & hpaeInnerCapturerManager)186 void WaitForMsgProcessing(std::shared_ptr<HpaeInnerCapturerManager>& hpaeInnerCapturerManager)
187 {
188     while (hpaeInnerCapturerManager->IsMsgProcessing()) {
189         std::this_thread::sleep_for(std::chrono::milliseconds(20));  // 20ms frameLen, need optimize
190     }
191     std::this_thread::sleep_for(std::chrono::milliseconds(40));  // 40ms wait time, need optimize
192 }
193 
HpaeInnerCapturerManagerFuzzTest1()194 void HpaeInnerCapturerManagerFuzzTest1()
195 {
196     HpaeSinkInfo sinkInfo = GetInCapSinkInfo();
197     auto hpaeInnerCapturerManager = std::make_shared<HPAE::HpaeInnerCapturerManager>(sinkInfo);
198     hpaeInnerCapturerManager->Init();
199     HpaeStreamInfo recordStreamInfo = GetInCapRecordStreamInfo();
200     hpaeInnerCapturerManager->CreateStream(recordStreamInfo);
201     hpaeInnerCapturerManager->Start(recordStreamInfo.sessionId);
202     WaitForMsgProcessing(hpaeInnerCapturerManager);
203     hpaeInnerCapturerManager->GetThreadName();
204     HpaeSourceOutputInfo sourceOutoputInfo;
205 
206     HpaeStreamInfo playStreamInfo = GetInCapPlayStreamInfo();
207     hpaeInnerCapturerManager->CreateStream(playStreamInfo);
208     WaitForMsgProcessing(hpaeInnerCapturerManager);
209     std::shared_ptr<WriteFixedDataCb> writeInPlayDataCb = std::make_shared<WriteFixedDataCb>(SAMPLE_S16LE);
210     hpaeInnerCapturerManager->RegisterWriteCallback(playStreamInfo.sessionId, writeInPlayDataCb);
211     hpaeInnerCapturerManager->Start(playStreamInfo.sessionId);
212     hpaeInnerCapturerManager->Pause(recordStreamInfo.sessionId);
213     hpaeInnerCapturerManager->Pause(playStreamInfo.sessionId);
214     hpaeInnerCapturerManager->Flush(recordStreamInfo.sessionId);
215     hpaeInnerCapturerManager->Drain(playStreamInfo.sessionId);
216     WaitForMsgProcessing(hpaeInnerCapturerManager);
217     HpaeSinkInputInfo sinkInputInfo;
218     hpaeInnerCapturerManager->GetSinkInputInfo(playStreamInfo.sessionId, sinkInputInfo);
219     hpaeInnerCapturerManager->GetSourceOutputInfo(recordStreamInfo.sessionId, sourceOutoputInfo);
220     hpaeInnerCapturerManager->Stop(recordStreamInfo.sessionId);
221     hpaeInnerCapturerManager->Release(recordStreamInfo.sessionId);
222     hpaeInnerCapturerManager->Release(playStreamInfo.sessionId);
223     WaitForMsgProcessing(hpaeInnerCapturerManager);
224     hpaeInnerCapturerManager->DeInit();
225 }
226 
HpaeInnerCapturerManagerFuzzTest2()227 void HpaeInnerCapturerManagerFuzzTest2()
228 {
229     HpaeSinkInfo sinkInfo = GetInCapSinkInfo();
230     auto hpaeInnerCapturerManager = std::make_shared<HPAE::HpaeInnerCapturerManager>(sinkInfo);
231     hpaeInnerCapturerManager->Init();
232     hpaeInnerCapturerManager->GetThreadName();
233     HpaeStreamInfo recordStreamInfo = GetInCapRecordFuzzStreamInfo();
234     hpaeInnerCapturerManager->CreateStream(recordStreamInfo);
235     uint32_t recordSessionId = GetData<uint32_t>();
236     hpaeInnerCapturerManager->Start(recordSessionId);
237     WaitForMsgProcessing(hpaeInnerCapturerManager);
238     HpaeSourceOutputInfo sourceOutoputInfo;
239 
240     HpaeStreamInfo playStreamInfo = GetInCapPlayFuzzStreamInfo();
241     hpaeInnerCapturerManager->CreateStream(playStreamInfo);
242     WaitForMsgProcessing(hpaeInnerCapturerManager);
243     std::shared_ptr<WriteFixedDataCb> writeInPlayDataCb = std::make_shared<WriteFixedDataCb>(SAMPLE_S16LE);
244     uint32_t playSessionId = GetData<uint32_t>();
245     hpaeInnerCapturerManager->RegisterWriteCallback(playSessionId, writeInPlayDataCb);
246 
247     hpaeInnerCapturerManager->Start(playSessionId);
248     hpaeInnerCapturerManager->Pause(recordSessionId);
249     hpaeInnerCapturerManager->Pause(playSessionId);
250     hpaeInnerCapturerManager->Flush(recordSessionId);
251     hpaeInnerCapturerManager->Drain(playSessionId);
252     WaitForMsgProcessing(hpaeInnerCapturerManager);
253     HpaeSinkInputInfo sinkInputInfo;
254     hpaeInnerCapturerManager->GetSinkInputInfo(playSessionId, sinkInputInfo);
255     hpaeInnerCapturerManager->GetSourceOutputInfo(recordSessionId, sourceOutoputInfo);
256     hpaeInnerCapturerManager->Stop(recordSessionId);
257     hpaeInnerCapturerManager->Release(recordSessionId);
258     hpaeInnerCapturerManager->Release(playSessionId);
259     WaitForMsgProcessing(hpaeInnerCapturerManager);
260     hpaeInnerCapturerManager->DeInit();
261 }
262 
HpaeInnerCapturerManagerFuzzTest3()263 void HpaeInnerCapturerManagerFuzzTest3()
264 {
265     HpaeSinkInfo sinkInfo = GetInCapSinkInfo();
266     auto hpaeInnerCapturerManager = std::make_shared<HPAE::HpaeInnerCapturerManager>(sinkInfo);
267     hpaeInnerCapturerManager->GetThreadName();
268     HpaeStreamInfo recordStreamInfo = GetInCapRecordFuzzStreamInfo();
269     hpaeInnerCapturerManager->CreateStream(recordStreamInfo);
270     uint32_t recordSessionId = GetData<uint32_t>();
271     hpaeInnerCapturerManager->Start(recordSessionId);
272     WaitForMsgProcessing(hpaeInnerCapturerManager);
273     HpaeSourceOutputInfo sourceOutoputInfo;
274 
275     HpaeStreamInfo playStreamInfo = GetInCapPlayFuzzStreamInfo();
276     hpaeInnerCapturerManager->CreateStream(playStreamInfo);
277     WaitForMsgProcessing(hpaeInnerCapturerManager);
278     std::shared_ptr<WriteFixedDataCb> writeInPlayDataCb = std::make_shared<WriteFixedDataCb>(SAMPLE_S16LE);
279     uint32_t playSessionId = GetData<uint32_t>();
280     hpaeInnerCapturerManager->RegisterWriteCallback(playSessionId, writeInPlayDataCb);
281 
282     hpaeInnerCapturerManager->Start(playSessionId);
283     hpaeInnerCapturerManager->Pause(recordSessionId);
284     hpaeInnerCapturerManager->Pause(playSessionId);
285     hpaeInnerCapturerManager->Flush(recordSessionId);
286     hpaeInnerCapturerManager->Drain(playSessionId);
287     WaitForMsgProcessing(hpaeInnerCapturerManager);
288     HpaeSinkInputInfo sinkInputInfo;
289     hpaeInnerCapturerManager->GetSinkInputInfo(playSessionId, sinkInputInfo);
290     hpaeInnerCapturerManager->GetSourceOutputInfo(recordSessionId, sourceOutoputInfo);
291     hpaeInnerCapturerManager->Stop(recordSessionId);
292     hpaeInnerCapturerManager->Release(recordSessionId);
293     hpaeInnerCapturerManager->Release(playSessionId);
294     WaitForMsgProcessing(hpaeInnerCapturerManager);
295     hpaeInnerCapturerManager->DeInit();
296 }
297 
HpaeInnerCapturerManagerAddNodeToSinkFuzzTest1()298 void HpaeInnerCapturerManagerAddNodeToSinkFuzzTest1()
299 {
300     HpaeSinkInfo sinkInfo = GetInCapSinkInfo();
301     auto hpaeInnerCapturerManager = std::make_shared<HPAE::HpaeInnerCapturerManager>(sinkInfo);
302     hpaeInnerCapturerManager->Init();
303     WaitForMsgProcessing(hpaeInnerCapturerManager);
304     HpaeStreamInfo recordStreamInfo = GetInCapRecordStreamInfo();
305     hpaeInnerCapturerManager->CreateStream(recordStreamInfo);
306     hpaeInnerCapturerManager->Start(recordStreamInfo.sessionId);
307     WaitForMsgProcessing(hpaeInnerCapturerManager);
308 
309     HpaeStreamInfo playStreamInfo = GetInCapPlayStreamInfo();
310     hpaeInnerCapturerManager->CreateStream(playStreamInfo);
311     hpaeInnerCapturerManager->Start(playStreamInfo.sessionId);
312     HpaeStreamInfo playSencondStreamInfo = GetInCapPlayStreamInfo();
313     ++playSencondStreamInfo.sessionId;
314     hpaeInnerCapturerManager->CreateStream(playSencondStreamInfo);
315     hpaeInnerCapturerManager->Start(playSencondStreamInfo.sessionId);
316     WaitForMsgProcessing(hpaeInnerCapturerManager);
317     HpaeNodeInfo playSencondNodeInfo;
318     playSencondNodeInfo.sessionId = playSencondStreamInfo.sessionId + 1;
319     playSencondNodeInfo.channels = STEREO;
320     playSencondNodeInfo.format = SAMPLE_S16LE;
321     playSencondNodeInfo.frameLen = DEFAULT_FRAME_LENGTH2;
322     playSencondNodeInfo.samplingRate = SAMPLE_RATE_44100;
323     playSencondNodeInfo.sceneType = HPAE_SCENE_EFFECT_NONE;
324     playSencondNodeInfo.deviceClass = DEFAULT_TEST_DEVICE_CLASS;
325     playSencondNodeInfo.deviceNetId = DEFAULT_TEST_DEVICE_NETWORKID;
326     std::shared_ptr<HpaeSinkInputNode> HpaeSinkInputSencondNode =
327         std::make_shared<HpaeSinkInputNode>(playSencondNodeInfo);
328     hpaeInnerCapturerManager->Release(playStreamInfo.sessionId);
329     WaitForMsgProcessing(hpaeInnerCapturerManager);
330     hpaeInnerCapturerManager->AddSingleNodeToSinkInner(HpaeSinkInputSencondNode, false);
331     hpaeInnerCapturerManager->SuspendStreamManager(true);
332     WaitForMsgProcessing(hpaeInnerCapturerManager);
333     hpaeInnerCapturerManager->AddNodeToSink(HpaeSinkInputSencondNode);
334     hpaeInnerCapturerManager->SuspendStreamManager(false);
335     WaitForMsgProcessing(hpaeInnerCapturerManager);
336     hpaeInnerCapturerManager->Release(playSencondNodeInfo.sessionId);
337     hpaeInnerCapturerManager->Release(playSencondStreamInfo.sessionId);
338     hpaeInnerCapturerManager->Release(recordStreamInfo.sessionId);
339     WaitForMsgProcessing(hpaeInnerCapturerManager);
340     hpaeInnerCapturerManager->DeInit();
341 }
342 
HpaeInnerCapturerManagerAddNodeToSinkFuzzTest2()343 void HpaeInnerCapturerManagerAddNodeToSinkFuzzTest2()
344 {
345     HpaeSinkInfo sinkInfo = GetInCapSinkInfo();
346     auto hpaeInnerCapturerManager = std::make_shared<HPAE::HpaeInnerCapturerManager>(sinkInfo);
347     HpaeStreamInfo recordStreamInfo = GetInCapRecordFuzzStreamInfo();
348     hpaeInnerCapturerManager->CreateStream(recordStreamInfo);
349     uint32_t recordSessionId = GetData<uint32_t>();
350     hpaeInnerCapturerManager->Start(recordSessionId);
351 
352     HpaeStreamInfo playStreamInfo = GetInCapPlayFuzzStreamInfo();
353     uint32_t playSessionId = GetData<uint32_t>();
354     hpaeInnerCapturerManager->CreateStream(playStreamInfo);
355     hpaeInnerCapturerManager->Start(playSessionId);
356     HpaeStreamInfo playSencondStreamInfo = GetInCapPlayFuzzStreamInfo();
357     ++playSencondStreamInfo.sessionId;
358     hpaeInnerCapturerManager->CreateStream(playSencondStreamInfo);
359     hpaeInnerCapturerManager->Start(playSencondStreamInfo.sessionId);
360     WaitForMsgProcessing(hpaeInnerCapturerManager);
361     HpaeNodeInfo playSencondNodeInfo;
362     playSencondNodeInfo.sessionId = GetData<uint32_t>();
363     playSencondNodeInfo.channels = STEREO;
364     playSencondNodeInfo.format = SAMPLE_S16LE;
365     playSencondNodeInfo.frameLen = GetData<uint64_t>();
366     playSencondNodeInfo.samplingRate = SAMPLE_RATE_44100;
367     playSencondNodeInfo.sceneType = HPAE_SCENE_EFFECT_NONE;
368     playSencondNodeInfo.deviceClass = DEFAULT_TEST_DEVICE_CLASS;
369     playSencondNodeInfo.deviceNetId = DEFAULT_TEST_DEVICE_NETWORKID;
370     std::shared_ptr<HpaeSinkInputNode> HpaeSinkInputSencondNode =
371         std::make_shared<HpaeSinkInputNode>(playSencondNodeInfo);
372     hpaeInnerCapturerManager->Release(playSessionId);
373     WaitForMsgProcessing(hpaeInnerCapturerManager);
374     bool isConnect = GetData<bool>();
375     hpaeInnerCapturerManager->AddSingleNodeToSinkInner(HpaeSinkInputSencondNode, isConnect);
376     bool isSuspend1 = GetData<bool>();
377     hpaeInnerCapturerManager->SuspendStreamManager(isSuspend1);
378     WaitForMsgProcessing(hpaeInnerCapturerManager);
379     hpaeInnerCapturerManager->AddNodeToSink(HpaeSinkInputSencondNode);
380     bool isSuspend2 = GetData<bool>();
381     hpaeInnerCapturerManager->SuspendStreamManager(isSuspend2);
382     WaitForMsgProcessing(hpaeInnerCapturerManager);
383     hpaeInnerCapturerManager->Release(playSencondNodeInfo.sessionId);
384     hpaeInnerCapturerManager->Release(playSencondStreamInfo.sessionId);
385     hpaeInnerCapturerManager->Release(recordSessionId);
386     WaitForMsgProcessing(hpaeInnerCapturerManager);
387     hpaeInnerCapturerManager->DeInit();
388 }
389 
HpaeInnerCapturerManagerAddNodeToSinkFuzzTest3()390 void HpaeInnerCapturerManagerAddNodeToSinkFuzzTest3()
391 {
392     HpaeSinkInfo sinkInfo = GetInCapSinkInfo();
393     auto hpaeInnerCapturerManager = std::make_shared<HPAE::HpaeInnerCapturerManager>(sinkInfo);
394     hpaeInnerCapturerManager->Init();
395     WaitForMsgProcessing(hpaeInnerCapturerManager);
396     HpaeStreamInfo recordStreamInfo = GetInCapRecordFuzzStreamInfo();
397     hpaeInnerCapturerManager->CreateStream(recordStreamInfo);
398     uint32_t recordSessionId = GetData<uint32_t>();
399     hpaeInnerCapturerManager->Start(recordSessionId);
400 
401     HpaeStreamInfo playStreamInfo = GetInCapPlayFuzzStreamInfo();
402     uint32_t playSessionId = GetData<uint32_t>();
403     hpaeInnerCapturerManager->CreateStream(playStreamInfo);
404     hpaeInnerCapturerManager->Start(playSessionId);
405     HpaeStreamInfo playSencondStreamInfo = GetInCapPlayFuzzStreamInfo();
406     ++playSencondStreamInfo.sessionId;
407     hpaeInnerCapturerManager->CreateStream(playSencondStreamInfo);
408     hpaeInnerCapturerManager->Start(playSencondStreamInfo.sessionId);
409     WaitForMsgProcessing(hpaeInnerCapturerManager);
410     HpaeNodeInfo playSencondNodeInfo;
411     playSencondNodeInfo.sessionId = GetData<uint32_t>();
412     playSencondNodeInfo.channels = STEREO;
413     playSencondNodeInfo.format = SAMPLE_S16LE;
414     playSencondNodeInfo.frameLen = GetData<uint64_t>();
415     playSencondNodeInfo.samplingRate = SAMPLE_RATE_44100;
416     playSencondNodeInfo.sceneType = HPAE_SCENE_EFFECT_NONE;
417     playSencondNodeInfo.deviceClass = DEFAULT_TEST_DEVICE_CLASS;
418     playSencondNodeInfo.deviceNetId = DEFAULT_TEST_DEVICE_NETWORKID;
419     std::shared_ptr<HpaeSinkInputNode> HpaeSinkInputSencondNode =
420         std::make_shared<HpaeSinkInputNode>(playSencondNodeInfo);
421     hpaeInnerCapturerManager->Release(playSessionId);
422     WaitForMsgProcessing(hpaeInnerCapturerManager);
423     bool isConnect = GetData<bool>();
424     hpaeInnerCapturerManager->AddSingleNodeToSinkInner(HpaeSinkInputSencondNode, isConnect);
425     bool isSuspend1 = GetData<bool>();
426     hpaeInnerCapturerManager->SuspendStreamManager(isSuspend1);
427     WaitForMsgProcessing(hpaeInnerCapturerManager);
428     hpaeInnerCapturerManager->AddNodeToSink(HpaeSinkInputSencondNode);
429     bool isSuspend2 = GetData<bool>();
430     hpaeInnerCapturerManager->SuspendStreamManager(isSuspend2);
431     WaitForMsgProcessing(hpaeInnerCapturerManager);
432     hpaeInnerCapturerManager->Release(playSencondNodeInfo.sessionId);
433     hpaeInnerCapturerManager->Release(playSencondStreamInfo.sessionId);
434     hpaeInnerCapturerManager->Release(recordSessionId);
435     WaitForMsgProcessing(hpaeInnerCapturerManager);
436     hpaeInnerCapturerManager->DeInit();
437 }
438 
HpaeInnerCapturerManagerOtherFuzzTest1()439 void HpaeInnerCapturerManagerOtherFuzzTest1()
440 {
441     HpaeSinkInfo sinkInfo = GetInCapSinkInfo();
442     auto hpaeInnerCapturerManager = std::make_shared<HPAE::HpaeInnerCapturerManager>(sinkInfo);
443     hpaeInnerCapturerManager->Init();
444     WaitForMsgProcessing(hpaeInnerCapturerManager);
445     HpaeStreamInfo recordStreamInfo = GetInCapRecordStreamInfo();
446     hpaeInnerCapturerManager->CreateStream(recordStreamInfo);
447     WaitForMsgProcessing(hpaeInnerCapturerManager);
448     hpaeInnerCapturerManager->Start(recordStreamInfo.sessionId);
449     WaitForMsgProcessing(hpaeInnerCapturerManager);
450 
451     HpaeStreamInfo playStreamInfo = GetInCapPlayStreamInfo();
452     hpaeInnerCapturerManager->CreateStream(playStreamInfo);
453     WaitForMsgProcessing(hpaeInnerCapturerManager);
454     std::shared_ptr<WriteFixedDataCb> writeInPlayDataCb = std::make_shared<WriteFixedDataCb>(SAMPLE_S16LE);
455     hpaeInnerCapturerManager->RegisterWriteCallback(playStreamInfo.sessionId, writeInPlayDataCb);
456     hpaeInnerCapturerManager->Start(playStreamInfo.sessionId);
457     WaitForMsgProcessing(hpaeInnerCapturerManager);
458 
459     hpaeInnerCapturerManager->GetAllSinkInputsInfo();
460     hpaeInnerCapturerManager->GetAllSourceOutputsInfo();
461     hpaeInnerCapturerManager->GetSinkInfo();
462     hpaeInnerCapturerManager->GetDeviceHDFDumpInfo();
463     WaitForMsgProcessing(hpaeInnerCapturerManager);
464     int32_t testVariable = 1;
465     hpaeInnerCapturerManager->SetClientVolume(playStreamInfo.sessionId, 1.0f);
466     hpaeInnerCapturerManager->SetRate(playStreamInfo.sessionId, testVariable);
467     hpaeInnerCapturerManager->SetAudioEffectMode(playStreamInfo.sessionId, testVariable);
468     hpaeInnerCapturerManager->GetAudioEffectMode(playStreamInfo.sessionId, testVariable);
469     hpaeInnerCapturerManager->SetPrivacyType(playStreamInfo.sessionId, testVariable);
470     hpaeInnerCapturerManager->GetPrivacyType(playStreamInfo.sessionId, testVariable);
471     hpaeInnerCapturerManager->GetWritableSize(playStreamInfo.sessionId);
472     hpaeInnerCapturerManager->UpdateSpatializationState(playStreamInfo.sessionId, true, true);
473     hpaeInnerCapturerManager->UpdateMaxLength(playStreamInfo.sessionId, testVariable);
474     hpaeInnerCapturerManager->SetClientVolume(playStreamInfo.sessionId, 1.0f);
475     bool isMute = GetData<bool>();
476     hpaeInnerCapturerManager->SetMute(isMute);
477     WaitForMsgProcessing(hpaeInnerCapturerManager);
478     hpaeInnerCapturerManager->DeInit();
479 }
480 
HpaeInnerCapturerManagerOtherFuzzTest2()481 void HpaeInnerCapturerManagerOtherFuzzTest2()
482 {
483     HpaeSinkInfo sinkInfo = GetInCapSinkInfo();
484     auto hpaeInnerCapturerManager = std::make_shared<HPAE::HpaeInnerCapturerManager>(sinkInfo);
485     HpaeStreamInfo recordStreamInfo = GetInCapRecordFuzzStreamInfo();
486     hpaeInnerCapturerManager->CreateStream(recordStreamInfo);
487     uint32_t recordSessionId = GetData<uint32_t>();
488     WaitForMsgProcessing(hpaeInnerCapturerManager);
489     hpaeInnerCapturerManager->Start(recordSessionId);
490     WaitForMsgProcessing(hpaeInnerCapturerManager);
491 
492     HpaeStreamInfo playStreamInfo = GetInCapPlayFuzzStreamInfo();
493     hpaeInnerCapturerManager->CreateStream(playStreamInfo);
494     WaitForMsgProcessing(hpaeInnerCapturerManager);
495 
496     std::shared_ptr<WriteFixedDataCb> writeInPlayDataCb = std::make_shared<WriteFixedDataCb>(SAMPLE_S16LE);
497     uint32_t playSessionId = GetData<uint32_t>();
498     hpaeInnerCapturerManager->RegisterWriteCallback(playSessionId, writeInPlayDataCb);
499     hpaeInnerCapturerManager->Start(playSessionId);
500     WaitForMsgProcessing(hpaeInnerCapturerManager);
501 
502     hpaeInnerCapturerManager->GetAllSinkInputsInfo();
503     hpaeInnerCapturerManager->GetAllSourceOutputsInfo();
504     hpaeInnerCapturerManager->GetSinkInfo();
505     hpaeInnerCapturerManager->GetDeviceHDFDumpInfo();
506     WaitForMsgProcessing(hpaeInnerCapturerManager);
507     int32_t testVariable = GetData<int32_t>();
508     float volume = GetData<float>();
509     hpaeInnerCapturerManager->SetClientVolume(playSessionId, volume);
510     hpaeInnerCapturerManager->SetRate(playSessionId, testVariable);
511     hpaeInnerCapturerManager->SetAudioEffectMode(playSessionId, testVariable);
512     hpaeInnerCapturerManager->GetAudioEffectMode(playSessionId, testVariable);
513     hpaeInnerCapturerManager->SetPrivacyType(playSessionId, testVariable);
514     hpaeInnerCapturerManager->GetPrivacyType(playSessionId, testVariable);
515     hpaeInnerCapturerManager->GetWritableSize(playSessionId);
516     hpaeInnerCapturerManager->UpdateSpatializationState(playSessionId, true, true);
517     hpaeInnerCapturerManager->UpdateMaxLength(playSessionId, testVariable);
518     hpaeInnerCapturerManager->SetClientVolume(playSessionId, volume);
519     bool isMute = GetData<bool>();
520     hpaeInnerCapturerManager->SetMute(isMute);
521     WaitForMsgProcessing(hpaeInnerCapturerManager);
522     hpaeInnerCapturerManager->DeInit();
523 }
524 
HpaeInnerCapturerManagerOtherFuzzTest3()525 void HpaeInnerCapturerManagerOtherFuzzTest3()
526 {
527     HpaeSinkInfo sinkInfo = GetInCapSinkInfo();
528     auto hpaeInnerCapturerManager = std::make_shared<HPAE::HpaeInnerCapturerManager>(sinkInfo);
529     hpaeInnerCapturerManager->Init();
530     WaitForMsgProcessing(hpaeInnerCapturerManager);
531     HpaeStreamInfo recordStreamInfo = GetInCapRecordFuzzStreamInfo();
532     hpaeInnerCapturerManager->CreateStream(recordStreamInfo);
533     uint32_t recordSessionId = GetData<uint32_t>();
534     WaitForMsgProcessing(hpaeInnerCapturerManager);
535     hpaeInnerCapturerManager->Start(recordSessionId);
536     WaitForMsgProcessing(hpaeInnerCapturerManager);
537 
538     HpaeStreamInfo playStreamInfo = GetInCapPlayFuzzStreamInfo();
539     hpaeInnerCapturerManager->CreateStream(playStreamInfo);
540     WaitForMsgProcessing(hpaeInnerCapturerManager);
541 
542     std::shared_ptr<WriteFixedDataCb> writeInPlayDataCb = std::make_shared<WriteFixedDataCb>(SAMPLE_S16LE);
543     uint32_t playSessionId = GetData<uint32_t>();
544     hpaeInnerCapturerManager->RegisterWriteCallback(playSessionId, writeInPlayDataCb);
545     hpaeInnerCapturerManager->Start(playSessionId);
546     WaitForMsgProcessing(hpaeInnerCapturerManager);
547 
548     hpaeInnerCapturerManager->GetAllSinkInputsInfo();
549     hpaeInnerCapturerManager->GetAllSourceOutputsInfo();
550     hpaeInnerCapturerManager->GetSinkInfo();
551     hpaeInnerCapturerManager->GetDeviceHDFDumpInfo();
552     WaitForMsgProcessing(hpaeInnerCapturerManager);
553     int32_t testVariable = GetData<int32_t>();
554     float volume = GetData<float>();
555     hpaeInnerCapturerManager->SetClientVolume(playSessionId, volume);
556     hpaeInnerCapturerManager->SetRate(playSessionId, testVariable);
557     hpaeInnerCapturerManager->SetAudioEffectMode(playSessionId, testVariable);
558     hpaeInnerCapturerManager->GetAudioEffectMode(playSessionId, testVariable);
559     hpaeInnerCapturerManager->SetPrivacyType(playSessionId, testVariable);
560     hpaeInnerCapturerManager->GetPrivacyType(playSessionId, testVariable);
561     hpaeInnerCapturerManager->GetWritableSize(playSessionId);
562     hpaeInnerCapturerManager->UpdateSpatializationState(playSessionId, true, true);
563     hpaeInnerCapturerManager->UpdateMaxLength(playSessionId, testVariable);
564     hpaeInnerCapturerManager->SetClientVolume(playSessionId, volume);
565     bool isMute = GetData<bool>();
566     hpaeInnerCapturerManager->SetMute(isMute);
567     WaitForMsgProcessing(hpaeInnerCapturerManager);
568     hpaeInnerCapturerManager->DeInit();
569 }
570 
HpaeInnerCapturerManagerReloadFuzzTest1()571 void HpaeInnerCapturerManagerReloadFuzzTest1()
572 {
573     HpaeSinkInfo sinkInfo = GetInCapSinkInfo();
574     auto hpaeInnerCapturerManager = std::make_shared<HPAE::HpaeInnerCapturerManager>(sinkInfo);
575     hpaeInnerCapturerManager->Init();
576     WaitForMsgProcessing(hpaeInnerCapturerManager);
577     HpaeStreamInfo playStreamInfo = GetInCapPlayStreamInfo();
578     ++playStreamInfo.sessionId;
579     hpaeInnerCapturerManager->CreateStream(playStreamInfo);
580     WaitForMsgProcessing(hpaeInnerCapturerManager);
581     hpaeInnerCapturerManager->ReloadRenderManager(sinkInfo, false);
582     WaitForMsgProcessing(hpaeInnerCapturerManager);
583     hpaeInnerCapturerManager->ReloadRenderManager(sinkInfo, true);
584     WaitForMsgProcessing(hpaeInnerCapturerManager);
585     hpaeInnerCapturerManager->DeInit();
586     hpaeInnerCapturerManager->ReloadRenderManager(sinkInfo, true);
587     WaitForMsgProcessing(hpaeInnerCapturerManager);
588     hpaeInnerCapturerManager->DeInit();
589 }
590 
HpaeInnerCapturerManagerReloadFuzzTest2()591 void HpaeInnerCapturerManagerReloadFuzzTest2()
592 {
593     HpaeSinkInfo sinkInfo = GetInCapFuzzSinkInfo();
594     auto hpaeInnerCapturerManager = std::make_shared<HPAE::HpaeInnerCapturerManager>(sinkInfo);
595     hpaeInnerCapturerManager->Init();
596     WaitForMsgProcessing(hpaeInnerCapturerManager);
597     HpaeStreamInfo playStreamInfo = GetInCapPlayFuzzStreamInfo();
598     ++playStreamInfo.sessionId;
599     hpaeInnerCapturerManager->CreateStream(playStreamInfo);
600     WaitForMsgProcessing(hpaeInnerCapturerManager);
601     bool isReload = GetData<bool>();
602     hpaeInnerCapturerManager->ReloadRenderManager(sinkInfo, isReload);
603     WaitForMsgProcessing(hpaeInnerCapturerManager);
604     isReload = GetData<bool>();
605     hpaeInnerCapturerManager->ReloadRenderManager(sinkInfo, isReload);
606     WaitForMsgProcessing(hpaeInnerCapturerManager);
607     hpaeInnerCapturerManager->DeInit();
608     isReload = GetData<bool>();
609     hpaeInnerCapturerManager->ReloadRenderManager(sinkInfo, isReload);
610     WaitForMsgProcessing(hpaeInnerCapturerManager);
611     hpaeInnerCapturerManager->DeInit();
612 }
613 
HpaeInnerCapturerManagerReloadFuzzTest3()614 void HpaeInnerCapturerManagerReloadFuzzTest3()
615 {
616     HpaeSinkInfo sinkInfo = GetInCapFuzzSinkInfo();
617     auto hpaeInnerCapturerManager = std::make_shared<HPAE::HpaeInnerCapturerManager>(sinkInfo);
618     hpaeInnerCapturerManager->Init();
619     WaitForMsgProcessing(hpaeInnerCapturerManager);
620     HpaeStreamInfo playStreamInfo = GetInCapPlayFuzzStreamInfo();
621     ++playStreamInfo.sessionId;
622     hpaeInnerCapturerManager->CreateStream(playStreamInfo);
623     WaitForMsgProcessing(hpaeInnerCapturerManager);
624     bool isReload = GetData<bool>();
625     hpaeInnerCapturerManager->ReloadRenderManager(sinkInfo, isReload);
626     WaitForMsgProcessing(hpaeInnerCapturerManager);
627     isReload = GetData<bool>();
628     hpaeInnerCapturerManager->ReloadRenderManager(sinkInfo, isReload);
629     WaitForMsgProcessing(hpaeInnerCapturerManager);
630     hpaeInnerCapturerManager->DeInit();
631     isReload = GetData<bool>();
632     hpaeInnerCapturerManager->ReloadRenderManager(sinkInfo, isReload);
633     WaitForMsgProcessing(hpaeInnerCapturerManager);
634     hpaeInnerCapturerManager->DeInit();
635 }
636 
MoveStreamFuzzTest()637 void MoveStreamFuzzTest()
638 {
639     HpaeSinkInfo sinkInfo;
640     auto hpaeInnerCapturerManager = std::make_shared<HpaeInnerCapturerManager>(sinkInfo);
641     hpaeInnerCapturerManager->Init();
642     uint32_t sessionId = GetData<uint32_t>();
643     std::string sinkName = "13222";
644     hpaeInnerCapturerManager->MoveStream(sessionId, sinkName);
645     WaitForMsgProcessing(hpaeInnerCapturerManager);
646     hpaeInnerCapturerManager->DeInit();
647 }
648 
MoveAllStreamFuzzTest()649 void MoveAllStreamFuzzTest()
650 {
651     HpaeSinkInfo sinkInfo;
652     auto hpaeInnerCapturerManager = std::make_shared<HpaeInnerCapturerManager>(sinkInfo);
653     hpaeInnerCapturerManager->Init();
654     std::vector<uint32_t> sessionId = {GetData<uint32_t>(), GetData<uint32_t>(), GetData<uint32_t>()};
655     std::string sinkName = "13222";
656     hpaeInnerCapturerManager->MoveAllStream(sinkName, sessionId);
657     WaitForMsgProcessing(hpaeInnerCapturerManager);
658     hpaeInnerCapturerManager->DeInit();
659 }
660 
OnNodeStatusUpdateFuzzTest()661 void OnNodeStatusUpdateFuzzTest()
662 {
663     HpaeSinkInfo sinkInfo;
664     auto hpaeInnerCapturerManager = std::make_shared<HpaeInnerCapturerManager>(sinkInfo);
665     hpaeInnerCapturerManager->Init();
666     uint32_t sessionId = GetData<uint32_t>();
667     IOperation operation = IOperation::OPERATION_INVALID;
668     hpaeInnerCapturerManager->OnNodeStatusUpdate(sessionId, operation);
669     WaitForMsgProcessing(hpaeInnerCapturerManager);
670     hpaeInnerCapturerManager->DeInit();
671 }
672 
OnFadeDoneFuzzTest()673 void OnFadeDoneFuzzTest()
674 {
675     HpaeSinkInfo sinkInfo;
676     auto hpaeInnerCapturerManager = std::make_shared<HpaeInnerCapturerManager>(sinkInfo);
677     hpaeInnerCapturerManager->Init();
678     uint32_t sessionId = GetData<uint32_t>();
679     IOperation operation = IOperation::OPERATION_INVALID;
680     hpaeInnerCapturerManager->OnFadeDone(sessionId, operation);
681     WaitForMsgProcessing(hpaeInnerCapturerManager);
682     hpaeInnerCapturerManager->DeInit();
683 }
684 
685 typedef void (*TestFuncs[16])();
686 
687 TestFuncs g_testFuncs = {
688     HpaeInnerCapturerManagerFuzzTest1,
689     HpaeInnerCapturerManagerFuzzTest2,
690     HpaeInnerCapturerManagerFuzzTest3,
691     HpaeInnerCapturerManagerAddNodeToSinkFuzzTest1,
692     HpaeInnerCapturerManagerAddNodeToSinkFuzzTest2,
693     HpaeInnerCapturerManagerAddNodeToSinkFuzzTest3,
694     HpaeInnerCapturerManagerOtherFuzzTest1,
695     HpaeInnerCapturerManagerOtherFuzzTest2,
696     HpaeInnerCapturerManagerOtherFuzzTest3,
697     HpaeInnerCapturerManagerReloadFuzzTest1,
698     HpaeInnerCapturerManagerReloadFuzzTest2,
699     HpaeInnerCapturerManagerReloadFuzzTest3,
700     MoveStreamFuzzTest,
701     MoveAllStreamFuzzTest,
702     OnNodeStatusUpdateFuzzTest,
703     OnFadeDoneFuzzTest,
704 };
705 
FuzzTest(const uint8_t * rawData,size_t size)706 bool FuzzTest(const uint8_t *rawData, size_t size)
707 {
708     if (rawData == nullptr) {
709         return false;
710     }
711 
712     // initialize data
713     RAW_DATA = rawData;
714     g_dataSize = size;
715     g_pos = 0;
716 
717     uint32_t code = GetData<uint32_t>();
718     uint32_t len = GetArrLength(g_testFuncs);
719     if (len > 0) {
720         g_testFuncs[code % len]();
721     } else {
722         AUDIO_INFO_LOG("%{public}s: The len length is equal to 0", __func__);
723     }
724 
725     return true;
726 }
727 
728 } // namespace AudioStandard
729 } // namespace OHOS
730 
731 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)732 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
733 {
734     if (size < OHOS::AudioStandard::THRESHOLD) {
735         return 0;
736     }
737 
738     OHOS::AudioStandard::FuzzTest(data, size);
739     return 0;
740 }