1 /*
2 * Copyright (c) 2024-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 <fstream>
17 #include <securec.h>
18
19 #include "hpae_format_convert.h"
20 #include "hpae_mixer_node.h"
21 #include "hpae_node_common.h"
22 #include "hpae_pcm_dumper.h"
23 #include "hpae_process_cluster.h"
24 #include "hpae_sink_input_node.h"
25 #include "../fuzz_utils.h"
26
27 using namespace std;
28 using namespace OHOS::AudioStandard::HPAE;
29
30 namespace OHOS {
31 namespace AudioStandard {
32
33 FuzzUtils &g_fuzzUtils = FuzzUtils::GetInstance();
34 const size_t FUZZ_INPUT_SIZE_THRESHOLD = 10;
35 const uint32_t DEFAULT_FRAME_LENGTH = 960; // 20ms at 48kHz
36 const uint32_t DEFAULT_CHANNEL_COUNT = 2;
37 const uint32_t DEFAULT_SAMPLE_RATE = 48000;
38 const uint32_t TEST_ID = 1243;
39 typedef void (*TestPtr)();
40
GetTestNodeInfo(HpaeNodeInfo & nodeInfo)41 static void GetTestNodeInfo(HpaeNodeInfo &nodeInfo)
42 {
43 nodeInfo.nodeId = TEST_ID;
44 nodeInfo.frameLen = DEFAULT_FRAME_LENGTH;
45 nodeInfo.samplingRate = SAMPLE_RATE_48000;
46 nodeInfo.channels = STEREO;
47 nodeInfo.format = SAMPLE_F32LE;
48 }
49
CreateBufferInfo(uint32_t frames,bool multiFrames=false)50 PcmBufferInfo CreateBufferInfo(uint32_t frames, bool multiFrames = false)
51 {
52 PcmBufferInfo info;
53 info.ch = DEFAULT_CHANNEL_COUNT;
54 info.frameLen = DEFAULT_FRAME_LENGTH;
55 info.rate = DEFAULT_SAMPLE_RATE;
56 info.frames = frames;
57 info.isMultiFrames = multiFrames;
58 return info;
59 }
60
HpaeMixerNodeSignalProcessFuzzTest()61 void HpaeMixerNodeSignalProcessFuzzTest()
62 {
63 HpaeNodeInfo nodeInfo;
64 GetTestNodeInfo(nodeInfo);
65 std::shared_ptr<HpaeMixerNode> hpaeMixerNode = std::make_shared<HpaeMixerNode>(nodeInfo);
66 if (hpaeMixerNode == nullptr) {
67 return;
68 }
69 PcmBufferInfo pcmBufferInfo(0, 1, g_fuzzUtils.GetData<uint32_t>());
70 HpaePcmBuffer hpaePcmBuffer(pcmBufferInfo);
71 std::vector<HpaePcmBuffer *> inputs;
72 inputs.push_back(&hpaePcmBuffer);
73 hpaeMixerNode->SignalProcess(inputs);
74 }
75
HpaeMixerNodeCheckUpdateInfoFuzzTest()76 void HpaeMixerNodeCheckUpdateInfoFuzzTest()
77 {
78 HpaeNodeInfo nodeInfo;
79 GetTestNodeInfo(nodeInfo);
80 std::shared_ptr<HpaeMixerNode> hpaeMixerNode = std::make_shared<HpaeMixerNode>(nodeInfo);
81 if (hpaeMixerNode == nullptr) {
82 return;
83 }
84 PcmBufferInfo pcmBufferInfo(0, 1, g_fuzzUtils.GetData<uint32_t>());
85 HpaePcmBuffer hpaePcmBuffer(pcmBufferInfo);
86 hpaeMixerNode->CheckUpdateInfo(&hpaePcmBuffer);
87 }
88
HpaeMixerNodeCheckUpdateInfoForDisConnectFuzzTest()89 void HpaeMixerNodeCheckUpdateInfoForDisConnectFuzzTest()
90 {
91 HpaeNodeInfo nodeInfo;
92 GetTestNodeInfo(nodeInfo);
93 std::shared_ptr<HpaeMixerNode> hpaeMixerNode = std::make_shared<HpaeMixerNode>(nodeInfo);
94 if (hpaeMixerNode == nullptr) {
95 return;
96 }
97 hpaeMixerNode->pcmBufferInfo_ = CreateBufferInfo(g_fuzzUtils.GetData<uint32_t>());
98 hpaeMixerNode->CheckUpdateInfoForDisConnect();
99 }
100
HpaeMixerNodeDrainProcessFuzzTest()101 void HpaeMixerNodeDrainProcessFuzzTest()
102 {
103 HpaeNodeInfo nodeInfo;
104 GetTestNodeInfo(nodeInfo);
105 std::shared_ptr<HpaeMixerNode> hpaeMixerNode = std::make_shared<HpaeMixerNode>(nodeInfo);
106 if (hpaeMixerNode == nullptr) {
107 return;
108 }
109 hpaeMixerNode->DrainProcess();
110 }
111
HpaeNodeCommonTransStreamTypeToSceneTypeFuzzTest()112 void HpaeNodeCommonTransStreamTypeToSceneTypeFuzzTest()
113 {
114 AudioStreamType streamType = g_fuzzUtils.GetData<AudioStreamType>();
115 TransStreamTypeToSceneType(streamType);
116 }
117
HpaeNodeCommonTransNodeInfoForCollaborationFuzzTest()118 void HpaeNodeCommonTransNodeInfoForCollaborationFuzzTest()
119 {
120 HpaeNodeInfo nodeInfo;
121 GetTestNodeInfo(nodeInfo);
122 nodeInfo.effectInfo.effectScene = g_fuzzUtils.GetData<AudioEffectScene>();
123 bool isCollaborationEnabled = g_fuzzUtils.GetData<bool>();
124 TransNodeInfoForCollaboration(nodeInfo, isCollaborationEnabled);
125 }
126
HpaeNodeCommonTransSourceTypeToSceneTypeFuzzTest()127 void HpaeNodeCommonTransSourceTypeToSceneTypeFuzzTest()
128 {
129 SourceType sourceType = g_fuzzUtils.GetData<SourceType>();
130 TransSourceTypeToSceneType(sourceType);
131 }
132
HpaeNodeCommonCheckSceneTypeNeedMicRefFuzzTest()133 void HpaeNodeCommonCheckSceneTypeNeedMicRefFuzzTest()
134 {
135 HpaeProcessorType processorType = g_fuzzUtils.GetData<HpaeProcessorType>();
136 CheckSceneTypeNeedEc(processorType);
137 CheckSceneTypeNeedMicRef(processorType);
138 }
139
HpaeNodeCommonTransProcessType2EnhanceSceneFuzzTest()140 void HpaeNodeCommonTransProcessType2EnhanceSceneFuzzTest()
141 {
142 HpaeProcessorType processorType = g_fuzzUtils.GetData<HpaeProcessorType>();
143 TransProcessType2EnhanceScene(processorType);
144 }
145
HpaeNodeCommonConvertUsToFrameCountFuzzTest()146 void HpaeNodeCommonConvertUsToFrameCountFuzzTest()
147 {
148 HpaeNodeInfo nodeInfo;
149 GetTestNodeInfo(nodeInfo);
150 uint64_t usTime = g_fuzzUtils.GetData<uint64_t>();
151 ConvertUsToFrameCount(usTime, nodeInfo);
152 }
153
HpaeNodeCommonConvertDatalenToUsFuzzTest()154 void HpaeNodeCommonConvertDatalenToUsFuzzTest()
155 {
156 HpaeNodeInfo nodeInfo;
157 GetTestNodeInfo(nodeInfo);
158 size_t bufferSize = g_fuzzUtils.GetData<size_t>();
159 ConvertDatalenToUs(bufferSize, nodeInfo);
160 }
161
HpaeNodeCommonAdjustMchSinkInfoFuzzTest()162 void HpaeNodeCommonAdjustMchSinkInfoFuzzTest()
163 {
164 AudioModuleInfo audioModuleInfo;
165 audioModuleInfo.channelLayout = "CH_LAYOUT_STEREO";
166 HpaeSinkInfo sinkInfo;
167 sinkInfo.deviceName = "DP_MCH_speaker";
168 bool isTestString = g_fuzzUtils.GetData<bool>();
169 if (isTestString) {
170 sinkInfo.deviceName = "test_device_name";
171 }
172
173 AdjustMchSinkInfo(audioModuleInfo, sinkInfo);
174 }
175
HpaeNodeCommonCheckSourceInfoIsDifferentFuzzTest()176 void HpaeNodeCommonCheckSourceInfoIsDifferentFuzzTest()
177 {
178 HpaeSourceInfo oldInfo;
179 oldInfo.sourceId = g_fuzzUtils.GetData<uint32_t>();
180 oldInfo.deviceNetId = "old_test_device_net_id";
181 oldInfo.deviceClass = "old_test_device_class";
182 oldInfo.adapterName = "old_test_adapter_name";
183 oldInfo.sourceName = "old_test_source_name";
184 oldInfo.sourceType = g_fuzzUtils.GetData<SourceType>();
185 oldInfo.filePath = "old_test_file_path";
186 oldInfo.deviceName = "old_test_device_name";
187 HpaeSourceInfo info;
188 info.sourceId = g_fuzzUtils.GetData<uint32_t>();
189 info.deviceNetId = "test_device_net_id";
190 info.deviceClass = "test_device_class";
191 info.adapterName = "test_adapter_name";
192 info.sourceName = "test_source_name";
193 info.sourceType = g_fuzzUtils.GetData<SourceType>();
194 info.filePath = "test_file_path";
195 info.deviceName = "test_device_name";
196
197 CheckSourceInfoIsDifferent(info, oldInfo);
198 }
199
HpaeNodeCommonRecoverNodeInfoForCollaborationFuzzTest()200 void HpaeNodeCommonRecoverNodeInfoForCollaborationFuzzTest()
201 {
202 HpaeNodeInfo nodeInfo;
203 GetTestNodeInfo(nodeInfo);
204 nodeInfo.effectInfo.effectScene = g_fuzzUtils.GetData<AudioEffectScene>();
205
206 RecoverNodeInfoForCollaboration(nodeInfo);
207 }
208
HpaeProcessClusterDoProcessFuzzTest()209 void HpaeProcessClusterDoProcessFuzzTest()
210 {
211 HpaeNodeInfo nodeInfo;
212 GetTestNodeInfo(nodeInfo);
213 HpaeSinkInfo dummySinkInfo;
214 dummySinkInfo.sinkId = g_fuzzUtils.GetData<uint32_t>();
215 std::shared_ptr<HpaeProcessCluster> hpaeProcessCluster =
216 std::make_shared<HpaeProcessCluster>(nodeInfo, dummySinkInfo);
217 if (hpaeProcessCluster == nullptr) {
218 return;
219 }
220 hpaeProcessCluster->DoProcess();
221 }
222
HpaeProcessClusterGetConverterNodeCountFuzzTest()223 void HpaeProcessClusterGetConverterNodeCountFuzzTest()
224 {
225 HpaeNodeInfo nodeInfo;
226 GetTestNodeInfo(nodeInfo);
227 HpaeSinkInfo dummySinkInfo;
228 dummySinkInfo.sinkId = g_fuzzUtils.GetData<uint32_t>();
229 std::shared_ptr<HpaeProcessCluster> hpaeProcessCluster =
230 std::make_shared<HpaeProcessCluster>(nodeInfo, dummySinkInfo);
231 if (hpaeProcessCluster == nullptr) {
232 return;
233 }
234 hpaeProcessCluster->ResetAll();
235 hpaeProcessCluster->GetGainNodeCount();
236 hpaeProcessCluster->GetConverterNodeCount();
237 }
238
HpaeProcessClusterConnectMixerNodeFuzzTest()239 void HpaeProcessClusterConnectMixerNodeFuzzTest()
240 {
241 HpaeNodeInfo nodeInfo;
242 GetTestNodeInfo(nodeInfo);
243 HpaeSinkInfo dummySinkInfo;
244 dummySinkInfo.sinkId = g_fuzzUtils.GetData<uint32_t>();
245 std::shared_ptr<HpaeProcessCluster> hpaeProcessCluster =
246 std::make_shared<HpaeProcessCluster>(nodeInfo, dummySinkInfo);
247 if (hpaeProcessCluster == nullptr) {
248 return;
249 }
250 hpaeProcessCluster->ConnectMixerNode();
251 }
252
HpaeProcessClusterCreateGainNodeFuzzTest()253 void HpaeProcessClusterCreateGainNodeFuzzTest()
254 {
255 HpaeNodeInfo nodeInfo;
256 GetTestNodeInfo(nodeInfo);
257 HpaeSinkInfo dummySinkInfo;
258 dummySinkInfo.sinkId = g_fuzzUtils.GetData<uint32_t>();
259 std::shared_ptr<HpaeProcessCluster> hpaeProcessCluster =
260 std::make_shared<HpaeProcessCluster>(nodeInfo, dummySinkInfo);
261 if (hpaeProcessCluster == nullptr) {
262 return;
263 }
264 uint32_t sessionId = g_fuzzUtils.GetData<uint32_t>();
265 HpaeNodeInfo preNodeInfo;
266 GetTestNodeInfo(preNodeInfo);
267 hpaeProcessCluster->CreateGainNode(sessionId, preNodeInfo);
268 }
269
HpaeProcessClusterCreateConverterNodeFuzzTest()270 void HpaeProcessClusterCreateConverterNodeFuzzTest()
271 {
272 HpaeNodeInfo nodeInfo;
273 GetTestNodeInfo(nodeInfo);
274 HpaeSinkInfo dummySinkInfo;
275 dummySinkInfo.sinkId = g_fuzzUtils.GetData<uint32_t>();
276 std::shared_ptr<HpaeProcessCluster> hpaeProcessCluster =
277 std::make_shared<HpaeProcessCluster>(nodeInfo, dummySinkInfo);
278 if (hpaeProcessCluster == nullptr) {
279 return;
280 }
281 uint32_t sessionId = g_fuzzUtils.GetData<uint32_t>();
282 HpaeNodeInfo preNodeInfo;
283 GetTestNodeInfo(preNodeInfo);
284 hpaeProcessCluster->CreateConverterNode(sessionId, preNodeInfo);
285 }
286
HpaeProcessClusterCreateLoudnessGainNodeFuzzTest()287 void HpaeProcessClusterCreateLoudnessGainNodeFuzzTest()
288 {
289 HpaeNodeInfo nodeInfo;
290 GetTestNodeInfo(nodeInfo);
291 HpaeSinkInfo dummySinkInfo;
292 dummySinkInfo.sinkId = g_fuzzUtils.GetData<uint32_t>();
293 std::shared_ptr<HpaeProcessCluster> hpaeProcessCluster =
294 std::make_shared<HpaeProcessCluster>(nodeInfo, dummySinkInfo);
295 if (hpaeProcessCluster == nullptr) {
296 return;
297 }
298 uint32_t sessionId = g_fuzzUtils.GetData<uint32_t>();
299 HpaeNodeInfo preNodeInfo;
300 GetTestNodeInfo(preNodeInfo);
301 hpaeProcessCluster->CreateLoudnessGainNode(sessionId, preNodeInfo);
302 }
303
HpaeProcessClusterConnectFuzzTest()304 void HpaeProcessClusterConnectFuzzTest()
305 {
306 HpaeNodeInfo nodeInfo;
307 GetTestNodeInfo(nodeInfo);
308 HpaeSinkInfo dummySinkInfo;
309 dummySinkInfo.sinkId = g_fuzzUtils.GetData<uint32_t>();
310 std::shared_ptr<HpaeProcessCluster> hpaeProcessCluster =
311 std::make_shared<HpaeProcessCluster>(nodeInfo, dummySinkInfo);
312 if (hpaeProcessCluster == nullptr) {
313 return;
314 }
315
316 std::shared_ptr<HpaeSinkInputNode> hpaeSinkInputNode = std::make_shared<HpaeSinkInputNode>(nodeInfo);
317 hpaeProcessCluster->Connect(hpaeSinkInputNode);
318 }
319
HpaeProcessClusterDisConnectMixerNodeFuzzTest()320 void HpaeProcessClusterDisConnectMixerNodeFuzzTest()
321 {
322 HpaeNodeInfo nodeInfo;
323 GetTestNodeInfo(nodeInfo);
324 HpaeSinkInfo dummySinkInfo;
325 dummySinkInfo.sinkId = g_fuzzUtils.GetData<uint32_t>();
326 std::shared_ptr<HpaeProcessCluster> hpaeProcessCluster =
327 std::make_shared<HpaeProcessCluster>(nodeInfo, dummySinkInfo);
328 if (hpaeProcessCluster == nullptr) {
329 return;
330 }
331 hpaeProcessCluster->renderEffectNode_ = std::make_shared<HpaeRenderEffectNode>(nodeInfo);
332 hpaeProcessCluster->DisConnectMixerNode();
333 }
334
HpaeProcessClusterGetNodeInputFormatInfoFuzzTest()335 void HpaeProcessClusterGetNodeInputFormatInfoFuzzTest()
336 {
337 HpaeNodeInfo nodeInfo;
338 GetTestNodeInfo(nodeInfo);
339 HpaeSinkInfo dummySinkInfo;
340 dummySinkInfo.sinkId = g_fuzzUtils.GetData<uint32_t>();
341 std::shared_ptr<HpaeProcessCluster> hpaeProcessCluster =
342 std::make_shared<HpaeProcessCluster>(nodeInfo, dummySinkInfo);
343 if (hpaeProcessCluster == nullptr) {
344 return;
345 }
346 AudioBasicFormat basicFormat;
347 uint32_t sessionId = g_fuzzUtils.GetData<uint32_t>();
348 hpaeProcessCluster->GetNodeInputFormatInfo(sessionId, basicFormat);
349 }
350
HpaeProcessClusterAudioRendererStopFuzzTest()351 void HpaeProcessClusterAudioRendererStopFuzzTest()
352 {
353 HpaeNodeInfo nodeInfo;
354 GetTestNodeInfo(nodeInfo);
355 HpaeSinkInfo dummySinkInfo;
356 dummySinkInfo.sinkId = g_fuzzUtils.GetData<uint32_t>();
357 std::shared_ptr<HpaeProcessCluster> hpaeProcessCluster =
358 std::make_shared<HpaeProcessCluster>(nodeInfo, dummySinkInfo);
359 if (hpaeProcessCluster == nullptr) {
360 return;
361 }
362 HpaeNodeInfo nodeInfoTest;
363 GetTestNodeInfo(nodeInfoTest);
364 hpaeProcessCluster->AudioRendererStart(nodeInfoTest);
365 hpaeProcessCluster->AudioRendererStop(nodeInfoTest);
366 }
367
HpaeProcessClusterGetConverterNodeByIdFuzzTest()368 void HpaeProcessClusterGetConverterNodeByIdFuzzTest()
369 {
370 HpaeNodeInfo nodeInfo;
371 GetTestNodeInfo(nodeInfo);
372 HpaeSinkInfo dummySinkInfo;
373 dummySinkInfo.sinkId = g_fuzzUtils.GetData<uint32_t>();
374 std::shared_ptr<HpaeProcessCluster> hpaeProcessCluster =
375 std::make_shared<HpaeProcessCluster>(nodeInfo, dummySinkInfo);
376 if (hpaeProcessCluster == nullptr) {
377 return;
378 }
379 uint32_t sessionId = g_fuzzUtils.GetData<uint32_t>();
380 hpaeProcessCluster->GetGainNodeById(sessionId);
381 hpaeProcessCluster->GetConverterNodeById(sessionId);
382 }
383
HpaeProcessClusterSetupAudioLimiterFuzzTest()384 void HpaeProcessClusterSetupAudioLimiterFuzzTest()
385 {
386 HpaeNodeInfo nodeInfo;
387 GetTestNodeInfo(nodeInfo);
388 HpaeSinkInfo dummySinkInfo;
389 dummySinkInfo.sinkId = g_fuzzUtils.GetData<uint32_t>();
390 std::shared_ptr<HpaeProcessCluster> hpaeProcessCluster =
391 std::make_shared<HpaeProcessCluster>(nodeInfo, dummySinkInfo);
392 if (hpaeProcessCluster == nullptr) {
393 return;
394 }
395 hpaeProcessCluster->isConnectedToOutputCluster = g_fuzzUtils.GetData<bool>();
396 hpaeProcessCluster->GetConnectedFlag();
397 hpaeProcessCluster->SetupAudioLimiter();
398 }
399
HpaeRenderEffectNodeDoProcessFuzzTest()400 void HpaeRenderEffectNodeDoProcessFuzzTest()
401 {
402 HpaeNodeInfo nodeInfo;
403 GetTestNodeInfo(nodeInfo);
404 std::shared_ptr<HpaeRenderEffectNode> hpaeRenderEffectNode = std::make_shared<HpaeRenderEffectNode>(nodeInfo);
405 if (hpaeRenderEffectNode == nullptr) {
406 return;
407 }
408 hpaeRenderEffectNode->sceneType_ = "SCENE_COLLABORATIVE";
409 hpaeRenderEffectNode->enableProcess_ = g_fuzzUtils.GetData<bool>();
410 bool isTestString = g_fuzzUtils.GetData<bool>();
411 if (isTestString) {
412 hpaeRenderEffectNode->sceneType_ = "test_scene_type";
413 }
414 hpaeRenderEffectNode->DoProcess();
415 }
416
HpaeRenderEffectNodeSignalProcessFuzzTest()417 void HpaeRenderEffectNodeSignalProcessFuzzTest()
418 {
419 HpaeNodeInfo nodeInfo;
420 GetTestNodeInfo(nodeInfo);
421 std::shared_ptr<HpaeRenderEffectNode> hpaeRenderEffectNode = std::make_shared<HpaeRenderEffectNode>(nodeInfo);
422 if (hpaeRenderEffectNode == nullptr) {
423 return;
424 }
425
426 std::vector<HpaePcmBuffer *> inputs;
427 PcmBufferInfo pcmBufferInfo(MONO, DEFAULT_FRAME_LENGTH, SAMPLE_RATE_44100);
428 HpaePcmBuffer hpaePcmBuffer(pcmBufferInfo);
429 inputs.emplace_back(&hpaePcmBuffer);
430 bool isClear = g_fuzzUtils.GetData<bool>();
431 if (isClear) {
432 inputs.clear();
433 }
434 hpaeRenderEffectNode->SignalProcess(inputs);
435 }
436
HpaeRenderEffectNodeSplitCollaborativeDataFuzzTest()437 void HpaeRenderEffectNodeSplitCollaborativeDataFuzzTest()
438 {
439 HpaeNodeInfo nodeInfo;
440 GetTestNodeInfo(nodeInfo);
441 std::shared_ptr<HpaeRenderEffectNode> hpaeRenderEffectNode = std::make_shared<HpaeRenderEffectNode>(nodeInfo);
442 if (hpaeRenderEffectNode == nullptr) {
443 return;
444 }
445
446 hpaeRenderEffectNode->SplitCollaborativeData();
447 }
448
HpaeRenderEffectNodeAudioRendererStartFuzzTest()449 void HpaeRenderEffectNodeAudioRendererStartFuzzTest()
450 {
451 HpaeNodeInfo nodeInfo;
452 GetTestNodeInfo(nodeInfo);
453 std::shared_ptr<HpaeRenderEffectNode> hpaeRenderEffectNode = std::make_shared<HpaeRenderEffectNode>(nodeInfo);
454 if (hpaeRenderEffectNode == nullptr) {
455 return;
456 }
457
458 HpaeNodeInfo nodeInfoTest;
459 GetTestNodeInfo(nodeInfoTest);
460 hpaeRenderEffectNode->AudioRendererStart(nodeInfoTest);
461 hpaeRenderEffectNode->AudioRendererStop(nodeInfoTest);
462 }
463
HpaeRenderEffectNodeUpdateAudioEffectChainInfoFuzzTest()464 void HpaeRenderEffectNodeUpdateAudioEffectChainInfoFuzzTest()
465 {
466 HpaeNodeInfo nodeInfo;
467 GetTestNodeInfo(nodeInfo);
468 std::shared_ptr<HpaeRenderEffectNode> hpaeRenderEffectNode = std::make_shared<HpaeRenderEffectNode>(nodeInfo);
469 if (hpaeRenderEffectNode == nullptr) {
470 return;
471 }
472
473 HpaeNodeInfo nodeInfoTest;
474 GetTestNodeInfo(nodeInfoTest);
475 nodeInfoTest.effectInfo.effectScene = g_fuzzUtils.GetData<AudioEffectScene>();
476 hpaeRenderEffectNode->UpdateAudioEffectChainInfo(nodeInfoTest);
477 }
478
HpaeRenderEffectNodeReconfigOutputBufferFuzzTest()479 void HpaeRenderEffectNodeReconfigOutputBufferFuzzTest()
480 {
481 HpaeNodeInfo nodeInfo;
482 GetTestNodeInfo(nodeInfo);
483 std::shared_ptr<HpaeRenderEffectNode> hpaeRenderEffectNode = std::make_shared<HpaeRenderEffectNode>(nodeInfo);
484 if (hpaeRenderEffectNode == nullptr) {
485 return;
486 }
487
488 hpaeRenderEffectNode->ReconfigOutputBuffer();
489 }
490
HpaeRenderEffectNodeGetExpectedInputChannelInfoFuzzTest()491 void HpaeRenderEffectNodeGetExpectedInputChannelInfoFuzzTest()
492 {
493 HpaeNodeInfo nodeInfo;
494 GetTestNodeInfo(nodeInfo);
495 std::shared_ptr<HpaeRenderEffectNode> hpaeRenderEffectNode = std::make_shared<HpaeRenderEffectNode>(nodeInfo);
496 if (hpaeRenderEffectNode == nullptr) {
497 return;
498 }
499 AudioBasicFormat basicFormat;
500 basicFormat.format = g_fuzzUtils.GetData<AudioSampleFormat>();
501 basicFormat.rate = g_fuzzUtils.GetData<AudioSamplingRate>();
502
503 hpaeRenderEffectNode->GetExpectedInputChannelInfo(basicFormat);
504 }
505
HpaeRenderEffectNodeIsByPassEffectZeroVolumeFuzzTest()506 void HpaeRenderEffectNodeIsByPassEffectZeroVolumeFuzzTest()
507 {
508 HpaeNodeInfo nodeInfo;
509 GetTestNodeInfo(nodeInfo);
510 std::shared_ptr<HpaeRenderEffectNode> hpaeRenderEffectNode = std::make_shared<HpaeRenderEffectNode>(nodeInfo);
511 if (hpaeRenderEffectNode == nullptr) {
512 return;
513 }
514
515 hpaeRenderEffectNode->isDisplayEffectZeroVolume_ = g_fuzzUtils.GetData<bool>();
516 PcmBufferInfo pcmBufferInfo(MONO, DEFAULT_FRAME_LENGTH, SAMPLE_RATE_44100);
517 HpaePcmBuffer hpaePcmBuffer(pcmBufferInfo);
518 hpaeRenderEffectNode->IsByPassEffectZeroVolume(&hpaePcmBuffer);
519 }
520
ConvertToFloatFuzzTest()521 void ConvertToFloatFuzzTest()
522 {
523 AudioSampleFormat format = g_fuzzUtils.GetData<AudioSampleFormat>();
524 float dst[1] = {0};
525 if (format == SAMPLE_U8) {
526 uint8_t src[1] = {g_fuzzUtils.GetData<uint8_t>()};
527 ConvertToFloat(format, 1, src, dst);
528 } else if (format == SAMPLE_S16LE) {
529 int16_t src[1] = {g_fuzzUtils.GetData<int16_t>()};
530 ConvertToFloat(format, 1, src, dst);
531 } else if (format == SAMPLE_S24LE) {
532 uint8_t src[1] = {g_fuzzUtils.GetData<uint8_t>()};
533 ConvertToFloat(format, 1, src, dst);
534 } else if (format == SAMPLE_S32LE) {
535 int32_t src[1] = {g_fuzzUtils.GetData<int32_t>()};
536 ConvertToFloat(format, 1, src, dst);
537 } else {
538 float src[1] = {g_fuzzUtils.GetData<float>()};
539 ConvertToFloat(format, 1, src, dst);
540 }
541 }
542
ConvertFromFloatFuzzTest()543 void ConvertFromFloatFuzzTest()
544 {
545 AudioSampleFormat format = g_fuzzUtils.GetData<AudioSampleFormat>();
546 float src[1] = {g_fuzzUtils.GetData<float>()};
547 if (format == SAMPLE_U8) {
548 uint8_t dst[1] = {0};
549 ConvertFromFloat(format, 1, src, dst);
550 } else if (format == SAMPLE_S16LE) {
551 int16_t dst[1] = {0};
552 ConvertFromFloat(format, 1, src, dst);
553 } else if (format == SAMPLE_S24LE) {
554 uint8_t dst[4] = {0};
555 ConvertFromFloat(format, 1, src, dst);
556 } else if (format == SAMPLE_S32LE) {
557 int32_t dst[1] = {0};
558 ConvertFromFloat(format, 1, src, dst);
559 } else {
560 float dst[1] = {0};
561 ConvertFromFloat(format, 1, src, dst);
562 }
563 }
564
HpaePcmDumperDumpFuzzTest()565 void HpaePcmDumperDumpFuzzTest()
566 {
567 std::string testFilePath = "/test/test.txt";
568 HpaePcmDumper dumper(testFilePath);
569 int8_t buffer[] = {0, g_fuzzUtils.GetData<int8_t>()};
570 int32_t length = sizeof(buffer) / sizeof(buffer[0]);
571 dumper.Dump(buffer, length);
572 }
573
HpaePcmDumperCheckAndReopenHandleFuzzTest()574 void HpaePcmDumperCheckAndReopenHandleFuzzTest()
575 {
576 std::string testFilePath = "/test/test.txt";
577 HpaePcmDumper dumper(testFilePath);
578 dumper.CheckAndReopenHandle();
579 }
580
581 vector<TestPtr> g_testPtrs = {
582 HpaeMixerNodeSignalProcessFuzzTest,
583 HpaeMixerNodeCheckUpdateInfoFuzzTest,
584 HpaeMixerNodeCheckUpdateInfoForDisConnectFuzzTest,
585 HpaeMixerNodeDrainProcessFuzzTest,
586 HpaeNodeCommonTransStreamTypeToSceneTypeFuzzTest,
587 HpaeNodeCommonTransNodeInfoForCollaborationFuzzTest,
588 HpaeNodeCommonTransSourceTypeToSceneTypeFuzzTest,
589 HpaeNodeCommonCheckSceneTypeNeedMicRefFuzzTest,
590 HpaeNodeCommonTransProcessType2EnhanceSceneFuzzTest,
591 HpaeNodeCommonConvertUsToFrameCountFuzzTest,
592 HpaeNodeCommonConvertDatalenToUsFuzzTest,
593 HpaeNodeCommonAdjustMchSinkInfoFuzzTest,
594 HpaeNodeCommonCheckSourceInfoIsDifferentFuzzTest,
595 HpaeNodeCommonRecoverNodeInfoForCollaborationFuzzTest,
596 HpaeProcessClusterDoProcessFuzzTest,
597 HpaeProcessClusterGetConverterNodeCountFuzzTest,
598 HpaeProcessClusterConnectMixerNodeFuzzTest,
599 HpaeProcessClusterCreateGainNodeFuzzTest,
600 HpaeProcessClusterCreateConverterNodeFuzzTest,
601 HpaeProcessClusterCreateLoudnessGainNodeFuzzTest,
602 HpaeProcessClusterConnectFuzzTest,
603 HpaeProcessClusterDisConnectMixerNodeFuzzTest,
604 HpaeProcessClusterGetNodeInputFormatInfoFuzzTest,
605 HpaeProcessClusterAudioRendererStopFuzzTest,
606 HpaeProcessClusterGetConverterNodeByIdFuzzTest,
607 HpaeProcessClusterSetupAudioLimiterFuzzTest,
608 HpaeRenderEffectNodeDoProcessFuzzTest,
609 HpaeRenderEffectNodeSignalProcessFuzzTest,
610 HpaeRenderEffectNodeSplitCollaborativeDataFuzzTest,
611 HpaeRenderEffectNodeAudioRendererStartFuzzTest,
612 HpaeRenderEffectNodeUpdateAudioEffectChainInfoFuzzTest,
613 HpaeRenderEffectNodeReconfigOutputBufferFuzzTest,
614 HpaeRenderEffectNodeGetExpectedInputChannelInfoFuzzTest,
615 HpaeRenderEffectNodeIsByPassEffectZeroVolumeFuzzTest,
616 ConvertToFloatFuzzTest,
617 ConvertFromFloatFuzzTest,
618 HpaePcmDumperDumpFuzzTest,
619 HpaePcmDumperCheckAndReopenHandleFuzzTest,
620 };
621
622 } // namespace AudioStandard
623 } // namesapce OHOS
624
625 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)626 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
627 {
628 if (size < OHOS::AudioStandard::FUZZ_INPUT_SIZE_THRESHOLD) {
629 return 0;
630 }
631
632 OHOS::AudioStandard::g_fuzzUtils.fuzzTest(data, size, OHOS::AudioStandard::g_testPtrs);
633 return 0;
634 }