1 /*
2 * Copyright (c) 2024 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 <memory>
20 #include "securec.h"
21
22 #include "audio_effect_log.h"
23 #include "audio_effect_chain.h"
24 #ifdef SUPPORT_OLD_ENGINE
25 #include "audio_effect_chain_adapter.h"
26 #include "audio_enhance_chain_adapter.h"
27 #endif
28 #include "audio_effect_chain_manager.h"
29 #include "audio_enhance_chain.h"
30 #include "audio_enhance_chain_manager.h"
31 #include "chain_pool.h"
32 #include "thread_handler.h"
33 using namespace std;
34
35 namespace OHOS {
36 namespace AudioStandard {
37 const int32_t LIMITSIZE = 4;
38 const string EXTRASCENETYPE = "2";
39 const uint32_t AUDIOEFFECTSCENE_LENGTH = 6;
40 const uint32_t CHANNEL_NUM = 10;
41 constexpr uint32_t INFOCHANNELS = 2;
42 constexpr uint64_t INFOCHANNELLAYOUT = 0x3;
43 static const uint8_t *RAW_DATA = nullptr;
44 static size_t g_dataSize = 0;
45 static size_t g_pos;
46 const size_t THRESHOLD = 10;
47 const int32_t NUM_2 = 2;
48 vector<EffectChain> DEFAULT_EFFECT_CHAINS = {{"EFFECTCHAIN_SPK_MUSIC", {}, ""}, {"EFFECTCHAIN_BT_MUSIC", {}, ""}};
49 vector<shared_ptr<AudioEffectLibEntry>> DEFAULT_EFFECT_LIBRARY_LIST = {};
50
51 EffectChainManagerParam DEFAULT_EFFECT_CHAIN_MANAGER_PARAM{
52 3,
53 "SCENE_DEFAULT",
54 {},
55 {{"SCENE_MOVIE_&_EFFECT_DEFAULT_&_DEVICE_TYPE_SPEAKER", "EFFECTCHAIN_SPK_MUSIC"},
56 {"SCENE_MOVIE_&_EFFECT_DEFAULT_&_DEVICE_TYPE_BLUETOOTH_A2DP", "EFFECTCHAIN_BT_MUSIC"}},
57 {{"effect1", "property1"}, {"effect4", "property5"}, {"effect1", "property4"}}
58 };
59
60 /*
61 * describe: get data from outside untrusted data(RAW_DATA) which size is according to sizeof(T)
62 * tips: only support basic type
63 */
64 template<class T>
GetData()65 T GetData()
66 {
67 T object {};
68 size_t objectSize = sizeof(object);
69 if (RAW_DATA == nullptr || objectSize > g_dataSize - g_pos) {
70 return object;
71 }
72 errno_t ret = memcpy_s(&object, objectSize, RAW_DATA + g_pos, objectSize);
73 if (ret != EOK) {
74 return {};
75 }
76 g_pos += objectSize;
77 return object;
78 }
79
80 template<class T>
GetArrLength(T & arr)81 uint32_t GetArrLength(T& arr)
82 {
83 if (arr == nullptr) {
84 AUDIO_INFO_LOG("%{public}s: The array length is equal to 0", __func__);
85 return 0;
86 }
87 return sizeof(arr) / sizeof(arr[0]);
88 }
89
AudioEffectChainEnhance(std::shared_ptr<AudioEffectChain> audioEffectChain)90 void AudioEffectChainEnhance(std::shared_ptr<AudioEffectChain> audioEffectChain)
91 {
92 std::string sceneType = "SCENE_MUSIC";
93 #ifdef SENSOR_ENABLE
94 std::shared_ptr<HeadTracker> headTracker = nullptr;
95 headTracker = std::make_shared<HeadTracker>();
96 audioEffectChain = std::make_shared<AudioEffectChain>(sceneType, headTracker);
97 #else
98 audioEffectChain = std::make_shared<AudioEffectChain>(sceneType);
99 #endif
100
101 int32_t streamUsage = GetData<int32_t>();
102 audioEffectChain->SetStreamUsage(streamUsage);
103
104 std::string effect = "";
105 std::string property = "";
106 audioEffectChain->SetEffectProperty(effect, property);
107
108 audioEffectChain->UpdateEffectParam();
109 audioEffectChain->UpdateMultichannelIoBufferConfigInner();
110
111 float volume = GetData<float>();
112 audioEffectChain->GetFinalVolume();
113 audioEffectChain->SetFinalVolume(volume);
114 }
115
AudioEffectChainEnhanceFuzzTest()116 void AudioEffectChainEnhanceFuzzTest()
117 {
118 std::shared_ptr<AudioEffectChain> audioEffectChain = nullptr;
119 std::string sceneType = "SCENE_MUSIC";
120 #ifdef SENSOR_ENABLE
121 std::shared_ptr<HeadTracker> headTracker = nullptr;
122 headTracker = std::make_shared<HeadTracker>();
123 audioEffectChain = std::make_shared<AudioEffectChain>(sceneType, headTracker);
124 #else
125 audioEffectChain = std::make_shared<AudioEffectChain>(sceneType);
126 #endif
127 audioEffectChain->SetEffectMode("EFFECT_DEFAULT");
128 audioEffectChain->SetExtraSceneType(EXTRASCENETYPE);
129 uint32_t currSceneTypeInt = GetData<uint32_t>();
130 currSceneTypeInt = (currSceneTypeInt % AUDIOEFFECTSCENE_LENGTH);
131 AudioEffectScene currSceneType = static_cast<AudioEffectScene>(currSceneTypeInt);
132 audioEffectChain->SetEffectCurrSceneType(currSceneType);
133 AudioEffectChainEnhance(audioEffectChain);
134 }
135
AudioEffectChainManagerEnhanceFuzzTest()136 void AudioEffectChainManagerEnhanceFuzzTest()
137 {
138 std::shared_ptr<AudioEffectVolume> audioEffectVolume = std::make_shared<AudioEffectVolume>();
139 AudioEffectChainManager::GetInstance()->EffectDspVolumeUpdate(audioEffectVolume);
140
141 std::string mainkey = "audio_effect";
142 std::string subkey = "update_audio_effect_type";
143 std::string extraSceneType = "0";
144 AudioEffectChainManager::GetInstance()->UpdateParamExtra(mainkey, subkey, extraSceneType);
145 AudioEffectChainManager::GetInstance()->SetSpatializationSceneTypeToChains();
146 AudioEffectChainManager::GetInstance()->UpdateStreamUsage();
147 AudioEffectChainManager::GetInstance()->UpdateCurrSceneTypeAndStreamUsageForDsp();
148
149 std::string sceneType = "SCENE_DEFAULT";
150 AudioEffectChainManager::GetInstance()->GetSceneTypeToChainCount(sceneType);
151
152 std::set<std::string> sessions = {"12345", "67890", "34567"};
153 uint32_t maxSessionID = GetData<uint32_t>();
154 const std::string sessionID = "12345";
155 std::string sceneTypeMax = "EFFECT_NONE";
156 SessionEffectInfo sessionEffectInfo = {
157 "EFFECT_NONE",
158 "SCENE_MOVIE",
159 INFOCHANNELS,
160 INFOCHANNELLAYOUT,
161 };
162
163 AudioEffectChainManager::GetInstance()->sessionIDToEffectInfoMap_[sessionID] = sessionEffectInfo;
164 const std::string scenePairType = "SCENE_MUSIC_&_DEVICE_TYPE_SPEAKER";
165 AudioEffectChainManager::GetInstance()->FindMaxSessionID(maxSessionID, sceneTypeMax, scenePairType, sessions);
166 }
167
AudioEffectChainAdapterFuzzTest()168 void AudioEffectChainAdapterFuzzTest()
169 {
170 #ifdef SUPPORT_OLD_ENGINE
171 struct BufferAttr bufferAttr;
172 char sceneType[] = "SCENE_MUSIC";
173 EffectChainManagerProcess(sceneType, &bufferAttr);
174
175 const char *sceneTypeExist = "SCENE_MUSIC";
176 EffectChainManagerGetSceneCount(sceneTypeExist);
177
178 const char *effectMode = "EFFECT_DEFAULT";
179 EffectChainManagerExist(sceneTypeExist, effectMode);
180
181 const uint64_t channelLayout = CH_LAYOUT_MONO;
182 pa_channel_map processCm;
183 ConvertChLayoutToPaChMap(channelLayout, &processCm);
184
185 const uint64_t channelLayout2 = CH_LAYOUT_STEREO;
186 pa_channel_map processCm2;
187 ConvertChLayoutToPaChMap(channelLayout2, &processCm2);
188 EffectChainManagerEffectUpdate();
189 EffectChainManagerStreamUsageUpdate();
190 #endif
191 }
192
ConvertChLayoutToPaChMapFuzzTest()193 void ConvertChLayoutToPaChMapFuzzTest()
194 {
195 #ifdef SUPPORT_OLD_ENGINE
196 const char *sceneType = "SCENE_MUSIC";
197 AudioEffectChainManager::GetInstance()->InitAudioEffectChainManager(DEFAULT_EFFECT_CHAINS,
198 DEFAULT_EFFECT_CHAIN_MANAGER_PARAM, DEFAULT_EFFECT_LIBRARY_LIST);
199 EffectChainManagerInitCb(sceneType);
200
201 const uint64_t channelLayout = CH_LAYOUT_MONO;
202 pa_channel_map processCm;
203 ConvertChLayoutToPaChMap(channelLayout, &processCm);
204
205 const uint64_t channelLayout2 = CH_LAYOUT_STEREO;
206 pa_channel_map processCm2;
207 ConvertChLayoutToPaChMap(channelLayout2, &processCm2);
208
209 AudioEffectChainManager::GetInstance()->ResetInfo();
210 #endif
211 }
212
EffectChainManagerDeleteSessionInfoFuzzTest()213 void EffectChainManagerDeleteSessionInfoFuzzTest()
214 {
215 #ifdef SUPPORT_OLD_ENGINE
216 const char *sceneType = "SCENE_MUSIC";
217 AudioEffectChainManager::GetInstance()->InitAudioEffectChainManager(DEFAULT_EFFECT_CHAINS,
218 DEFAULT_EFFECT_CHAIN_MANAGER_PARAM, DEFAULT_EFFECT_LIBRARY_LIST);
219 EffectChainManagerInitCb(sceneType);
220
221 const char *sessionid = "123456";
222 SessionInfoPack pack = {2, "3", "EFFECT_DEFAULT", "true", "1", "1"};
223 EffectChainManagerAddSessionInfo(sceneType, sessionid, pack);
224
225 sceneType = nullptr;
226 // Intentionally test with nullptr for fuzzing
227 EffectChainManagerDeleteSessionInfo(sceneType, sessionid);
228 AudioEffectChainManager::GetInstance()->ResetInfo();
229 #endif
230 }
231
EffectChainManagerReturnEffectChannelInfoFuzzTest()232 void EffectChainManagerReturnEffectChannelInfoFuzzTest()
233 {
234 #ifdef SUPPORT_OLD_ENGINE
235 const char *sceneType = "test_scene";
236 uint32_t channels = 0;
237 EffectChainManagerReturnEffectChannelInfo(sceneType, &channels, nullptr);
238 #endif
239 }
240
EffectChainManagerQueryHdiSupportedChannelLayoutFuzzTest()241 void EffectChainManagerQueryHdiSupportedChannelLayoutFuzzTest()
242 {
243 #ifdef SUPPORT_OLD_ENGINE
244 uint32_t channels = GetData<uint32_t>();
245 uint64_t channelLayout = GetData<uint64_t>();
246 // Intentionally test with nullptr for fuzzing
247 EffectChainManagerQueryHdiSupportedChannelLayout(nullptr, nullptr);
248 EffectChainManagerQueryHdiSupportedChannelLayout(&channels, &channelLayout);
249 #endif
250 }
251
EffectChainManagerSceneCheckFuzzTest()252 void EffectChainManagerSceneCheckFuzzTest()
253 {
254 #ifdef SUPPORT_OLD_ENGINE
255 EffectChainManagerSceneCheck(nullptr, nullptr);
256 #endif
257 }
258
EffectChainManagerGetSceneCountFuzzTest()259 void EffectChainManagerGetSceneCountFuzzTest()
260 {
261 #ifdef SUPPORT_OLD_ENGINE
262 EffectChainManagerGetSceneCount(nullptr);
263 #endif
264 }
265
AudioEnhanceChainMoreFuzzTest()266 void AudioEnhanceChainMoreFuzzTest()
267 {
268 std::string scene = "scene";
269 AudioEnhanceParamAdapter algoParam;
270 AudioEnhanceDeviceAttr deviceAttr;
271 uint64_t chainId = GetData<uint64_t>();
272 std::shared_ptr<AudioEnhanceChain> audioEnhanceChain =
273 std::make_shared<AudioEnhanceChain>(chainId, scene, ScenePriority::PRIOR_SCENE, algoParam, deviceAttr);
274 if (audioEnhanceChain == nullptr) {
275 return;
276 }
277
278 std::vector<uint8_t> src(LIMITSIZE);
279 std::vector<uint8_t> dst(LIMITSIZE);
280 uint32_t channel = CHANNEL_NUM;
281 uint32_t offset = 0;
282 audioEnhanceChain->DeinterleaverData(src.data(), channel, dst.data(), offset);
283
284 EnhanceTransBuffer transBuf = {};
285 transBuf.micData = dst.data();
286 transBuf.micDataLen = dst.size();
287 audioEnhanceChain->ApplyEnhanceChain(transBuf);
288
289 std::vector<uint8_t> outBuf(LIMITSIZE);
290 audioEnhanceChain->GetOutputDataFromChain(outBuf.data(), outBuf.size());
291 }
292
AudioEnhanceChainSetParaFuzzTest()293 void AudioEnhanceChainSetParaFuzzTest()
294 {
295 std::string scene = "RECORD";
296 AudioEnhanceParamAdapter algoParam = {};
297 AudioEnhanceDeviceAttr deviceAttr = {};
298 uint64_t chainId = GetData<uint64_t>();
299 std::shared_ptr<AudioEnhanceChain> audioEnhanceChain =
300 std::make_shared<AudioEnhanceChain>(chainId, scene, ScenePriority::NORMAL_SCENE, algoParam, deviceAttr);
301 if (audioEnhanceChain == nullptr) {
302 return;
303 }
304
305 std::vector<EnhanceModulePara> moduleParas;
306 audioEnhanceChain->CreateAllEnhanceModule(moduleParas);
307
308 std::string inputDevice = "inputDevice";
309 std::string deviceName = "deviceName";
310 audioEnhanceChain->SetInputDevice(inputDevice, deviceName);
311
312 std::string effect = "voip_up";
313 std::string prop = "test_prop";
314 audioEnhanceChain->SetEnhanceProperty(effect, prop);
315
316 bool isMute = (GetData<uint32_t>() % 2 == 0);
317 uint32_t systemVol = GetData<uint32_t>();
318 audioEnhanceChain->SetEnhanceParam(isMute, systemVol);
319
320 uint32_t foldState = GetData<uint32_t>();
321 audioEnhanceChain->SetFoldState(foldState);
322
323 audioEnhanceChain->SetThreadHandler(nullptr);
324 audioEnhanceChain->InitCommand();
325 }
326
AudioEnhanceChainGetParaFuzzTest()327 void AudioEnhanceChainGetParaFuzzTest()
328 {
329 std::string scene = "VOIP_UP";
330 AudioEnhanceParamAdapter algoParam = {};
331 AudioEnhanceDeviceAttr deviceAttr = {};
332 uint64_t chainId = GetData<uint64_t>();
333 std::shared_ptr<AudioEnhanceChain> audioEnhanceChain =
334 std::make_shared<AudioEnhanceChain>(chainId, scene, ScenePriority::NORMAL_SCENE, algoParam, deviceAttr);
335 if (audioEnhanceChain == nullptr) {
336 return;
337 }
338
339 audioEnhanceChain->IsEmptyEnhanceHandles();
340 audioEnhanceChain->GetChainId();
341 audioEnhanceChain->GetScenePriority();
342
343 AudioBufferConfig micConfig = {};
344 AudioBufferConfig ecConfig = {};
345 AudioBufferConfig micRefConfig = {};
346 audioEnhanceChain->GetAlgoConfig(micConfig, ecConfig, micRefConfig);
347 }
348
ChainPoolFuzzTest()349 void ChainPoolFuzzTest()
350 {
351 ChainPool::GetInstance().AddChain(nullptr);
352
353 std::string scene = "TRANS";
354 AudioEnhanceParamAdapter algoParam = {};
355 AudioEnhanceDeviceAttr deviceAttr = {};
356 uint64_t chainId = GetData<uint64_t>();
357 std::shared_ptr<AudioEnhanceChain> audioEnhanceChain =
358 std::make_shared<AudioEnhanceChain>(chainId, scene, ScenePriority::NORMAL_SCENE, algoParam, deviceAttr);
359
360 ChainPool::GetInstance().AddChain(audioEnhanceChain);
361 ChainPool::GetInstance().GetChainById(chainId);
362 ChainPool::GetInstance().GetAllChain();
363 ChainPool::GetInstance().DeleteChain(chainId);
364 }
365
ThreadHandlerFuzzTest()366 void ThreadHandlerFuzzTest()
367 {
368 std::string name = "test_thread";
369 auto handler = ThreadHandler::NewInstance(name);
370 if (handler == nullptr) {
371 return;
372 }
373
374 auto task1 = []() {
375 AUDIO_INFO_LOG("execute task 1");
376 };
377 handler->PostTask(task1);
378
379 auto task2 = []() {
380 AUDIO_INFO_LOG("execute task 2");
381 };
382 handler->EnsureTask(task2);
383 }
384
AudioEnhanceChainManagerMoreFuzzTest()385 void AudioEnhanceChainManagerMoreFuzzTest()
386 {
387 AudioEnhanceChainManager *audioEnhanceChainMananger = AudioEnhanceChainManager::GetInstance();
388
389 const uint32_t bufferLen = 1000;
390 std::vector<uint8_t> dummyData(bufferLen, 0x08);
391 EnhanceTransBuffer transBuf = {};
392 transBuf.micData = dummyData.data();
393 transBuf.micDataLen = dummyData.size();
394
395 uint64_t sceneKeyCode = GetData<uint64_t>();
396 audioEnhanceChainMananger->ApplyEnhanceChainById(sceneKeyCode, transBuf);
397
398 std::vector<uint8_t> output(bufferLen);
399 audioEnhanceChainMananger->GetChainOutputDataById(sceneKeyCode, output.data(), output.size());
400 }
401
AudioEnhanceChainAdapterMoreFuzzTest()402 void AudioEnhanceChainAdapterMoreFuzzTest()
403 {
404 #ifdef SUPPORT_OLD_ENGINE
405 void *data = nullptr;
406 uint32_t length = GetData<uint32_t>();
407 CopyToEnhanceBufferAdapter(data, length);
408 CopyEcdataToEnhanceBufferAdapter(data, length);
409 CopyMicRefdataToEnhanceBufferAdapter(data, length);
410 CopyFromEnhanceBufferAdapter(data, length);
411
412 uint64_t sceneKeyCode = GetData<uint64_t>();
413 EnhanceChainManagerProcess(sceneKeyCode, length);
414
415 uint32_t captureId = GetData<uint32_t>();
416 EnhanceChainManagerProcessDefault(captureId, length);
417 #endif
418 }
419
420 using FuzzFunc = decltype(AudioEffectChainEnhanceFuzzTest);
421 FuzzFunc *g_fuzzFuncs[] = {
422 AudioEffectChainEnhanceFuzzTest,
423 AudioEffectChainManagerEnhanceFuzzTest,
424 AudioEffectChainAdapterFuzzTest,
425 ConvertChLayoutToPaChMapFuzzTest,
426 EffectChainManagerDeleteSessionInfoFuzzTest,
427 EffectChainManagerReturnEffectChannelInfoFuzzTest,
428 EffectChainManagerQueryHdiSupportedChannelLayoutFuzzTest,
429 EffectChainManagerSceneCheckFuzzTest,
430 EffectChainManagerGetSceneCountFuzzTest,
431 AudioEnhanceChainMoreFuzzTest,
432 AudioEnhanceChainManagerMoreFuzzTest,
433 AudioEnhanceChainAdapterMoreFuzzTest,
434 AudioEnhanceChainSetParaFuzzTest,
435 AudioEnhanceChainGetParaFuzzTest,
436 ChainPoolFuzzTest,
437 ThreadHandlerFuzzTest,
438 };
439
FuzzTest(const uint8_t * rawData,size_t size)440 bool FuzzTest(const uint8_t* rawData, size_t size)
441 {
442 if (rawData == nullptr) {
443 return false;
444 }
445
446 // initialize data
447 RAW_DATA = rawData;
448 g_dataSize = size;
449 g_pos = 0;
450
451 uint32_t code = GetData<uint32_t>();
452 uint32_t len = GetArrLength(g_fuzzFuncs);
453 if (len > 0) {
454 g_fuzzFuncs[code % len]();
455 } else {
456 AUDIO_INFO_LOG("%{public}s: The len length is equal to 0", __func__);
457 }
458
459 return true;
460 }
461 } // namespace AudioStandard
462 } // namesapce OHOS
463
464 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)465 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
466 {
467 if (size < OHOS::AudioStandard::THRESHOLD) {
468 return 0;
469 }
470
471 OHOS::AudioStandard::FuzzTest(data, size);
472 return 0;
473 }
474