1 /*
2 * Copyright (c) 2023 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 "avcodec_common.h"
19 #include "avcodec_audio_common.h"
20 #include "native_avcodec_audioencoder.h"
21 #include "common/native_mfmagic.h"
22 #include "native_avcodec_audiocodec.h"
23 #include "avcodec_audio_encoder.h"
24 #define FUZZ_PROJECT_NAME "audiodecoderConfigure_fuzzer"
25 namespace OHOS {
AudioAACConfigureFuzzTest(const uint8_t * data,size_t size)26 bool AudioAACConfigureFuzzTest(const uint8_t *data, size_t size)
27 {
28 if (size < sizeof(int64_t)) {
29 return false;
30 }
31 OH_AVCodec *source = OH_AudioCodec_CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AAC, true);
32
33 int32_t intData = *reinterpret_cast<const int32_t *>(data);
34 int64_t longData = *reinterpret_cast<const int64_t *>(data);
35 OH_AVFormat *format = OH_AVFormat_Create();
36 OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, intData);
37 OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, intData);
38 OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, longData);
39 OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUDIO_SAMPLE_FORMAT, intData);
40 OH_AVFormat_SetIntValue(format, OH_MD_KEY_BITS_PER_CODED_SAMPLE, intData);
41 OH_AVFormat_SetIntValue(format, OH_MD_KEY_COMPLIANCE_LEVEL, intData);
42 OH_AVFormat_SetIntValue(format, OH_MD_KEY_AAC_IS_ADTS, 1); //aactest
43
44 OH_AudioCodec_Configure(source, format);
45 if (source) {
46 OH_AudioCodec_Destroy(source);
47 }
48 if (format != nullptr) {
49 OH_AVFormat_Destroy(format);
50 format = nullptr;
51 }
52
53 OH_AVCodec *encodersource = OH_AudioCodec_CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AAC, false);
54 if (encodersource == nullptr) {
55 return false;
56 }
57
58 format = OH_AVFormat_Create();
59 OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, intData);
60 OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, intData);
61 OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, longData);
62 OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUDIO_SAMPLE_FORMAT, intData);
63 OH_AVFormat_SetIntValue(format, OH_MD_KEY_BITS_PER_CODED_SAMPLE, intData);
64 OH_AVFormat_SetIntValue(format, OH_MD_KEY_COMPLIANCE_LEVEL, intData);
65
66 OH_AudioCodec_Configure(encodersource, format);
67 if (encodersource) {
68 OH_AudioCodec_Destroy(encodersource);
69 }
70 if (format != nullptr) {
71 OH_AVFormat_Destroy(format);
72 format = nullptr;
73 }
74 return true;
75 }
76
AudioFlacConfigureFuzzTest(const uint8_t * data,size_t size)77 bool AudioFlacConfigureFuzzTest(const uint8_t *data, size_t size)
78 {
79 if (size < sizeof(int64_t)) {
80 return false;
81 }
82 OH_AVCodec *decodersource = OH_AudioCodec_CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_FLAC, true);
83 if (decodersource == nullptr) {
84 return false;
85 }
86 int32_t intData = *reinterpret_cast<const int32_t *>(data);
87 int64_t longData = *reinterpret_cast<const int64_t *>(data);
88 OH_AVFormat *format = OH_AVFormat_Create();
89 OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, intData);
90 OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, intData);
91 OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, longData);
92 OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUDIO_SAMPLE_FORMAT, intData);
93 OH_AVFormat_SetIntValue(format, OH_MD_KEY_BITS_PER_CODED_SAMPLE, intData);
94 OH_AVFormat_SetIntValue(format, OH_MD_KEY_COMPLIANCE_LEVEL, intData);
95
96 OH_AudioCodec_Configure(decodersource, format);
97 if (decodersource) {
98 OH_AudioCodec_Destroy(decodersource);
99 }
100 if (format != nullptr) {
101 OH_AVFormat_Destroy(format);
102 format = nullptr;
103 }
104
105 OH_AVCodec *encodersource = OH_AudioCodec_CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_FLAC, false);
106 if (encodersource == nullptr) {
107 return false;
108 }
109
110 format = OH_AVFormat_Create();
111 OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, intData);
112 OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, intData);
113 OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, longData);
114 OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUDIO_SAMPLE_FORMAT, intData);
115 OH_AVFormat_SetIntValue(format, OH_MD_KEY_BITS_PER_CODED_SAMPLE, intData);
116 OH_AVFormat_SetIntValue(format, OH_MD_KEY_COMPLIANCE_LEVEL, intData);
117
118 OH_AudioCodec_Configure(encodersource, format);
119 if (encodersource) {
120 OH_AudioCodec_Destroy(encodersource);
121 }
122 if (format != nullptr) {
123 OH_AVFormat_Destroy(format);
124 format = nullptr;
125 }
126 return true;
127 }
128
AudioMP3ConfigureFuzzTest(const uint8_t * data,size_t size)129 bool AudioMP3ConfigureFuzzTest(const uint8_t *data, size_t size)
130 {
131 if (size < sizeof(int64_t)) {
132 return false;
133 }
134 OH_AVCodec *decodersource = OH_AudioCodec_CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_MPEG, true);
135 if (decodersource == nullptr) {
136 return false;
137 }
138 int32_t intData = *reinterpret_cast<const int32_t *>(data);
139 int64_t longData = *reinterpret_cast<const int64_t *>(data);
140 OH_AVFormat *format = OH_AVFormat_Create();
141 OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, intData);
142 OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, intData);
143 OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, longData);
144 OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUDIO_SAMPLE_FORMAT, intData);
145 OH_AVFormat_SetIntValue(format, OH_MD_KEY_BITS_PER_CODED_SAMPLE, intData);
146 OH_AVFormat_SetIntValue(format, OH_MD_KEY_COMPLIANCE_LEVEL, intData);
147
148 OH_AudioCodec_Configure(decodersource, format);
149 if (decodersource) {
150 OH_AudioCodec_Destroy(decodersource);
151 }
152 if (format != nullptr) {
153 OH_AVFormat_Destroy(format);
154 format = nullptr;
155 }
156 return true;
157 }
158
AudioVorbisConfigureFuzzTest(const uint8_t * data,size_t size)159 bool AudioVorbisConfigureFuzzTest(const uint8_t *data, size_t size)
160 {
161 if (size < sizeof(int64_t)) {
162 return false;
163 }
164 OH_AVCodec *decodersource = OH_AudioCodec_CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_VORBIS, true);
165 if (decodersource == nullptr) {
166 return false;
167 }
168 int32_t intData = *reinterpret_cast<const int32_t *>(data);
169 int64_t longData = *reinterpret_cast<const int64_t *>(data);
170 OH_AVFormat *format = OH_AVFormat_Create();
171 OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, intData);
172 OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, intData);
173 OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, longData);
174 OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUDIO_SAMPLE_FORMAT, intData);
175 OH_AVFormat_SetIntValue(format, OH_MD_KEY_BITS_PER_CODED_SAMPLE, intData);
176 OH_AVFormat_SetIntValue(format, OH_MD_KEY_COMPLIANCE_LEVEL, intData);
177
178 OH_AudioCodec_Configure(decodersource, format);
179 if (decodersource) {
180 OH_AudioCodec_Destroy(decodersource);
181 }
182 if (format != nullptr) {
183 OH_AVFormat_Destroy(format);
184 format = nullptr;
185 }
186 return true;
187 }
188
AudioLBVCConfigureFuzzTest(const uint8_t * data,size_t size)189 bool AudioLBVCConfigureFuzzTest(const uint8_t *data, size_t size)
190 {
191 if (size < sizeof(int64_t)) {
192 return false;
193 }
194 OH_AVCodec *decodersource = OH_AudioCodec_CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_LBVC, true);
195 if (decodersource == nullptr) {
196 return false;
197 }
198 int32_t intData = *reinterpret_cast<const int32_t *>(data);
199 int64_t longData = *reinterpret_cast<const int64_t *>(data);
200 OH_AVFormat *format = OH_AVFormat_Create();
201 OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, intData);
202 OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, intData);
203 OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, longData);
204 OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUDIO_SAMPLE_FORMAT, intData);
205 OH_AVFormat_SetIntValue(format, OH_MD_KEY_BITS_PER_CODED_SAMPLE, intData);
206 OH_AVFormat_SetIntValue(format, OH_MD_KEY_COMPLIANCE_LEVEL, intData);
207
208 OH_AudioCodec_Configure(decodersource, format);
209 if (decodersource) {
210 OH_AudioCodec_Destroy(decodersource);
211 }
212 if (format != nullptr) {
213 OH_AVFormat_Destroy(format);
214 format = nullptr;
215 }
216
217 OH_AVCodec *encodersource = OH_AudioCodec_CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_LBVC, false);
218 if (encodersource == nullptr) {
219 return false;
220 }
221
222 format = OH_AVFormat_Create();
223 OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, intData);
224 OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, intData);
225 OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, longData);
226 OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUDIO_SAMPLE_FORMAT, intData);
227 OH_AVFormat_SetIntValue(format, OH_MD_KEY_BITS_PER_CODED_SAMPLE, intData);
228 OH_AVFormat_SetIntValue(format, OH_MD_KEY_COMPLIANCE_LEVEL, intData);
229
230 OH_AudioCodec_Configure(encodersource, format);
231 if (encodersource) {
232 OH_AudioCodec_Destroy(encodersource);
233 }
234 if (format != nullptr) {
235 OH_AVFormat_Destroy(format);
236 format = nullptr;
237 }
238 return true;
239 }
240
AudioAMRNBConfigureFuzzTest(const uint8_t * data,size_t size)241 bool AudioAMRNBConfigureFuzzTest(const uint8_t *data, size_t size)
242 {
243 if (size < sizeof(int64_t)) {
244 return false;
245 }
246 OH_AVCodec *decodersource = OH_AudioCodec_CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AMR_NB, true);
247 if (decodersource == nullptr) {
248 return false;
249 }
250 int32_t intData = *reinterpret_cast<const int32_t *>(data);
251 int64_t longData = *reinterpret_cast<const int64_t *>(data);
252 OH_AVFormat *format = OH_AVFormat_Create();
253 OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, intData);
254 OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, intData);
255 OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, longData);
256 OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUDIO_SAMPLE_FORMAT, intData);
257 OH_AVFormat_SetIntValue(format, OH_MD_KEY_BITS_PER_CODED_SAMPLE, intData);
258 OH_AVFormat_SetIntValue(format, OH_MD_KEY_COMPLIANCE_LEVEL, intData);
259
260 OH_AudioCodec_Configure(decodersource, format);
261 if (decodersource) {
262 OH_AudioCodec_Destroy(decodersource);
263 }
264 if (format != nullptr) {
265 OH_AVFormat_Destroy(format);
266 format = nullptr;
267 }
268
269 OH_AVCodec *encodersource = OH_AudioCodec_CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AMR_NB, false);
270 if (encodersource == nullptr) {
271 return false;
272 }
273
274 format = OH_AVFormat_Create();
275 OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, intData);
276 OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, intData);
277 OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, longData);
278 OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUDIO_SAMPLE_FORMAT, intData);
279 OH_AVFormat_SetIntValue(format, OH_MD_KEY_BITS_PER_CODED_SAMPLE, intData);
280 OH_AVFormat_SetIntValue(format, OH_MD_KEY_COMPLIANCE_LEVEL, intData);
281
282 OH_AudioCodec_Configure(encodersource, format);
283 if (encodersource) {
284 OH_AudioCodec_Destroy(encodersource);
285 }
286 if (format != nullptr) {
287 OH_AVFormat_Destroy(format);
288 format = nullptr;
289 }
290 return true;
291 }
292
AudioAMRWBConfigureFuzzTest(const uint8_t * data,size_t size)293 bool AudioAMRWBConfigureFuzzTest(const uint8_t *data, size_t size)
294 {
295 if (size < sizeof(int64_t)) {
296 return false;
297 }
298 OH_AVCodec *decodersource = OH_AudioCodec_CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AMR_WB, true);
299 if (decodersource == nullptr) {
300 return false;
301 }
302 int32_t intData = *reinterpret_cast<const int32_t *>(data);
303 int64_t longData = *reinterpret_cast<const int64_t *>(data);
304 OH_AVFormat *format = OH_AVFormat_Create();
305 OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, intData);
306 OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, intData);
307 OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, longData);
308 OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUDIO_SAMPLE_FORMAT, intData);
309 OH_AVFormat_SetIntValue(format, OH_MD_KEY_BITS_PER_CODED_SAMPLE, intData);
310 OH_AVFormat_SetIntValue(format, OH_MD_KEY_COMPLIANCE_LEVEL, intData);
311
312 OH_AudioCodec_Configure(decodersource, format);
313 if (decodersource) {
314 OH_AudioCodec_Destroy(decodersource);
315 }
316 if (format != nullptr) {
317 OH_AVFormat_Destroy(format);
318 format = nullptr;
319 }
320
321 OH_AVCodec *encodersource = OH_AudioCodec_CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_AMR_WB, false);
322 if (encodersource == nullptr) {
323 return false;
324 }
325
326 format = OH_AVFormat_Create();
327 OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, intData);
328 OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, intData);
329 OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, longData);
330 OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUDIO_SAMPLE_FORMAT, intData);
331 OH_AVFormat_SetIntValue(format, OH_MD_KEY_BITS_PER_CODED_SAMPLE, intData);
332 OH_AVFormat_SetIntValue(format, OH_MD_KEY_COMPLIANCE_LEVEL, intData);
333
334 OH_AudioCodec_Configure(encodersource, format);
335 if (encodersource) {
336 OH_AudioCodec_Destroy(encodersource);
337 }
338 if (format != nullptr) {
339 OH_AVFormat_Destroy(format);
340 format = nullptr;
341 }
342 return true;
343 }
344
AudioAPEConfigureFuzzTest(const uint8_t * data,size_t size)345 bool AudioAPEConfigureFuzzTest(const uint8_t *data, size_t size)
346 {
347 if (size < sizeof(int64_t)) {
348 return false;
349 }
350 OH_AVCodec *decodersource = OH_AudioCodec_CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_APE, true);
351 if (decodersource == nullptr) {
352 return false;
353 }
354 int32_t intData = *reinterpret_cast<const int32_t *>(data);
355 int64_t longData = *reinterpret_cast<const int64_t *>(data);
356 OH_AVFormat *format = OH_AVFormat_Create();
357 OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, intData);
358 OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, intData);
359 OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, longData);
360 OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUDIO_SAMPLE_FORMAT, intData);
361 OH_AVFormat_SetIntValue(format, OH_MD_KEY_BITS_PER_CODED_SAMPLE, intData);
362 OH_AVFormat_SetIntValue(format, OH_MD_KEY_COMPLIANCE_LEVEL, intData);
363
364 OH_AudioCodec_Configure(decodersource, format);
365 if (decodersource) {
366 OH_AudioCodec_Destroy(decodersource);
367 }
368 if (format != nullptr) {
369 OH_AVFormat_Destroy(format);
370 format = nullptr;
371 }
372
373 OH_AVCodec *encodersource = OH_AudioCodec_CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_APE, false);
374 if (encodersource == nullptr) {
375 return false;
376 }
377
378 format = OH_AVFormat_Create();
379 OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, intData);
380 OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, intData);
381 OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, longData);
382 OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUDIO_SAMPLE_FORMAT, intData);
383 OH_AVFormat_SetIntValue(format, OH_MD_KEY_BITS_PER_CODED_SAMPLE, intData);
384 OH_AVFormat_SetIntValue(format, OH_MD_KEY_COMPLIANCE_LEVEL, intData);
385
386 OH_AudioCodec_Configure(encodersource, format);
387 if (encodersource) {
388 OH_AudioCodec_Destroy(encodersource);
389 }
390 if (format != nullptr) {
391 OH_AVFormat_Destroy(format);
392 format = nullptr;
393 }
394 return true;
395 }
396
AudioOPUSConfigureFuzzTest(const uint8_t * data,size_t size)397 bool AudioOPUSConfigureFuzzTest(const uint8_t *data, size_t size)
398 {
399 if (size < sizeof(int64_t)) {
400 return false;
401 }
402 OH_AVCodec *decodersource = OH_AudioCodec_CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_OPUS, true);
403 if (decodersource == nullptr) {
404 return false;
405 }
406 int32_t intData = *reinterpret_cast<const int32_t *>(data);
407 int64_t longData = *reinterpret_cast<const int64_t *>(data);
408 OH_AVFormat *format = OH_AVFormat_Create();
409 OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, intData);
410 OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, intData);
411 OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, longData);
412 OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUDIO_SAMPLE_FORMAT, intData);
413 OH_AVFormat_SetIntValue(format, OH_MD_KEY_BITS_PER_CODED_SAMPLE, intData);
414 OH_AVFormat_SetIntValue(format, OH_MD_KEY_COMPLIANCE_LEVEL, intData);
415
416 OH_AudioCodec_Configure(decodersource, format);
417 if (decodersource) {
418 OH_AudioCodec_Destroy(decodersource);
419 }
420 if (format != nullptr) {
421 OH_AVFormat_Destroy(format);
422 format = nullptr;
423 }
424
425 OH_AVCodec *encodersource = OH_AudioCodec_CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_OPUS, false);
426 if (encodersource == nullptr) {
427 return false;
428 }
429
430 format = OH_AVFormat_Create();
431 OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, intData);
432 OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, intData);
433 OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, longData);
434 OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUDIO_SAMPLE_FORMAT, intData);
435 OH_AVFormat_SetIntValue(format, OH_MD_KEY_BITS_PER_CODED_SAMPLE, intData);
436 OH_AVFormat_SetIntValue(format, OH_MD_KEY_COMPLIANCE_LEVEL, intData);
437
438 OH_AudioCodec_Configure(encodersource, format);
439 if (encodersource) {
440 OH_AudioCodec_Destroy(encodersource);
441 }
442 if (format != nullptr) {
443 OH_AVFormat_Destroy(format);
444 format = nullptr;
445 }
446 return true;
447 }
448
AudioG711ConfigureFuzzTest(const uint8_t * data,size_t size)449 bool AudioG711ConfigureFuzzTest(const uint8_t *data, size_t size)
450 {
451 if (size < sizeof(int64_t)) {
452 return false;
453 }
454 OH_AVCodec *decodersource = OH_AudioCodec_CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU, true);
455 if (decodersource == nullptr) {
456 return false;
457 }
458 int32_t intData = *reinterpret_cast<const int32_t *>(data);
459 int64_t longData = *reinterpret_cast<const int64_t *>(data);
460 OH_AVFormat *format = OH_AVFormat_Create();
461 OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, intData);
462 OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, intData);
463 OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, longData);
464 OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUDIO_SAMPLE_FORMAT, intData);
465 OH_AVFormat_SetIntValue(format, OH_MD_KEY_BITS_PER_CODED_SAMPLE, intData);
466 OH_AVFormat_SetIntValue(format, OH_MD_KEY_COMPLIANCE_LEVEL, intData);
467
468 OH_AudioCodec_Configure(decodersource, format);
469 if (decodersource) {
470 OH_AudioCodec_Destroy(decodersource);
471 }
472 if (format != nullptr) {
473 OH_AVFormat_Destroy(format);
474 format = nullptr;
475 }
476
477 OH_AVCodec *encodersource = OH_AudioCodec_CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU, false);
478 if (encodersource == nullptr) {
479 return false;
480 }
481
482 format = OH_AVFormat_Create();
483 OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, intData);
484 OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, intData);
485 OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, longData);
486 OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUDIO_SAMPLE_FORMAT, intData);
487 OH_AVFormat_SetIntValue(format, OH_MD_KEY_BITS_PER_CODED_SAMPLE, intData);
488 OH_AVFormat_SetIntValue(format, OH_MD_KEY_COMPLIANCE_LEVEL, intData);
489
490 OH_AudioCodec_Configure(encodersource, format);
491 if (encodersource) {
492 OH_AudioCodec_Destroy(encodersource);
493 }
494 if (format != nullptr) {
495 OH_AVFormat_Destroy(format);
496 format = nullptr;
497 }
498 return true;
499 }
500
AudioVividConfigureFuzzTest(const uint8_t * data,size_t size)501 bool AudioVividConfigureFuzzTest(const uint8_t *data, size_t size)
502 {
503 if (size < sizeof(int64_t)) {
504 return false;
505 }
506 OH_AVCodec *decodersource = OH_AudioCodec_CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_VIVID, true);
507 if (decodersource == nullptr) {
508 return false;
509 }
510 int32_t intData = *reinterpret_cast<const int32_t *>(data);
511 int64_t longData = *reinterpret_cast<const int64_t *>(data);
512 OH_AVFormat *format = OH_AVFormat_Create();
513 OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, intData);
514 OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, intData);
515 OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, longData);
516 OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUDIO_SAMPLE_FORMAT, intData);
517 OH_AVFormat_SetIntValue(format, OH_MD_KEY_BITS_PER_CODED_SAMPLE, intData);
518 OH_AVFormat_SetIntValue(format, OH_MD_KEY_COMPLIANCE_LEVEL, intData);
519
520 OH_AudioCodec_Configure(decodersource, format);
521 if (decodersource) {
522 OH_AudioCodec_Destroy(decodersource);
523 }
524 if (format != nullptr) {
525 OH_AVFormat_Destroy(format);
526 format = nullptr;
527 }
528 return true;
529 }
530
531 } // namespace OHOS
532
533 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)534 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
535 {
536 /* Run your code on data */
537 OHOS::AudioAACConfigureFuzzTest(data, size);
538 OHOS::AudioFlacConfigureFuzzTest(data, size);
539 OHOS::AudioMP3ConfigureFuzzTest(data, size);
540 OHOS::AudioVorbisConfigureFuzzTest(data, size);
541 OHOS::AudioLBVCConfigureFuzzTest(data, size);
542 OHOS::AudioAMRNBConfigureFuzzTest(data, size);
543 OHOS::AudioAMRWBConfigureFuzzTest(data, size);
544 OHOS::AudioAPEConfigureFuzzTest(data, size);
545 OHOS::AudioOPUSConfigureFuzzTest(data, size);
546 OHOS::AudioG711ConfigureFuzzTest(data, size);
547 OHOS::AudioVividConfigureFuzzTest(data, size);
548 return 0;
549 }
550