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 "audio_errors.h"
16 #include "hpae_capturer_manager.h"
17 #include "audio_info.h"
18 #include "../fuzz_utils.h"
19
20 namespace OHOS {
21 namespace AudioStandard {
22 using namespace std;
23 using namespace OHOS::AudioStandard::HPAE;
24
25 FuzzUtils &g_fuzzUtils = FuzzUtils::GetInstance();
26 const size_t FUZZ_INPUT_SIZE_THRESHOLD = 10;
27
28 typedef void (*TestFuncs)();
29
30 vector<HpaeProcessorType> HpaeProcessorTypeVec = {
31 HPAE_SCENE_DEFAULT,
32 HPAE_SCENE_MUSIC,
33 HPAE_SCENE_GAME,
34 HPAE_SCENE_MOVIE,
35 HPAE_SCENE_SPEECH,
36 HPAE_SCENE_RING,
37 HPAE_SCENE_VOIP_DOWN,
38 HPAE_SCENE_OTHERS,
39 HPAE_SCENE_EFFECT_NONE,
40 HPAE_SCENE_EFFECT_OUT,
41 HPAE_SCENE_SPLIT_MEDIA,
42 HPAE_SCENE_SPLIT_NAVIGATION,
43 HPAE_SCENE_SPLIT_COMMUNICATION,
44 HPAE_SCENE_VOIP_UP,
45 HPAE_SCENE_RECORD,
46 HPAE_SCENE_PRE_ENHANCE,
47 HPAE_SCENE_ASR,
48 HPAE_SCENE_VOICE_MESSAGE,
49 HPAE_SCENE_COLLABORATIVE,
50 };
51
52 vector<AudioEnhanceScene> AudioEnhanceSceneVec = {
53 SCENE_VOIP_UP,
54 SCENE_RECORD,
55 SCENE_PRE_ENHANCE,
56 SCENE_ASR,
57 SCENE_VOICE_MESSAGE,
58 SCENE_NONE,
59 };
60
61 vector<HpaeSessionState> HpaeSessionStateVec = {
62 HPAE_SESSION_INVALID,
63 HPAE_SESSION_NEW,
64 HPAE_SESSION_PREPARED,
65 HPAE_SESSION_RUNNING,
66 HPAE_SESSION_PAUSING,
67 HPAE_SESSION_PAUSED,
68 HPAE_SESSION_STOPPING,
69 HPAE_SESSION_STOPPED,
70 HPAE_SESSION_RELEASED
71 };
72
73 vector<IOperation> IOperationVec = {
74 OPERATION_INVALID,
75 OPERATION_STARTED,
76 OPERATION_PAUSED,
77 OPERATION_STOPPED,
78 OPERATION_FLUSHED,
79 OPERATION_DRAINED,
80 OPERATION_RELEASED,
81 OPERATION_UNDERRUN,
82 OPERATION_UNDERFLOW,
83 OPERATION_SET_OFFLOAD_ENABLE,
84 OPERATION_UNSET_OFFLOAD_ENABLE,
85 OPERATION_DATA_LINK_CONNECTING,
86 OPERATION_DATA_LINK_CONNECTED,
87 };
88
89 vector<MoveSessionType> MoveSessionTypeVec = {
90 MOVE_SINGLE,
91 MOVE_ALL,
92 MOVE_PREFER,
93 };
94
GetSourceInfo()95 HPAE::HpaeSourceInfo GetSourceInfo()
96 {
97 HPAE::HpaeSourceInfo sourceInfo;
98 sourceInfo.sourceId = g_fuzzUtils.GetData<uint32_t>();
99 sourceInfo.deviceNetId = "device_net_id";
100 sourceInfo.deviceClass = "device_class";
101 sourceInfo.adapterName = "adapter_name";
102 sourceInfo.sourceName = "source_name";
103 sourceInfo.sourceType = SOURCE_TYPE_PLAYBACK_CAPTURE;
104 sourceInfo.filePath = "/data/test_file.wav";
105 sourceInfo.deviceName = "device_name";
106 sourceInfo.frameLen = g_fuzzUtils.GetData<size_t>();
107 sourceInfo.format = SAMPLE_U8;
108 sourceInfo.channels = CHANNEL_3;
109 sourceInfo.channelLayout = g_fuzzUtils.GetData<uint64_t>();
110 sourceInfo.volume = g_fuzzUtils.GetData<float>();
111 sourceInfo.ecType = HPAE_EC_TYPE_SAME_ADAPTER;
112 sourceInfo.ecFormat = SAMPLE_U8;
113 sourceInfo.ecChannels = CHANNEL_4;
114 sourceInfo.micRefFormat = SAMPLE_U8;
115 sourceInfo.micRefChannels = CHANNEL_5;
116 sourceInfo.ecAdapterName = "ec_adapter_name";
117 return sourceInfo;
118 }
119
CapturerSourceStartFuzzTest()120 void CapturerSourceStartFuzzTest()
121 {
122 HpaeSourceInfo sourceInfo = GetSourceInfo();
123 std::shared_ptr<HpaeCapturerManager> hpaeCapturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
124 if (hpaeCapturerManager == nullptr) {
125 return;
126 }
127 hpaeCapturerManager->CapturerSourceStart();
128 }
129
CreateOutputSessionFuzzTest()130 void CreateOutputSessionFuzzTest()
131 {
132 HpaeSourceInfo sourceInfo = GetSourceInfo();
133 std::shared_ptr<HpaeCapturerManager> hpaeCapturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
134 if (hpaeCapturerManager == nullptr) {
135 return;
136 }
137 HpaeStreamInfo streamInfo;
138 uint32_t sessionId = 0;
139 hpaeCapturerManager->CreateOutputSession(streamInfo);
140 hpaeCapturerManager->DeleteOutputSession(sessionId);
141 }
142
CaptureEffectCreateFuzzTest()143 void CaptureEffectCreateFuzzTest()
144 {
145 HpaeSourceInfo sourceInfo = GetSourceInfo();
146 std::shared_ptr<HpaeCapturerManager> hpaeCapturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
147 if (hpaeCapturerManager == nullptr) {
148 return;
149 }
150 uint32_t index = g_fuzzUtils.GetData<uint32_t>() % HpaeProcessorTypeVec.size();
151 HpaeProcessorType processorType = HpaeProcessorTypeVec[index];
152 index = g_fuzzUtils.GetData<uint32_t>() % AudioEnhanceSceneVec.size();
153 AudioEnhanceScene sceneType = AudioEnhanceSceneVec[index];
154 HpaeNodeInfo nodeInfo;
155 if (hpaeCapturerManager->sceneClusterMap_[processorType] == nullptr) {
156 hpaeCapturerManager->sceneClusterMap_[processorType] = std::make_shared<HpaeSourceProcessCluster>(
157 nodeInfo);
158 }
159 hpaeCapturerManager->CaptureEffectCreate(processorType, sceneType);
160 hpaeCapturerManager->CaptureEffectRelease(processorType);
161 }
162
SetSessionStateFuzzTest()163 void SetSessionStateFuzzTest()
164 {
165 HpaeSourceInfo sourceInfo = GetSourceInfo();
166 std::shared_ptr<HpaeCapturerManager> hpaeCapturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
167 if (hpaeCapturerManager == nullptr) {
168 return;
169 }
170 HpaeNodeInfo nodeInfo;
171 uint32_t sessionId = g_fuzzUtils.GetData<uint32_t>();
172 HpaeCapturerSessionInfo sessionInfo;
173 hpaeCapturerManager->sessionNodeMap_[sessionId] = sessionInfo;
174 hpaeCapturerManager->sourceOutputNodeMap_[sessionId] = std::make_shared<HpaeSourceOutputNode>(nodeInfo);
175 uint32_t index = g_fuzzUtils.GetData<uint32_t>() % HpaeSessionStateVec.size();
176 HpaeSessionState capturerState = HpaeSessionStateVec[index];
177 hpaeCapturerManager->SetSessionState(sessionId, capturerState);
178 }
179
SetMuteFuzzTest()180 void SetMuteFuzzTest()
181 {
182 HpaeSourceInfo sourceInfo = GetSourceInfo();
183 std::shared_ptr<HpaeCapturerManager> hpaeCapturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
184 if (hpaeCapturerManager == nullptr) {
185 return;
186 }
187 bool isMute = g_fuzzUtils.GetData<bool>();
188 hpaeCapturerManager->SetMute(isMute);
189 }
190
PrepareCapturerFuzzTest()191 void PrepareCapturerFuzzTest()
192 {
193 HpaeSourceInfo sourceInfo = GetSourceInfo();
194 std::shared_ptr<HpaeCapturerManager> hpaeCapturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
195 if (hpaeCapturerManager == nullptr) {
196 return;
197 }
198 HpaeNodeInfo ecNodeInfo;
199 hpaeCapturerManager->sourceInfo_ = sourceInfo;
200 hpaeCapturerManager->sourceInfo_.ecType = g_fuzzUtils.GetData<HpaeEcType>();
201 hpaeCapturerManager->PrepareCapturerEc(ecNodeInfo);
202 hpaeCapturerManager->sourceInfo_.micRef = g_fuzzUtils.GetData<HpaeMicRefSwitch>();
203 hpaeCapturerManager->PrepareCapturerMicRef(ecNodeInfo);
204 hpaeCapturerManager->GetSourceInfo();
205 hpaeCapturerManager->GetAllSourceOutputsInfo();
206 }
207
CheckIfAnyStreamRunningFuzzTest()208 void CheckIfAnyStreamRunningFuzzTest()
209 {
210 HpaeSourceInfo sourceInfo = GetSourceInfo();
211 std::shared_ptr<HpaeCapturerManager> hpaeCapturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
212 if (hpaeCapturerManager == nullptr) {
213 return;
214 }
215 uint32_t sessionId = g_fuzzUtils.GetData<uint32_t>();
216 HpaeCapturerSessionInfo sessionInfo;
217 sessionInfo.state = HPAE_SESSION_RUNNING;
218 hpaeCapturerManager->sessionNodeMap_[sessionId] = sessionInfo;
219 hpaeCapturerManager->CheckIfAnyStreamRunning();
220 }
221
DumpSourceInfoFuzzTest()222 void DumpSourceInfoFuzzTest()
223 {
224 HpaeSourceInfo sourceInfo = GetSourceInfo();
225 std::shared_ptr<HpaeCapturerManager> hpaeCapturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
226 if (hpaeCapturerManager == nullptr) {
227 return;
228 }
229 hpaeCapturerManager->isInit_ = true;
230 hpaeCapturerManager->DumpSourceInfo();
231 }
232
OnRequestLatencyFuzzTest()233 void OnRequestLatencyFuzzTest()
234 {
235 HpaeSourceInfo sourceInfo = GetSourceInfo();
236 std::shared_ptr<HpaeCapturerManager> hpaeCapturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
237 if (hpaeCapturerManager == nullptr) {
238 return;
239 }
240 uint32_t sessionId = g_fuzzUtils.GetData<uint32_t>();
241 uint64_t latency = g_fuzzUtils.GetData<uint64_t>();
242 hpaeCapturerManager->OnRequestLatency(sessionId, latency);
243 }
244
OnNotifyQueueFuzzTest()245 void OnNotifyQueueFuzzTest()
246 {
247 HpaeSourceInfo sourceInfo = GetSourceInfo();
248 std::shared_ptr<HpaeCapturerManager> hpaeCapturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
249 if (hpaeCapturerManager == nullptr) {
250 return;
251 }
252 hpaeCapturerManager->hpaeSignalProcessThread_ = std::make_unique<HpaeSignalProcessThread>();
253 if (hpaeCapturerManager->hpaeSignalProcessThread_ == nullptr) {
254 return;
255 }
256 hpaeCapturerManager->OnNotifyQueue();
257 }
258
MoveStreamFuzzTest()259 void MoveStreamFuzzTest()
260 {
261 HpaeSourceInfo sourceInfo = GetSourceInfo();
262 std::shared_ptr<HpaeCapturerManager> hpaeCapturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
263 if (hpaeCapturerManager == nullptr) {
264 return;
265 }
266 HpaeNodeInfo nodeInfo;
267 uint32_t sessionId = g_fuzzUtils.GetData<uint32_t>();
268 HpaeCapturerSessionInfo sessionInfo;
269 hpaeCapturerManager->sessionNodeMap_[sessionId] = sessionInfo;
270 hpaeCapturerManager->sourceOutputNodeMap_[sessionId] = std::make_shared<HpaeSourceOutputNode>(nodeInfo);
271 if (hpaeCapturerManager->sourceOutputNodeMap_.empty()) {
272 return;
273 }
274 std::string sourceName = "source_name";
275 hpaeCapturerManager->MoveStream(sessionId, sourceName);
276 }
277
DeactivateThreadFuzzTest()278 void DeactivateThreadFuzzTest()
279 {
280 HpaeSourceInfo sourceInfo = GetSourceInfo();
281 std::shared_ptr<HpaeCapturerManager> hpaeCapturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
282 if (hpaeCapturerManager == nullptr) {
283 return;
284 }
285 hpaeCapturerManager->hpaeSignalProcessThread_ = std::make_unique<HpaeSignalProcessThread>();
286 if (hpaeCapturerManager->hpaeSignalProcessThread_ == nullptr) {
287 return;
288 }
289 hpaeCapturerManager->DeactivateThread();
290 }
291
GetSourceOutputInfoFuzzTest()292 void GetSourceOutputInfoFuzzTest()
293 {
294 HpaeSourceInfo sourceInfo = GetSourceInfo();
295 std::shared_ptr<HpaeCapturerManager> hpaeCapturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
296 if (hpaeCapturerManager == nullptr) {
297 return;
298 }
299 uint32_t sessionId = g_fuzzUtils.GetData<uint32_t>();
300 HpaeSourceOutputInfo sourceOutputInfo;
301 hpaeCapturerManager->GetSourceOutputInfo(sessionId, sourceOutputInfo);
302 }
303
RegisterReadCallbackFuzzTest()304 void RegisterReadCallbackFuzzTest()
305 {
306 HpaeSourceInfo sourceInfo = GetSourceInfo();
307 std::shared_ptr<HpaeCapturerManager> hpaeCapturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
308 if (hpaeCapturerManager == nullptr) {
309 return;
310 }
311 HpaeNodeInfo nodeInfo;
312 uint32_t sessionId = g_fuzzUtils.GetData<uint32_t>();
313 hpaeCapturerManager->sourceOutputNodeMap_[sessionId] = std::make_shared<HpaeSourceOutputNode>(nodeInfo);
314 if (hpaeCapturerManager->sourceOutputNodeMap_.empty()) {
315 return;
316 }
317 const std::weak_ptr<ICapturerStreamCallback> callback = std::weak_ptr<ICapturerStreamCallback>();
318 hpaeCapturerManager->RegisterReadCallback(sessionId, callback);
319 }
320
OnNodeStatusUpdateFuzzTest()321 void OnNodeStatusUpdateFuzzTest()
322 {
323 HpaeSourceInfo sourceInfo = GetSourceInfo();
324 std::shared_ptr<HpaeCapturerManager> hpaeCapturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
325 if (hpaeCapturerManager == nullptr) {
326 return;
327 }
328 uint32_t sessionId = g_fuzzUtils.GetData<uint32_t>();
329 uint32_t index = g_fuzzUtils.GetData<uint32_t>() % IOperationVec.size();
330 IOperation operation = IOperationVec[index];
331 hpaeCapturerManager->OnNodeStatusUpdate(sessionId, operation);
332 }
333
AddAllNodesToSourceFuzzTest()334 void AddAllNodesToSourceFuzzTest()
335 {
336 HpaeSourceInfo sourceInfo = GetSourceInfo();
337 std::shared_ptr<HpaeCapturerManager> hpaeCapturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
338 if (hpaeCapturerManager == nullptr) {
339 return;
340 }
341 HpaeCaptureMoveInfo moveInfo;
342 HpaeNodeInfo nodeInfo;
343 moveInfo.sessionId = g_fuzzUtils.GetData<uint32_t>();
344 moveInfo.sessionInfo.sceneType = HPAE_SCENE_DEFAULT;
345 moveInfo.sourceOutputNode = std::make_shared<HpaeSourceOutputNode>(nodeInfo);
346 std::vector<HpaeCaptureMoveInfo> moveInfos;
347 moveInfos.push_back(moveInfo);
348 bool isConnect = g_fuzzUtils.GetData<bool>();
349 hpaeCapturerManager->AddAllNodesToSource(moveInfos, isConnect);
350 }
351
AddNodeToSourceFuzzTest()352 void AddNodeToSourceFuzzTest()
353 {
354 HpaeSourceInfo sourceInfo = GetSourceInfo();
355 std::shared_ptr<HpaeCapturerManager> hpaeCapturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
356 if (hpaeCapturerManager == nullptr) {
357 return;
358 }
359 HpaeCaptureMoveInfo moveInfo;
360 hpaeCapturerManager->AddNodeToSource(moveInfo);
361 }
362
AddSingleNodeToSourceFuzzTest()363 void AddSingleNodeToSourceFuzzTest()
364 {
365 HpaeSourceInfo sourceInfo = GetSourceInfo();
366 std::shared_ptr<HpaeCapturerManager> hpaeCapturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
367 if (hpaeCapturerManager == nullptr) {
368 return;
369 }
370 HpaeCaptureMoveInfo moveInfo;
371 bool isConnect = g_fuzzUtils.GetData<bool>();
372 hpaeCapturerManager->AddSingleNodeToSource(moveInfo, isConnect);
373 }
374
MoveAllStreamFuzzTest()375 void MoveAllStreamFuzzTest()
376 {
377 HpaeSourceInfo sourceInfo = GetSourceInfo();
378 std::shared_ptr<HpaeCapturerManager> hpaeCapturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
379 if (hpaeCapturerManager == nullptr) {
380 return;
381 }
382 std::string sourceName = "source_name";
383 uint32_t sessionId = g_fuzzUtils.GetData<uint32_t>();
384 std::vector<uint32_t> sessionIds;
385 sessionIds.push_back(sessionId);
386 uint32_t index = g_fuzzUtils.GetData<uint32_t>() % MoveSessionTypeVec.size();
387 MoveSessionType moveType = MoveSessionTypeVec[index];
388 hpaeCapturerManager->MoveAllStream(sourceName, sessionIds, moveType);
389 }
390
UpdateAppsUidAndSessionIdFuzzTest()391 void UpdateAppsUidAndSessionIdFuzzTest()
392 {
393 HpaeSourceInfo sourceInfo = GetSourceInfo();
394 std::shared_ptr<HpaeCapturerManager> hpaeCapturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
395 if (hpaeCapturerManager == nullptr) {
396 return;
397 }
398 int32_t appsUid = g_fuzzUtils.GetData<int32_t>();
399 int32_t sessionId = g_fuzzUtils.GetData<int32_t>();
400 hpaeCapturerManager->appsUid_.push_back(appsUid);
401 hpaeCapturerManager->sessionsId_.push_back(sessionId);
402 HpaeNodeInfo nodeInfo;
403 hpaeCapturerManager->sourceOutputNodeMap_[sessionId] = std::make_shared<HpaeSourceOutputNode>(nodeInfo);
404 if (hpaeCapturerManager->sourceOutputNodeMap_.empty()) {
405 return;
406 }
407 hpaeCapturerManager->UpdateAppsUidAndSessionId();
408 }
409
ReleaseFuzzTest()410 void ReleaseFuzzTest()
411 {
412 HpaeSourceInfo sourceInfo = GetSourceInfo();
413 std::shared_ptr<HpaeCapturerManager> hpaeCapturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
414 if (hpaeCapturerManager == nullptr) {
415 return;
416 }
417 int32_t sessionId = g_fuzzUtils.GetData<int32_t>();
418 hpaeCapturerManager->Release(sessionId);
419 }
420
DrainFuzzTest()421 void DrainFuzzTest()
422 {
423 HpaeSourceInfo sourceInfo = GetSourceInfo();
424 std::shared_ptr<HpaeCapturerManager> hpaeCapturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
425 if (hpaeCapturerManager == nullptr) {
426 return;
427 }
428 hpaeCapturerManager->isInit_ = true;
429 int32_t sessionId = g_fuzzUtils.GetData<int32_t>();
430 HpaeNodeInfo nodeInfo;
431 hpaeCapturerManager->sourceOutputNodeMap_[sessionId] = std::make_shared<HpaeSourceOutputNode>(nodeInfo);
432 if (hpaeCapturerManager->sourceOutputNodeMap_.empty()) {
433 return;
434 }
435 hpaeCapturerManager->Drain(sessionId);
436 }
437
FlushFuzzTest()438 void FlushFuzzTest()
439 {
440 HpaeSourceInfo sourceInfo = GetSourceInfo();
441 std::shared_ptr<HpaeCapturerManager> hpaeCapturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
442 if (hpaeCapturerManager == nullptr) {
443 return;
444 }
445 hpaeCapturerManager->isInit_ = true;
446 int32_t sessionId = g_fuzzUtils.GetData<int32_t>();
447 HpaeNodeInfo nodeInfo;
448 hpaeCapturerManager->sourceOutputNodeMap_[sessionId] = std::make_shared<HpaeSourceOutputNode>(nodeInfo);
449 if (hpaeCapturerManager->sourceOutputNodeMap_.empty()) {
450 return;
451 }
452 hpaeCapturerManager->Flush(sessionId);
453 }
454
455 vector<TestFuncs> g_testFuncs = {
456 CapturerSourceStartFuzzTest,
457 CreateOutputSessionFuzzTest,
458 CaptureEffectCreateFuzzTest,
459 SetSessionStateFuzzTest,
460 SetMuteFuzzTest,
461 PrepareCapturerFuzzTest,
462 CheckIfAnyStreamRunningFuzzTest,
463 DumpSourceInfoFuzzTest,
464 OnRequestLatencyFuzzTest,
465 OnNotifyQueueFuzzTest,
466 MoveStreamFuzzTest,
467 DeactivateThreadFuzzTest,
468 GetSourceOutputInfoFuzzTest,
469 OnNodeStatusUpdateFuzzTest,
470 AddAllNodesToSourceFuzzTest,
471 AddNodeToSourceFuzzTest,
472 AddSingleNodeToSourceFuzzTest,
473 MoveAllStreamFuzzTest,
474 UpdateAppsUidAndSessionIdFuzzTest,
475 ReleaseFuzzTest,
476 DrainFuzzTest,
477 FlushFuzzTest,
478 };
479 } // namespace AudioStandard
480 } // namesapce OHOS
481
482 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)483 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
484 {
485 if (size < OHOS::AudioStandard::FUZZ_INPUT_SIZE_THRESHOLD) {
486 return 0;
487 }
488
489 OHOS::AudioStandard::g_fuzzUtils.fuzzTest(data, size, OHOS::AudioStandard::g_testFuncs);
490 return 0;
491 }