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 <cstddef>
17 #include <cstdint>
18 #include "audio_effect.h"
19 #include "audio_effect_chain.h"
20 #include "audio_effect_log.h"
21 #include "audio_effect_chain_manager.h"
22 #include "audio_effect_chain_adapter.h"
23 #include "audio_enhance_chain_adapter.h"
24 #include "audio_enhance_chain_manager.h"
25 #include "audio_errors.h"
26 #include "audio_head_tracker.h"
27
28 namespace OHOS {
29 namespace AudioStandard {
30 using namespace std;
31
32 const char* SCENETYPEMUSIC = "SCENE_MUSIC";
33 const char* SESSIONIDDEFAULT = "123456";
34 const char* EFFECTDEFAULT = "EFFECT_DEFAULT";
35 const uint32_t AUDIOEFFECTSCENE_LENGTH = 6;
36 const uint32_t AUDIOENCODINGTYPE_LENGTH = 3;
37 const string EXTRASCENETYPE = "2";
38 const int32_t DEFAULT_RATE = 48000;
39 const int32_t DEFAULT_CHANNEL = 4;
40 const int32_t DEFAULT_FORMAT = 1;
41 const int32_t MAX_EXTRA_NUM = 3;
42 const float SYSTEM_VOLINFO = 0.75f;
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
48 vector<EffectChain> DEFAULT_EFFECT_CHAINS = {{"EFFECTCHAIN_SPK_MUSIC", {}, ""}, {"EFFECTCHAIN_BT_MUSIC", {}, ""}};
49 vector<shared_ptr<AudioEffectLibEntry>> DEFAULT_EFFECT_LIBRARY_LIST = {};
50 EffectChainManagerParam DEFAULT_MAP{
51 3,
52 "SCENE_DEFAULT",
53 {},
54 {{"SCENE_MOVIE_&_EFFECT_DEFAULT_&_DEVICE_TYPE_SPEAKER", "EFFECTCHAIN_SPK_MUSIC"},
55 {"SCENE_MOVIE_&_EFFECT_DEFAULT_&_DEVICE_TYPE_BLUETOOTH_A2DP", "EFFECTCHAIN_BT_MUSIC"}},
56 {{"effect1", "property1"}, {"effect4", "property5"}, {"effect1", "property4"}}
57 };
58
59 #define DEFAULT_NUM_CHANNEL 2
60 #define DEFAULT_CHANNELLAYOUT 3
61
62 /*
63 * describe: get data from outside untrusted data(RAW_DATA) which size is according to sizeof(T)
64 * tips: only support basic type
65 */
66 template<class T>
GetData()67 T GetData()
68 {
69 T object {};
70 size_t objectSize = sizeof(object);
71 if (RAW_DATA == nullptr || objectSize > g_dataSize - g_pos) {
72 return object;
73 }
74 errno_t ret = memcpy_s(&object, objectSize, RAW_DATA + g_pos, objectSize);
75 if (ret != EOK) {
76 return {};
77 }
78 g_pos += objectSize;
79 return object;
80 }
81
82 template<class T>
GetArrLength(T & arr)83 uint32_t GetArrLength(T& arr)
84 {
85 if (arr == nullptr) {
86 AUDIO_INFO_LOG("%{public}s: The array length is equal to 0", __func__);
87 return 0;
88 }
89 return sizeof(arr) / sizeof(arr[0]);
90 }
91
EffectChainManagerInitCbFuzzTest()92 void EffectChainManagerInitCbFuzzTest()
93 {
94 AudioEffectChainManager::GetInstance()->InitAudioEffectChainManager(DEFAULT_EFFECT_CHAINS, DEFAULT_MAP,
95 DEFAULT_EFFECT_LIBRARY_LIST);
96
97 const char *sceneType = SCENETYPEMUSIC;
98 EffectChainManagerInitCb(sceneType);
99 sceneType = nullptr;
100 EffectChainManagerInitCb(sceneType);
101 sceneType = "";
102 EffectChainManagerInitCb(sceneType);
103 }
104
EffectChainManagerCreateCbFuzzTest()105 void EffectChainManagerCreateCbFuzzTest()
106 {
107 const char *sceneType = SCENETYPEMUSIC;
108 EffectChainManagerInitCb(sceneType);
109
110 const char *sessionid = SESSIONIDDEFAULT;
111 EffectChainManagerCreateCb(sceneType, sessionid);
112 EffectChainManagerReleaseCb(sceneType, sessionid);
113 sessionid = "";
114 EffectChainManagerCreateCb(sceneType, sessionid);
115 EffectChainManagerReleaseCb(sceneType, sessionid);
116 }
117
EffectChainManagerCheckEffectOffloadFuzzTest()118 void EffectChainManagerCheckEffectOffloadFuzzTest()
119 {
120 const char *sceneType = "";
121 EffectChainManagerInitCb(sceneType);
122 EffectChainManagerCheckEffectOffload();
123 }
124
EffectChainManagerAddSessionInfoFuzzTest()125 void EffectChainManagerAddSessionInfoFuzzTest()
126 {
127 EffectChainManagerInitCb(SCENETYPEMUSIC);
128
129 SessionInfoPack pack = {2, "3", EFFECTDEFAULT, "true"};
130 EffectChainManagerAddSessionInfo(SCENETYPEMUSIC, SESSIONIDDEFAULT, pack);
131 }
132
EffectChainManagerDeleteSessionInfoFuzzTest()133 void EffectChainManagerDeleteSessionInfoFuzzTest()
134 {
135 EffectChainManagerInitCb(SCENETYPEMUSIC);
136
137 SessionInfoPack pack = {2, "3", SESSIONIDDEFAULT, "true"};
138 EffectChainManagerAddSessionInfo(SCENETYPEMUSIC, SESSIONIDDEFAULT, pack);
139 EffectChainManagerDeleteSessionInfo(SCENETYPEMUSIC, SESSIONIDDEFAULT);
140 }
141
EffectChainManagerReturnEffectChannelInfoFuzzTest()142 void EffectChainManagerReturnEffectChannelInfoFuzzTest()
143 {
144 EffectChainManagerInitCb(SCENETYPEMUSIC);
145
146 SessionInfoPack pack = {2, "3", SESSIONIDDEFAULT, "true"};
147 EffectChainManagerAddSessionInfo(SCENETYPEMUSIC, SESSIONIDDEFAULT, pack);
148
149 uint32_t processChannels = GetData<uint32_t>();
150 uint64_t processChannelLayout = GetData<uint64_t>();
151 EffectChainManagerReturnEffectChannelInfo(SCENETYPEMUSIC, &processChannels, &processChannelLayout);
152 }
153
EffectChainManagerReturnMultiChannelInfoFuzzTest()154 void EffectChainManagerReturnMultiChannelInfoFuzzTest()
155 {
156 EffectChainManagerInitCb(SCENETYPEMUSIC);
157
158 uint32_t processChannels = GetData<uint32_t>();
159 uint64_t processChannelLayout = GetData<uint64_t>();
160 EffectChainManagerReturnMultiChannelInfo(&processChannels, &processChannelLayout);
161 }
162
EffectChainManagerSceneCheckFuzzTest()163 void EffectChainManagerSceneCheckFuzzTest()
164 {
165 EffectChainManagerInitCb("SCENE_MUSIC");
166 EffectChainManagerSceneCheck("SCENE_MUSIC", "SCENE_MUSIC");
167 }
168
EffectChainManagerProcessFuzzTest()169 void EffectChainManagerProcessFuzzTest()
170 {
171 EffectChainManagerInitCb(SCENETYPEMUSIC);
172 }
173
EffectChainManagerMultichannelUpdateFuzzTest()174 void EffectChainManagerMultichannelUpdateFuzzTest()
175 {
176 EffectChainManagerInitCb(SCENETYPEMUSIC);
177 EffectChainManagerMultichannelUpdate(nullptr);
178 EffectChainManagerMultichannelUpdate(SCENETYPEMUSIC);
179 }
180
EffectChainManagerExistFuzzTest()181 void EffectChainManagerExistFuzzTest()
182 {
183 EffectChainManagerInitCb(SCENETYPEMUSIC);
184 }
185
EffectChainManagerVolumeUpdateFuzzTest()186 void EffectChainManagerVolumeUpdateFuzzTest()
187 {
188 EffectChainManagerInitCb(SCENETYPEMUSIC);
189 EffectChainManagerVolumeUpdate(SESSIONIDDEFAULT);
190 }
191
AudioEffectChainManagerFirst(std::shared_ptr<AudioEffectChain> audioEffectChain)192 void AudioEffectChainManagerFirst(std::shared_ptr<AudioEffectChain> audioEffectChain)
193 {
194 audioEffectChain->IsEmptyEffectHandles();
195 const uint32_t channels = GetData<uint32_t>();
196 const uint64_t channelLayout = GetData<uint64_t>();
197 audioEffectChain->UpdateMultichannelIoBufferConfig(channels, channelLayout);
198 std::string sceneMode = "EFFECT_DEFAULT";
199 AudioEffectConfig ioBufferConfig;
200 AudioBufferConfig inputCfg;
201 uint32_t samplingRate = GetData<uint32_t>();
202 uint32_t channel = GetData<uint32_t>();
203 uint8_t format = GetData<uint8_t>();
204 uint64_t channelLayouts = GetData<uint64_t>();
205 uint32_t encoding_int = GetData<uint32_t>();
206 encoding_int = (encoding_int%AUDIOENCODINGTYPE_LENGTH)-1;
207 AudioEncodingType encoding = static_cast<AudioEncodingType>(encoding_int);
208 inputCfg.samplingRate = samplingRate;
209 inputCfg.channels = channel;
210 inputCfg.format = format;
211 inputCfg.channelLayout = channelLayouts;
212 inputCfg.encoding = encoding;
213 ioBufferConfig.inputCfg = inputCfg;
214 ioBufferConfig.outputCfg = inputCfg;
215 audioEffectChain->StoreOldEffectChainInfo(sceneMode, ioBufferConfig);
216 }
217
AudioEffectChainFuzzTest()218 void AudioEffectChainFuzzTest()
219 {
220 std::shared_ptr<AudioEffectChain> audioEffectChain = nullptr;
221 std::string sceneType = "SCENE_MUSIC";
222 #ifdef SENSOR_ENABLE
223 std::shared_ptr<HeadTracker> headTracker = nullptr;
224 headTracker = std::make_shared<HeadTracker>();
225 audioEffectChain = std::make_shared<AudioEffectChain>(sceneType, headTracker);
226 #else
227 audioEffectChain = std::make_shared<AudioEffectChain>(sceneType);
228 #endif
229 audioEffectChain->SetEffectMode("EFFECT_DEFAULT");
230 audioEffectChain->SetExtraSceneType(EXTRASCENETYPE);
231 uint32_t currSceneType_int = GetData<uint32_t>();
232 currSceneType_int = (currSceneType_int % AUDIOEFFECTSCENE_LENGTH);
233 AudioEffectScene currSceneType = GetData<AudioEffectScene>();
234 audioEffectChain->SetEffectCurrSceneType(currSceneType);
235 AudioEffectChainManagerFirst(audioEffectChain);
236 }
237
AudioEnhanceChainManagerFuzzTest(AudioEnhanceChainManager * audioEnhanceChainMananger)238 void AudioEnhanceChainManagerFuzzTest(AudioEnhanceChainManager *audioEnhanceChainMananger)
239 {
240 audioEnhanceChainMananger->InitEnhanceBuffer();
241 AudioEnhancePropertyArray propertyArray;
242 AudioVolumeType volumeType = GetData<AudioVolumeType>();
243 audioEnhanceChainMananger->SetVolumeInfo(volumeType, SYSTEM_VOLINFO);
244 bool isMute = true;
245 audioEnhanceChainMananger->SetMicrophoneMuteInfo(isMute);
246 isMute = false;
247 audioEnhanceChainMananger->SetMicrophoneMuteInfo(isMute);
248 uint32_t renderId = GetData<uint32_t>();
249 DeviceType newDeviceType = GetData<DeviceType>();
250 audioEnhanceChainMananger->SetOutputDevice(renderId, newDeviceType);
251 audioEnhanceChainMananger->GetAudioEnhanceProperty(propertyArray);
252 audioEnhanceChainMananger->ResetInfo();
253 audioEnhanceChainMananger->SetInputDevice(DEFAULT_CHANNEL, newDeviceType);
254 }
255
AudioEnhanceChainFuzzTest()256 void AudioEnhanceChainFuzzTest()
257 {
258 EffectChainManagerParam managerParam;
259 managerParam.maxExtraNum = MAX_EXTRA_NUM;
260 managerParam.defaultSceneName = "SCENE_DEFAULT";
261 managerParam.priorSceneList = {};
262 managerParam.sceneTypeToChainNameMap = {{"SCENE_RECORD_&_ENHANCE_DEFAULT_&_DEVICE_TYPE_MIC", "EFFECTCHAIN_RECORD"}};
263 managerParam.effectDefaultProperty = {
264 {"effect1", "property1"}, {"effect2", "property2"}, {"effect3", "property3"}
265 };
266 std::vector<std::shared_ptr<AudioEffectLibEntry>> enhanceLibraryList;
267 enhanceLibraryList = {};
268 AudioEnhanceChainManager *audioEnhanceChainMananger = AudioEnhanceChainManager::GetInstance();
269 EffectChain testChain;
270 testChain.name = "EFFECTCHAIN_RECORD";
271 testChain.apply = {"record"};
272 std::vector<EffectChain> enhanceChains;
273 enhanceChains.emplace_back(testChain);
274 audioEnhanceChainMananger->InitAudioEnhanceChainManager(enhanceChains, managerParam, enhanceLibraryList);
275 DeviceAttrAdapter validAdapter = {DEFAULT_RATE, DEFAULT_CHANNEL, DEFAULT_FORMAT, true,
276 DEFAULT_RATE, DEFAULT_CHANNEL, DEFAULT_FORMAT, true, DEFAULT_RATE, DEFAULT_CHANNEL, DEFAULT_FORMAT};
277 EnhanceChainManagerCreateCb(AUDIOEFFECTSCENE_LENGTH, &validAdapter);
278 EnhanceChainManagerReleaseCb(AUDIOEFFECTSCENE_LENGTH);
279 EnhanceChainManagerExist(AUDIOEFFECTSCENE_LENGTH);
280 pa_sample_spec micSpec;
281 pa_sample_spec ecSpec;
282 pa_sample_spec micRefSpec;
283 pa_sample_spec_init(&micSpec);
284 pa_sample_spec_init(&ecSpec);
285 pa_sample_spec_init(&micRefSpec);
286 EnhanceChainManagerCreateCb(AUDIOEFFECTSCENE_LENGTH, &validAdapter);
287 EnhanceChainManagerGetAlgoConfig(AUDIOEFFECTSCENE_LENGTH, &micSpec, &ecSpec, &micRefSpec);
288 EnhanceChainManagerIsEmptyEnhanceChain();
289 EnhanceChainManagerInitEnhanceBuffer();
290 const char *invalidScene = "SCENE_RECORD";
291 uint64_t sceneTypeCode = GetData<uint64_t>();
292 GetSceneTypeCode(invalidScene, &sceneTypeCode);
293 AudioEnhanceChainManagerFuzzTest(audioEnhanceChainMananger);
294 }
295
296 typedef void (*TestFuncs[14])();
297
298 TestFuncs g_testFuncs = {
299 EffectChainManagerInitCbFuzzTest,
300 EffectChainManagerCreateCbFuzzTest,
301 EffectChainManagerCheckEffectOffloadFuzzTest,
302 EffectChainManagerAddSessionInfoFuzzTest,
303 EffectChainManagerDeleteSessionInfoFuzzTest,
304 EffectChainManagerReturnEffectChannelInfoFuzzTest,
305 EffectChainManagerReturnMultiChannelInfoFuzzTest,
306 EffectChainManagerSceneCheckFuzzTest,
307 EffectChainManagerProcessFuzzTest,
308 EffectChainManagerMultichannelUpdateFuzzTest,
309 EffectChainManagerExistFuzzTest,
310 EffectChainManagerVolumeUpdateFuzzTest,
311 AudioEffectChainFuzzTest,
312 AudioEnhanceChainFuzzTest,
313 };
314
FuzzTest(const uint8_t * rawData,size_t size)315 bool FuzzTest(const uint8_t* rawData, size_t size)
316 {
317 if (rawData == nullptr) {
318 return false;
319 }
320
321 // initialize data
322 RAW_DATA = rawData;
323 g_dataSize = size;
324 g_pos = 0;
325
326 uint32_t code = GetData<uint32_t>();
327 uint32_t len = GetArrLength(g_testFuncs);
328 if (len > 0) {
329 g_testFuncs[code % len]();
330 } else {
331 AUDIO_INFO_LOG("%{public}s: The len length is equal to 0", __func__);
332 }
333
334 return true;
335 }
336 } // namespace AudioStandard
337 } // namespace OHOS
338
339 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)340 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
341 {
342 if (size < OHOS::AudioStandard::THRESHOLD) {
343 return 0;
344 }
345
346 OHOS::AudioStandard::FuzzTest(data, size);
347 return 0;
348 }
349