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_audio_format_converter_node.h"
20 #include "hpae_capture_effect_node.h"
21 #include "hpae_co_buffer_node.h"
22 #include "hpae_sink_input_node.h"
23 #include "hpae_source_input_node.h"
24 #include "../fuzz_utils.h"
25
26 using namespace std;
27 using namespace OHOS::AudioStandard::HPAE;
28
29 namespace OHOS {
30 namespace AudioStandard {
31
32 FuzzUtils &g_fuzzUtils = FuzzUtils::GetInstance();
33 const size_t FUZZ_INPUT_SIZE_THRESHOLD = 10;
34 const uint32_t DEFAULT_FRAME_LENGTH = 960; // 20ms at 48kHz
35 const uint32_t DEFAULT_NODE_ID = 1243;
36 const uint32_t DEFAULT_CHANNEL_COUNT = 2;
37 const uint32_t DEFAULT_SAMPLE_RATE = 48000;
38 typedef void (*TestPtr)();
39
40 class INodeFormatInfoCallbackTest : public INodeFormatInfoCallback {
41 public:
GetNodeInputFormatInfo(uint32_t sessionId,AudioBasicFormat & basicFormat)42 int32_t GetNodeInputFormatInfo(uint32_t sessionId, AudioBasicFormat &basicFormat) override
43 {
44 return 0;
45 }
46 };
47
CreateHpaeAudioFormatConverterNode(std::shared_ptr<HpaeAudioFormatConverterNode> & nodePtr)48 static void CreateHpaeAudioFormatConverterNode(std::shared_ptr<HpaeAudioFormatConverterNode> &nodePtr)
49 {
50 HpaeNodeInfo preNodeInfo;
51 preNodeInfo.channels = CHANNEL_UNKNOW;
52 preNodeInfo.frameLen = 0;
53 preNodeInfo.nodeId = g_fuzzUtils.GetData<uint32_t>();
54 preNodeInfo.samplingRate = SAMPLE_RATE_8000;
55 preNodeInfo.sceneType = HPAE_SCENE_DEFAULT;
56 preNodeInfo.deviceClass = "test_device_class";
57 HpaeNodeInfo nodeInfo;
58 nodeInfo.samplingRate = SAMPLE_RATE_48000;
59 nodeInfo.format = SAMPLE_F32LE;
60 nodeInfo.channels = STEREO;
61 nodeInfo.frameLen = DEFAULT_FRAME_LENGTH;
62 nodeInfo.channelLayout = CH_LAYOUT_STEREO;
63 nodePtr = make_shared<HpaeAudioFormatConverterNode>(preNodeInfo, nodeInfo);
64 }
65
GetTestNodeInfo(HpaeNodeInfo & nodeInfo)66 static void GetTestNodeInfo(HpaeNodeInfo &nodeInfo)
67 {
68 nodeInfo.samplingRate = SAMPLE_RATE_48000;
69 nodeInfo.format = SAMPLE_F32LE;
70 nodeInfo.channels = STEREO;
71 nodeInfo.frameLen = DEFAULT_FRAME_LENGTH;
72 nodeInfo.channelLayout = CH_LAYOUT_STEREO;
73 }
74
CreateBufferInfo(uint32_t frames,bool multiFrames=false)75 PcmBufferInfo CreateBufferInfo(uint32_t frames, bool multiFrames = false)
76 {
77 PcmBufferInfo info;
78 info.ch = DEFAULT_CHANNEL_COUNT;
79 info.frameLen = DEFAULT_FRAME_LENGTH;
80 info.rate = DEFAULT_SAMPLE_RATE;
81 info.frames = frames;
82 info.isMultiFrames = multiFrames;
83 return info;
84 }
85
HpaeAudioFormatConverterNodeRegisterCallbackFuzzTest()86 void HpaeAudioFormatConverterNodeRegisterCallbackFuzzTest()
87 {
88 std::shared_ptr<HpaeAudioFormatConverterNode> nodePtr;
89 CreateHpaeAudioFormatConverterNode(nodePtr);
90 if (nodePtr == nullptr) {
91 return;
92 }
93 INodeFormatInfoCallbackTest callback;
94 INodeFormatInfoCallback *callbackPtr = &callback;
95 nodePtr->RegisterCallback(callbackPtr);
96 }
97
HpaeAudioFormatConverterNodeSignalProcessFuzzTest()98 void HpaeAudioFormatConverterNodeSignalProcessFuzzTest()
99 {
100 std::shared_ptr<HpaeAudioFormatConverterNode> nodePtr;
101 CreateHpaeAudioFormatConverterNode(nodePtr);
102 if (nodePtr == nullptr) {
103 return;
104 }
105 PcmBufferInfo pcmBufferInfo(0, 1, g_fuzzUtils.GetData<uint32_t>());
106 HpaePcmBuffer hpaePcmBuffer(pcmBufferInfo);
107 std::vector<HpaePcmBuffer *> inputs;
108 inputs.push_back(&hpaePcmBuffer);
109 nodePtr->SignalProcess(inputs);
110 }
111
HpaeAudioFormatConverterNodeConverterProcessFuzzTest()112 void HpaeAudioFormatConverterNodeConverterProcessFuzzTest()
113 {
114 std::shared_ptr<HpaeAudioFormatConverterNode> nodePtr;
115 CreateHpaeAudioFormatConverterNode(nodePtr);
116 if (nodePtr == nullptr) {
117 return;
118 }
119 float *dstData = nodePtr->converterOutput_.GetPcmDataBuffer();
120 float *tmpData = nodePtr->tmpOutBuf_.GetPcmDataBuffer();
121 PcmBufferInfo pcmBufferInfo = CreateBufferInfo(1);
122 HpaePcmBuffer inputBuffer(pcmBufferInfo);
123 float *srcData = inputBuffer.GetPcmDataBuffer();
124 nodePtr->ConverterProcess(srcData, dstData, tmpData, &inputBuffer);
125 }
126
HpaeAudioFormatConverterNodeCheckUpdateOutInfoFuzzTest()127 void HpaeAudioFormatConverterNodeCheckUpdateOutInfoFuzzTest()
128 {
129 std::shared_ptr<HpaeAudioFormatConverterNode> nodePtr;
130 CreateHpaeAudioFormatConverterNode(nodePtr);
131 if (nodePtr == nullptr) {
132 return;
133 }
134 INodeFormatInfoCallbackTest callback;
135 INodeFormatInfoCallback *callbackPtr = &callback;
136 nodePtr->RegisterCallback(callbackPtr);
137 nodePtr->CheckUpdateOutInfo();
138 }
139
HpaeAudioFormatConverterNodeCheckUpdateInInfoFuzzTest()140 void HpaeAudioFormatConverterNodeCheckUpdateInInfoFuzzTest()
141 {
142 std::shared_ptr<HpaeAudioFormatConverterNode> nodePtr;
143 CreateHpaeAudioFormatConverterNode(nodePtr);
144 if (nodePtr == nullptr) {
145 return;
146 }
147 PcmBufferInfo pcmBufferInfo(0, 1, g_fuzzUtils.GetData<uint32_t>());
148 HpaePcmBuffer inputBuffer(pcmBufferInfo);
149 nodePtr->CheckUpdateInInfo(&inputBuffer);
150 }
151
HpaeAudioFormatConverterNodeUpdateTmpOutPcmBufferInfoFuzzTest()152 void HpaeAudioFormatConverterNodeUpdateTmpOutPcmBufferInfoFuzzTest()
153 {
154 std::shared_ptr<HpaeAudioFormatConverterNode> nodePtr;
155 CreateHpaeAudioFormatConverterNode(nodePtr);
156 if (nodePtr == nullptr) {
157 return;
158 }
159 PcmBufferInfo outPcmBufferInfo(0, 1, g_fuzzUtils.GetData<uint32_t>());
160 PcmBufferInfo pcmBufferInfo(MONO, DEFAULT_FRAME_LENGTH, SAMPLE_RATE_44100);
161 nodePtr->UpdateTmpOutPcmBufferInfo(outPcmBufferInfo);
162 }
163
HpaeAudioFormatConverterNodeCheckAndUpdateInfoFuzzTest()164 void HpaeAudioFormatConverterNodeCheckAndUpdateInfoFuzzTest()
165 {
166 std::shared_ptr<HpaeAudioFormatConverterNode> nodePtr;
167 CreateHpaeAudioFormatConverterNode(nodePtr);
168 if (nodePtr == nullptr) {
169 return;
170 }
171 PcmBufferInfo pcmBufferInfo(0, 1, g_fuzzUtils.GetData<uint32_t>());
172 HpaePcmBuffer inputBuffer(pcmBufferInfo);
173 nodePtr->CheckAndUpdateInfo(&inputBuffer);
174 }
175
HpaeAudioFormatConverterNodeConnectWithInfoFuzzTest()176 void HpaeAudioFormatConverterNodeConnectWithInfoFuzzTest()
177 {
178 std::shared_ptr<HpaeAudioFormatConverterNode> nodePtr;
179 CreateHpaeAudioFormatConverterNode(nodePtr);
180 if (nodePtr == nullptr) {
181 return;
182 }
183 HpaeNodeInfo nodeInfo;
184 nodeInfo.nodeId = DEFAULT_NODE_ID;
185 nodeInfo.frameLen = DEFAULT_FRAME_LENGTH;
186 nodeInfo.samplingRate = SAMPLE_RATE_48000;
187 nodeInfo.channels = STEREO;
188 nodeInfo.format = SAMPLE_F32LE;
189 std::shared_ptr<HpaeSourceInputNode> hpaeSourceInputNode = std::make_shared<HpaeSourceInputNode>(nodeInfo);
190 std::shared_ptr<OutputNode<HpaePcmBuffer *>> outputNode = hpaeSourceInputNode;
191
192 HpaeNodeInfo nodeInfoTest;
193 nodePtr->ConnectWithInfo(outputNode, nodeInfoTest);
194 }
195
HpaeAudioFormatConverterNodeDisConnectWithInfoFuzzTest()196 void HpaeAudioFormatConverterNodeDisConnectWithInfoFuzzTest()
197 {
198 std::shared_ptr<HpaeAudioFormatConverterNode> nodePtr;
199 CreateHpaeAudioFormatConverterNode(nodePtr);
200 if (nodePtr == nullptr) {
201 return;
202 }
203 HpaeNodeInfo nodeInfo;
204 nodeInfo.nodeId = DEFAULT_NODE_ID;
205 nodeInfo.frameLen = DEFAULT_FRAME_LENGTH;
206 nodeInfo.samplingRate = SAMPLE_RATE_48000;
207 nodeInfo.channels = STEREO;
208 nodeInfo.format = SAMPLE_F32LE;
209 std::shared_ptr<HpaeSourceInputNode> hpaeSourceInputNode = std::make_shared<HpaeSourceInputNode>(nodeInfo);
210 std::shared_ptr<OutputNode<HpaePcmBuffer *>> outputNode = hpaeSourceInputNode;
211
212 HpaeNodeInfo nodeInfoTest;
213 nodePtr->DisConnectWithInfo(outputNode, nodeInfoTest);
214 }
215
HpaeCaptureEffectNodeResetFuzzTest()216 void HpaeCaptureEffectNodeResetFuzzTest()
217 {
218 HpaeNodeInfo nodeInfo;
219 GetTestNodeInfo(nodeInfo);
220 std::shared_ptr<HpaeCaptureEffectNode> hpaeCaptureEffectNode = std::make_shared<HpaeCaptureEffectNode>(nodeInfo);
221 if (hpaeCaptureEffectNode == nullptr) {
222 return;
223 }
224 hpaeCaptureEffectNode->Reset();
225 }
226
HpaeCaptureEffectNodeSignalProcessFuzzTest()227 void HpaeCaptureEffectNodeSignalProcessFuzzTest()
228 {
229 HpaeNodeInfo nodeInfo;
230 GetTestNodeInfo(nodeInfo);
231 std::shared_ptr<HpaeCaptureEffectNode> hpaeCaptureEffectNode = std::make_shared<HpaeCaptureEffectNode>(nodeInfo);
232 if (hpaeCaptureEffectNode == nullptr) {
233 return;
234 }
235 PcmBufferInfo outPcmBufferInfo(MONO, DEFAULT_FRAME_LENGTH, SAMPLE_RATE_44100);
236 hpaeCaptureEffectNode->outPcmBuffer_ = make_unique<HpaePcmBuffer>(outPcmBufferInfo);
237 PcmBufferInfo pcmBufferInfo(MONO, DEFAULT_FRAME_LENGTH, SAMPLE_RATE_44100);
238 HpaePcmBuffer hpaePcmBuffer(pcmBufferInfo);
239 std::vector<HpaePcmBuffer *> inputs;
240 inputs.push_back(&hpaePcmBuffer);
241 bool isClear = g_fuzzUtils.GetData<bool>();
242 if (isClear) {
243 inputs.clear();
244 }
245 hpaeCaptureEffectNode->SignalProcess(inputs);
246 }
247
HpaeCaptureEffectNodeGetCapturerEffectConfigFuzzTest()248 void HpaeCaptureEffectNodeGetCapturerEffectConfigFuzzTest()
249 {
250 HpaeNodeInfo nodeInfo;
251 GetTestNodeInfo(nodeInfo);
252 std::shared_ptr<HpaeCaptureEffectNode> hpaeCaptureEffectNode = std::make_shared<HpaeCaptureEffectNode>(nodeInfo);
253 if (hpaeCaptureEffectNode == nullptr) {
254 return;
255 }
256 HpaeNodeInfo nodeInfoTest;
257 GetTestNodeInfo(nodeInfoTest);
258 HpaeSourceBufferType type = g_fuzzUtils.GetData<HpaeSourceBufferType>();
259 hpaeCaptureEffectNode->capturerEffectConfigMap_.insert({type, nodeInfoTest});
260 HpaeNodeInfo hpaeNodeInfoByGetCapturerEffectConfig;
261 hpaeCaptureEffectNode->GetCapturerEffectConfig(hpaeNodeInfoByGetCapturerEffectConfig, type);
262 }
263
HpaeCaptureEffectNodeSetCapturerEffectConfigFuzzTest()264 void HpaeCaptureEffectNodeSetCapturerEffectConfigFuzzTest()
265 {
266 HpaeNodeInfo nodeInfo;
267 GetTestNodeInfo(nodeInfo);
268 std::shared_ptr<HpaeCaptureEffectNode> hpaeCaptureEffectNode = std::make_shared<HpaeCaptureEffectNode>(nodeInfo);
269 if (hpaeCaptureEffectNode == nullptr) {
270 return;
271 }
272 AudioBufferConfig audioBufferConfig1 = {
273 .samplingRate = g_fuzzUtils.GetData<uint32_t>(),
274 .channels = g_fuzzUtils.GetData<uint32_t>(),
275 .format = g_fuzzUtils.GetData<uint8_t>(),
276 };
277 AudioBufferConfig audioBufferConfig2 = {
278 .samplingRate = g_fuzzUtils.GetData<uint32_t>(),
279 .channels = g_fuzzUtils.GetData<uint32_t>(),
280 .format = g_fuzzUtils.GetData<uint8_t>(),
281 };
282 AudioBufferConfig audioBufferConfig3 = {
283 .samplingRate = g_fuzzUtils.GetData<uint32_t>(),
284 .channels = g_fuzzUtils.GetData<uint32_t>(),
285 .format = g_fuzzUtils.GetData<uint8_t>(),
286 };
287 hpaeCaptureEffectNode->SetCapturerEffectConfig(audioBufferConfig1, audioBufferConfig2, audioBufferConfig3);
288 }
289
HpaeCoBufferNodeEnqueueFuzzTest()290 void HpaeCoBufferNodeEnqueueFuzzTest()
291 {
292 std::shared_ptr<HpaeCoBufferNode> coBufferNode = std::make_shared<HpaeCoBufferNode>();
293 if (coBufferNode == nullptr) {
294 return;
295 }
296
297 PcmBufferInfo pcmBufferInfo(MONO, DEFAULT_FRAME_LENGTH, SAMPLE_RATE_44100);
298 HpaePcmBuffer hpaePcmBuffer(pcmBufferInfo);
299 coBufferNode->Enqueue(&hpaePcmBuffer);
300 }
301
HpaeCoBufferNodeDoProcessFuzzTest()302 void HpaeCoBufferNodeDoProcessFuzzTest()
303 {
304 std::shared_ptr<HpaeCoBufferNode> coBufferNode = std::make_shared<HpaeCoBufferNode>();
305 if (coBufferNode == nullptr) {
306 return;
307 }
308 coBufferNode->enqueueRunning_ = g_fuzzUtils.GetData<bool>();
309 coBufferNode->DoProcess();
310 }
311
HpaeCoBufferNodeResetFuzzTest()312 void HpaeCoBufferNodeResetFuzzTest()
313 {
314 HpaeCoBufferNode hpaeCoBufferNode;
315 std::shared_ptr<OutputNode<HpaePcmBuffer*>> preNode = make_shared<HpaeCoBufferNode>();
316 if (preNode == nullptr) {
317 return;
318 }
319 preNode->GetOutputPort();
320 hpaeCoBufferNode.inputStream_.outputPorts_.insert({preNode->GetOutputPort(), preNode->GetSharedInstance()});
321 hpaeCoBufferNode.Reset();
322 }
323
HpaeCoBufferNodeResetAllFuzzTest()324 void HpaeCoBufferNodeResetAllFuzzTest()
325 {
326 HpaeCoBufferNode hpaeCoBufferNode;
327 std::shared_ptr<OutputNode<HpaePcmBuffer*>> preNode = make_shared<HpaeCoBufferNode>();
328 if (preNode == nullptr) {
329 return;
330 }
331 preNode->GetOutputPort();
332 hpaeCoBufferNode.inputStream_.outputPorts_.insert({preNode->GetOutputPort(), preNode->GetSharedInstance()});
333 hpaeCoBufferNode.ResetAll();
334 }
335
HpaeCoBufferNodeGetOutputPortFuzzTest()336 void HpaeCoBufferNodeGetOutputPortFuzzTest()
337 {
338 std::shared_ptr<HpaeCoBufferNode> coBufferNode = std::make_shared<HpaeCoBufferNode>();
339 if (coBufferNode == nullptr) {
340 return;
341 }
342 coBufferNode->GetOutputPort();
343 }
344
HpaeCoBufferNodeConnectFuzzTest()345 void HpaeCoBufferNodeConnectFuzzTest()
346 {
347 std::shared_ptr<HpaeCoBufferNode> coBufferNode = std::make_shared<HpaeCoBufferNode>();
348 if (coBufferNode == nullptr) {
349 return;
350 }
351 HpaeNodeInfo sinkInputNodeInfo;
352 GetTestNodeInfo(sinkInputNodeInfo);
353 std::shared_ptr<HpaeSinkInputNode> sinkInputNode = std::make_shared<HpaeSinkInputNode>(sinkInputNodeInfo);
354 if (sinkInputNode == nullptr) {
355 return;
356 }
357
358 coBufferNode->connectedProcessCluster_.insert(sinkInputNode->GetNodeInfo().sceneType);
359 coBufferNode->Connect(sinkInputNode);
360 }
361
HpaeCoBufferNodeDisConnectFuzzTest()362 void HpaeCoBufferNodeDisConnectFuzzTest()
363 {
364 std::shared_ptr<HpaeCoBufferNode> coBufferNode = std::make_shared<HpaeCoBufferNode>();
365 if (coBufferNode == nullptr) {
366 return;
367 }
368 HpaeNodeInfo sinkInputNodeInfo;
369 GetTestNodeInfo(sinkInputNodeInfo);
370 std::shared_ptr<HpaeSinkInputNode> sinkInputNode = std::make_shared<HpaeSinkInputNode>(sinkInputNodeInfo);
371 coBufferNode->DisConnect(sinkInputNode);
372 }
373
HpaeCoBufferNodeSetLatencyFuzzTest()374 void HpaeCoBufferNodeSetLatencyFuzzTest()
375 {
376 std::shared_ptr<HpaeCoBufferNode> coBufferNode = std::make_shared<HpaeCoBufferNode>();
377 if (coBufferNode == nullptr) {
378 return;
379 }
380 uint32_t latency = g_fuzzUtils.GetData<uint32_t>();
381 coBufferNode->SetLatency(latency);
382 }
383
HpaeCoBufferNodeFillSilenceFramesInnerFuzzTest()384 void HpaeCoBufferNodeFillSilenceFramesInnerFuzzTest()
385 {
386 std::shared_ptr<HpaeCoBufferNode> coBufferNode = std::make_shared<HpaeCoBufferNode>();
387 if (coBufferNode == nullptr) {
388 return;
389 }
390 uint32_t latencyMs = g_fuzzUtils.GetData<uint32_t>();
391
392 size_t cacheSize = g_fuzzUtils.GetData<size_t>();
393 coBufferNode->ringCache_ = AudioRingCache::Create(cacheSize);
394 coBufferNode->FillSilenceFramesInner(latencyMs);
395 }
396
HpaeCoBufferNodeProcessInputFrameInnerFuzzTest()397 void HpaeCoBufferNodeProcessInputFrameInnerFuzzTest()
398 {
399 std::shared_ptr<HpaeCoBufferNode> coBufferNode = std::make_shared<HpaeCoBufferNode>();
400 if (coBufferNode == nullptr) {
401 return;
402 }
403
404 size_t cacheSize = g_fuzzUtils.GetData<size_t>();
405 coBufferNode->ringCache_ = AudioRingCache::Create(cacheSize);
406
407 PcmBufferInfo pcmBufferInfo(MONO, DEFAULT_FRAME_LENGTH, SAMPLE_RATE_44100);
408 HpaePcmBuffer hpaePcmBuffer(pcmBufferInfo);
409 coBufferNode->ProcessInputFrameInner(&hpaePcmBuffer);
410 }
411
HpaeCoBufferNodeProcessOutputFrameInnerFuzzTest()412 void HpaeCoBufferNodeProcessOutputFrameInnerFuzzTest()
413 {
414 std::shared_ptr<HpaeCoBufferNode> coBufferNode = std::make_shared<HpaeCoBufferNode>();
415 if (coBufferNode == nullptr) {
416 return;
417 }
418 size_t cacheSize = g_fuzzUtils.GetData<size_t>();
419 coBufferNode->ringCache_ = AudioRingCache::Create(cacheSize);
420 coBufferNode->ProcessOutputFrameInner();
421 }
422
HpaeCoBufferNodeSetOutputClusterConnectedFuzzTest()423 void HpaeCoBufferNodeSetOutputClusterConnectedFuzzTest()
424 {
425 std::shared_ptr<HpaeCoBufferNode> coBufferNode = std::make_shared<HpaeCoBufferNode>();
426 if (coBufferNode == nullptr) {
427 return;
428 }
429
430 bool isConnect = g_fuzzUtils.GetData<bool>();
431 coBufferNode->SetOutputClusterConnected(isConnect);
432 coBufferNode->IsOutputClusterConnected();
433 }
434
435 vector<TestPtr> g_testPtrs = {
436 HpaeAudioFormatConverterNodeRegisterCallbackFuzzTest,
437 HpaeAudioFormatConverterNodeSignalProcessFuzzTest,
438 HpaeAudioFormatConverterNodeConverterProcessFuzzTest,
439 HpaeAudioFormatConverterNodeCheckUpdateOutInfoFuzzTest,
440 HpaeAudioFormatConverterNodeCheckUpdateInInfoFuzzTest,
441 HpaeAudioFormatConverterNodeUpdateTmpOutPcmBufferInfoFuzzTest,
442 HpaeAudioFormatConverterNodeCheckAndUpdateInfoFuzzTest,
443 HpaeAudioFormatConverterNodeConnectWithInfoFuzzTest,
444 HpaeAudioFormatConverterNodeDisConnectWithInfoFuzzTest,
445 HpaeCaptureEffectNodeResetFuzzTest,
446 HpaeCaptureEffectNodeSignalProcessFuzzTest,
447 HpaeCaptureEffectNodeGetCapturerEffectConfigFuzzTest,
448 HpaeCaptureEffectNodeSetCapturerEffectConfigFuzzTest,
449 HpaeCoBufferNodeEnqueueFuzzTest,
450 HpaeCoBufferNodeDoProcessFuzzTest,
451 HpaeCoBufferNodeResetFuzzTest,
452 HpaeCoBufferNodeResetAllFuzzTest,
453 HpaeCoBufferNodeGetOutputPortFuzzTest,
454 HpaeCoBufferNodeConnectFuzzTest,
455 HpaeCoBufferNodeDisConnectFuzzTest,
456 HpaeCoBufferNodeSetLatencyFuzzTest,
457 HpaeCoBufferNodeFillSilenceFramesInnerFuzzTest,
458 HpaeCoBufferNodeProcessInputFrameInnerFuzzTest,
459 HpaeCoBufferNodeProcessOutputFrameInnerFuzzTest,
460 HpaeCoBufferNodeSetOutputClusterConnectedFuzzTest,
461 };
462
463 } // namespace AudioStandard
464 } // namesapce OHOS
465
466 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)467 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
468 {
469 if (size < OHOS::AudioStandard::FUZZ_INPUT_SIZE_THRESHOLD) {
470 return 0;
471 }
472
473 OHOS::AudioStandard::g_fuzzUtils.fuzzTest(data, size, OHOS::AudioStandard::g_testPtrs);
474 return 0;
475 }