1 /*
2 * Copyright (c) 2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <iostream>
17 #include <cstddef>
18 #include <cstdint>
19 #include <vector>
20 #include <memory>
21 #include <queue>
22 #include <string>
23 #undef private
24 #include "hpae_source_process_cluster.h"
25 #include "hpae_source_input_cluster.h"
26 #include "hpae_source_input_node.h"
27 #include "hpae_source_output_node.h"
28 #include "audio_effect.h"
29 #include "audio_engine_log.h"
30 using namespace std;
31 using namespace OHOS::AudioStandard::HPAE;
32
33 namespace OHOS {
34 namespace AudioStandard {
35 using namespace std;
36 static const uint8_t *RAW_DATA = nullptr;
37 static size_t g_dataSize = 0;
38 static size_t g_pos;
39 const size_t THRESHOLD = 10;
40 const uint32_t DEFAULT_FRAME_LENGTH = 960;
41 const uint32_t DEFAULT_NODE_ID = 1243;
42 typedef void (*TestPtr)(const uint8_t *, size_t);
43
44 template<class T>
GetData()45 T GetData()
46 {
47 T object {};
48 size_t objectSize = sizeof(object);
49 if (RAW_DATA == nullptr || objectSize > g_dataSize - g_pos) {
50 return object;
51 }
52 errno_t ret = memcpy_s(&object, objectSize, RAW_DATA + g_pos, objectSize);
53 if (ret != EOK) {
54 return {};
55 }
56 g_pos += objectSize;
57 return object;
58 }
59
60 template<class T>
GetArrLength(T & arr)61 uint32_t GetArrLength(T& arr)
62 {
63 if (arr == nullptr) {
64 AUDIO_INFO_LOG("%{public}s: The array length is equal to 0", __func__);
65 return 0;
66 }
67 return sizeof(arr) / sizeof(arr[0]);
68 }
69
GetTestNodeInfo(HpaeNodeInfo & nodeInfo)70 static void GetTestNodeInfo(HpaeNodeInfo &nodeInfo)
71 {
72 nodeInfo.nodeId = DEFAULT_NODE_ID;
73 nodeInfo.frameLen = DEFAULT_FRAME_LENGTH;
74 nodeInfo.samplingRate = SAMPLE_RATE_48000;
75 nodeInfo.channels = STEREO;
76 nodeInfo.format = SAMPLE_S16LE;
77 nodeInfo.sceneType = HPAE_SCENE_MUSIC;
78 nodeInfo.sourceBufferType = HPAE_SOURCE_BUFFER_TYPE_MIC;
79 }
80
DoProcessFuzzTest()81 void DoProcessFuzzTest()
82 {
83 HpaeNodeInfo nodeInfo;
84 GetTestNodeInfo(nodeInfo);
85 auto hpaeSourceProcessCluster = std::make_shared<HpaeSourceProcessCluster>(nodeInfo);
86 hpaeSourceProcessCluster->DoProcess();
87 }
88
ResetFuzzTest()89 void ResetFuzzTest()
90 {
91 HpaeNodeInfo nodeInfo;
92 GetTestNodeInfo(nodeInfo);
93 auto hpaeSourceProcessCluster = std::make_shared<HpaeSourceProcessCluster>(nodeInfo);
94 hpaeSourceProcessCluster->Reset();
95 }
96
ResetAllFuzzTest()97 void ResetAllFuzzTest()
98 {
99 HpaeNodeInfo nodeInfo;
100 GetTestNodeInfo(nodeInfo);
101 auto hpaeSourceProcessCluster = std::make_shared<HpaeSourceProcessCluster>(nodeInfo);
102 hpaeSourceProcessCluster->ResetAll();
103 }
104
GetSharedInstanceFuzzTest()105 void GetSharedInstanceFuzzTest()
106 {
107 HpaeNodeInfo nodeInfo;
108 GetTestNodeInfo(nodeInfo);
109 auto hpaeSourceProcessCluster = std::make_shared<HpaeSourceProcessCluster>(nodeInfo);
110 hpaeSourceProcessCluster->GetSharedInstance();
111 }
112
GetSharedInstanceWithNodeInfoFuzzTest()113 void GetSharedInstanceWithNodeInfoFuzzTest()
114 {
115 HpaeNodeInfo nodeInfo;
116 GetTestNodeInfo(nodeInfo);
117 auto hpaeSourceProcessCluster = std::make_shared<HpaeSourceProcessCluster>(nodeInfo);
118 hpaeSourceProcessCluster->GetSharedInstance(nodeInfo);
119 }
120
GetOutputPortFuzzTest()121 void GetOutputPortFuzzTest()
122 {
123 HpaeNodeInfo nodeInfo;
124 GetTestNodeInfo(nodeInfo);
125 auto hpaeSourceProcessCluster = std::make_shared<HpaeSourceProcessCluster>(nodeInfo);
126 hpaeSourceProcessCluster->GetOutputPort();
127 }
128
GetOutputPortWithNodeInfoFuzzTest()129 void GetOutputPortWithNodeInfoFuzzTest()
130 {
131 HpaeNodeInfo nodeInfo;
132 GetTestNodeInfo(nodeInfo);
133 auto hpaeSourceProcessCluster = std::make_shared<HpaeSourceProcessCluster>(nodeInfo);
134 hpaeSourceProcessCluster->GetOutputPort(nodeInfo);
135 }
136
ConnectFuzzTest()137 void ConnectFuzzTest()
138 {
139 HpaeNodeInfo nodeInfo;
140 GetTestNodeInfo(nodeInfo);
141 auto hpaeSourceProcessCluster = std::make_shared<HpaeSourceProcessCluster>(nodeInfo);
142 std::shared_ptr<HpaeSourceInputCluster> hpaeSourceInputCluster =
143 std::make_shared<HpaeSourceInputCluster>(nodeInfo);
144 hpaeSourceProcessCluster->Connect(hpaeSourceInputCluster);
145 hpaeSourceProcessCluster->DisConnect(hpaeSourceInputCluster);
146 }
147
ConnectWithNodeInfoFuzzTest()148 void ConnectWithNodeInfoFuzzTest()
149 {
150 HpaeNodeInfo nodeInfo;
151 GetTestNodeInfo(nodeInfo);
152 auto hpaeSourceProcessCluster = std::make_shared<HpaeSourceProcessCluster>(nodeInfo);
153 std::shared_ptr<HpaeSourceInputCluster> hpaeSourceInputCluster =
154 std::make_shared<HpaeSourceInputCluster>(nodeInfo);
155 hpaeSourceProcessCluster->ConnectWithInfo(hpaeSourceInputCluster, nodeInfo);
156 hpaeSourceProcessCluster->DisConnectWithInfo(hpaeSourceInputCluster, nodeInfo);
157 }
158
DisConnectFuzzTest()159 void DisConnectFuzzTest()
160 {
161 HpaeNodeInfo nodeInfo;
162 GetTestNodeInfo(nodeInfo);
163 auto hpaeSourceProcessCluster = std::make_shared<HpaeSourceProcessCluster>(nodeInfo);
164 std::shared_ptr<HpaeSourceInputCluster> hpaeSourceInputCluster =
165 std::make_shared<HpaeSourceInputCluster>(nodeInfo);
166 hpaeSourceProcessCluster->DisConnect(hpaeSourceInputCluster);
167 }
168
DisConnectWithNodeInfoFuzzTest()169 void DisConnectWithNodeInfoFuzzTest()
170 {
171 HpaeNodeInfo nodeInfo;
172 GetTestNodeInfo(nodeInfo);
173 auto hpaeSourceProcessCluster = std::make_shared<HpaeSourceProcessCluster>(nodeInfo);
174 std::shared_ptr<HpaeSourceInputCluster> hpaeSourceInputCluster =
175 std::make_shared<HpaeSourceInputCluster>(nodeInfo);
176 hpaeSourceProcessCluster->DisConnectWithInfo(hpaeSourceInputCluster, nodeInfo);
177 }
178
GetCapturerEffectConfigFuzzTest()179 void GetCapturerEffectConfigFuzzTest()
180 {
181 HpaeNodeInfo nodeInfo;
182 GetTestNodeInfo(nodeInfo);
183 auto hpaeSourceProcessCluster = std::make_shared<HpaeSourceProcessCluster>(nodeInfo);
184 hpaeSourceProcessCluster->GetCapturerEffectConfig(nodeInfo);
185 }
186
GetOutputPortNumFuzzTest()187 void GetOutputPortNumFuzzTest()
188 {
189 HpaeNodeInfo nodeInfo;
190 GetTestNodeInfo(nodeInfo);
191 auto hpaeSourceProcessCluster = std::make_shared<HpaeSourceProcessCluster>(nodeInfo);
192 hpaeSourceProcessCluster->GetOutputPortNum();
193 }
194
CaptureEffectCreateFuzzTest()195 void CaptureEffectCreateFuzzTest()
196 {
197 HpaeNodeInfo nodeInfo;
198 GetTestNodeInfo(nodeInfo);
199 auto hpaeSourceProcessCluster = std::make_shared<HpaeSourceProcessCluster>(nodeInfo);
200 uint64_t sceneKeyCode = GetData<uint64_t>();
201 CaptureEffectAttr attr;
202 hpaeSourceProcessCluster->CaptureEffectCreate(sceneKeyCode, attr);
203 }
204
CaptureEffectReleaseFuzzTest()205 void CaptureEffectReleaseFuzzTest()
206 {
207 HpaeNodeInfo nodeInfo;
208 GetTestNodeInfo(nodeInfo);
209 auto hpaeSourceProcessCluster = std::make_shared<HpaeSourceProcessCluster>(nodeInfo);
210 uint64_t sceneKeyCode = GetData<uint64_t>();
211 hpaeSourceProcessCluster->CaptureEffectRelease(sceneKeyCode);
212 }
213
GetCapturerEffectNodeUseCountFuzzTest()214 void GetCapturerEffectNodeUseCountFuzzTest()
215 {
216 HpaeNodeInfo nodeInfo;
217 GetTestNodeInfo(nodeInfo);
218 auto hpaeSourceProcessCluster = std::make_shared<HpaeSourceProcessCluster>(nodeInfo);
219 hpaeSourceProcessCluster->GetCapturerEffectNodeUseCount();
220 }
221
GetConverterNodeCountFuzzTest()222 void GetConverterNodeCountFuzzTest()
223 {
224 HpaeNodeInfo nodeInfo;
225 GetTestNodeInfo(nodeInfo);
226 auto hpaeSourceProcessCluster = std::make_shared<HpaeSourceProcessCluster>(nodeInfo);
227 hpaeSourceProcessCluster->GetConverterNodeCount();
228 }
229
GetPreOutNumFuzzTest()230 void GetPreOutNumFuzzTest()
231 {
232 HpaeNodeInfo nodeInfo;
233 GetTestNodeInfo(nodeInfo);
234 auto hpaeSourceProcessCluster = std::make_shared<HpaeSourceProcessCluster>(nodeInfo);
235 hpaeSourceProcessCluster->GetPreOutNum();
236 }
237
238 typedef void (*TestFuncs[18])();
239
240 TestFuncs g_testFuncs = {
241 DoProcessFuzzTest,
242 ResetFuzzTest,
243 ResetAllFuzzTest,
244 GetSharedInstanceFuzzTest,
245 GetSharedInstanceWithNodeInfoFuzzTest,
246 GetOutputPortFuzzTest,
247 GetOutputPortWithNodeInfoFuzzTest,
248 ConnectFuzzTest,
249 ConnectWithNodeInfoFuzzTest,
250 DisConnectFuzzTest,
251 DisConnectWithNodeInfoFuzzTest,
252 GetCapturerEffectConfigFuzzTest,
253 GetOutputPortNumFuzzTest,
254 CaptureEffectCreateFuzzTest,
255 CaptureEffectReleaseFuzzTest,
256 GetCapturerEffectNodeUseCountFuzzTest,
257 GetConverterNodeCountFuzzTest,
258 GetPreOutNumFuzzTest,
259 };
260
FuzzTest(const uint8_t * rawData,size_t size)261 bool FuzzTest(const uint8_t* rawData, size_t size)
262 {
263 if (rawData == nullptr) {
264 return false;
265 }
266
267 // initialize data
268 RAW_DATA = rawData;
269 g_dataSize = size;
270 g_pos = 0;
271
272 uint32_t code = GetData<uint32_t>();
273 uint32_t len = GetArrLength(g_testFuncs);
274 if (len > 0) {
275 g_testFuncs[code % len]();
276 } else {
277 AUDIO_INFO_LOG("%{public}s: The len length is equal to 0", __func__);
278 }
279
280 return true;
281 }
282
283 } // namespace AudioStandard
284 } // namesapce OHOS
285
286 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)287 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
288 {
289 if (size < OHOS::AudioStandard::THRESHOLD) {
290 return 0;
291 }
292
293 OHOS::AudioStandard::FuzzTest(data, size);
294 return 0;
295 }