1 /******************************************************************************
2 * *
3 * Copyright (C) 2023 The Android Open Source Project
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at:
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 *
17 *****************************************************************************
18 * Originally developed and contributed by Ittiam Systems Pvt. Ltd, Bangalore
19 */
20 /*****************************************************************************/
21 /* File includes */
22 /*****************************************************************************/
23 #include <string.h>
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include <stdint.h>
27 #include <fuzzer/FuzzedDataProvider.h>
28
29 extern "C" {
30 #include "ixheaac_type_def.h"
31 #include "impd_drc_common_enc.h"
32 #include "impd_drc_uni_drc.h"
33 #include "impd_drc_api.h"
34 #include "ixheaace_api.h"
35 #include "ixheaace_loudness_measurement.h"
36 }
37
38 static constexpr WORD32 k_sample_rates[] = {7350, 8000, 11025, 12000, 16000, 22050, 24000,
39 32000, 44100, 48000, 64000, 88200, 96000};
40 static constexpr WORD16 k_frame_length[] = {480, 512, 768, 960, 1024};
41
malloc_global(UWORD32 size,UWORD32 alignment)42 pVOID malloc_global(UWORD32 size, UWORD32 alignment) {
43 pVOID ptr = NULL;
44 if (posix_memalign((VOID **)&ptr, alignment, size)) {
45 ptr = NULL;
46 }
47 return ptr;
48 }
49
free_global(pVOID ptr)50 VOID free_global(pVOID ptr) { free(ptr); }
51
ixheaace_read_drc_config_params(ia_drc_enc_params_struct * pstr_enc_params,ia_drc_uni_drc_config_struct * pstr_uni_drc_config,ia_drc_loudness_info_set_struct * pstr_enc_loudness_info_set,ia_drc_uni_drc_gain_ext_struct * pstr_enc_gain_extension,FuzzedDataProvider * fuzzed_data,WORD32 in_ch)52 static VOID ixheaace_read_drc_config_params(
53 ia_drc_enc_params_struct *pstr_enc_params, ia_drc_uni_drc_config_struct *pstr_uni_drc_config,
54 ia_drc_loudness_info_set_struct *pstr_enc_loudness_info_set,
55 ia_drc_uni_drc_gain_ext_struct *pstr_enc_gain_extension, FuzzedDataProvider *fuzzed_data,
56 WORD32 in_ch) {
57 WORD32 n, g, s, m, ch, p;
58 WORD32 gain_set_channels;
59
60 pstr_enc_params->gain_sequence_present = fuzzed_data->ConsumeBool();
61 pstr_enc_params->delay_mode = fuzzed_data->ConsumeBool();
62 pstr_uni_drc_config->sample_rate_present = fuzzed_data->ConsumeBool();
63 pstr_uni_drc_config->str_drc_coefficients_uni_drc->drc_frame_size_present =
64 fuzzed_data->ConsumeBool();
65 pstr_uni_drc_config->loudness_info_set_present = fuzzed_data->ConsumeBool();
66
67 pstr_uni_drc_config->drc_instructions_uni_drc_count =
68 fuzzed_data->ConsumeIntegralInRange<WORD8>(0, MAX_DRC_INSTRUCTIONS_COUNT);
69 for (n = 0; n < pstr_uni_drc_config->drc_instructions_uni_drc_count; n++) {
70 ia_drc_instructions_uni_drc *pstr_drc_instructions_uni_drc =
71 &pstr_uni_drc_config->str_drc_instructions_uni_drc[n];
72 pstr_drc_instructions_uni_drc->drc_set_id = fuzzed_data->ConsumeIntegral<WORD8>();
73 pstr_drc_instructions_uni_drc->downmix_id = fuzzed_data->ConsumeIntegral<WORD8>();
74 pstr_drc_instructions_uni_drc->additional_downmix_id_present = fuzzed_data->ConsumeBool();
75 pstr_drc_instructions_uni_drc->additional_downmix_id_count =
76 fuzzed_data->ConsumeIntegral<WORD8>();
77 pstr_drc_instructions_uni_drc->drc_location = fuzzed_data->ConsumeIntegral<WORD8>();
78 pstr_drc_instructions_uni_drc->depends_on_drc_set_present = fuzzed_data->ConsumeBool();
79 pstr_drc_instructions_uni_drc->depends_on_drc_set = fuzzed_data->ConsumeIntegral<WORD8>();
80 pstr_drc_instructions_uni_drc->no_independent_use = fuzzed_data->ConsumeBool();
81 pstr_drc_instructions_uni_drc->drc_set_effect = fuzzed_data->ConsumeIntegral<WORD16>();
82 pstr_drc_instructions_uni_drc->drc_set_target_loudness_present = fuzzed_data->ConsumeBool();
83 pstr_drc_instructions_uni_drc->drc_set_target_loudness_value_upper =
84 fuzzed_data->ConsumeIntegral<WORD8>();
85 pstr_drc_instructions_uni_drc->drc_set_target_loudness_value_lower_present =
86 fuzzed_data->ConsumeBool();
87 pstr_drc_instructions_uni_drc->drc_set_target_loudness_value_lower =
88 fuzzed_data->ConsumeIntegral<WORD8>();
89
90 gain_set_channels = fuzzed_data->ConsumeIntegralInRange<WORD8>(0, MAX_CHANNEL_COUNT);
91 for (ch = 0; ch < gain_set_channels; ch++) {
92 pstr_drc_instructions_uni_drc->gain_set_index[ch] = fuzzed_data->ConsumeIntegral<WORD8>();
93 }
94 for (; ch < MAX_CHANNEL_COUNT; ch++) {
95 if (gain_set_channels > 0) {
96 pstr_drc_instructions_uni_drc->gain_set_index[ch] =
97 pstr_drc_instructions_uni_drc->gain_set_index[gain_set_channels - 1];
98 } else {
99 pstr_drc_instructions_uni_drc->gain_set_index[ch] = 0;
100 }
101 }
102
103 pstr_drc_instructions_uni_drc->num_drc_channel_groups =
104 fuzzed_data->ConsumeIntegralInRange<WORD8>(0, MAX_CHANNEL_GROUP_COUNT);
105 for (g = 0; g < pstr_drc_instructions_uni_drc->num_drc_channel_groups; g++) {
106 pstr_drc_instructions_uni_drc->str_gain_modifiers[g].gain_scaling_present[0] =
107 fuzzed_data->ConsumeBool();
108 pstr_drc_instructions_uni_drc->str_gain_modifiers[g].attenuation_scaling[0] =
109 fuzzed_data->ConsumeFloatingPoint<FLOAT32>();
110 pstr_drc_instructions_uni_drc->str_gain_modifiers[g].amplification_scaling[0] =
111 fuzzed_data->ConsumeFloatingPoint<FLOAT32>();
112 pstr_drc_instructions_uni_drc->str_gain_modifiers[g].gain_offset_present[0] =
113 fuzzed_data->ConsumeBool();
114 pstr_drc_instructions_uni_drc->str_gain_modifiers[g].gain_offset[0] =
115 fuzzed_data->ConsumeFloatingPoint<FLOAT32>();
116 }
117
118 pstr_drc_instructions_uni_drc->limiter_peak_target_present = fuzzed_data->ConsumeBool();
119 pstr_drc_instructions_uni_drc->limiter_peak_target =
120 fuzzed_data->ConsumeFloatingPoint<FLOAT32>();
121 pstr_drc_instructions_uni_drc->drc_instructions_type = fuzzed_data->ConsumeIntegral<WORD8>();
122 pstr_drc_instructions_uni_drc->mae_group_id = fuzzed_data->ConsumeIntegral<WORD8>();
123 pstr_drc_instructions_uni_drc->mae_group_preset_id = fuzzed_data->ConsumeIntegral<WORD8>();
124 }
125
126 pstr_uni_drc_config->drc_coefficients_uni_drc_count =
127 fuzzed_data->ConsumeIntegralInRange<WORD8>(0, MAX_DRC_COEFF_COUNT);
128 for (n = 0; n < pstr_uni_drc_config->drc_coefficients_uni_drc_count; n++) {
129 ia_drc_coefficients_uni_drc_struct *pstr_drc_coefficients_uni_drc =
130 &pstr_uni_drc_config->str_drc_coefficients_uni_drc[n];
131 pstr_drc_coefficients_uni_drc->drc_location = fuzzed_data->ConsumeIntegral<WORD8>();
132 pstr_drc_coefficients_uni_drc->gain_set_count =
133 fuzzed_data->ConsumeIntegralInRange<WORD8>(0, GAIN_SET_COUNT_MAX);
134 for (s = 0; s < pstr_drc_coefficients_uni_drc->gain_set_count; s++) {
135 pstr_drc_coefficients_uni_drc->str_gain_set_params[s].gain_coding_profile =
136 fuzzed_data->ConsumeIntegral<WORD8>();
137 pstr_drc_coefficients_uni_drc->str_gain_set_params[s].gain_interpolation_type =
138 fuzzed_data->ConsumeBool();
139 pstr_drc_coefficients_uni_drc->str_gain_set_params[s].full_frame =
140 fuzzed_data->ConsumeBool();
141 pstr_drc_coefficients_uni_drc->str_gain_set_params[s].time_alignment =
142 fuzzed_data->ConsumeBool();
143 pstr_drc_coefficients_uni_drc->str_gain_set_params[s].time_delta_min_present =
144 fuzzed_data->ConsumeBool();
145 pstr_drc_coefficients_uni_drc->str_gain_set_params[s].band_count =
146 fuzzed_data->ConsumeIntegralInRange<WORD8>(0, MAX_BAND_COUNT);
147 if (pstr_drc_coefficients_uni_drc->str_gain_set_params[s].band_count == 1) {
148 pstr_drc_coefficients_uni_drc->str_gain_set_params[s].gain_params[0].nb_points =
149 fuzzed_data->ConsumeIntegralInRange<WORD16>(0, MAX_GAIN_POINTS);
150 for (p = 0;
151 p < pstr_drc_coefficients_uni_drc->str_gain_set_params[s].gain_params[0].nb_points;
152 p++) {
153 pstr_drc_coefficients_uni_drc->str_gain_set_params[s].gain_params[0].gain_points[p].x =
154 fuzzed_data->ConsumeFloatingPoint<FLOAT32>();
155 pstr_drc_coefficients_uni_drc->str_gain_set_params[s].gain_params[0].gain_points[p].y =
156 fuzzed_data->ConsumeFloatingPoint<FLOAT32>();
157 }
158 pstr_drc_coefficients_uni_drc->str_gain_set_params[s].gain_params[0].width =
159 fuzzed_data->ConsumeFloatingPoint<FLOAT32>();
160 pstr_drc_coefficients_uni_drc->str_gain_set_params[s].gain_params[0].attack =
161 fuzzed_data->ConsumeFloatingPoint<FLOAT32>();
162 pstr_drc_coefficients_uni_drc->str_gain_set_params[s].gain_params[0].decay =
163 fuzzed_data->ConsumeFloatingPoint<FLOAT32>();
164 pstr_drc_coefficients_uni_drc->str_gain_set_params[s].gain_params[0].drc_characteristic =
165 fuzzed_data->ConsumeIntegral<WORD8>();
166 pstr_drc_coefficients_uni_drc->str_gain_set_params[s]
167 .gain_params[0]
168 .crossover_freq_index = fuzzed_data->ConsumeIntegral<WORD8>();
169 } else {
170 for (m = 0; m < pstr_drc_coefficients_uni_drc->str_gain_set_params[s].band_count; m++) {
171 pstr_drc_coefficients_uni_drc->str_gain_set_params[s].gain_params[m].nb_points =
172 fuzzed_data->ConsumeIntegralInRange<WORD16>(0, MAX_GAIN_POINTS);
173 for (p = 0;
174 p < pstr_drc_coefficients_uni_drc->str_gain_set_params[s].gain_params[m].nb_points;
175 p++) {
176 pstr_drc_coefficients_uni_drc->str_gain_set_params[s]
177 .gain_params[m]
178 .gain_points[p]
179 .x = fuzzed_data->ConsumeFloatingPoint<FLOAT32>();
180 pstr_drc_coefficients_uni_drc->str_gain_set_params[s]
181 .gain_params[m]
182 .gain_points[p]
183 .y = fuzzed_data->ConsumeFloatingPoint<FLOAT32>();
184 }
185 pstr_drc_coefficients_uni_drc->str_gain_set_params[s].gain_params[m].width =
186 fuzzed_data->ConsumeFloatingPoint<FLOAT32>();
187 pstr_drc_coefficients_uni_drc->str_gain_set_params[s].gain_params[m].attack =
188 fuzzed_data->ConsumeFloatingPoint<FLOAT32>();
189 pstr_drc_coefficients_uni_drc->str_gain_set_params[s].gain_params[m].decay =
190 fuzzed_data->ConsumeFloatingPoint<FLOAT32>();
191 pstr_drc_coefficients_uni_drc->str_gain_set_params[s].drc_band_type =
192 fuzzed_data->ConsumeBool();
193 pstr_drc_coefficients_uni_drc->str_gain_set_params[s]
194 .gain_params[m]
195 .start_sub_band_index = fuzzed_data->ConsumeIntegral<WORD16>();
196 pstr_drc_coefficients_uni_drc->str_gain_set_params[s]
197 .gain_params[m]
198 .drc_characteristic = fuzzed_data->ConsumeIntegral<WORD8>();
199 pstr_drc_coefficients_uni_drc->str_gain_set_params[s]
200 .gain_params[m]
201 .crossover_freq_index = fuzzed_data->ConsumeIntegral<WORD8>();
202 }
203 }
204 }
205 }
206
207 pstr_enc_loudness_info_set->loudness_info_count =
208 fuzzed_data->ConsumeIntegralInRange<WORD8>(0, MAX_LOUDNESS_INFO_COUNT);
209 for (n = 0; n < pstr_enc_loudness_info_set->loudness_info_count; n++) {
210 pstr_enc_loudness_info_set->str_loudness_info[n].drc_set_id =
211 fuzzed_data->ConsumeIntegral<WORD8>();
212 pstr_enc_loudness_info_set->str_loudness_info[n].downmix_id =
213 fuzzed_data->ConsumeIntegral<WORD8>();
214 pstr_enc_loudness_info_set->str_loudness_info[n].sample_peak_level_present =
215 fuzzed_data->ConsumeBool();
216 if (1 == pstr_enc_loudness_info_set->str_loudness_info[n].sample_peak_level_present) {
217 pstr_enc_loudness_info_set->str_loudness_info[n].sample_peak_level =
218 fuzzed_data->ConsumeFloatingPoint<FLOAT32>();
219 }
220 pstr_enc_loudness_info_set->str_loudness_info[n].true_peak_level_present =
221 fuzzed_data->ConsumeBool();
222 if (1 == pstr_enc_loudness_info_set->str_loudness_info[n].true_peak_level_present) {
223 pstr_enc_loudness_info_set->str_loudness_info[n].true_peak_level =
224 fuzzed_data->ConsumeFloatingPoint<FLOAT32>();
225 pstr_enc_loudness_info_set->str_loudness_info[n].true_peak_level_measurement_system =
226 fuzzed_data->ConsumeIntegral<WORD8>();
227 pstr_enc_loudness_info_set->str_loudness_info[n].true_peak_level_reliability =
228 fuzzed_data->ConsumeIntegral<WORD8>();
229 }
230
231 pstr_enc_loudness_info_set->str_loudness_info[n].measurement_count =
232 fuzzed_data->ConsumeIntegralInRange<WORD8>(0, MAX_MEASUREMENT_COUNT);
233 for (m = 0; m < pstr_enc_loudness_info_set->str_loudness_info[n].measurement_count; m++) {
234 pstr_enc_loudness_info_set->str_loudness_info[n].str_loudness_measure[m].method_definition =
235 fuzzed_data->ConsumeIntegral<WORD8>();
236 pstr_enc_loudness_info_set->str_loudness_info[n].str_loudness_measure[m].method_value =
237 fuzzed_data->ConsumeFloatingPoint<FLOAT32>();
238 pstr_enc_loudness_info_set->str_loudness_info[n]
239 .str_loudness_measure[m]
240 .measurement_system = fuzzed_data->ConsumeIntegral<WORD8>();
241 pstr_enc_loudness_info_set->str_loudness_info[n].str_loudness_measure[m].reliability =
242 fuzzed_data->ConsumeIntegral<WORD8>();
243 }
244 }
245
246 pstr_enc_loudness_info_set->loudness_info_album_count =
247 fuzzed_data->ConsumeIntegralInRange<WORD8>(0, MAX_LOUDNESS_INFO_COUNT);
248 for (n = 0; n < pstr_enc_loudness_info_set->loudness_info_album_count; n++) {
249 pstr_enc_loudness_info_set->str_loudness_info_album[n].drc_set_id =
250 fuzzed_data->ConsumeIntegral<WORD8>();
251 pstr_enc_loudness_info_set->str_loudness_info_album[n].downmix_id =
252 fuzzed_data->ConsumeIntegral<WORD8>();
253 pstr_enc_loudness_info_set->str_loudness_info_album[n].sample_peak_level_present =
254 fuzzed_data->ConsumeBool();
255 if (1 == pstr_enc_loudness_info_set->str_loudness_info_album[n].sample_peak_level_present) {
256 pstr_enc_loudness_info_set->str_loudness_info_album[n].sample_peak_level =
257 fuzzed_data->ConsumeFloatingPoint<FLOAT32>();
258 }
259 pstr_enc_loudness_info_set->str_loudness_info_album[n].true_peak_level_present =
260 fuzzed_data->ConsumeBool();
261 if (1 == pstr_enc_loudness_info_set->str_loudness_info_album[n].true_peak_level_present) {
262 pstr_enc_loudness_info_set->str_loudness_info_album[n].true_peak_level =
263 fuzzed_data->ConsumeFloatingPoint<FLOAT32>();
264 pstr_enc_loudness_info_set->str_loudness_info_album[n].true_peak_level_measurement_system =
265 fuzzed_data->ConsumeIntegral<WORD8>();
266 pstr_enc_loudness_info_set->str_loudness_info_album[n].true_peak_level_reliability =
267 fuzzed_data->ConsumeIntegral<WORD8>();
268 }
269
270 pstr_enc_loudness_info_set->str_loudness_info_album[n].measurement_count =
271 fuzzed_data->ConsumeIntegralInRange<WORD8>(0, MAX_MEASUREMENT_COUNT);
272 for (m = 0; m < pstr_enc_loudness_info_set->str_loudness_info_album[n].measurement_count;
273 m++) {
274 pstr_enc_loudness_info_set->str_loudness_info_album[n]
275 .str_loudness_measure[m]
276 .method_definition = fuzzed_data->ConsumeIntegral<WORD8>();
277 pstr_enc_loudness_info_set->str_loudness_info_album[n]
278 .str_loudness_measure[m]
279 .method_value = fuzzed_data->ConsumeFloatingPoint<FLOAT32>();
280 pstr_enc_loudness_info_set->str_loudness_info_album[n]
281 .str_loudness_measure[m]
282 .measurement_system = fuzzed_data->ConsumeIntegral<WORD8>();
283 pstr_enc_loudness_info_set->str_loudness_info_album[n].str_loudness_measure[m].reliability =
284 fuzzed_data->ConsumeIntegral<WORD8>();
285 }
286 }
287
288 pstr_uni_drc_config->str_channel_layout.layout_signaling_present = fuzzed_data->ConsumeBool();
289 pstr_uni_drc_config->str_channel_layout.defined_layout = fuzzed_data->ConsumeIntegral<WORD8>();
290 pstr_uni_drc_config->str_channel_layout.speaker_position[0] =
291 fuzzed_data->ConsumeIntegral<WORD8>();
292
293 pstr_uni_drc_config->downmix_instructions_count =
294 fuzzed_data->ConsumeIntegralInRange<WORD8>(0, MAX_DOWNMIX_INSTRUCTION_COUNT);
295 for (n = 0; n < pstr_uni_drc_config->downmix_instructions_count; n++) {
296 pstr_uni_drc_config->str_downmix_instructions[n].target_layout =
297 fuzzed_data->ConsumeIntegral<WORD8>();
298 pstr_uni_drc_config->str_downmix_instructions[n].downmix_coefficients_present =
299 fuzzed_data->ConsumeBool();
300 }
301
302 pstr_uni_drc_config->drc_description_basic_present = fuzzed_data->ConsumeBool();
303 pstr_uni_drc_config->uni_drc_config_ext_present = fuzzed_data->ConsumeBool();
304 pstr_enc_loudness_info_set->loudness_info_set_ext_present = fuzzed_data->ConsumeBool();
305 pstr_enc_gain_extension->uni_drc_gain_ext_present = fuzzed_data->ConsumeBool();
306
307 if (pstr_uni_drc_config->uni_drc_config_ext_present) {
308 pstr_uni_drc_config->str_uni_drc_config_ext.uni_drc_config_ext_type[0] = UNIDRC_CONF_EXT_V1;
309 pstr_uni_drc_config->str_uni_drc_config_ext.downmix_instructions_v1_present =
310 fuzzed_data->ConsumeBool();
311 if (pstr_uni_drc_config->str_uni_drc_config_ext.downmix_instructions_v1_present) {
312 /*********** str_downmix_instructions_v1 *************/
313
314 pstr_uni_drc_config->str_uni_drc_config_ext.downmix_instructions_v1_count =
315 fuzzed_data->ConsumeIntegralInRange<WORD8>(0, DOWNMIX_INSTRUCTIONS_COUNT_MAX);
316 for (n = 0; n < pstr_uni_drc_config->str_uni_drc_config_ext.downmix_instructions_v1_count;
317 n++) {
318 ia_drc_downmix_instructions_struct *pstr_downmix_instructions_v1 =
319 &pstr_uni_drc_config->str_uni_drc_config_ext.str_downmix_instructions_v1[n];
320 pstr_downmix_instructions_v1->downmix_id = fuzzed_data->ConsumeIntegral<WORD8>();
321 ;
322 pstr_downmix_instructions_v1->target_ch_count = fuzzed_data->ConsumeIntegral<WORD8>();
323 pstr_downmix_instructions_v1->target_layout = fuzzed_data->ConsumeIntegral<WORD8>();
324 pstr_downmix_instructions_v1->downmix_coefficients_present = fuzzed_data->ConsumeBool();
325 if (pstr_downmix_instructions_v1->downmix_coefficients_present) {
326 FLOAT32 dwn_mix_coeff = 0.0f;
327 for (s = 0; s < pstr_downmix_instructions_v1->target_layout; s++) {
328 dwn_mix_coeff = fuzzed_data->ConsumeFloatingPoint<FLOAT32>();
329 for (ch = 0; ch < in_ch; ch++) {
330 pstr_downmix_instructions_v1->downmix_coeff[in_ch * s + ch] = dwn_mix_coeff;
331 }
332 }
333 }
334 }
335 }
336
337 pstr_uni_drc_config->str_uni_drc_config_ext.drc_coeffs_and_instructions_uni_drc_v1_present =
338 fuzzed_data->ConsumeBool();
339 if (pstr_uni_drc_config->str_uni_drc_config_ext
340 .drc_coeffs_and_instructions_uni_drc_v1_present) {
341 /*********** str_drc_coefficients_uni_drc_v1 *************/
342
343 pstr_uni_drc_config->str_uni_drc_config_ext.drc_coefficients_uni_drc_v1_count =
344 fuzzed_data->ConsumeIntegralInRange<WORD8>(0, DRC_COEFFICIENTS_UNIDRC_V1_COUNT_MAX);
345 for (n = 0;
346 n < pstr_uni_drc_config->str_uni_drc_config_ext.drc_coefficients_uni_drc_v1_count;
347 n++) {
348 ia_drc_coefficients_uni_drc_struct *pstr_drc_coefficients_uni_drc_v1 =
349 &pstr_uni_drc_config->str_uni_drc_config_ext.str_drc_coefficients_uni_drc_v1[n];
350 pstr_drc_coefficients_uni_drc_v1->drc_location = fuzzed_data->ConsumeIntegral<WORD8>();
351 pstr_drc_coefficients_uni_drc_v1->gain_set_count =
352 fuzzed_data->ConsumeIntegralInRange<WORD8>(0, GAIN_SET_COUNT_MAX);
353 for (s = 0; s < pstr_drc_coefficients_uni_drc_v1->gain_set_count; s++) {
354 pstr_drc_coefficients_uni_drc_v1->str_gain_set_params[s].gain_coding_profile =
355 fuzzed_data->ConsumeIntegral<WORD8>();
356 pstr_drc_coefficients_uni_drc_v1->str_gain_set_params[s].gain_interpolation_type =
357 fuzzed_data->ConsumeBool();
358 pstr_drc_coefficients_uni_drc_v1->str_gain_set_params[s].full_frame =
359 fuzzed_data->ConsumeBool();
360 pstr_drc_coefficients_uni_drc_v1->str_gain_set_params[s].time_alignment =
361 fuzzed_data->ConsumeBool();
362 pstr_drc_coefficients_uni_drc_v1->str_gain_set_params[s].time_delta_min_present =
363 fuzzed_data->ConsumeBool();
364 pstr_drc_coefficients_uni_drc_v1->str_gain_set_params[s].band_count =
365 fuzzed_data->ConsumeIntegralInRange<WORD8>(0, MAX_BAND_COUNT);
366 if (pstr_drc_coefficients_uni_drc_v1->str_gain_set_params[s].band_count == 1) {
367 pstr_drc_coefficients_uni_drc_v1->str_gain_set_params[s].gain_params[0].nb_points =
368 fuzzed_data->ConsumeIntegralInRange<WORD16>(0, MAX_GAIN_POINTS);
369 for (p = 0; p < pstr_drc_coefficients_uni_drc_v1->str_gain_set_params[s]
370 .gain_params[0]
371 .nb_points;
372 p++) {
373 pstr_drc_coefficients_uni_drc_v1->str_gain_set_params[s]
374 .gain_params[0]
375 .gain_points[p]
376 .x = fuzzed_data->ConsumeFloatingPoint<FLOAT32>();
377 pstr_drc_coefficients_uni_drc_v1->str_gain_set_params[s]
378 .gain_params[0]
379 .gain_points[p]
380 .y = fuzzed_data->ConsumeFloatingPoint<FLOAT32>();
381 }
382 pstr_drc_coefficients_uni_drc_v1->str_gain_set_params[s].gain_params[0].width =
383 fuzzed_data->ConsumeFloatingPoint<FLOAT32>();
384 pstr_drc_coefficients_uni_drc_v1->str_gain_set_params[s].gain_params[0].attack =
385 fuzzed_data->ConsumeFloatingPoint<FLOAT32>();
386 pstr_drc_coefficients_uni_drc_v1->str_gain_set_params[s].gain_params[0].decay =
387 fuzzed_data->ConsumeFloatingPoint<FLOAT32>();
388 pstr_drc_coefficients_uni_drc_v1->str_gain_set_params[s]
389 .gain_params[0]
390 .drc_characteristic = fuzzed_data->ConsumeIntegral<WORD8>();
391 ;
392 pstr_drc_coefficients_uni_drc_v1->str_gain_set_params[s]
393 .gain_params[0]
394 .crossover_freq_index = fuzzed_data->ConsumeIntegral<WORD8>();
395 } else {
396 for (m = 0; m < pstr_drc_coefficients_uni_drc_v1->str_gain_set_params[s].band_count;
397 m++) {
398 pstr_drc_coefficients_uni_drc_v1->str_gain_set_params[s].gain_params[m].nb_points =
399 fuzzed_data->ConsumeIntegralInRange<WORD16>(0, MAX_GAIN_POINTS);
400 for (p = 0; p < pstr_drc_coefficients_uni_drc_v1->str_gain_set_params[s]
401 .gain_params[m]
402 .nb_points;
403 p++) {
404 pstr_drc_coefficients_uni_drc_v1->str_gain_set_params[s]
405 .gain_params[m]
406 .gain_points[p]
407 .x = fuzzed_data->ConsumeFloatingPoint<FLOAT32>();
408 pstr_drc_coefficients_uni_drc_v1->str_gain_set_params[s]
409 .gain_params[m]
410 .gain_points[p]
411 .y = fuzzed_data->ConsumeFloatingPoint<FLOAT32>();
412 }
413 pstr_drc_coefficients_uni_drc_v1->str_gain_set_params[s].gain_params[m].width =
414 fuzzed_data->ConsumeFloatingPoint<FLOAT32>();
415 pstr_drc_coefficients_uni_drc_v1->str_gain_set_params[s].gain_params[m].attack =
416 fuzzed_data->ConsumeFloatingPoint<FLOAT32>();
417 pstr_drc_coefficients_uni_drc_v1->str_gain_set_params[s].gain_params[m].decay =
418 fuzzed_data->ConsumeFloatingPoint<FLOAT32>();
419 pstr_drc_coefficients_uni_drc_v1->str_gain_set_params[s].drc_band_type = 0;
420 pstr_drc_coefficients_uni_drc_v1->str_gain_set_params[s]
421 .gain_params[m]
422 .start_sub_band_index = fuzzed_data->ConsumeIntegral<WORD16>();
423 pstr_drc_coefficients_uni_drc_v1->str_gain_set_params[s]
424 .gain_params[m]
425 .drc_characteristic = fuzzed_data->ConsumeIntegral<WORD8>();
426 ;
427 pstr_drc_coefficients_uni_drc_v1->str_gain_set_params[s]
428 .gain_params[m]
429 .crossover_freq_index = fuzzed_data->ConsumeIntegral<WORD8>();
430 }
431 }
432 }
433 }
434
435 /*********** str_drc_instructions_uni_drc_v1 *************/
436 pstr_uni_drc_config->str_uni_drc_config_ext.drc_instructions_uni_drc_v1_count =
437 fuzzed_data->ConsumeIntegralInRange<WORD8>(0, DRC_INSTRUCTIONS_UNIDRC_V1_COUNT_MAX);
438 for (n = 0;
439 n < pstr_uni_drc_config->str_uni_drc_config_ext.drc_instructions_uni_drc_v1_count;
440 n++) {
441 ia_drc_instructions_uni_drc *pstr_drc_instructions_uni_drc =
442 &pstr_uni_drc_config->str_uni_drc_config_ext.str_drc_instructions_uni_drc_v1[n];
443 pstr_drc_instructions_uni_drc->drc_set_id = fuzzed_data->ConsumeIntegral<WORD8>();
444 pstr_drc_instructions_uni_drc->downmix_id = fuzzed_data->ConsumeIntegral<WORD8>();
445 pstr_drc_instructions_uni_drc->additional_downmix_id_present = fuzzed_data->ConsumeBool();
446 pstr_drc_instructions_uni_drc->additional_downmix_id_count =
447 fuzzed_data->ConsumeIntegral<WORD8>();
448 pstr_drc_instructions_uni_drc->drc_location = fuzzed_data->ConsumeIntegral<WORD8>();
449 pstr_drc_instructions_uni_drc->depends_on_drc_set_present = fuzzed_data->ConsumeBool();
450 pstr_drc_instructions_uni_drc->depends_on_drc_set = fuzzed_data->ConsumeIntegral<WORD8>();
451 pstr_drc_instructions_uni_drc->no_independent_use = fuzzed_data->ConsumeBool();
452 pstr_drc_instructions_uni_drc->drc_set_effect = fuzzed_data->ConsumeIntegral<WORD16>();
453 pstr_drc_instructions_uni_drc->drc_set_target_loudness_present =
454 fuzzed_data->ConsumeBool();
455 pstr_drc_instructions_uni_drc->drc_set_target_loudness_value_upper =
456 fuzzed_data->ConsumeIntegral<WORD8>();
457 pstr_drc_instructions_uni_drc->drc_set_target_loudness_value_lower_present =
458 fuzzed_data->ConsumeBool();
459 pstr_drc_instructions_uni_drc->drc_set_target_loudness_value_lower =
460 fuzzed_data->ConsumeIntegral<WORD8>();
461
462 gain_set_channels = fuzzed_data->ConsumeIntegralInRange<WORD8>(0, MAX_CHANNEL_COUNT);
463 for (ch = 0; ch < gain_set_channels; ch++) {
464 pstr_drc_instructions_uni_drc->gain_set_index[ch] =
465 fuzzed_data->ConsumeIntegral<WORD8>();
466 }
467 for (; ch < MAX_CHANNEL_COUNT; ch++) {
468 if (gain_set_channels > 0) {
469 pstr_drc_instructions_uni_drc->gain_set_index[ch] =
470 pstr_drc_instructions_uni_drc->gain_set_index[gain_set_channels - 1];
471 } else {
472 pstr_drc_instructions_uni_drc->gain_set_index[ch] = 0;
473 }
474 }
475
476 pstr_drc_instructions_uni_drc->num_drc_channel_groups =
477 fuzzed_data->ConsumeIntegralInRange<WORD8>(0, MAX_CHANNEL_GROUP_COUNT);
478 for (g = 0; g < pstr_drc_instructions_uni_drc->num_drc_channel_groups; g++) {
479 pstr_drc_instructions_uni_drc->str_gain_modifiers[g].gain_scaling_present[0] =
480 fuzzed_data->ConsumeBool();
481 pstr_drc_instructions_uni_drc->str_gain_modifiers[g].attenuation_scaling[0] =
482 fuzzed_data->ConsumeFloatingPoint<FLOAT32>();
483 pstr_drc_instructions_uni_drc->str_gain_modifiers[g].amplification_scaling[0] =
484 fuzzed_data->ConsumeFloatingPoint<FLOAT32>();
485 pstr_drc_instructions_uni_drc->str_gain_modifiers[g].gain_offset_present[0] =
486 fuzzed_data->ConsumeBool();
487 pstr_drc_instructions_uni_drc->str_gain_modifiers[g].gain_offset[0] =
488 fuzzed_data->ConsumeFloatingPoint<FLOAT32>();
489 }
490
491 pstr_drc_instructions_uni_drc->limiter_peak_target_present = fuzzed_data->ConsumeBool();
492 pstr_drc_instructions_uni_drc->limiter_peak_target =
493 fuzzed_data->ConsumeFloatingPoint<FLOAT32>();
494 pstr_drc_instructions_uni_drc->drc_instructions_type =
495 fuzzed_data->ConsumeIntegral<WORD8>();
496 pstr_drc_instructions_uni_drc->mae_group_id = fuzzed_data->ConsumeIntegral<WORD8>();
497 pstr_drc_instructions_uni_drc->mae_group_preset_id =
498 fuzzed_data->ConsumeIntegral<WORD8>();
499 }
500 }
501 }
502 }
503
ixheaace_fuzzer_flag(ixheaace_input_config * pstr_in_cfg,ia_drc_input_config * pstr_drc_cfg,FuzzedDataProvider * fuzzed_data,WORD32 in_ch)504 static VOID ixheaace_fuzzer_flag(ixheaace_input_config *pstr_in_cfg,
505 ia_drc_input_config *pstr_drc_cfg,
506 FuzzedDataProvider *fuzzed_data, WORD32 in_ch) {
507 // Set Default value for AAC config structure
508
509 pstr_in_cfg->i_bitrate = fuzzed_data->ConsumeIntegral<WORD32>();
510 pstr_in_cfg->i_use_mps = fuzzed_data->ConsumeBool();
511 pstr_in_cfg->i_use_adts = fuzzed_data->ConsumeBool();
512 pstr_in_cfg->i_use_es = fuzzed_data->ConsumeBool();
513 pstr_in_cfg->aac_config.use_tns = fuzzed_data->ConsumeBool();
514 pstr_in_cfg->aac_config.noise_filling = fuzzed_data->ConsumeBool();
515 pstr_in_cfg->ui_pcm_wd_sz = fuzzed_data->ConsumeIntegral<WORD8>();
516 pstr_in_cfg->i_channels = fuzzed_data->ConsumeIntegral<WORD8>();
517 if (fuzzed_data->ConsumeBool()) {
518 pstr_in_cfg->i_samp_freq = fuzzed_data->PickValueInArray(k_sample_rates);
519 } else {
520 pstr_in_cfg->i_samp_freq = fuzzed_data->ConsumeIntegral<UWORD32>();
521 }
522 if (fuzzed_data->ConsumeBool()) {
523 pstr_in_cfg->frame_length = fuzzed_data->PickValueInArray(k_frame_length);
524 } else {
525 pstr_in_cfg->frame_length = fuzzed_data->ConsumeIntegral<WORD16>();
526 }
527 pstr_in_cfg->aot = fuzzed_data->ConsumeIntegral<WORD8>();
528 pstr_in_cfg->esbr_flag = fuzzed_data->ConsumeBool();
529 pstr_in_cfg->aac_config.full_bandwidth = fuzzed_data->ConsumeBool();
530 pstr_in_cfg->aac_config.bitreservoir_size = fuzzed_data->ConsumeIntegral<WORD16>();
531 pstr_in_cfg->i_mps_tree_config = fuzzed_data->ConsumeIntegral<WORD8>();
532 pstr_in_cfg->i_channels_mask = fuzzed_data->ConsumeIntegral<WORD8>();
533 pstr_in_cfg->cplx_pred = fuzzed_data->ConsumeBool();
534 pstr_in_cfg->usac_en = fuzzed_data->ConsumeBool();
535 pstr_in_cfg->ccfl_idx = fuzzed_data->ConsumeIntegral<WORD8>();
536 pstr_in_cfg->pvc_active = fuzzed_data->ConsumeBool();
537 pstr_in_cfg->harmonic_sbr = fuzzed_data->ConsumeBool();
538 pstr_in_cfg->hq_esbr = fuzzed_data->ConsumeBool();
539 pstr_in_cfg->use_drc_element = fuzzed_data->ConsumeBool();
540 pstr_in_cfg->inter_tes_active = fuzzed_data->ConsumeBool();
541 pstr_in_cfg->codec_mode = fuzzed_data->ConsumeIntegral<WORD8>();
542 pstr_in_cfg->random_access_interval = fuzzed_data->ConsumeIntegral<WORD32>();
543 pstr_in_cfg->method_def = fuzzed_data->ConsumeIntegral<WORD32>();
544 pstr_in_cfg->measurement_system = fuzzed_data->ConsumeIntegral<WORD32>();
545 pstr_in_cfg->measured_loudness = fuzzed_data->ConsumeIntegral<WORD32>();
546 pstr_in_cfg->stream_id = fuzzed_data->ConsumeIntegral<UWORD16>();
547 pstr_in_cfg->use_delay_adjustment = fuzzed_data->ConsumeIntegral<WORD32>();
548 /* DRC */
549 if (pstr_in_cfg->use_drc_element == 1) {
550 ixheaace_read_drc_config_params(&pstr_drc_cfg->str_enc_params,
551 &pstr_drc_cfg->str_uni_drc_config,
552 &pstr_drc_cfg->str_enc_loudness_info_set,
553 &pstr_drc_cfg->str_enc_gain_extension, fuzzed_data, in_ch);
554 }
555 }
556
ia_enhaacplus_enc_pcm_data_read(std::vector<WORD8> input_vec,UWORD32 num_samples,WORD32 num_channels,WORD16 ** data)557 IA_ERRORCODE ia_enhaacplus_enc_pcm_data_read(std::vector<WORD8> input_vec, UWORD32 num_samples,
558 WORD32 num_channels, WORD16 **data) {
559 UWORD32 count = 0;
560 UWORD8 channel_no;
561 UWORD32 sample_no = 0;
562 UWORD32 i = 0;
563 while (count < num_samples) {
564 sample_no = (count / num_channels);
565 channel_no = (UWORD8)(count % num_channels);
566 data[channel_no][sample_no] = *input_vec.data();
567 i++;
568 count++;
569 }
570 return 0;
571 }
572
ixheaace_calculate_loudness_measure(ixheaace_input_config * pstr_in_cfg,ixheaace_output_config * pstr_out_cfg,FuzzedDataProvider * fuzzed_data)573 static IA_ERRORCODE ixheaace_calculate_loudness_measure(ixheaace_input_config *pstr_in_cfg,
574 ixheaace_output_config *pstr_out_cfg,
575 FuzzedDataProvider *fuzzed_data) {
576 WORD32 input_size;
577 WORD32 count = 0;
578 IA_ERRORCODE err_code = 0;
579 VOID *loudness_handle =
580 malloc_global(ixheaace_loudness_info_get_handle_size(), DEFAULT_MEM_ALIGN_8);
581 if (loudness_handle == NULL) {
582 printf("fatal error: libxaac encoder: Memory allocation failed");
583 return -1;
584 }
585
586 err_code = ixheaace_loudness_init_params(loudness_handle, pstr_in_cfg, pstr_out_cfg);
587
588 if (err_code) {
589 free_global(loudness_handle);
590 return -1;
591 }
592 input_size = (pstr_out_cfg->samp_freq / 10) * (pstr_in_cfg->i_channels);
593 WORD16 **samples = 0;
594 samples =
595 (WORD16 **)malloc_global(pstr_in_cfg->i_channels * sizeof(*samples), DEFAULT_MEM_ALIGN_8);
596 if (samples == NULL) {
597 printf("fatal error: libxaac encoder: Memory allocation failed");
598 free_global(loudness_handle);
599 return -1;
600 }
601 for (count = 0; count < pstr_in_cfg->i_channels; count++) {
602 samples[count] = (WORD16 *)malloc_global(
603 (pstr_out_cfg->samp_freq / 10) * sizeof(*samples[count]), DEFAULT_MEM_ALIGN_8);
604 if (samples[count] == NULL) {
605 printf("fatal error: libxaac encoder: Memory allocation failed");
606 while (count) {
607 count--;
608 free_global(samples[count]);
609 }
610 free_global(samples);
611 free_global(loudness_handle);
612 return -1;
613 }
614 memset(samples[count], 0, (pstr_out_cfg->samp_freq / 10) * sizeof(*samples[count]));
615 }
616 count = 0;
617 while (count <= fuzzed_data->remaining_bytes()) {
618 std::vector<WORD8> input_vec = fuzzed_data->ConsumeBytes<WORD8>(input_size);
619 err_code =
620 ia_enhaacplus_enc_pcm_data_read(input_vec, input_size, pstr_in_cfg->i_channels, samples);
621 if (err_code) {
622 for (count = 0; count < pstr_in_cfg->i_channels; count++) {
623 free_global(samples[count]);
624 }
625 free_global(samples);
626 free_global(loudness_handle);
627 return -1;
628 }
629 pstr_in_cfg->measured_loudness = ixheaace_measure_loudness(loudness_handle, samples);
630 count += input_size;
631 }
632 if (pstr_in_cfg->method_def == METHOD_DEFINITION_PROGRAM_LOUDNESS) {
633 pstr_in_cfg->measured_loudness = ixheaace_measure_integrated_loudness(loudness_handle);
634 }
635 for (count = 0; count < pstr_in_cfg->i_channels; count++) {
636 free_global(samples[count]);
637 }
638 free_global(samples);
639 free_global(loudness_handle);
640 return err_code;
641 }
642
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)643 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
644 FuzzedDataProvider fuzzed_data(data, size);
645 FuzzedDataProvider fuzzed_data_loudness(data, size);
646
647 /* Error code */
648 IA_ERRORCODE err_code = 0;
649
650 /* API obj */
651 pVOID pv_ia_process_api_obj;
652
653 pWORD8 pb_inp_buf = NULL;
654 WORD32 input_size = 0;
655 WORD32 read_inp_data = 1;
656 WORD32 num_proc_iterations = 0;
657
658 /* ******************************************************************/
659 /* The API config structure */
660 /* ******************************************************************/
661
662 ixheaace_user_config_struct str_enc_api{};
663
664 ixheaace_input_config *pstr_in_cfg = &str_enc_api.input_config;
665 ixheaace_output_config *pstr_out_cfg = &str_enc_api.output_config;
666 pstr_in_cfg->pv_drc_cfg = malloc_global(sizeof(ia_drc_input_config), DEFAULT_MEM_ALIGN_8);
667 ia_drc_input_config *pstr_drc_cfg = (ia_drc_input_config *)pstr_in_cfg->pv_drc_cfg;
668 memset(pstr_drc_cfg, 0, sizeof(ia_drc_input_config));
669
670 pstr_out_cfg->malloc_xheaace = &malloc_global;
671 pstr_out_cfg->free_xheaace = &free_global;
672
673 /* ******************************************************************/
674 /* Parse input configuration parameters */
675 /* ******************************************************************/
676 ixheaace_fuzzer_flag(pstr_in_cfg, pstr_drc_cfg, &fuzzed_data, pstr_in_cfg->i_channels);
677
678 /*1st pass -> Loudness Measurement */
679 if (pstr_in_cfg->aot == AOT_USAC || pstr_in_cfg->usac_en) {
680 err_code =
681 ixheaace_calculate_loudness_measure(pstr_in_cfg, pstr_out_cfg, &fuzzed_data_loudness);
682 if (err_code) {
683 if (pstr_drc_cfg) {
684 free(pstr_drc_cfg);
685 pstr_drc_cfg = NULL;
686 }
687 /* Fatal error code */
688 if (err_code & 0x80000000) {
689 ixheaace_delete((pVOID)pstr_out_cfg);
690 return 0;
691 }
692 return -1;
693 }
694 }
695
696 err_code = ixheaace_create((pVOID)pstr_in_cfg, (pVOID)pstr_out_cfg);
697 if (err_code) {
698 if (pstr_drc_cfg) {
699 free(pstr_drc_cfg);
700 pstr_drc_cfg = NULL;
701 }
702 /* Fatal error code */
703 if (err_code & 0x80000000) {
704 ixheaace_delete((pVOID)pstr_out_cfg);
705 return 0;
706 }
707 }
708
709 pv_ia_process_api_obj = pstr_out_cfg->pv_ia_process_api_obj;
710 pb_inp_buf = (pWORD8)pstr_out_cfg->mem_info_table[IA_MEMTYPE_INPUT].mem_ptr;
711
712 /* End first part */
713
714 /* Second part */
715 /* Initialize process */
716 /* Get config params */
717
718 input_size = pstr_out_cfg->input_size;
719 memset(pb_inp_buf, 0, input_size);
720
721 while (fuzzed_data.remaining_bytes()) {
722 if (read_inp_data) {
723 if (fuzzed_data.ConsumeBool()) {
724 std::vector<WORD8> input_vec = fuzzed_data.ConsumeBytes<WORD8>(input_size);
725 if (input_vec.size()) {
726 memcpy(pb_inp_buf, input_vec.data(), input_vec.size());
727 }
728 } else {
729 memset(pb_inp_buf, fuzzed_data.ConsumeIntegral<WORD8>(), input_size);
730 }
731 }
732 ixheaace_process(pv_ia_process_api_obj, (pVOID)pstr_in_cfg, (pVOID)pstr_out_cfg);
733 num_proc_iterations++;
734 if (pstr_out_cfg->i_out_bytes == 0) {
735 read_inp_data = 0;
736 } else {
737 read_inp_data = 1;
738 }
739 /* Stop processing after 500 frames */
740 if (num_proc_iterations > 500) break;
741 }
742
743 ixheaace_delete((pVOID)pstr_out_cfg);
744
745 if (pstr_drc_cfg) {
746 free(pstr_drc_cfg);
747 }
748 return 0;
749 }
750
751 /* End ia_main_process() */
752