1 /******************************************************************************
2 *
3 * Copyright (C) 2018 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 #include <stdio.h>
21 #include <string.h>
22 #include <math.h>
23 #include "impd_type_def.h"
24 #include "impd_drc_bitbuffer.h"
25 #include "impd_drc_extr_delta_coded_info.h"
26 #include "impd_drc_common.h"
27 #include "impd_drc_struct.h"
28 #include "impd_drc_parser.h"
29 #include "impd_drc_filter_bank.h"
30 #include "impd_drc_rom.h"
31
impd_parametric_drc_ffwd_init_drc_curve_params(WORD32 drc_characteristic,ia_parametric_drc_type_feed_forward_struct * str_parametric_drc_type_feed_forward)32 static VOID impd_parametric_drc_ffwd_init_drc_curve_params(
33 WORD32 drc_characteristic, ia_parametric_drc_type_feed_forward_struct*
34 str_parametric_drc_type_feed_forward) {
35 WORD32* node_level = str_parametric_drc_type_feed_forward->node_level;
36 WORD32* node_gain = str_parametric_drc_type_feed_forward->node_gain;
37
38 switch (drc_characteristic) {
39 case 7:
40 str_parametric_drc_type_feed_forward->node_count = 5;
41 node_level[0] = -22;
42 node_gain[0] = 6;
43 node_level[1] = -10;
44 node_gain[1] = 0;
45 node_level[2] = 10;
46 node_gain[2] = 0;
47 node_level[3] = 20;
48 node_gain[3] = -5;
49 node_level[4] = 40;
50 node_gain[4] = -24;
51 break;
52 case 8:
53 str_parametric_drc_type_feed_forward->node_count = 5;
54 node_level[0] = -12;
55 node_gain[0] = 6;
56 node_level[1] = 0;
57 node_gain[1] = 0;
58 node_level[2] = 5;
59 node_gain[2] = 0;
60 node_level[3] = 15;
61 node_gain[3] = -5;
62 node_level[4] = 35;
63 node_gain[4] = -24;
64 break;
65 case 9:
66 str_parametric_drc_type_feed_forward->node_count = 4;
67 node_level[0] = -34;
68 node_gain[0] = 12;
69 node_level[1] = -10;
70 node_gain[1] = 0;
71 node_level[2] = 10;
72 node_gain[2] = 0;
73 node_level[3] = 40;
74 node_gain[3] = -15;
75 break;
76 case 10:
77 str_parametric_drc_type_feed_forward->node_count = 5;
78 node_level[0] = -24;
79 node_gain[0] = 12;
80 node_level[1] = 0;
81 node_gain[1] = 0;
82 node_level[2] = 5;
83 node_gain[2] = 0;
84 node_level[3] = 15;
85 node_gain[3] = -5;
86 node_level[4] = 35;
87 node_gain[4] = -24;
88 break;
89 case 11:
90 str_parametric_drc_type_feed_forward->node_count = 5;
91 node_level[0] = -19;
92 node_gain[0] = 15;
93 node_level[1] = 0;
94 node_gain[1] = 0;
95 node_level[2] = 5;
96 node_gain[2] = 0;
97 node_level[3] = 15;
98 node_gain[3] = -5;
99 node_level[4] = 35;
100 node_gain[4] = -24;
101 break;
102 default:
103 str_parametric_drc_type_feed_forward->disable_paramteric_drc = 1;
104 }
105
106 return;
107 }
108
impd_parametric_drc_ffwd_init_drc_gain_smooth_params(WORD32 drc_characteristic,ia_parametric_drc_type_feed_forward_struct * str_parametric_drc_type_feed_forward)109 static VOID impd_parametric_drc_ffwd_init_drc_gain_smooth_params(
110 WORD32 drc_characteristic, ia_parametric_drc_type_feed_forward_struct*
111 str_parametric_drc_type_feed_forward) {
112 str_parametric_drc_type_feed_forward->gain_smooth_attack_time_slow = 100;
113 str_parametric_drc_type_feed_forward->gain_smooth_time_fast_present = 1;
114 str_parametric_drc_type_feed_forward->gain_smooth_attack_time_fast = 10;
115 str_parametric_drc_type_feed_forward->gain_smooth_threshold_present = 1;
116 str_parametric_drc_type_feed_forward->gain_smooth_hold_off_count_present = 1;
117 str_parametric_drc_type_feed_forward->gain_smooth_hold_off = 10;
118
119 switch (drc_characteristic) {
120 case 7:
121 case 8:
122 case 9:
123 str_parametric_drc_type_feed_forward->gain_smooth_release_time_slow =
124 3000;
125 str_parametric_drc_type_feed_forward->gain_smooth_release_time_fast =
126 1000;
127 str_parametric_drc_type_feed_forward->gain_smooth_attack_threshold = 15;
128 str_parametric_drc_type_feed_forward->gain_smooth_rel_threshold = 20;
129 break;
130 case 10:
131 str_parametric_drc_type_feed_forward->gain_smooth_release_time_slow =
132 10000;
133 str_parametric_drc_type_feed_forward->gain_smooth_release_time_fast =
134 1000;
135 str_parametric_drc_type_feed_forward->gain_smooth_attack_threshold = 15;
136 str_parametric_drc_type_feed_forward->gain_smooth_rel_threshold = 20;
137 break;
138 case 11:
139 str_parametric_drc_type_feed_forward->gain_smooth_release_time_slow =
140 1000;
141 str_parametric_drc_type_feed_forward->gain_smooth_release_time_fast = 200;
142 str_parametric_drc_type_feed_forward->gain_smooth_attack_threshold = 10;
143 str_parametric_drc_type_feed_forward->gain_smooth_rel_threshold = 10;
144 break;
145 default:
146 str_parametric_drc_type_feed_forward->gain_smooth_release_time_slow =
147 3000;
148 str_parametric_drc_type_feed_forward->gain_smooth_release_time_fast =
149 1000;
150 str_parametric_drc_type_feed_forward->gain_smooth_attack_threshold = 15;
151 str_parametric_drc_type_feed_forward->gain_smooth_rel_threshold = 20;
152 break;
153 }
154
155 return;
156 }
157
impd_parse_parametric_drc_ffwd(ia_bit_buf_struct * it_bit_buff,WORD32 parametric_drc_frame_size,ia_parametric_drc_type_feed_forward_struct * str_parametric_drc_type_feed_forward)158 static WORD32 impd_parse_parametric_drc_ffwd(
159 ia_bit_buf_struct* it_bit_buff, WORD32 parametric_drc_frame_size,
160 ia_parametric_drc_type_feed_forward_struct*
161 str_parametric_drc_type_feed_forward) {
162 WORD32 i = 0, tmp = 0;
163 // WORD32 err = 0;
164
165 str_parametric_drc_type_feed_forward->disable_paramteric_drc = 0;
166
167 tmp = impd_read_bits_buf(it_bit_buff, 3);
168 if (it_bit_buff->error) return it_bit_buff->error;
169
170 str_parametric_drc_type_feed_forward->level_estim_k_weighting_type =
171 (tmp >> 1) & 3;
172 str_parametric_drc_type_feed_forward->level_estim_integration_time_present =
173 tmp & 1;
174
175 if (str_parametric_drc_type_feed_forward
176 ->level_estim_integration_time_present) {
177 tmp = impd_read_bits_buf(it_bit_buff, 6);
178 if (it_bit_buff->error) return it_bit_buff->error;
179 str_parametric_drc_type_feed_forward->level_estim_integration_time =
180 (tmp + 1) * parametric_drc_frame_size;
181 } else {
182 str_parametric_drc_type_feed_forward->level_estim_integration_time =
183 parametric_drc_frame_size;
184 }
185
186 str_parametric_drc_type_feed_forward->drc_curve_definition_type =
187 impd_read_bits_buf(it_bit_buff, 1);
188 if (it_bit_buff->error) return it_bit_buff->error;
189
190 if (str_parametric_drc_type_feed_forward->drc_curve_definition_type == 0) {
191 str_parametric_drc_type_feed_forward->drc_characteristic =
192 impd_read_bits_buf(it_bit_buff, 7);
193 if (it_bit_buff->error) return it_bit_buff->error;
194 impd_parametric_drc_ffwd_init_drc_curve_params(
195 str_parametric_drc_type_feed_forward->drc_characteristic,
196 str_parametric_drc_type_feed_forward);
197 } else {
198 str_parametric_drc_type_feed_forward->drc_characteristic = 0;
199
200 tmp = impd_read_bits_buf(it_bit_buff, 15);
201 if (it_bit_buff->error) return it_bit_buff->error;
202
203 str_parametric_drc_type_feed_forward->node_count = ((tmp >> 12) & 3) + 2;
204 str_parametric_drc_type_feed_forward->node_level[0] =
205 -11 - ((tmp >> 6) & 0x3f);
206 str_parametric_drc_type_feed_forward->node_gain[0] = (tmp & 0x3f) - 39;
207
208 for (i = 1; i < str_parametric_drc_type_feed_forward->node_count; i++) {
209 tmp = impd_read_bits_buf(it_bit_buff, 11);
210 if (it_bit_buff->error) return it_bit_buff->error;
211
212 str_parametric_drc_type_feed_forward->node_level[i] =
213 str_parametric_drc_type_feed_forward->node_level[i - 1] + 1 +
214 ((tmp >> 6) & 0x1f);
215 str_parametric_drc_type_feed_forward->node_gain[i] = (tmp & 0x3f) - 39;
216 }
217 }
218
219 impd_parametric_drc_ffwd_init_drc_gain_smooth_params(
220 str_parametric_drc_type_feed_forward->drc_characteristic,
221 str_parametric_drc_type_feed_forward);
222
223 str_parametric_drc_type_feed_forward->drc_gain_smooth_parameters_present =
224 impd_read_bits_buf(it_bit_buff, 1);
225 if (it_bit_buff->error) return it_bit_buff->error;
226 if (str_parametric_drc_type_feed_forward
227 ->drc_gain_smooth_parameters_present) {
228 tmp = impd_read_bits_buf(it_bit_buff, 17);
229 if (it_bit_buff->error) return it_bit_buff->error;
230
231 str_parametric_drc_type_feed_forward->gain_smooth_attack_time_slow =
232 ((tmp >> 9) & 0xff) * 5;
233 str_parametric_drc_type_feed_forward->gain_smooth_release_time_slow =
234 ((tmp >> 1) & 0xff) * 40;
235 str_parametric_drc_type_feed_forward->gain_smooth_time_fast_present =
236 tmp & 1;
237
238 if (str_parametric_drc_type_feed_forward->gain_smooth_time_fast_present) {
239 tmp = impd_read_bits_buf(it_bit_buff, 17);
240 if (it_bit_buff->error) return it_bit_buff->error;
241
242 str_parametric_drc_type_feed_forward->gain_smooth_attack_time_fast =
243 ((tmp >> 9) & 0xff) * 5;
244 str_parametric_drc_type_feed_forward->gain_smooth_release_time_fast =
245 ((tmp >> 1) & 0xff) * 20;
246 str_parametric_drc_type_feed_forward->gain_smooth_threshold_present =
247 tmp & 1;
248
249 if (str_parametric_drc_type_feed_forward->gain_smooth_threshold_present) {
250 str_parametric_drc_type_feed_forward->gain_smooth_attack_threshold =
251 impd_read_bits_buf(it_bit_buff, 5);
252 if (it_bit_buff->error) return it_bit_buff->error;
253 if (str_parametric_drc_type_feed_forward
254 ->gain_smooth_attack_threshold == 31) {
255 str_parametric_drc_type_feed_forward->gain_smooth_attack_threshold =
256 1000;
257 }
258
259 str_parametric_drc_type_feed_forward->gain_smooth_rel_threshold =
260 impd_read_bits_buf(it_bit_buff, 5);
261 if (it_bit_buff->error) return it_bit_buff->error;
262 if (str_parametric_drc_type_feed_forward->gain_smooth_rel_threshold ==
263 31) {
264 str_parametric_drc_type_feed_forward->gain_smooth_rel_threshold =
265 1000;
266 }
267 }
268 } else {
269 str_parametric_drc_type_feed_forward->gain_smooth_attack_time_fast =
270 str_parametric_drc_type_feed_forward->gain_smooth_attack_time_slow;
271 str_parametric_drc_type_feed_forward->gain_smooth_release_time_fast =
272 str_parametric_drc_type_feed_forward->gain_smooth_release_time_slow;
273 }
274
275 str_parametric_drc_type_feed_forward->gain_smooth_hold_off_count_present =
276 impd_read_bits_buf(it_bit_buff, 1);
277 if (it_bit_buff->error) return it_bit_buff->error;
278
279 if (str_parametric_drc_type_feed_forward
280 ->gain_smooth_hold_off_count_present) {
281 str_parametric_drc_type_feed_forward->gain_smooth_hold_off =
282 impd_read_bits_buf(it_bit_buff, 7);
283 if (it_bit_buff->error) return it_bit_buff->error;
284 }
285 }
286 return 0;
287 }
288
impd_parse_parametric_drc_lim(ia_bit_buf_struct * it_bit_buff,ia_parametric_drc_lim_struct * parametric_drc_lim)289 static WORD32 impd_parse_parametric_drc_lim(
290 ia_bit_buf_struct* it_bit_buff,
291 ia_parametric_drc_lim_struct* parametric_drc_lim) {
292 // WORD32 err = 0;
293 WORD32 tmp = 0;
294
295 parametric_drc_lim->disable_paramteric_drc = 0;
296
297 parametric_drc_lim->parametric_lim_threshold_present =
298 impd_read_bits_buf(it_bit_buff, 1);
299 if (it_bit_buff->error) return it_bit_buff->error;
300
301 if (parametric_drc_lim->parametric_lim_threshold_present) {
302 tmp = impd_read_bits_buf(it_bit_buff, 8);
303 if (it_bit_buff->error) return it_bit_buff->error;
304 parametric_drc_lim->parametric_lim_threshold = -tmp * 0.125f;
305 } else {
306 parametric_drc_lim->parametric_lim_threshold =
307 PARAM_DRC_TYPE_LIM_THRESHOLD_DEFAULT;
308 }
309
310 parametric_drc_lim->parametric_lim_release_present =
311 impd_read_bits_buf(it_bit_buff, 1);
312 if (it_bit_buff->error) return it_bit_buff->error;
313 if (parametric_drc_lim->parametric_lim_release_present) {
314 tmp = impd_read_bits_buf(it_bit_buff, 8);
315 if (it_bit_buff->error) return it_bit_buff->error;
316 parametric_drc_lim->parametric_lim_release = tmp * 10;
317 } else {
318 parametric_drc_lim->parametric_lim_release =
319 PARAM_DRC_TYPE_LIM_RELEASE_DEFAULT;
320 }
321
322 parametric_drc_lim->parametric_lim_attack = PARAM_DRC_TYPE_LIM_ATTACK_DEFAULT;
323 parametric_drc_lim->drc_characteristic = 0;
324
325 return 0;
326 }
327
328 WORD32
impd_parametric_drc_parse_gain_set_params(ia_bit_buf_struct * it_bit_buff,ia_drc_config * drc_config,ia_parametric_drc_gain_set_params_struct * str_parametric_drc_gain_set_params)329 impd_parametric_drc_parse_gain_set_params(
330 ia_bit_buf_struct* it_bit_buff, ia_drc_config* drc_config,
331 ia_parametric_drc_gain_set_params_struct*
332 str_parametric_drc_gain_set_params) {
333 WORD32 i = 0, bsDrcInputLoudness = 0, bs_channel_weight = 0, temp;
334 // WORD32 err = 0;
335 temp = impd_read_bits_buf(it_bit_buff, 7);
336 if (it_bit_buff->error) return it_bit_buff->error;
337
338 str_parametric_drc_gain_set_params->parametric_drc_id = (temp >> 3) & 0xf;
339 str_parametric_drc_gain_set_params->side_chain_config_type = temp & 7;
340
341 if (str_parametric_drc_gain_set_params->side_chain_config_type) {
342 temp = impd_read_bits_buf(it_bit_buff, 8);
343 if (it_bit_buff->error) return it_bit_buff->error;
344
345 str_parametric_drc_gain_set_params->downmix_id = (temp >> 1) & 0x7f;
346 str_parametric_drc_gain_set_params->level_estim_channel_weight_format =
347 temp & 1;
348
349 if (str_parametric_drc_gain_set_params->downmix_id == ID_FOR_BASE_LAYOUT) {
350 str_parametric_drc_gain_set_params->ch_count_from_dwnmix_id =
351 drc_config->channel_layout.base_channel_count;
352 } else if (str_parametric_drc_gain_set_params->downmix_id ==
353 ID_FOR_ANY_DOWNMIX) {
354 str_parametric_drc_gain_set_params->ch_count_from_dwnmix_id = 1;
355 } else {
356 for (i = 0; i < drc_config->dwnmix_instructions_count; i++) {
357 if (str_parametric_drc_gain_set_params->downmix_id ==
358 drc_config->dwnmix_instructions[i].downmix_id)
359 break;
360 }
361 if (i == drc_config->dwnmix_instructions_count) {
362 /* dwnmix_instructions not found */
363 return (UNEXPECTED_ERROR);
364 }
365 str_parametric_drc_gain_set_params->ch_count_from_dwnmix_id =
366 drc_config->dwnmix_instructions[i].target_channel_count;
367 }
368
369 for (i = 0; i < str_parametric_drc_gain_set_params->ch_count_from_dwnmix_id;
370 i++) {
371 if (str_parametric_drc_gain_set_params
372 ->level_estim_channel_weight_format == 0) {
373 str_parametric_drc_gain_set_params->level_estim_ch_weight[i] =
374 (FLOAT32)impd_read_bits_buf(it_bit_buff, 1);
375 if (it_bit_buff->error) return it_bit_buff->error;
376 } else {
377 bs_channel_weight = impd_read_bits_buf(it_bit_buff, 4);
378 if (it_bit_buff->error) return it_bit_buff->error;
379 str_parametric_drc_gain_set_params->level_estim_ch_weight[i] =
380 (FLOAT32)pow(10.0f, 0.05f * channel_weight[bs_channel_weight]);
381 }
382 }
383 } else {
384 str_parametric_drc_gain_set_params->downmix_id = 0;
385 str_parametric_drc_gain_set_params->ch_count_from_dwnmix_id = 0;
386 }
387
388 str_parametric_drc_gain_set_params->drc_input_loudness_present =
389 impd_read_bits_buf(it_bit_buff, 1);
390 if (it_bit_buff->error) return it_bit_buff->error;
391
392 if (str_parametric_drc_gain_set_params->drc_input_loudness_present) {
393 bsDrcInputLoudness = impd_read_bits_buf(it_bit_buff, 8);
394 if (it_bit_buff->error) return it_bit_buff->error;
395 str_parametric_drc_gain_set_params->drc_input_loudness =
396 -57.75f + bsDrcInputLoudness * 0.25f;
397 }
398
399 return 0;
400 }
401
impd_parametric_drc_gen_virtual_gain_sets(ia_drc_config * drc_config)402 static WORD32 impd_parametric_drc_gen_virtual_gain_sets(
403 ia_drc_config* drc_config) {
404 WORD32 i = 0, j = 0, c1 = -1, c0 = -1, parametric_drc_id = 0,
405 drc_characteristic = 0;
406 ia_uni_drc_coeffs_struct* str_p_loc_drc_coefficients_uni_drc;
407 ia_parametric_drc_instructions_struct* str_parametric_drc_instructions;
408 ia_drc_coeff_parametric_drc_struct* str_drc_coeff_param_drc =
409 &(drc_config->str_drc_config_ext.str_drc_coeff_param_drc);
410
411 for (i = 0; i < drc_config->drc_coefficients_drc_count; i++) {
412 if (drc_config->str_p_loc_drc_coefficients_uni_drc[i].drc_location ==
413 str_drc_coeff_param_drc->drc_location) {
414 if (drc_config->str_p_loc_drc_coefficients_uni_drc[i].version == 0) {
415 c0 = i;
416 } else {
417 c1 = i;
418 }
419 }
420 }
421 if (c1 >= 0) {
422 str_p_loc_drc_coefficients_uni_drc =
423 &(drc_config->str_p_loc_drc_coefficients_uni_drc[c1]);
424 } else if (c0 >= 0) {
425 str_p_loc_drc_coefficients_uni_drc =
426 &(drc_config->str_p_loc_drc_coefficients_uni_drc[c0]);
427 } else {
428 str_p_loc_drc_coefficients_uni_drc =
429 &drc_config->str_p_loc_drc_coefficients_uni_drc
430 [drc_config->drc_coefficients_drc_count];
431
432 str_p_loc_drc_coefficients_uni_drc->version = 1;
433 str_p_loc_drc_coefficients_uni_drc->drc_location =
434 str_drc_coeff_param_drc->drc_location;
435 str_p_loc_drc_coefficients_uni_drc->drc_frame_size_present = 0;
436
437 str_p_loc_drc_coefficients_uni_drc->gain_set_count = 0;
438 str_p_loc_drc_coefficients_uni_drc->gain_set_count_plus = 0;
439
440 str_p_loc_drc_coefficients_uni_drc->drc_characteristic_left_present = 0;
441 str_p_loc_drc_coefficients_uni_drc->drc_characteristic_right_present = 0;
442 str_p_loc_drc_coefficients_uni_drc->shape_filters_present = 0;
443 str_p_loc_drc_coefficients_uni_drc->gain_sequence_count = 0;
444 drc_config->drc_coefficients_drc_count += 1;
445 }
446 str_p_loc_drc_coefficients_uni_drc->gain_set_count_plus =
447 str_p_loc_drc_coefficients_uni_drc->gain_set_count +
448 str_drc_coeff_param_drc->parametric_drc_gain_set_count;
449 for (i = str_p_loc_drc_coefficients_uni_drc->gain_set_count;
450 i < str_p_loc_drc_coefficients_uni_drc->gain_set_count_plus; i++) {
451 str_p_loc_drc_coefficients_uni_drc->gain_set_params[i].band_count = 1;
452
453 parametric_drc_id =
454 drc_config->str_drc_config_ext.str_drc_coeff_param_drc
455 .str_parametric_drc_gain_set_params
456 [i - str_p_loc_drc_coefficients_uni_drc->gain_set_count]
457 .parametric_drc_id;
458
459 for (j = 0;
460 j < drc_config->str_drc_config_ext.parametric_drc_instructions_count;
461 j++) {
462 if (parametric_drc_id ==
463 drc_config->str_drc_config_ext.str_parametric_drc_instructions[j]
464 .parametric_drc_id)
465 break;
466 }
467 if (j == drc_config->str_drc_config_ext.parametric_drc_instructions_count) {
468 /* str_parametric_drc_instructions not found */
469 return (UNEXPECTED_ERROR);
470 }
471 str_parametric_drc_instructions =
472 &drc_config->str_drc_config_ext.str_parametric_drc_instructions[j];
473
474 drc_characteristic = 0;
475 if (str_parametric_drc_instructions->parametric_drc_preset_id_present) {
476 drc_characteristic = str_parametric_drc_instructions->drc_characteristic;
477 } else if (str_parametric_drc_instructions->parametric_drc_type ==
478 PARAM_DRC_TYPE_FF) {
479 if (str_parametric_drc_instructions->str_parametric_drc_type_feed_forward
480 .drc_curve_definition_type == 0) {
481 drc_characteristic =
482 str_parametric_drc_instructions
483 ->str_parametric_drc_type_feed_forward.drc_characteristic;
484 }
485 }
486 if (drc_characteristic != 0) {
487 str_p_loc_drc_coefficients_uni_drc->gain_set_params[i]
488 .gain_params[0]
489 .drc_characteristic_present = 1;
490 str_p_loc_drc_coefficients_uni_drc->gain_set_params[i]
491 .gain_params[0]
492 .drc_characteristic_format_is_cicp = 1;
493 str_p_loc_drc_coefficients_uni_drc->gain_set_params[i]
494 .gain_params[0]
495 .drc_characteristic = drc_characteristic;
496 } else {
497 str_p_loc_drc_coefficients_uni_drc->gain_set_params[i]
498 .gain_params[0]
499 .drc_characteristic_present = 0;
500 str_p_loc_drc_coefficients_uni_drc->gain_set_params[i]
501 .gain_params[0]
502 .drc_characteristic_format_is_cicp = 0;
503 str_p_loc_drc_coefficients_uni_drc->gain_set_params[i]
504 .gain_params[0]
505 .drc_characteristic = 0;
506 }
507 }
508
509 return 0;
510 }
511
impd_parametic_drc_parse_coeff(ia_bit_buf_struct * it_bit_buff,ia_drc_config * drc_config,ia_drc_coeff_parametric_drc_struct * str_drc_coeff_param_drc)512 static WORD32 impd_parametic_drc_parse_coeff(
513 ia_bit_buf_struct* it_bit_buff, ia_drc_config* drc_config,
514 ia_drc_coeff_parametric_drc_struct* str_drc_coeff_param_drc) {
515 WORD32 i = 0, err = 0, code = 0, mu = 0, nu = 0, temp;
516
517 temp = impd_read_bits_buf(it_bit_buff, 5);
518 if (it_bit_buff->error) return it_bit_buff->error;
519
520 str_drc_coeff_param_drc->drc_location = (temp >> 1) & 0xf;
521 str_drc_coeff_param_drc->parametric_drc_frame_size_format = temp & 1;
522
523 if (str_drc_coeff_param_drc->parametric_drc_frame_size) {
524 code = impd_read_bits_buf(it_bit_buff, 15);
525 if (it_bit_buff->error) return it_bit_buff->error;
526 str_drc_coeff_param_drc->parametric_drc_frame_size = code + 1;
527 } else {
528 code = impd_read_bits_buf(it_bit_buff, 4);
529 if (it_bit_buff->error) return it_bit_buff->error;
530 str_drc_coeff_param_drc->parametric_drc_frame_size = 1 << code;
531 }
532
533 str_drc_coeff_param_drc->parametric_drc_delay_max_present =
534 impd_read_bits_buf(it_bit_buff, 1);
535 if (str_drc_coeff_param_drc->parametric_drc_delay_max_present) {
536 temp = impd_read_bits_buf(it_bit_buff, 8);
537 if (it_bit_buff->error) return it_bit_buff->error;
538
539 mu = (temp >> 3) & 0x1f;
540 nu = temp & 3;
541
542 str_drc_coeff_param_drc->parametric_drc_delay_max = 16 * mu * (1 << nu);
543 }
544
545 temp = impd_read_bits_buf(it_bit_buff, 7);
546 if (it_bit_buff->error) return it_bit_buff->error;
547
548 str_drc_coeff_param_drc->reset_parametric_drc = (temp >> 6) & 1;
549 str_drc_coeff_param_drc->parametric_drc_gain_set_count = temp & 0x3f;
550
551 if (str_drc_coeff_param_drc->parametric_drc_gain_set_count >
552 SEQUENCE_COUNT_MAX)
553 return (UNEXPECTED_ERROR);
554
555 for (i = 0; i < str_drc_coeff_param_drc->parametric_drc_gain_set_count; i++) {
556 err = impd_parametric_drc_parse_gain_set_params(
557 it_bit_buff, drc_config,
558 &(str_drc_coeff_param_drc->str_parametric_drc_gain_set_params[i]));
559 if (err) return (err);
560 }
561
562 return 0;
563 }
564
impd_parse_parametric_drc_instructions(ia_bit_buf_struct * it_bit_buff,WORD32 parametric_drc_frame_size,ia_parametric_drc_instructions_struct * str_parametric_drc_instructions)565 static WORD32 impd_parse_parametric_drc_instructions(
566 ia_bit_buf_struct* it_bit_buff, WORD32 parametric_drc_frame_size,
567 ia_parametric_drc_instructions_struct* str_parametric_drc_instructions) {
568 WORD32 i = 0, err = 0, temp;
569 WORD32 bit_size_len, bit_size, other_bit;
570
571 str_parametric_drc_instructions->drc_characteristic = 0;
572 str_parametric_drc_instructions->disable_paramteric_drc = 0;
573
574 temp = impd_read_bits_buf(it_bit_buff, 5);
575 if (it_bit_buff->error) return it_bit_buff->error;
576
577 str_parametric_drc_instructions->parametric_drc_id = (temp >> 1) & 0xf;
578 str_parametric_drc_instructions->parametric_drc_look_ahead_flag = temp & 1;
579
580 if (str_parametric_drc_instructions->parametric_drc_look_ahead_flag) {
581 str_parametric_drc_instructions->parametric_drc_look_ahead =
582 impd_read_bits_buf(it_bit_buff, 7);
583 if (it_bit_buff->error) return it_bit_buff->error;
584 } else {
585 str_parametric_drc_instructions->parametric_drc_look_ahead = 0;
586 }
587
588 str_parametric_drc_instructions->parametric_drc_preset_id_present =
589 impd_read_bits_buf(it_bit_buff, 1);
590 if (it_bit_buff->error) return it_bit_buff->error;
591
592 if (str_parametric_drc_instructions->parametric_drc_preset_id_present) {
593 str_parametric_drc_instructions->parametric_drc_preset_id =
594 impd_read_bits_buf(it_bit_buff, 7);
595 if (it_bit_buff->error) return it_bit_buff->error;
596
597 switch (str_parametric_drc_instructions->parametric_drc_preset_id) {
598 case 0:
599 case 1:
600 case 2:
601 case 3:
602 case 4:
603 str_parametric_drc_instructions->drc_characteristic =
604 str_parametric_drc_instructions->parametric_drc_preset_id + 7;
605 str_parametric_drc_instructions->parametric_drc_type =
606 PARAM_DRC_TYPE_FF;
607
608 str_parametric_drc_instructions->str_parametric_drc_type_feed_forward
609 .level_estim_k_weighting_type = 2;
610 str_parametric_drc_instructions->str_parametric_drc_type_feed_forward
611 .level_estim_integration_time = parametric_drc_frame_size;
612
613 impd_parametric_drc_ffwd_init_drc_curve_params(
614 str_parametric_drc_instructions->drc_characteristic,
615 &str_parametric_drc_instructions
616 ->str_parametric_drc_type_feed_forward);
617 impd_parametric_drc_ffwd_init_drc_gain_smooth_params(
618 str_parametric_drc_instructions->drc_characteristic,
619 &str_parametric_drc_instructions
620 ->str_parametric_drc_type_feed_forward);
621
622 break;
623 default:
624 str_parametric_drc_instructions->disable_paramteric_drc = 1;
625 break;
626 }
627 } else {
628 str_parametric_drc_instructions->parametric_drc_type =
629 impd_read_bits_buf(it_bit_buff, 3);
630 if (it_bit_buff->error) return it_bit_buff->error;
631
632 if (str_parametric_drc_instructions->parametric_drc_type ==
633 PARAM_DRC_TYPE_FF) {
634 err = impd_parse_parametric_drc_ffwd(
635 it_bit_buff, parametric_drc_frame_size,
636 &(str_parametric_drc_instructions
637 ->str_parametric_drc_type_feed_forward));
638 if (err) return (err);
639 str_parametric_drc_instructions->disable_paramteric_drc =
640 str_parametric_drc_instructions->str_parametric_drc_type_feed_forward
641 .disable_paramteric_drc;
642 str_parametric_drc_instructions->drc_characteristic =
643 str_parametric_drc_instructions->str_parametric_drc_type_feed_forward
644 .drc_characteristic;
645 } else if (str_parametric_drc_instructions->parametric_drc_type ==
646 PARAM_DRC_TYPE_LIM) {
647 err = impd_parse_parametric_drc_lim(
648 it_bit_buff, &(str_parametric_drc_instructions->parametric_drc_lim));
649 if (err) return (err);
650 str_parametric_drc_instructions->disable_paramteric_drc =
651 str_parametric_drc_instructions->parametric_drc_lim
652 .disable_paramteric_drc;
653 str_parametric_drc_instructions->drc_characteristic =
654 str_parametric_drc_instructions->parametric_drc_lim
655 .drc_characteristic;
656 if (str_parametric_drc_instructions->parametric_drc_look_ahead_flag) {
657 str_parametric_drc_instructions->parametric_drc_lim
658 .parametric_lim_attack =
659 str_parametric_drc_instructions->parametric_drc_look_ahead;
660 }
661 } else {
662 bit_size_len = impd_read_bits_buf(it_bit_buff, 3) + 4;
663 if (it_bit_buff->error) return it_bit_buff->error;
664
665 bit_size = impd_read_bits_buf(it_bit_buff, bit_size_len);
666 if (it_bit_buff->error) return it_bit_buff->error;
667 str_parametric_drc_instructions->len_bit_size = bit_size + 1;
668
669 switch (str_parametric_drc_instructions->parametric_drc_type) {
670 default:
671 str_parametric_drc_instructions->disable_paramteric_drc = 1;
672 for (i = 0; i < str_parametric_drc_instructions->len_bit_size; i++) {
673 other_bit = impd_read_bits_buf(it_bit_buff, 1);
674 if (it_bit_buff->error) return it_bit_buff->error;
675 }
676 break;
677 }
678 }
679 }
680
681 return 0;
682 }
683
impd_parse_loud_info_set_ext_eq(ia_bit_buf_struct * it_bit_buff,ia_drc_loudness_info_set_struct * loudness_info_set)684 WORD32 impd_parse_loud_info_set_ext_eq(
685 ia_bit_buf_struct* it_bit_buff,
686 ia_drc_loudness_info_set_struct* loudness_info_set) {
687 WORD32 err, i, offset, version = 1, temp;
688 WORD32 loudness_info_v1_album_cnt, loudness_info_v1_cnt;
689
690 temp = impd_read_bits_buf(it_bit_buff, 12);
691 if (it_bit_buff->error) return it_bit_buff->error;
692
693 loudness_info_v1_album_cnt = (temp >> 6) & 0x3f;
694 loudness_info_v1_cnt = temp & 0x3f;
695
696 offset = loudness_info_set->loudness_info_album_count;
697 loudness_info_set->loudness_info_album_count += loudness_info_v1_album_cnt;
698 for (i = 0; i < loudness_info_v1_album_cnt; i++) {
699 err = impd_parse_loudness_info(
700 it_bit_buff, version,
701 &loudness_info_set->str_loudness_info_album[i + offset]);
702 if (err) return (err);
703 }
704 offset = loudness_info_set->loudness_info_count;
705 loudness_info_set->loudness_info_count += loudness_info_v1_cnt;
706 for (i = 0; i < loudness_info_v1_cnt; i++) {
707 err = impd_parse_loudness_info(
708 it_bit_buff, version, &loudness_info_set->loudness_info[i + offset]);
709 if (err) return (err);
710 }
711 return (0);
712 }
713
impd_parse_ch_layout(ia_bit_buf_struct * it_bit_buff,ia_drc_params_bs_dec_struct * ia_drc_params_struct,ia_channel_layout_struct * channel_layout)714 WORD32 impd_parse_ch_layout(ia_bit_buf_struct* it_bit_buff,
715 ia_drc_params_bs_dec_struct* ia_drc_params_struct,
716 ia_channel_layout_struct* channel_layout) {
717 // WORD32 err = 0;
718 WORD32 i;
719
720 channel_layout->base_channel_count = impd_read_bits_buf(it_bit_buff, 7);
721 if (it_bit_buff->error) return it_bit_buff->error;
722 if (ia_drc_params_struct->lfe_channel_map_count != -1 &&
723 channel_layout->base_channel_count !=
724 ia_drc_params_struct->lfe_channel_map_count) {
725 return (UNEXPECTED_ERROR);
726 }
727 channel_layout->layout_signaling_present = impd_read_bits_buf(it_bit_buff, 1);
728 if (it_bit_buff->error) return it_bit_buff->error;
729
730 if (channel_layout->layout_signaling_present) {
731 channel_layout->defined_layout = impd_read_bits_buf(it_bit_buff, 8);
732 if (it_bit_buff->error) return it_bit_buff->error;
733
734 if (channel_layout->defined_layout == 0) {
735 for (i = 0; i < channel_layout->base_channel_count; i++) {
736 channel_layout->speaker_position[i] =
737 impd_read_bits_buf(it_bit_buff, 7);
738 if (it_bit_buff->error) return it_bit_buff->error;
739 if (channel_layout->speaker_position[i] == 3 ||
740 channel_layout->speaker_position[i] == 26) {
741 ia_drc_params_struct->lfe_channel_map[i] = 1;
742 } else {
743 ia_drc_params_struct->lfe_channel_map[i] = 0;
744 }
745 }
746 }
747 }
748
749 return (0);
750 }
751
752 WORD32
impd_parse_dwnmix_instructions(ia_bit_buf_struct * it_bit_buff,WORD32 version,ia_drc_params_bs_dec_struct * ia_drc_params_struct,ia_channel_layout_struct * channel_layout,ia_downmix_instructions_struct * dwnmix_instructions)753 impd_parse_dwnmix_instructions(
754 ia_bit_buf_struct* it_bit_buff, WORD32 version,
755 ia_drc_params_bs_dec_struct* ia_drc_params_struct,
756 ia_channel_layout_struct* channel_layout,
757 ia_downmix_instructions_struct* dwnmix_instructions) {
758 // WORD32 err = 0;
759 WORD32 i, j, k, temp;
760
761 temp = impd_read_bits_buf(it_bit_buff, 23);
762 if (it_bit_buff->error) return it_bit_buff->error;
763
764 dwnmix_instructions->downmix_id = (temp >> 16) & 0x7f;
765 dwnmix_instructions->target_channel_count = (temp >> 9) & 0x7f;
766 dwnmix_instructions->target_layout = (temp >> 1) & 0xff;
767 dwnmix_instructions->downmix_coefficients_present = temp & 1;
768
769 if (dwnmix_instructions->downmix_coefficients_present) {
770 if (version == 0) {
771 WORD32 dmix_coeff;
772 k = 0;
773 for (i = 0; i < dwnmix_instructions->target_channel_count; i++) {
774 for (j = 0; j < channel_layout->base_channel_count; j++) {
775 dmix_coeff = impd_read_bits_buf(it_bit_buff, 4);
776 if (it_bit_buff->error) return it_bit_buff->error;
777
778 if (ia_drc_params_struct->lfe_channel_map[j]) {
779 dwnmix_instructions->downmix_coefficient[k] =
780 (FLOAT32)pow(10.0f, 0.05f * dwnmix_coeff_lfe[dmix_coeff]);
781 } else {
782 dwnmix_instructions->downmix_coefficient[k] =
783 (FLOAT32)pow(10.0f, 0.05f * dwnmix_coeff[dmix_coeff]);
784 }
785 k++;
786 }
787 }
788 } else {
789 WORD32 dmix_coeff_v1, bs_dmix_offset;
790 FLOAT32 a, b, dmix_offset, sum;
791
792 bs_dmix_offset = impd_read_bits_buf(it_bit_buff, 4);
793 if (it_bit_buff->error) return it_bit_buff->error;
794 k = 0;
795 for (i = 0; i < dwnmix_instructions->target_channel_count; i++) {
796 for (j = 0; j < channel_layout->base_channel_count; j++) {
797 dmix_coeff_v1 = impd_read_bits_buf(it_bit_buff, 5);
798 if (it_bit_buff->error) return it_bit_buff->error;
799 dwnmix_instructions->downmix_coefficient[k] =
800 dwnmix_coeff_v1[dmix_coeff_v1];
801 k++;
802 }
803 }
804 switch (bs_dmix_offset) {
805 case 0:
806 dmix_offset = 0.0f;
807 break;
808 case 1:
809 a = 20.0f * (FLOAT32)log10(
810 (FLOAT32)dwnmix_instructions->target_channel_count /
811 (FLOAT32)channel_layout->base_channel_count);
812 dmix_offset = 0.5f * (FLOAT32)floor(0.5f + a);
813 break;
814 case 2:
815 a = 20.0f * (FLOAT32)log10(
816 (FLOAT32)dwnmix_instructions->target_channel_count /
817 (FLOAT32)channel_layout->base_channel_count);
818 dmix_offset = 0.5f * (FLOAT32)floor(0.5f + 2.0f * a);
819 break;
820 case 3:
821 sum = 0.0f;
822 for (k = 0; k < dwnmix_instructions->target_channel_count *
823 channel_layout->base_channel_count;
824 k++) {
825 sum += (FLOAT32)pow(
826 10.0f, 0.1f * dwnmix_instructions->downmix_coefficient[k]);
827 }
828 b = 10.0f * (FLOAT32)log10(sum);
829 dmix_offset = 0.5f * (FLOAT32)floor(0.5f + 2.0f * b);
830 break;
831
832 default:
833 return (BITSTREAM_ERROR);
834 break;
835 }
836 for (k = 0; k < dwnmix_instructions->target_channel_count *
837 channel_layout->base_channel_count;
838 k++) {
839 dwnmix_instructions->downmix_coefficient[k] = (FLOAT32)pow(
840 10.0f, 0.05f * (dwnmix_instructions->downmix_coefficient[k] +
841 dmix_offset));
842 }
843 }
844 }
845 return (0);
846 }
847
impd_drc_gen_instructions_for_drc_off(ia_drc_config * drc_config)848 VOID impd_drc_gen_instructions_for_drc_off(ia_drc_config* drc_config) {
849 WORD32 i, k, s;
850 ia_drc_instructions_struct* str_drc_instruction_str;
851 s = -1;
852
853 k = drc_config->drc_instructions_uni_drc_count;
854
855 str_drc_instruction_str = &(drc_config->str_drc_instruction_str[k]);
856 memset(str_drc_instruction_str, 0, sizeof(ia_drc_instructions_struct));
857 str_drc_instruction_str->drc_set_id = s;
858 s--;
859 str_drc_instruction_str->downmix_id[0] = ID_FOR_BASE_LAYOUT;
860 str_drc_instruction_str->dwnmix_id_count = 1;
861 str_drc_instruction_str->drc_apply_to_dwnmix = 0;
862 str_drc_instruction_str->depends_on_drc_set_present = 0;
863 str_drc_instruction_str->no_independent_use = 0;
864 str_drc_instruction_str->gain_element_count = 0;
865 for (i = 1; i < drc_config->dwnmix_instructions_count + 1; i++) {
866 str_drc_instruction_str = &(drc_config->str_drc_instruction_str[k + i]);
867 memset(str_drc_instruction_str, 0, sizeof(ia_drc_instructions_struct));
868 str_drc_instruction_str->drc_set_id = s;
869 s--;
870 str_drc_instruction_str->drc_set_complexity_level = 0;
871 str_drc_instruction_str->requires_eq = 0;
872 str_drc_instruction_str->downmix_id[0] =
873 drc_config->dwnmix_instructions[i - 1].downmix_id;
874 str_drc_instruction_str->dwnmix_id_count = 1;
875 str_drc_instruction_str->drc_apply_to_dwnmix = 0;
876 str_drc_instruction_str->depends_on_drc_set_present = 0;
877 str_drc_instruction_str->no_independent_use = 0;
878 str_drc_instruction_str->gain_element_count = 0;
879 }
880 drc_config->drc_instructions_count_plus =
881 drc_config->drc_instructions_uni_drc_count +
882 drc_config->dwnmix_instructions_count + 1;
883 return;
884 }
885
886 WORD32
impd_parse_drc_config_ext(ia_bit_buf_struct * it_bit_buff,ia_drc_params_bs_dec_struct * ia_drc_params_struct,ia_drc_config * drc_config,ia_drc_config_ext * str_drc_config_ext)887 impd_parse_drc_config_ext(ia_bit_buf_struct* it_bit_buff,
888 ia_drc_params_bs_dec_struct* ia_drc_params_struct,
889 ia_drc_config* drc_config,
890 ia_drc_config_ext* str_drc_config_ext) {
891 WORD32 err = 0, i, k;
892 WORD32 bit_size_len, ext_size_bits, bit_size, other_bit;
893
894 k = 0;
895 str_drc_config_ext->drc_config_ext_type[k] =
896 impd_read_bits_buf(it_bit_buff, 4);
897 if (it_bit_buff->error) return it_bit_buff->error;
898 while (str_drc_config_ext->drc_config_ext_type[k] != UNIDRCCONFEXT_TERM) {
899 bit_size_len = impd_read_bits_buf(it_bit_buff, 4);
900 if (it_bit_buff->error) return it_bit_buff->error;
901 ext_size_bits = bit_size_len + 4;
902
903 bit_size = impd_read_bits_buf(it_bit_buff, ext_size_bits);
904 if (it_bit_buff->error) return it_bit_buff->error;
905 str_drc_config_ext->ext_bit_size[k] = bit_size + 1;
906
907 switch (str_drc_config_ext->drc_config_ext_type[k]) {
908 case UNIDRCCONFEXT_PARAM_DRC:
909 str_drc_config_ext->parametric_drc_present = 1;
910 err = impd_parametic_drc_parse_coeff(
911 it_bit_buff, drc_config,
912 &(str_drc_config_ext->str_drc_coeff_param_drc));
913 if (err) return (err);
914 str_drc_config_ext->parametric_drc_instructions_count =
915 impd_read_bits_buf(it_bit_buff, 4);
916 if (it_bit_buff->error) return it_bit_buff->error;
917 if (str_drc_config_ext->parametric_drc_instructions_count >
918 PARAM_DRC_INSTRUCTIONS_COUNT_MAX)
919 return (UNEXPECTED_ERROR);
920
921 for (i = 0; i < str_drc_config_ext->parametric_drc_instructions_count;
922 i++) {
923 err = impd_parse_parametric_drc_instructions(
924 it_bit_buff, str_drc_config_ext->str_drc_coeff_param_drc
925 .parametric_drc_frame_size,
926 &(str_drc_config_ext->str_parametric_drc_instructions[i]));
927 if (err) return (err);
928 }
929 break;
930 case UNIDRCCONFEXT_V1:
931 str_drc_config_ext->drc_extension_v1_present = 1;
932 err = impd_parse_drc_ext_v1(it_bit_buff, ia_drc_params_struct,
933 drc_config, str_drc_config_ext);
934 if (err) return (err);
935 break;
936 default:
937 for (i = 0; i < str_drc_config_ext->ext_bit_size[k]; i++) {
938 other_bit = impd_read_bits_buf(it_bit_buff, 1);
939 if (it_bit_buff->error) return it_bit_buff->error;
940 }
941 break;
942 }
943 k++;
944 str_drc_config_ext->drc_config_ext_type[k] =
945 impd_read_bits_buf(it_bit_buff, 4);
946 if (it_bit_buff->error) return it_bit_buff->error;
947 }
948
949 return (0);
950 }
951
impd_parse_split_drc_characteristic(ia_bit_buf_struct * it_bit_buff,const WORD32 side,ia_split_drc_characteristic_struct * split_drc_characteristic)952 static WORD32 impd_parse_split_drc_characteristic(
953 ia_bit_buf_struct* it_bit_buff, const WORD32 side,
954 ia_split_drc_characteristic_struct* split_drc_characteristic) {
955 // WORD32 err = 0;
956 WORD32 i, temp;
957
958 split_drc_characteristic->characteristic_format =
959 impd_read_bits_buf(it_bit_buff, 1);
960 if (it_bit_buff->error) return it_bit_buff->error;
961 if (split_drc_characteristic->characteristic_format == 0) {
962 WORD32 bsGain, bsIoRatio, bsExp;
963 bsGain = impd_read_bits_buf(it_bit_buff, 6);
964 if (it_bit_buff->error) return it_bit_buff->error;
965 if (side == LEFT_SIDE) {
966 split_drc_characteristic->gain = (FLOAT32)bsGain;
967 } else {
968 split_drc_characteristic->gain = (FLOAT32)-bsGain;
969 }
970 temp = impd_read_bits_buf(it_bit_buff, 8);
971 if (it_bit_buff->error) return it_bit_buff->error;
972
973 bsIoRatio = (temp >> 4) & 0xf;
974 bsExp = temp & 0xf;
975 split_drc_characteristic->in_out_ratio = 0.05f + 0.15f * bsIoRatio;
976
977 if (bsExp < 15) {
978 split_drc_characteristic->exp = 1.0f + 2.0f * bsExp;
979 } else {
980 split_drc_characteristic->exp = 1000.0f;
981 }
982 split_drc_characteristic->flip_sign = impd_read_bits_buf(it_bit_buff, 1);
983 if (it_bit_buff->error) return it_bit_buff->error;
984 } else {
985 WORD32 char_node_cnt, node_level_delta, node_gain;
986 char_node_cnt = impd_read_bits_buf(it_bit_buff, 2);
987 if (it_bit_buff->error) return it_bit_buff->error;
988 split_drc_characteristic->characteristic_node_count = char_node_cnt + 1;
989 split_drc_characteristic->node_level[0] = DRC_INPUT_LOUDNESS_TARGET;
990 split_drc_characteristic->node_gain[0] = 0.0f;
991 for (i = 1; i <= split_drc_characteristic->characteristic_node_count; i++) {
992 node_level_delta = impd_read_bits_buf(it_bit_buff, 5);
993 if (it_bit_buff->error) return it_bit_buff->error;
994 if (side == LEFT_SIDE) {
995 split_drc_characteristic->node_level[i] =
996 split_drc_characteristic->node_level[i - 1] -
997 (1.0f + node_level_delta);
998 } else {
999 split_drc_characteristic->node_level[i] =
1000 split_drc_characteristic->node_level[i - 1] +
1001 (1.0f + node_level_delta);
1002 }
1003 node_gain = impd_read_bits_buf(it_bit_buff, 8);
1004 if (it_bit_buff->error) return it_bit_buff->error;
1005 split_drc_characteristic->node_gain[i] = 0.5f * node_gain - 64.0f;
1006 }
1007 }
1008 return (0);
1009 }
1010
1011 WORD32
impd_drc_gen_instructions_derived_data(ia_drc_config * drc_config,ia_drc_params_bs_dec_struct * ia_drc_params_struct,ia_drc_instructions_struct * str_drc_instruction_str)1012 impd_drc_gen_instructions_derived_data(
1013 ia_drc_config* drc_config,
1014 ia_drc_params_bs_dec_struct* ia_drc_params_struct,
1015 ia_drc_instructions_struct* str_drc_instruction_str) {
1016 WORD32 n, g;
1017 ia_uni_drc_coeffs_struct* str_p_loc_drc_coefficients_uni_drc = NULL;
1018 ia_drc_coeff_parametric_drc_struct* str_drc_coeff_param_drc = NULL;
1019 WORD32 gain_element_count = 0;
1020
1021 for (n = 0; n < drc_config->drc_coefficients_drc_count; n++) {
1022 if (drc_config->str_p_loc_drc_coefficients_uni_drc[n].drc_location ==
1023 str_drc_instruction_str->drc_location)
1024 break;
1025 }
1026 if ((n == drc_config->drc_coefficients_drc_count) &&
1027 (drc_config->drc_coefficients_drc_count > 0)) {
1028 return -1;
1029 }
1030 str_p_loc_drc_coefficients_uni_drc =
1031 &(drc_config->str_p_loc_drc_coefficients_uni_drc[n]);
1032
1033 if (drc_config->drc_config_ext_present &&
1034 drc_config->str_drc_config_ext.parametric_drc_present &&
1035 drc_config->str_drc_config_ext.str_drc_coeff_param_drc.drc_location ==
1036 str_drc_instruction_str->drc_location) {
1037 str_drc_coeff_param_drc =
1038 &drc_config->str_drc_config_ext.str_drc_coeff_param_drc;
1039 }
1040
1041 for (g = 0; g < str_drc_instruction_str->num_drc_ch_groups; g++) {
1042 WORD32 seq = str_drc_instruction_str->gain_set_index_for_channel_group[g];
1043 if (seq != -1 &&
1044 (drc_config->drc_coefficients_drc_count == 0 ||
1045 seq >= str_p_loc_drc_coefficients_uni_drc->gain_set_count)) {
1046 str_drc_instruction_str->ch_group_parametric_drc_flag[g] = 1;
1047 if (drc_config->drc_coefficients_drc_count != 0) {
1048 seq = seq - str_p_loc_drc_coefficients_uni_drc->gain_set_count;
1049 }
1050 str_drc_instruction_str->gain_set_idx_of_ch_group_parametric_drc[g] = seq;
1051
1052 if (str_drc_coeff_param_drc == NULL ||
1053 seq >= str_drc_coeff_param_drc->parametric_drc_gain_set_count) {
1054 /* parametric drc gain set not available */
1055 return (EXTERNAL_ERROR);
1056 }
1057 str_drc_instruction_str->gain_interpolation_type_for_channel_group[g] = 1;
1058 str_drc_instruction_str->time_delta_min_for_channel_group[g] =
1059 str_drc_coeff_param_drc->parametric_drc_frame_size;
1060 str_drc_instruction_str->time_alignment_for_channel_group[g] = 0;
1061 } else {
1062 str_drc_instruction_str->ch_group_parametric_drc_flag[g] = 0;
1063 }
1064 if (str_drc_instruction_str->ch_group_parametric_drc_flag[g] == 0) {
1065 if (seq >= str_p_loc_drc_coefficients_uni_drc->gain_set_count) {
1066 return -1;
1067 }
1068 str_drc_instruction_str->gain_interpolation_type_for_channel_group[g] =
1069 str_p_loc_drc_coefficients_uni_drc->gain_set_params[seq]
1070 .gain_interpolation_type;
1071 if (str_p_loc_drc_coefficients_uni_drc->gain_set_params[seq]
1072 .time_delt_min_flag) {
1073 str_drc_instruction_str->time_delta_min_for_channel_group[g] =
1074 str_p_loc_drc_coefficients_uni_drc->gain_set_params[seq]
1075 .time_delt_min_val;
1076 } else {
1077 str_drc_instruction_str->time_delta_min_for_channel_group[g] =
1078 ia_drc_params_struct->delta_tmin_default;
1079 }
1080 str_drc_instruction_str->time_alignment_for_channel_group[g] =
1081 str_p_loc_drc_coefficients_uni_drc->gain_set_params[seq]
1082 .time_alignment;
1083 }
1084 }
1085
1086 if (str_drc_instruction_str->drc_set_effect &
1087 (EFFECT_BIT_DUCK_OTHER | EFFECT_BIT_DUCK_SELF)) {
1088 str_drc_instruction_str->gain_element_count =
1089 str_drc_instruction_str->num_drc_ch_groups;
1090 } else {
1091 for (g = 0; g < str_drc_instruction_str->num_drc_ch_groups; g++) {
1092 if (str_drc_instruction_str->ch_group_parametric_drc_flag[g] == 1) {
1093 gain_element_count++;
1094 str_drc_instruction_str->band_count_of_ch_group[g] = 1;
1095 } else {
1096 WORD32 seq, band_count;
1097 seq = str_drc_instruction_str->gain_set_index_for_channel_group[g];
1098 band_count =
1099 str_p_loc_drc_coefficients_uni_drc->gain_set_params[seq].band_count;
1100 str_drc_instruction_str->band_count_of_ch_group[g] = band_count;
1101 gain_element_count += band_count;
1102 }
1103 }
1104 str_drc_instruction_str->gain_element_count = gain_element_count;
1105 }
1106
1107 return (0);
1108 }
1109
1110 WORD32
impd_parse_drc_config(ia_bit_buf_struct * it_bit_buff,ia_drc_params_bs_dec_struct * ia_drc_params_struct,ia_drc_config * drc_config)1111 impd_parse_drc_config(ia_bit_buf_struct* it_bit_buff,
1112 ia_drc_params_bs_dec_struct* ia_drc_params_struct,
1113 ia_drc_config* drc_config) {
1114 WORD32 i, err = 0, temp;
1115 WORD32 version = 0;
1116
1117 drc_config->sample_rate_present = impd_read_bits_buf(it_bit_buff, 1);
1118 if (it_bit_buff->error) return it_bit_buff->error;
1119
1120 if (drc_config->sample_rate_present == 1) {
1121 WORD32 bssample_rate;
1122 bssample_rate = impd_read_bits_buf(it_bit_buff, 18);
1123 if (it_bit_buff->error) return it_bit_buff->error;
1124 drc_config->sampling_rate = bssample_rate + 1000;
1125 }
1126
1127 temp = impd_read_bits_buf(it_bit_buff, 8);
1128 if (it_bit_buff->error) return it_bit_buff->error;
1129
1130 drc_config->dwnmix_instructions_count = (temp >> 1) & 0x7f;
1131 if (drc_config->dwnmix_instructions_count > DOWNMIX_INSTRUCTION_COUNT_MAX)
1132 return (UNEXPECTED_ERROR);
1133
1134 drc_config->drc_description_basic_present = temp & 1;
1135
1136 if (drc_config->drc_description_basic_present == 1) {
1137 temp = impd_read_bits_buf(it_bit_buff, 7);
1138 if (it_bit_buff->error) return it_bit_buff->error;
1139
1140 drc_config->drc_coefficients_basic_count = (temp >> 4) & 7;
1141 drc_config->drc_instructions_basic_count = temp & 0xf;
1142
1143 } else {
1144 drc_config->drc_coefficients_basic_count = 0;
1145 drc_config->drc_instructions_basic_count = 0;
1146 }
1147
1148 temp = impd_read_bits_buf(it_bit_buff, 9);
1149 if (it_bit_buff->error) return it_bit_buff->error;
1150
1151 drc_config->drc_coefficients_drc_count = (temp >> 6) & 7;
1152 drc_config->drc_instructions_uni_drc_count = temp & 0x3f;
1153
1154 err = impd_parse_ch_layout(it_bit_buff, ia_drc_params_struct,
1155 &drc_config->channel_layout);
1156 if (err) return (err);
1157
1158 for (i = 0; i < drc_config->dwnmix_instructions_count; i++) {
1159 err = impd_parse_dwnmix_instructions(
1160 it_bit_buff, version, ia_drc_params_struct, &drc_config->channel_layout,
1161 &(drc_config->dwnmix_instructions[i]));
1162 if (err) return (err);
1163 }
1164 for (i = 0; i < drc_config->drc_coefficients_basic_count; i++) {
1165 temp = impd_read_bits_buf(it_bit_buff, 11);
1166 if (it_bit_buff->error) return it_bit_buff->error;
1167
1168 drc_config->str_drc_coefficients_basic[i].drc_location = (temp >> 7) & 0xf;
1169 drc_config->str_drc_coefficients_basic[i].drc_characteristic = temp & 0x3f;
1170 }
1171 for (i = 0; i < drc_config->drc_instructions_basic_count; i++) {
1172 err = impd_drc_parse_instructions_basic(
1173 it_bit_buff, &(drc_config->str_drc_instructions_basic[i]));
1174 if (err) return (err);
1175 }
1176 for (i = 0; i < drc_config->drc_coefficients_drc_count; i++) {
1177 err = impd_drc_parse_coeff(
1178 it_bit_buff, version, ia_drc_params_struct,
1179 &(drc_config->str_p_loc_drc_coefficients_uni_drc[i]));
1180 if (err) return (err);
1181 }
1182 for (i = 0; i < drc_config->drc_instructions_uni_drc_count; i++) {
1183 err = impd_parse_drc_instructions_uni_drc(
1184 it_bit_buff, version, drc_config,
1185 &(drc_config->str_drc_instruction_str[i]));
1186 if (err) return (err);
1187 }
1188
1189 drc_config->drc_config_ext_present = impd_read_bits_buf(it_bit_buff, 1);
1190 if (it_bit_buff->error) return it_bit_buff->error;
1191
1192 if (drc_config->drc_config_ext_present == 1) {
1193 err =
1194 impd_parse_drc_config_ext(it_bit_buff, ia_drc_params_struct, drc_config,
1195 &(drc_config->str_drc_config_ext));
1196 if (err) return (err);
1197 }
1198
1199 if (drc_config->str_drc_config_ext.parametric_drc_present) {
1200 err = impd_parametric_drc_gen_virtual_gain_sets(drc_config);
1201 if (err) return (err);
1202 }
1203
1204 for (i = 0; i < drc_config->drc_instructions_uni_drc_count; i++) {
1205 err = impd_drc_gen_instructions_derived_data(
1206 drc_config, ia_drc_params_struct,
1207 &(drc_config->str_drc_instruction_str[i]));
1208 if (err) return (err);
1209 }
1210
1211 impd_drc_gen_instructions_for_drc_off(drc_config);
1212 return (0);
1213 }
1214
1215 WORD32
impd_dec_method_value(ia_bit_buf_struct * it_bit_buff,WORD32 method_def,FLOAT32 * method_val)1216 impd_dec_method_value(ia_bit_buf_struct* it_bit_buff, WORD32 method_def,
1217 FLOAT32* method_val) {
1218 // WORD32 err = 0;
1219 WORD32 tmp;
1220 FLOAT32 val;
1221 switch (method_def) {
1222 case METHOD_DEFINITION_UNKNOWN_OTHER:
1223 case METHOD_DEFINITION_PROGRAM_LOUDNESS:
1224 case METHOD_DEFINITION_ANCHOR_LOUDNESS:
1225 case METHOD_DEFINITION_MAX_OF_LOUDNESS_RANGE:
1226 case METHOD_DEFINITION_MOMENTARY_LOUDNESS_MAX:
1227 case METHOD_DEFINITION_SHORT_TERM_LOUDNESS_MAX:
1228 tmp = impd_read_bits_buf(it_bit_buff, 8);
1229 if (it_bit_buff->error) return it_bit_buff->error;
1230 val = -57.75f + tmp * 0.25f;
1231 break;
1232 case METHOD_DEFINITION_LOUDNESS_RANGE:
1233 tmp = impd_read_bits_buf(it_bit_buff, 8);
1234 if (it_bit_buff->error) return it_bit_buff->error;
1235 if (tmp == 0)
1236 val = 0.0f;
1237 else if (tmp <= 128)
1238 val = tmp * 0.25f;
1239 else if (tmp <= 204)
1240 val = 0.5f * tmp - 32.0f;
1241 else
1242 val = tmp - 134.0f;
1243 break;
1244 case METHOD_DEFINITION_MIXING_LEVEL:
1245 tmp = impd_read_bits_buf(it_bit_buff, 5);
1246 if (it_bit_buff->error) return it_bit_buff->error;
1247 val = tmp + 80.0f;
1248 break;
1249 case METHOD_DEFINITION_ROOM_TYPE:
1250 tmp = impd_read_bits_buf(it_bit_buff, 2);
1251 if (it_bit_buff->error) return it_bit_buff->error;
1252 val = (FLOAT32)tmp;
1253 break;
1254 case METHOD_DEFINITION_SHORT_TERM_LOUDNESS:
1255 tmp = impd_read_bits_buf(it_bit_buff, 8);
1256 if (it_bit_buff->error) return it_bit_buff->error;
1257 val = -116.f + tmp * 0.5f;
1258 break;
1259 default:
1260 return -1;
1261 break;
1262 }
1263 *method_val = val;
1264 return 0;
1265 }
1266
1267 WORD32
impd_parse_loudness_info_set(ia_bit_buf_struct * it_bit_buff,ia_drc_loudness_info_set_struct * loudness_info_set)1268 impd_parse_loudness_info_set(
1269 ia_bit_buf_struct* it_bit_buff,
1270 ia_drc_loudness_info_set_struct* loudness_info_set) {
1271 WORD32 err = 0, i, version = 0, offset, temp;
1272 WORD32 loudness_info_album_count, loudness_info_count;
1273
1274 temp = impd_read_bits_buf(it_bit_buff, 12);
1275 if (it_bit_buff->error) return it_bit_buff->error;
1276
1277 loudness_info_album_count = (temp >> 6) & 0x3f;
1278 loudness_info_count = temp & 0x3f;
1279
1280 offset = loudness_info_set->loudness_info_album_count;
1281 loudness_info_set->loudness_info_album_count += loudness_info_album_count;
1282 for (i = 0; i < loudness_info_set->loudness_info_album_count; i++) {
1283 err = impd_parse_loudness_info(
1284 it_bit_buff, version,
1285 &(loudness_info_set->str_loudness_info_album[i + offset]));
1286 if (err) return (err);
1287 }
1288
1289 offset = loudness_info_set->loudness_info_count;
1290 loudness_info_set->loudness_info_count += loudness_info_count;
1291 for (i = 0; i < loudness_info_set->loudness_info_count; i++) {
1292 err = impd_parse_loudness_info(
1293 it_bit_buff, version, &(loudness_info_set->loudness_info[i + offset]));
1294 if (err) return (err);
1295 }
1296
1297 loudness_info_set->loudness_info_set_ext_present =
1298 impd_read_bits_buf(it_bit_buff, 1);
1299 if (it_bit_buff->error) return it_bit_buff->error;
1300
1301 if (loudness_info_set->loudness_info_set_ext_present == 1) {
1302 err = impd_parse_loudness_info_set_ext(it_bit_buff, loudness_info_set);
1303 if (err) return (err);
1304 }
1305
1306 return (0);
1307 }
1308
1309 WORD32
impd_parse_gain_set_params_characteristics(ia_bit_buf_struct * it_bit_buff,WORD32 version,ia_gain_params_struct * gain_params)1310 impd_parse_gain_set_params_characteristics(ia_bit_buf_struct* it_bit_buff,
1311 WORD32 version,
1312 ia_gain_params_struct* gain_params) {
1313 // WORD32 err = 0;
1314 WORD32 temp;
1315 if (version == 0) {
1316 gain_params->drc_characteristic = impd_read_bits_buf(it_bit_buff, 7);
1317 if (it_bit_buff->error) return it_bit_buff->error;
1318 if (gain_params->drc_characteristic > 0) {
1319 gain_params->drc_characteristic_present = 1;
1320 gain_params->drc_characteristic_format_is_cicp = 1;
1321 } else {
1322 gain_params->drc_characteristic_present = 0;
1323 }
1324 } else {
1325 gain_params->drc_characteristic_present =
1326 impd_read_bits_buf(it_bit_buff, 1);
1327 if (it_bit_buff->error) return it_bit_buff->error;
1328 if (gain_params->drc_characteristic_present) {
1329 gain_params->drc_characteristic_format_is_cicp =
1330 impd_read_bits_buf(it_bit_buff, 1);
1331 if (it_bit_buff->error) return it_bit_buff->error;
1332 if (gain_params->drc_characteristic_format_is_cicp) {
1333 gain_params->drc_characteristic = impd_read_bits_buf(it_bit_buff, 7);
1334 if (it_bit_buff->error) return it_bit_buff->error;
1335 } else {
1336 temp = impd_read_bits_buf(it_bit_buff, 8);
1337 if (it_bit_buff->error) return it_bit_buff->error;
1338
1339 gain_params->drc_characteristic_left_index = (temp >> 4) & 0xf;
1340 gain_params->drc_characteristic_right_index = temp & 0xf;
1341 }
1342 }
1343 }
1344 return (0);
1345 }
1346
1347 WORD32
impd_parse_loudness_measure(ia_bit_buf_struct * it_bit_buff,ia_loudness_measure_struct * loudness_measure)1348 impd_parse_loudness_measure(ia_bit_buf_struct* it_bit_buff,
1349 ia_loudness_measure_struct* loudness_measure) {
1350 WORD32 err = 0, temp;
1351
1352 loudness_measure->method_def = impd_read_bits_buf(it_bit_buff, 4);
1353 if (it_bit_buff->error) return it_bit_buff->error;
1354
1355 err = impd_dec_method_value(it_bit_buff, loudness_measure->method_def,
1356 &(loudness_measure->method_val));
1357 if (err) return err;
1358
1359 temp = impd_read_bits_buf(it_bit_buff, 6);
1360 if (it_bit_buff->error) return it_bit_buff->error;
1361
1362 loudness_measure->measurement_system = (temp >> 2) & 0xf;
1363 loudness_measure->reliability = temp & 3;
1364
1365 return (0);
1366 }
1367
1368 WORD32
impd_dec_gain_modifiers(ia_bit_buf_struct * it_bit_buff,WORD32 version,WORD32 band_count,ia_gain_modifiers_struct * pstr_gain_modifiers)1369 impd_dec_gain_modifiers(ia_bit_buf_struct* it_bit_buff, WORD32 version,
1370 WORD32 band_count,
1371 ia_gain_modifiers_struct* pstr_gain_modifiers) {
1372 // WORD32 err = 0;
1373 WORD32 sign, temp;
1374
1375 if (version > 0) {
1376 WORD32 b;
1377 for (b = 0; b < band_count; b++) {
1378 pstr_gain_modifiers->target_characteristic_left_present[b] =
1379 impd_read_bits_buf(it_bit_buff, 1);
1380 if (it_bit_buff->error) return it_bit_buff->error;
1381 if (pstr_gain_modifiers->target_characteristic_left_present[b]) {
1382 pstr_gain_modifiers->target_characteristic_left_index[b] =
1383 impd_read_bits_buf(it_bit_buff, 4);
1384 if (it_bit_buff->error) return it_bit_buff->error;
1385 }
1386 pstr_gain_modifiers->target_characteristic_right_present[b] =
1387 impd_read_bits_buf(it_bit_buff, 1);
1388 if (it_bit_buff->error) return it_bit_buff->error;
1389 if (pstr_gain_modifiers->target_characteristic_right_present[b]) {
1390 pstr_gain_modifiers->target_characteristic_right_index[b] =
1391 impd_read_bits_buf(it_bit_buff, 4);
1392 if (it_bit_buff->error) return it_bit_buff->error;
1393 }
1394 pstr_gain_modifiers->gain_scaling_flag[b] =
1395 impd_read_bits_buf(it_bit_buff, 1);
1396 if (it_bit_buff->error) return it_bit_buff->error;
1397 if (pstr_gain_modifiers->gain_scaling_flag[b]) {
1398 temp = impd_read_bits_buf(it_bit_buff, 8);
1399 if (it_bit_buff->error) return it_bit_buff->error;
1400
1401 pstr_gain_modifiers->attn_scaling[b] = ((temp >> 4) & 0xf) * 0.125f;
1402 pstr_gain_modifiers->ampl_scaling[b] = (temp & 0xf) * 0.125f;
1403 }
1404
1405 pstr_gain_modifiers->gain_offset_flag[b] =
1406 impd_read_bits_buf(it_bit_buff, 1);
1407 if (it_bit_buff->error) return it_bit_buff->error;
1408 if (pstr_gain_modifiers->gain_offset_flag[b]) {
1409 FLOAT32 gain_offset;
1410 temp = impd_read_bits_buf(it_bit_buff, 6);
1411 if (it_bit_buff->error) return it_bit_buff->error;
1412
1413 sign = ((temp >> 5) & 1);
1414 gain_offset = (1 + (temp & 0x1f)) * 0.25f;
1415
1416 if (sign) {
1417 gain_offset = -gain_offset;
1418 }
1419 pstr_gain_modifiers->gain_offset[b] = gain_offset;
1420 }
1421 }
1422 if (band_count == 1) {
1423 pstr_gain_modifiers->shape_filter_flag =
1424 impd_read_bits_buf(it_bit_buff, 1);
1425 if (it_bit_buff->error) return it_bit_buff->error;
1426 if (pstr_gain_modifiers->shape_filter_flag) {
1427 pstr_gain_modifiers->shape_filter_idx =
1428 impd_read_bits_buf(it_bit_buff, 4);
1429 if (it_bit_buff->error) return it_bit_buff->error;
1430 }
1431 }
1432 } else if (version == 0) {
1433 WORD32 b, gain_scaling_flag, gain_offset_flag;
1434 FLOAT32 attn_scaling = 1.0f, ampl_scaling = 1.0f, gain_offset = 0.0f;
1435
1436 gain_scaling_flag = impd_read_bits_buf(it_bit_buff, 1);
1437 if (it_bit_buff->error) return it_bit_buff->error;
1438 if (gain_scaling_flag) {
1439 temp = impd_read_bits_buf(it_bit_buff, 8);
1440 if (it_bit_buff->error) return it_bit_buff->error;
1441
1442 attn_scaling = ((temp >> 4) & 0xf) * 0.125f;
1443 ampl_scaling = (temp & 0xf) * 0.125f;
1444 }
1445
1446 gain_offset_flag = impd_read_bits_buf(it_bit_buff, 1);
1447 if (it_bit_buff->error) return it_bit_buff->error;
1448 if (gain_offset_flag) {
1449 temp = impd_read_bits_buf(it_bit_buff, 6);
1450 if (it_bit_buff->error) return it_bit_buff->error;
1451
1452 sign = ((temp >> 5) & 1);
1453 gain_offset = (1 + (temp & 0x1f)) * 0.25f;
1454
1455 if (sign) {
1456 gain_offset = -gain_offset;
1457 }
1458 }
1459 for (b = 0; b < band_count; b++) {
1460 pstr_gain_modifiers->target_characteristic_left_present[b] = 0;
1461 pstr_gain_modifiers->target_characteristic_right_present[b] = 0;
1462 pstr_gain_modifiers->gain_scaling_flag[b] = gain_scaling_flag;
1463 pstr_gain_modifiers->attn_scaling[b] = attn_scaling;
1464 pstr_gain_modifiers->ampl_scaling[b] = ampl_scaling;
1465 pstr_gain_modifiers->gain_offset_flag[b] = gain_offset_flag;
1466 pstr_gain_modifiers->gain_offset[b] = gain_offset;
1467 }
1468 pstr_gain_modifiers->shape_filter_flag = 0;
1469 }
1470 return (0);
1471 }
1472
1473 WORD32
impd_parse_gain_set_params(ia_bit_buf_struct * it_bit_buff,WORD32 version,WORD32 * gain_seq_idx,ia_gain_set_params_struct * gain_set_params)1474 impd_parse_gain_set_params(ia_bit_buf_struct* it_bit_buff, WORD32 version,
1475 WORD32* gain_seq_idx,
1476 ia_gain_set_params_struct* gain_set_params) {
1477 WORD32 err = 0, i, temp;
1478
1479 temp = impd_read_bits_buf(it_bit_buff, 6);
1480 if (it_bit_buff->error) return it_bit_buff->error;
1481
1482 gain_set_params->gain_coding_profile = (temp >> 4) & 3;
1483 gain_set_params->gain_interpolation_type = (temp >> 3) & 1;
1484 gain_set_params->full_frame = (temp >> 2) & 1;
1485 gain_set_params->time_alignment = (temp >> 1) & 1;
1486 gain_set_params->time_delt_min_flag = temp & 1;
1487
1488 if (gain_set_params->time_delt_min_flag) {
1489 WORD32 time_delta_min;
1490 time_delta_min = impd_read_bits_buf(it_bit_buff, 11);
1491 if (it_bit_buff->error) return it_bit_buff->error;
1492 gain_set_params->time_delt_min_val = time_delta_min + 1;
1493 }
1494
1495 if (gain_set_params->gain_coding_profile == GAIN_CODING_PROFILE_CONSTANT) {
1496 gain_set_params->band_count = 1;
1497 *gain_seq_idx = (*gain_seq_idx) + 1;
1498 } else {
1499 gain_set_params->band_count = impd_read_bits_buf(it_bit_buff, 4);
1500 if (it_bit_buff->error) return it_bit_buff->error;
1501
1502 if (gain_set_params->band_count > 1) {
1503 gain_set_params->drc_band_type = impd_read_bits_buf(it_bit_buff, 1);
1504 if (it_bit_buff->error) return it_bit_buff->error;
1505 }
1506 for (i = 0; i < gain_set_params->band_count; i++) {
1507 if (version == 0) {
1508 *gain_seq_idx = (*gain_seq_idx) + 1;
1509 } else {
1510 WORD32 indexPresent;
1511 indexPresent = impd_read_bits_buf(it_bit_buff, 1);
1512 if (it_bit_buff->error) return it_bit_buff->error;
1513 if (indexPresent) {
1514 WORD32 bsIndex;
1515 bsIndex = impd_read_bits_buf(it_bit_buff, 6);
1516 if (it_bit_buff->error) return it_bit_buff->error;
1517 *gain_seq_idx = bsIndex;
1518 } else {
1519 *gain_seq_idx = (*gain_seq_idx) + 1;
1520 }
1521 }
1522 gain_set_params->gain_params[i].gain_seq_idx = *gain_seq_idx;
1523 err = impd_parse_gain_set_params_characteristics(
1524 it_bit_buff, version, &(gain_set_params->gain_params[i]));
1525 if (err) return (err);
1526 }
1527 if (gain_set_params->drc_band_type) {
1528 for (i = 1; i < gain_set_params->band_count; i++) {
1529 gain_set_params->gain_params[i].crossover_freq_idx =
1530 impd_read_bits_buf(it_bit_buff, 4);
1531 if (it_bit_buff->error) return it_bit_buff->error;
1532 }
1533 } else {
1534 for (i = 1; i < gain_set_params->band_count; i++) {
1535 gain_set_params->gain_params[i].start_subband_index =
1536 impd_read_bits_buf(it_bit_buff, 10);
1537 if (it_bit_buff->error) return it_bit_buff->error;
1538 }
1539 }
1540 }
1541
1542 return (0);
1543 }
1544
1545 WORD32
impd_sel_drc_coeff(ia_drc_config * drc_config,WORD32 location,ia_uni_drc_coeffs_struct ** str_p_loc_drc_coefficients_uni_drc)1546 impd_sel_drc_coeff(
1547 ia_drc_config* drc_config, WORD32 location,
1548 ia_uni_drc_coeffs_struct** str_p_loc_drc_coefficients_uni_drc) {
1549 WORD32 n;
1550 WORD32 c1 = -1;
1551 WORD32 c0 = -1;
1552 for (n = 0; n < drc_config->drc_coefficients_drc_count; n++) {
1553 if (drc_config->str_p_loc_drc_coefficients_uni_drc[n].drc_location ==
1554 location) {
1555 if (drc_config->str_p_loc_drc_coefficients_uni_drc[n].version == 0) {
1556 c0 = n;
1557 } else {
1558 c1 = n;
1559 }
1560 }
1561 }
1562 if (c1 >= 0) {
1563 *str_p_loc_drc_coefficients_uni_drc =
1564 &(drc_config->str_p_loc_drc_coefficients_uni_drc[c1]);
1565 } else if (c0 >= 0) {
1566 *str_p_loc_drc_coefficients_uni_drc =
1567 &(drc_config->str_p_loc_drc_coefficients_uni_drc[c0]);
1568 } else {
1569 *str_p_loc_drc_coefficients_uni_drc = NULL;
1570 }
1571 return (0);
1572 }
1573
1574 WORD32
impd_parse_loudness_info_set_ext(ia_bit_buf_struct * it_bit_buff,ia_drc_loudness_info_set_struct * loudness_info_set)1575 impd_parse_loudness_info_set_ext(
1576 ia_bit_buf_struct* it_bit_buff,
1577 ia_drc_loudness_info_set_struct* loudness_info_set) {
1578 WORD32 err = 0, i, k;
1579 WORD32 bit_size_len, ext_size_bits, bit_size, other_bit;
1580
1581 k = 0;
1582 loudness_info_set->str_loudness_info_set_ext.loudness_info_set_ext_type[k] =
1583 impd_read_bits_buf(it_bit_buff, 4);
1584 if (it_bit_buff->error) return it_bit_buff->error;
1585 while (loudness_info_set->str_loudness_info_set_ext
1586 .loudness_info_set_ext_type[k] != UNIDRCLOUDEXT_TERM) {
1587 bit_size_len = impd_read_bits_buf(it_bit_buff, 4);
1588 if (it_bit_buff->error) return it_bit_buff->error;
1589 ext_size_bits = bit_size_len + 4;
1590
1591 bit_size = impd_read_bits_buf(it_bit_buff, ext_size_bits);
1592 if (it_bit_buff->error) return it_bit_buff->error;
1593 loudness_info_set->str_loudness_info_set_ext.ext_bit_size[k] = bit_size + 1;
1594
1595 switch (loudness_info_set->str_loudness_info_set_ext
1596 .loudness_info_set_ext_type[k]) {
1597 case UNIDRCLOUDEXT_EQ:
1598 err = impd_parse_loud_info_set_ext_eq(it_bit_buff, loudness_info_set);
1599 if (err) return (err);
1600 break;
1601 default:
1602 for (i = 0;
1603 i < loudness_info_set->str_loudness_info_set_ext.ext_bit_size[k];
1604 i++) {
1605 other_bit = impd_read_bits_buf(it_bit_buff, 1);
1606 if (it_bit_buff->error) return it_bit_buff->error;
1607 }
1608 break;
1609 }
1610 k++;
1611 loudness_info_set->str_loudness_info_set_ext.loudness_info_set_ext_type[k] =
1612 impd_read_bits_buf(it_bit_buff, 4);
1613 if (it_bit_buff->error) return it_bit_buff->error;
1614 }
1615
1616 return (0);
1617 }
1618
1619 WORD32
impd_drc_parse_coeff(ia_bit_buf_struct * it_bit_buff,WORD32 version,ia_drc_params_bs_dec_struct * ia_drc_params_struct,ia_uni_drc_coeffs_struct * str_p_loc_drc_coefficients_uni_drc)1620 impd_drc_parse_coeff(
1621 ia_bit_buf_struct* it_bit_buff, WORD32 version,
1622 ia_drc_params_bs_dec_struct* ia_drc_params_struct,
1623 ia_uni_drc_coeffs_struct* str_p_loc_drc_coefficients_uni_drc) {
1624 WORD32 err = 0, i, drc_frame_size, temp;
1625 WORD32 gain_seq_idx = -1;
1626
1627 str_p_loc_drc_coefficients_uni_drc->version = version;
1628 if (version == 0) {
1629 WORD32 gain_sequence_count = 0;
1630 temp = impd_read_bits_buf(it_bit_buff, 5);
1631 if (it_bit_buff->error) return it_bit_buff->error;
1632
1633 str_p_loc_drc_coefficients_uni_drc->drc_location = (temp >> 1) & 0xf;
1634 str_p_loc_drc_coefficients_uni_drc->drc_frame_size_present = temp & 1;
1635
1636 if (str_p_loc_drc_coefficients_uni_drc->drc_frame_size_present == 1) {
1637 drc_frame_size = impd_read_bits_buf(it_bit_buff, 15);
1638 if (it_bit_buff->error) return it_bit_buff->error;
1639 str_p_loc_drc_coefficients_uni_drc->drc_frame_size = drc_frame_size + 1;
1640 }
1641
1642 str_p_loc_drc_coefficients_uni_drc->drc_characteristic_left_present = 0;
1643 str_p_loc_drc_coefficients_uni_drc->drc_characteristic_right_present = 0;
1644 str_p_loc_drc_coefficients_uni_drc->shape_filters_present = 0;
1645 str_p_loc_drc_coefficients_uni_drc->gain_set_count =
1646 impd_read_bits_buf(it_bit_buff, 6);
1647 if (it_bit_buff->error) return it_bit_buff->error;
1648 str_p_loc_drc_coefficients_uni_drc->gain_set_count_plus =
1649 str_p_loc_drc_coefficients_uni_drc->gain_set_count;
1650 for (i = 0; i < str_p_loc_drc_coefficients_uni_drc->gain_set_count; i++) {
1651 err = impd_parse_gain_set_params(
1652 it_bit_buff, version, &gain_seq_idx,
1653 &(str_p_loc_drc_coefficients_uni_drc->gain_set_params[i]));
1654 if (err) return (err);
1655
1656 if (str_p_loc_drc_coefficients_uni_drc->gain_set_params[i]
1657 .time_delt_min_flag) {
1658 if (str_p_loc_drc_coefficients_uni_drc->gain_set_params[i]
1659 .time_delt_min_val > ia_drc_params_struct->drc_frame_size) {
1660 /* drc time interval too big */
1661 return (PARAM_ERROR);
1662 }
1663 str_p_loc_drc_coefficients_uni_drc->gain_set_params[i]
1664 .num_gain_max_values =
1665 ia_drc_params_struct->drc_frame_size /
1666 str_p_loc_drc_coefficients_uni_drc->gain_set_params[i]
1667 .time_delt_min_val;
1668 err = impd_init_tbls(
1669 str_p_loc_drc_coefficients_uni_drc->gain_set_params[i]
1670 .num_gain_max_values,
1671 &(str_p_loc_drc_coefficients_uni_drc->gain_set_params[i]
1672 .str_tables));
1673 if (err) return (err);
1674 }
1675 gain_sequence_count +=
1676 str_p_loc_drc_coefficients_uni_drc->gain_set_params[i].band_count;
1677 }
1678 str_p_loc_drc_coefficients_uni_drc->gain_sequence_count =
1679 gain_sequence_count;
1680 } else {
1681 ia_shape_filter_block_params_struct* pstr_shape_filter_block_params;
1682 for (i = 0; i < SEQUENCE_COUNT_MAX; i++) {
1683 str_p_loc_drc_coefficients_uni_drc
1684 ->gain_set_params_index_for_gain_sequence[i] = -1;
1685 }
1686
1687 temp = impd_read_bits_buf(it_bit_buff, 5);
1688 if (it_bit_buff->error) return it_bit_buff->error;
1689
1690 str_p_loc_drc_coefficients_uni_drc->drc_location = (temp >> 1) & 0xf;
1691 str_p_loc_drc_coefficients_uni_drc->drc_frame_size_present = temp & 1;
1692
1693 if (str_p_loc_drc_coefficients_uni_drc->drc_frame_size_present == 1) {
1694 drc_frame_size = impd_read_bits_buf(it_bit_buff, 15);
1695 if (it_bit_buff->error) return it_bit_buff->error;
1696 str_p_loc_drc_coefficients_uni_drc->drc_frame_size = drc_frame_size + 1;
1697 }
1698 str_p_loc_drc_coefficients_uni_drc->drc_characteristic_left_present =
1699 impd_read_bits_buf(it_bit_buff, 1);
1700 if (it_bit_buff->error) return it_bit_buff->error;
1701 if (str_p_loc_drc_coefficients_uni_drc->drc_characteristic_left_present ==
1702 1) {
1703 str_p_loc_drc_coefficients_uni_drc->characteristic_left_count =
1704 impd_read_bits_buf(it_bit_buff, 4);
1705 if (it_bit_buff->error) return it_bit_buff->error;
1706
1707 if (str_p_loc_drc_coefficients_uni_drc->characteristic_left_count >
1708 SPLIT_CHARACTERISTIC_COUNT_MAX)
1709 return (UNEXPECTED_ERROR);
1710
1711 for (i = 1;
1712 i <= str_p_loc_drc_coefficients_uni_drc->characteristic_left_count;
1713 i++) {
1714 err = impd_parse_split_drc_characteristic(
1715 it_bit_buff, LEFT_SIDE, &(str_p_loc_drc_coefficients_uni_drc
1716 ->str_split_characteristic_left[i]));
1717 if (err) return (err);
1718 }
1719 }
1720 str_p_loc_drc_coefficients_uni_drc->drc_characteristic_right_present =
1721 impd_read_bits_buf(it_bit_buff, 1);
1722 if (it_bit_buff->error) return it_bit_buff->error;
1723 if (str_p_loc_drc_coefficients_uni_drc->drc_characteristic_right_present ==
1724 1) {
1725 str_p_loc_drc_coefficients_uni_drc->characteristic_right_count =
1726 impd_read_bits_buf(it_bit_buff, 4);
1727 if (it_bit_buff->error) return it_bit_buff->error;
1728
1729 if (str_p_loc_drc_coefficients_uni_drc->characteristic_right_count >
1730 SPLIT_CHARACTERISTIC_COUNT_MAX)
1731 return (UNEXPECTED_ERROR);
1732 for (i = 1;
1733 i <= str_p_loc_drc_coefficients_uni_drc->characteristic_right_count;
1734 i++) {
1735 err = impd_parse_split_drc_characteristic(
1736 it_bit_buff, RIGHT_SIDE,
1737 &(str_p_loc_drc_coefficients_uni_drc
1738 ->str_split_characteristic_right[i]));
1739 if (err) return (err);
1740 }
1741 }
1742 str_p_loc_drc_coefficients_uni_drc->shape_filters_present =
1743 impd_read_bits_buf(it_bit_buff, 1);
1744 if (it_bit_buff->error) return it_bit_buff->error;
1745 if (str_p_loc_drc_coefficients_uni_drc->shape_filters_present == 1) {
1746 str_p_loc_drc_coefficients_uni_drc->shape_num_filter =
1747 impd_read_bits_buf(it_bit_buff, 4);
1748 if (it_bit_buff->error) return it_bit_buff->error;
1749 for (i = 1; i <= str_p_loc_drc_coefficients_uni_drc->shape_num_filter;
1750 i++) {
1751 pstr_shape_filter_block_params =
1752 &(str_p_loc_drc_coefficients_uni_drc
1753 ->str_shape_filter_block_params[i]);
1754 pstr_shape_filter_block_params->lf_cut_filter_present =
1755 impd_read_bits_buf(it_bit_buff, 1);
1756 if (it_bit_buff->error) return it_bit_buff->error;
1757
1758 if (pstr_shape_filter_block_params->lf_cut_filter_present == 1) {
1759 temp = impd_read_bits_buf(it_bit_buff, 5);
1760 if (it_bit_buff->error) return it_bit_buff->error;
1761
1762 pstr_shape_filter_block_params->str_lf_cut_params.corner_freq_index =
1763 (temp >> 2) & 7;
1764 pstr_shape_filter_block_params->str_lf_cut_params
1765 .filter_strength_index = temp & 3;
1766 }
1767 pstr_shape_filter_block_params->lf_boost_filter_present =
1768 impd_read_bits_buf(it_bit_buff, 1);
1769 if (it_bit_buff->error) return it_bit_buff->error;
1770 if (pstr_shape_filter_block_params->lf_boost_filter_present == 1) {
1771 temp = impd_read_bits_buf(it_bit_buff, 5);
1772 if (it_bit_buff->error) return it_bit_buff->error;
1773
1774 pstr_shape_filter_block_params->str_lf_boost_params
1775 .corner_freq_index = (temp >> 2) & 7;
1776 pstr_shape_filter_block_params->str_lf_boost_params
1777 .filter_strength_index = temp & 3;
1778 }
1779 pstr_shape_filter_block_params->hf_cut_filter_present =
1780 impd_read_bits_buf(it_bit_buff, 1);
1781 if (it_bit_buff->error) return it_bit_buff->error;
1782 if (pstr_shape_filter_block_params->hf_cut_filter_present == 1) {
1783 temp = impd_read_bits_buf(it_bit_buff, 5);
1784 if (it_bit_buff->error) return it_bit_buff->error;
1785
1786 pstr_shape_filter_block_params->str_hfCutParams.corner_freq_index =
1787 (temp >> 2) & 7;
1788 pstr_shape_filter_block_params->str_hfCutParams
1789 .filter_strength_index = temp & 3;
1790 }
1791 pstr_shape_filter_block_params->hf_boost_filter_present =
1792 impd_read_bits_buf(it_bit_buff, 1);
1793 if (it_bit_buff->error) return it_bit_buff->error;
1794 if (pstr_shape_filter_block_params->hf_boost_filter_present == 1) {
1795 temp = impd_read_bits_buf(it_bit_buff, 5);
1796 if (it_bit_buff->error) return it_bit_buff->error;
1797
1798 pstr_shape_filter_block_params->str_hf_boost_params
1799 .corner_freq_index = (temp >> 2) & 7;
1800 pstr_shape_filter_block_params->str_hf_boost_params
1801 .filter_strength_index = temp & 3;
1802 }
1803 }
1804 }
1805
1806 temp = impd_read_bits_buf(it_bit_buff, 12);
1807 if (it_bit_buff->error) return it_bit_buff->error;
1808
1809 str_p_loc_drc_coefficients_uni_drc->gain_sequence_count =
1810 (temp >> 6) & 0x3f;
1811 str_p_loc_drc_coefficients_uni_drc->gain_set_count = temp & 0x3f;
1812
1813 str_p_loc_drc_coefficients_uni_drc->gain_set_count_plus =
1814 str_p_loc_drc_coefficients_uni_drc->gain_set_count;
1815 for (i = 0; i < str_p_loc_drc_coefficients_uni_drc->gain_set_count; i++) {
1816 err = impd_parse_gain_set_params(
1817 it_bit_buff, version, &gain_seq_idx,
1818 &(str_p_loc_drc_coefficients_uni_drc->gain_set_params[i]));
1819 if (err) return (err);
1820
1821 if (str_p_loc_drc_coefficients_uni_drc->gain_set_params[i]
1822 .time_delt_min_flag) {
1823 if (str_p_loc_drc_coefficients_uni_drc->gain_set_params[i]
1824 .time_delt_min_val > ia_drc_params_struct->drc_frame_size) {
1825 /* drc time interval too big */
1826 return (PARAM_ERROR);
1827 }
1828 str_p_loc_drc_coefficients_uni_drc->gain_set_params[i]
1829 .num_gain_max_values =
1830 ia_drc_params_struct->drc_frame_size /
1831 str_p_loc_drc_coefficients_uni_drc->gain_set_params[i]
1832 .time_delt_min_val;
1833 err = impd_init_tbls(
1834 str_p_loc_drc_coefficients_uni_drc->gain_set_params[i]
1835 .num_gain_max_values,
1836 &(str_p_loc_drc_coefficients_uni_drc->gain_set_params[i]
1837 .str_tables));
1838 if (err) return (err);
1839 }
1840 }
1841
1842 for (i = 0; i < str_p_loc_drc_coefficients_uni_drc->gain_set_count; i++) {
1843 WORD32 b;
1844 for (b = 0;
1845 b <
1846 str_p_loc_drc_coefficients_uni_drc->gain_set_params[i].band_count;
1847 b++) {
1848 str_p_loc_drc_coefficients_uni_drc
1849 ->gain_set_params_index_for_gain_sequence
1850 [str_p_loc_drc_coefficients_uni_drc->gain_set_params[i]
1851 .gain_params[b]
1852 .gain_seq_idx] = i;
1853 }
1854 }
1855 }
1856 return (0);
1857 }
1858
1859 WORD32
impd_drc_parse_instructions_basic(ia_bit_buf_struct * it_bit_buff,ia_drc_instructions_basic_struct * str_drc_instructions_basic)1860 impd_drc_parse_instructions_basic(
1861 ia_bit_buf_struct* it_bit_buff,
1862 ia_drc_instructions_basic_struct* str_drc_instructions_basic) {
1863 // WORD32 err = 0;
1864 WORD32 i, limiter_peak_target, temp;
1865 WORD32 additional_dmix_id_present, additional_dmix_id_cnt;
1866
1867 temp = impd_read_bits_buf(it_bit_buff, 18);
1868 if (it_bit_buff->error) return it_bit_buff->error;
1869
1870 str_drc_instructions_basic->drc_set_id = (temp >> 12) & 0x3f;
1871 str_drc_instructions_basic->drc_location = (temp >> 8) & 0xf;
1872 str_drc_instructions_basic->downmix_id[0] = (temp >> 1) & 0x7f;
1873 additional_dmix_id_present = temp & 1;
1874 str_drc_instructions_basic->dwnmix_id_count = 1;
1875
1876 if (additional_dmix_id_present) {
1877 additional_dmix_id_cnt = impd_read_bits_buf(it_bit_buff, 3);
1878 if (it_bit_buff->error) return it_bit_buff->error;
1879 for (i = 0; i < additional_dmix_id_cnt; i++) {
1880 str_drc_instructions_basic->downmix_id[i + 1] =
1881 impd_read_bits_buf(it_bit_buff, 7);
1882 if (it_bit_buff->error) return it_bit_buff->error;
1883 }
1884 str_drc_instructions_basic->dwnmix_id_count = 1 + additional_dmix_id_cnt;
1885 }
1886
1887 str_drc_instructions_basic->drc_set_effect =
1888 impd_read_bits_buf(it_bit_buff, 16);
1889 if (it_bit_buff->error) return it_bit_buff->error;
1890
1891 if ((str_drc_instructions_basic->drc_set_effect &
1892 (EFFECT_BIT_DUCK_OTHER | EFFECT_BIT_DUCK_SELF)) == 0) {
1893 str_drc_instructions_basic->limiter_peak_target_present =
1894 impd_read_bits_buf(it_bit_buff, 1);
1895 if (it_bit_buff->error) return it_bit_buff->error;
1896 if (str_drc_instructions_basic->limiter_peak_target_present) {
1897 limiter_peak_target = impd_read_bits_buf(it_bit_buff, 8);
1898 if (it_bit_buff->error) return it_bit_buff->error;
1899 str_drc_instructions_basic->limiter_peak_target =
1900 -limiter_peak_target * 0.125f;
1901 }
1902 }
1903
1904 str_drc_instructions_basic->drc_set_target_loudness_present =
1905 impd_read_bits_buf(it_bit_buff, 1);
1906 if (it_bit_buff->error) return it_bit_buff->error;
1907
1908 str_drc_instructions_basic->drc_set_target_loudness_value_upper = 0;
1909 str_drc_instructions_basic->drc_set_target_loudness_value_lower = -63;
1910
1911 if (str_drc_instructions_basic->drc_set_target_loudness_present == 1) {
1912 WORD32 bsDrcSetTargetLoudnessValueUpper, bsDrcSetTargetLoudnessValueLower;
1913 bsDrcSetTargetLoudnessValueUpper = impd_read_bits_buf(it_bit_buff, 6);
1914 if (it_bit_buff->error) return it_bit_buff->error;
1915 str_drc_instructions_basic->drc_set_target_loudness_value_upper =
1916 bsDrcSetTargetLoudnessValueUpper - 63;
1917
1918 str_drc_instructions_basic->drc_set_target_loudness_value_lower_present =
1919 impd_read_bits_buf(it_bit_buff, 1);
1920 if (it_bit_buff->error) return it_bit_buff->error;
1921
1922 if (str_drc_instructions_basic
1923 ->drc_set_target_loudness_value_lower_present == 1) {
1924 bsDrcSetTargetLoudnessValueLower = impd_read_bits_buf(it_bit_buff, 6);
1925 if (it_bit_buff->error) return it_bit_buff->error;
1926 str_drc_instructions_basic->drc_set_target_loudness_value_lower =
1927 bsDrcSetTargetLoudnessValueLower - 63;
1928 }
1929 }
1930
1931 return (0);
1932 }
1933
1934 WORD32
impd_dec_ducking_scaling(ia_bit_buf_struct * it_bit_buff,WORD32 * ducking_scaling_flag,FLOAT32 * p_ducking_scaling)1935 impd_dec_ducking_scaling(ia_bit_buf_struct* it_bit_buff,
1936 WORD32* ducking_scaling_flag,
1937 FLOAT32* p_ducking_scaling) {
1938 WORD32 ducking_scaling_present, ducking_scaling, sigma, mu;
1939
1940 ducking_scaling_present = impd_read_bits_buf(it_bit_buff, 1);
1941 if (it_bit_buff->error) return it_bit_buff->error;
1942
1943 if (ducking_scaling_present == 0) {
1944 *ducking_scaling_flag = 0;
1945 *p_ducking_scaling = 1.0f;
1946 } else {
1947 *ducking_scaling_flag = 1;
1948 ducking_scaling = impd_read_bits_buf(it_bit_buff, 4);
1949 if (it_bit_buff->error) return it_bit_buff->error;
1950
1951 sigma = ducking_scaling >> 3;
1952 mu = ducking_scaling & 0x7;
1953
1954 if (sigma == 0) {
1955 *p_ducking_scaling = 1.0f + 0.125f * (1.0f + mu);
1956 } else {
1957 *p_ducking_scaling = 1.0f - 0.125f * (1.0f + mu);
1958 }
1959 }
1960 return (0);
1961 }
1962
1963 WORD32
impd_parse_drc_instructions_uni_drc(ia_bit_buf_struct * it_bit_buff,WORD32 version,ia_drc_config * drc_config,ia_drc_instructions_struct * str_drc_instruction_str)1964 impd_parse_drc_instructions_uni_drc(
1965 ia_bit_buf_struct* it_bit_buff, WORD32 version, ia_drc_config* drc_config,
1966 ia_drc_instructions_struct* str_drc_instruction_str) {
1967 WORD32 err = 0, i, n, k, g, c, limiter_peak_target, idx;
1968 WORD32 additional_dmix_id_present, additional_dmix_id_cnt;
1969 ia_uni_drc_coeffs_struct* str_p_loc_drc_coefficients_uni_drc = NULL;
1970 WORD32 ch_cnt;
1971 WORD32 unique_idx[MAX_CHANNEL_COUNT];
1972 FLOAT32 unique_scaling[MAX_CHANNEL_COUNT];
1973 WORD32 match;
1974 WORD32 dmix_id_present;
1975 WORD32 repeat_parameters, repeat_parameters_cnt;
1976 WORD32 ducking_sequence;
1977 FLOAT32 factor;
1978
1979 str_drc_instruction_str->drc_set_id = impd_read_bits_buf(it_bit_buff, 6);
1980 if (it_bit_buff->error) return it_bit_buff->error;
1981 if (version == 0) {
1982 str_drc_instruction_str->drc_set_complexity_level =
1983 DRC_COMPLEXITY_LEVEL_MAX;
1984 } else {
1985 str_drc_instruction_str->drc_set_complexity_level =
1986 impd_read_bits_buf(it_bit_buff, 4);
1987 if (it_bit_buff->error) return it_bit_buff->error;
1988 }
1989 str_drc_instruction_str->drc_location = impd_read_bits_buf(it_bit_buff, 4);
1990 if (it_bit_buff->error) return it_bit_buff->error;
1991 dmix_id_present = 1;
1992 if (version >= 1) {
1993 dmix_id_present = impd_read_bits_buf(it_bit_buff, 1);
1994 if (it_bit_buff->error) return it_bit_buff->error;
1995 }
1996 if (dmix_id_present == 1) {
1997 str_drc_instruction_str->downmix_id[0] = impd_read_bits_buf(it_bit_buff, 7);
1998 if (it_bit_buff->error) return it_bit_buff->error;
1999 if (version >= 1) {
2000 str_drc_instruction_str->drc_apply_to_dwnmix =
2001 impd_read_bits_buf(it_bit_buff, 1);
2002 if (it_bit_buff->error) return it_bit_buff->error;
2003 }
2004 if (version == 0) {
2005 if (str_drc_instruction_str->downmix_id[0] == 0) {
2006 str_drc_instruction_str->drc_apply_to_dwnmix = 0;
2007 } else {
2008 str_drc_instruction_str->drc_apply_to_dwnmix = 1;
2009 }
2010 }
2011 additional_dmix_id_present = impd_read_bits_buf(it_bit_buff, 1);
2012 if (it_bit_buff->error) return it_bit_buff->error;
2013
2014 if (additional_dmix_id_present) {
2015 additional_dmix_id_cnt = impd_read_bits_buf(it_bit_buff, 3);
2016 if (it_bit_buff->error) return it_bit_buff->error;
2017 for (i = 0; i < additional_dmix_id_cnt; i++) {
2018 str_drc_instruction_str->downmix_id[i + 1] =
2019 impd_read_bits_buf(it_bit_buff, 7);
2020 if (it_bit_buff->error) return it_bit_buff->error;
2021 }
2022 str_drc_instruction_str->dwnmix_id_count = 1 + additional_dmix_id_cnt;
2023 } else {
2024 str_drc_instruction_str->dwnmix_id_count = 1;
2025 }
2026 } else {
2027 str_drc_instruction_str->downmix_id[0] = 0;
2028 str_drc_instruction_str->dwnmix_id_count = 1;
2029 }
2030
2031 str_drc_instruction_str->drc_set_effect = impd_read_bits_buf(it_bit_buff, 16);
2032 if (it_bit_buff->error) return it_bit_buff->error;
2033
2034 if ((str_drc_instruction_str->drc_set_effect &
2035 (EFFECT_BIT_DUCK_OTHER | EFFECT_BIT_DUCK_SELF)) == 0) {
2036 str_drc_instruction_str->limiter_peak_target_present =
2037 impd_read_bits_buf(it_bit_buff, 1);
2038 if (it_bit_buff->error) return it_bit_buff->error;
2039 if (str_drc_instruction_str->limiter_peak_target_present) {
2040 limiter_peak_target = impd_read_bits_buf(it_bit_buff, 8);
2041 if (it_bit_buff->error) return it_bit_buff->error;
2042 str_drc_instruction_str->limiter_peak_target =
2043 -limiter_peak_target * 0.125f;
2044 }
2045 }
2046
2047 str_drc_instruction_str->drc_set_target_loudness_present =
2048 impd_read_bits_buf(it_bit_buff, 1);
2049 if (it_bit_buff->error) return it_bit_buff->error;
2050
2051 str_drc_instruction_str->drc_set_target_loudness_value_upper = 0;
2052 str_drc_instruction_str->drc_set_target_loudness_value_lower = -63;
2053
2054 if (str_drc_instruction_str->drc_set_target_loudness_present == 1) {
2055 WORD32 bsDrcSetTargetLoudnessValueUpper, bsDrcSetTargetLoudnessValueLower;
2056 bsDrcSetTargetLoudnessValueUpper = impd_read_bits_buf(it_bit_buff, 6);
2057 if (it_bit_buff->error) return it_bit_buff->error;
2058 str_drc_instruction_str->drc_set_target_loudness_value_upper =
2059 bsDrcSetTargetLoudnessValueUpper - 63;
2060 str_drc_instruction_str->drc_set_target_loudness_value_lower_present =
2061 impd_read_bits_buf(it_bit_buff, 1);
2062 if (it_bit_buff->error) return it_bit_buff->error;
2063 if (str_drc_instruction_str->drc_set_target_loudness_value_lower_present ==
2064 1) {
2065 bsDrcSetTargetLoudnessValueLower = impd_read_bits_buf(it_bit_buff, 6);
2066 if (it_bit_buff->error) return it_bit_buff->error;
2067 str_drc_instruction_str->drc_set_target_loudness_value_lower =
2068 bsDrcSetTargetLoudnessValueLower - 63;
2069 }
2070 }
2071
2072 str_drc_instruction_str->depends_on_drc_set_present =
2073 impd_read_bits_buf(it_bit_buff, 1);
2074 if (it_bit_buff->error) return it_bit_buff->error;
2075
2076 str_drc_instruction_str->no_independent_use = 0;
2077 if (str_drc_instruction_str->depends_on_drc_set_present) {
2078 str_drc_instruction_str->depends_on_drc_set =
2079 impd_read_bits_buf(it_bit_buff, 6);
2080 if (it_bit_buff->error) return it_bit_buff->error;
2081 } else {
2082 str_drc_instruction_str->no_independent_use =
2083 impd_read_bits_buf(it_bit_buff, 1);
2084 if (it_bit_buff->error) return it_bit_buff->error;
2085 }
2086 if (version == 0) {
2087 str_drc_instruction_str->requires_eq = 0;
2088 } else {
2089 str_drc_instruction_str->requires_eq = impd_read_bits_buf(it_bit_buff, 1);
2090 if (it_bit_buff->error) return it_bit_buff->error;
2091 }
2092
2093 err = impd_sel_drc_coeff(drc_config, str_drc_instruction_str->drc_location,
2094 &str_p_loc_drc_coefficients_uni_drc);
2095 if (err) return (err);
2096
2097 ch_cnt = drc_config->channel_layout.base_channel_count;
2098
2099 for (c = 0; c < MAX_CHANNEL_COUNT; c++) {
2100 unique_idx[c] = -10;
2101 unique_scaling[c] = -10.0f;
2102 }
2103
2104 if (str_drc_instruction_str->drc_set_effect &
2105 (EFFECT_BIT_DUCK_OTHER | EFFECT_BIT_DUCK_SELF)) {
2106 c = 0;
2107 while (c < ch_cnt) {
2108 WORD32 bs_gain_set_idx;
2109 bs_gain_set_idx = impd_read_bits_buf(it_bit_buff, 6);
2110 if (it_bit_buff->error) return it_bit_buff->error;
2111 str_drc_instruction_str->gain_set_index[c] = bs_gain_set_idx - 1;
2112 impd_dec_ducking_scaling(
2113 it_bit_buff,
2114 &(str_drc_instruction_str->str_ducking_modifiers_for_channel[c]
2115 .ducking_scaling_flag),
2116 &(str_drc_instruction_str->str_ducking_modifiers_for_channel[c]
2117 .ducking_scaling));
2118
2119 c++;
2120
2121 repeat_parameters = impd_read_bits_buf(it_bit_buff, 1);
2122 if (it_bit_buff->error) return it_bit_buff->error;
2123
2124 if (repeat_parameters == 1) {
2125 repeat_parameters_cnt = impd_read_bits_buf(it_bit_buff, 5);
2126 if (it_bit_buff->error) return it_bit_buff->error;
2127
2128 repeat_parameters_cnt += 1;
2129 for (k = 0; k < repeat_parameters_cnt; k++) {
2130 str_drc_instruction_str->gain_set_index[c] =
2131 str_drc_instruction_str->gain_set_index[c - 1];
2132 str_drc_instruction_str->str_ducking_modifiers_for_channel[c]
2133 .ducking_scaling_flag =
2134 str_drc_instruction_str->str_ducking_modifiers_for_channel[c - 1]
2135 .ducking_scaling_flag;
2136 str_drc_instruction_str->str_ducking_modifiers_for_channel[c]
2137 .ducking_scaling =
2138 str_drc_instruction_str->str_ducking_modifiers_for_channel[c - 1]
2139 .ducking_scaling;
2140 c++;
2141 }
2142 }
2143 }
2144 if (c > ch_cnt) {
2145 return (UNEXPECTED_ERROR);
2146 }
2147 ducking_sequence = -1;
2148 g = 0;
2149 if (str_drc_instruction_str->drc_set_effect & EFFECT_BIT_DUCK_OTHER) {
2150 for (c = 0; c < ch_cnt; c++) {
2151 match = 0;
2152 idx = str_drc_instruction_str->gain_set_index[c];
2153 factor = str_drc_instruction_str->str_ducking_modifiers_for_channel[c]
2154 .ducking_scaling;
2155 if (idx < 0) {
2156 for (n = 0; n < g; n++) {
2157 if (unique_scaling[n] == factor) {
2158 match = 1;
2159 str_drc_instruction_str->channel_group_of_ch[c] = n;
2160 break;
2161 }
2162 }
2163 if (match == 0) {
2164 unique_idx[g] = idx;
2165 unique_scaling[g] = factor;
2166 str_drc_instruction_str->channel_group_of_ch[c] = g;
2167 g++;
2168 }
2169 } else {
2170 if ((ducking_sequence > 0) && (ducking_sequence != idx)) {
2171 /* drc for ducking can have only one ducking sequence */
2172 return (UNEXPECTED_ERROR);
2173 }
2174 ducking_sequence = idx;
2175 str_drc_instruction_str->channel_group_of_ch[c] = -1;
2176 }
2177 }
2178 str_drc_instruction_str->num_drc_ch_groups = g;
2179 if (ducking_sequence == -1) {
2180 /* ducking sequence not found */
2181 return (UNEXPECTED_ERROR);
2182 }
2183 } else if (str_drc_instruction_str->drc_set_effect & EFFECT_BIT_DUCK_SELF) {
2184 for (c = 0; c < ch_cnt; c++) {
2185 match = 0;
2186 idx = str_drc_instruction_str->gain_set_index[c];
2187 factor = str_drc_instruction_str->str_ducking_modifiers_for_channel[c]
2188 .ducking_scaling;
2189 if (idx >= 0) {
2190 for (n = 0; n < g; n++) {
2191 if ((unique_idx[n] == idx) && (unique_scaling[n] == factor)) {
2192 match = 1;
2193 str_drc_instruction_str->channel_group_of_ch[c] = n;
2194 break;
2195 }
2196 }
2197 if (match == 0) {
2198 unique_idx[g] = idx;
2199 unique_scaling[g] = factor;
2200 str_drc_instruction_str->channel_group_of_ch[c] = g;
2201 g++;
2202 }
2203 } else {
2204 str_drc_instruction_str->channel_group_of_ch[c] = -1;
2205 }
2206 }
2207 str_drc_instruction_str->num_drc_ch_groups = g;
2208 }
2209
2210 for (g = 0; g < str_drc_instruction_str->num_drc_ch_groups; g++) {
2211 WORD32 set =
2212 (str_drc_instruction_str->drc_set_effect & EFFECT_BIT_DUCK_OTHER)
2213 ? ducking_sequence
2214 : unique_idx[g];
2215 str_drc_instruction_str->gain_set_index_for_channel_group[g] = set;
2216 str_drc_instruction_str->str_ducking_modifiers_for_channel_group[g]
2217 .ducking_scaling = unique_scaling[g];
2218 if (unique_scaling[g] != 1.0f) {
2219 str_drc_instruction_str->str_ducking_modifiers_for_channel_group[g]
2220 .ducking_scaling_flag = 1;
2221 } else {
2222 str_drc_instruction_str->str_ducking_modifiers_for_channel_group[g]
2223 .ducking_scaling_flag = 0;
2224 }
2225 str_drc_instruction_str->band_count_of_ch_group[g] = 1;
2226 }
2227 } else {
2228 if (((version == 0) ||
2229 (str_drc_instruction_str->drc_apply_to_dwnmix != 0)) &&
2230 (str_drc_instruction_str->downmix_id[0] != 0) &&
2231 (str_drc_instruction_str->downmix_id[0] != ID_FOR_ANY_DOWNMIX) &&
2232 (str_drc_instruction_str->dwnmix_id_count == 1)) {
2233 for (i = 0; i < drc_config->dwnmix_instructions_count; i++) {
2234 if (str_drc_instruction_str->downmix_id[0] ==
2235 drc_config->dwnmix_instructions[i].downmix_id)
2236 break;
2237 }
2238 if (i == drc_config->dwnmix_instructions_count) {
2239 /* dwnmix_instructions not found */
2240 return (UNEXPECTED_ERROR);
2241 }
2242 ch_cnt = drc_config->dwnmix_instructions[i].target_channel_count;
2243 } else if (((version == 0) ||
2244 (str_drc_instruction_str->drc_apply_to_dwnmix != 0)) &&
2245 ((str_drc_instruction_str->downmix_id[0] ==
2246 ID_FOR_ANY_DOWNMIX) ||
2247 (str_drc_instruction_str->dwnmix_id_count > 1))) {
2248 ch_cnt = 1;
2249 }
2250
2251 c = 0;
2252 while (c < ch_cnt) {
2253 WORD32 bs_gain_set_idx;
2254 WORD32 repeat_gain_set_idx, repeat_gain_set_idx_cnt, temp;
2255
2256 temp = impd_read_bits_buf(it_bit_buff, 7);
2257 if (it_bit_buff->error) return it_bit_buff->error;
2258
2259 bs_gain_set_idx = (temp >> 1) & 0x7f;
2260 repeat_gain_set_idx = temp & 1;
2261
2262 str_drc_instruction_str->gain_set_index[c] = bs_gain_set_idx - 1;
2263 c++;
2264
2265 if (repeat_gain_set_idx == 1) {
2266 repeat_gain_set_idx_cnt = impd_read_bits_buf(it_bit_buff, 5);
2267 if (it_bit_buff->error) return it_bit_buff->error;
2268
2269 repeat_gain_set_idx_cnt += 1;
2270 for (k = 0; k < repeat_gain_set_idx_cnt; k++) {
2271 str_drc_instruction_str->gain_set_index[c] = bs_gain_set_idx - 1;
2272 c++;
2273 }
2274 }
2275 }
2276 if (c > ch_cnt) {
2277 return (UNEXPECTED_ERROR);
2278 }
2279
2280 g = 0;
2281 if ((str_drc_instruction_str->downmix_id[0] == ID_FOR_ANY_DOWNMIX) ||
2282 (str_drc_instruction_str->dwnmix_id_count > 1)) {
2283 WORD32 idx = str_drc_instruction_str->gain_set_index[0];
2284 if (idx >= 0) {
2285 unique_idx[0] = idx;
2286 g = 1;
2287 }
2288 } else {
2289 for (c = 0; c < ch_cnt; c++) {
2290 WORD32 idx = str_drc_instruction_str->gain_set_index[c];
2291 match = 0;
2292 if (idx >= 0) {
2293 for (n = 0; n < g; n++) {
2294 if (unique_idx[n] == idx) {
2295 match = 1;
2296 str_drc_instruction_str->channel_group_of_ch[c] = n;
2297 break;
2298 }
2299 }
2300 if (match == 0) {
2301 unique_idx[g] = idx;
2302 str_drc_instruction_str->channel_group_of_ch[c] = g;
2303 g++;
2304 }
2305 } else {
2306 str_drc_instruction_str->channel_group_of_ch[c] = -1;
2307 }
2308 }
2309 }
2310
2311 str_drc_instruction_str->num_drc_ch_groups = g;
2312 for (g = 0; g < str_drc_instruction_str->num_drc_ch_groups; g++) {
2313 WORD32 set, band_count;
2314
2315 set = unique_idx[g];
2316 str_drc_instruction_str->gain_set_index_for_channel_group[g] = set;
2317
2318 if (str_p_loc_drc_coefficients_uni_drc != NULL &&
2319 set < str_p_loc_drc_coefficients_uni_drc->gain_set_count) {
2320 band_count =
2321 str_p_loc_drc_coefficients_uni_drc->gain_set_params[set].band_count;
2322 } else {
2323 band_count = 1;
2324 }
2325
2326 err = impd_dec_gain_modifiers(
2327 it_bit_buff, version, band_count,
2328 &(str_drc_instruction_str->str_gain_modifiers_of_ch_group[g]));
2329 if (err) return (err);
2330 }
2331 }
2332
2333 return (0);
2334 }
2335 WORD32
impd_parse_loudness_info(ia_bit_buf_struct * it_bit_buff,WORD32 version,ia_loudness_info_struct * loudness_info)2336 impd_parse_loudness_info(ia_bit_buf_struct* it_bit_buff, WORD32 version,
2337 ia_loudness_info_struct* loudness_info) {
2338 WORD32 err = 0, sample_peak_level, true_peak_level, i, temp;
2339
2340 loudness_info->drc_set_id = impd_read_bits_buf(it_bit_buff, 6);
2341 if (it_bit_buff->error) return it_bit_buff->error;
2342
2343 if (version >= 1) {
2344 loudness_info->eq_set_id = impd_read_bits_buf(it_bit_buff, 6);
2345 if (it_bit_buff->error) return it_bit_buff->error;
2346 } else {
2347 loudness_info->eq_set_id = 0;
2348 }
2349
2350 temp = impd_read_bits_buf(it_bit_buff, 8);
2351 if (it_bit_buff->error) return it_bit_buff->error;
2352
2353 loudness_info->downmix_id = (temp >> 1) & 0x7f;
2354 loudness_info->sample_peak_level_present = temp & 1;
2355
2356 if (loudness_info->sample_peak_level_present) {
2357 sample_peak_level = impd_read_bits_buf(it_bit_buff, 12);
2358 if (it_bit_buff->error) return it_bit_buff->error;
2359
2360 if (sample_peak_level == 0) {
2361 loudness_info->sample_peak_level_present = 0;
2362 loudness_info->sample_peak_level = 0.0f;
2363 } else {
2364 loudness_info->sample_peak_level = 20.0f - sample_peak_level * 0.03125f;
2365 }
2366 }
2367
2368 loudness_info->true_peak_level_present = impd_read_bits_buf(it_bit_buff, 1);
2369 if (it_bit_buff->error) return it_bit_buff->error;
2370
2371 if (loudness_info->true_peak_level_present) {
2372 true_peak_level = impd_read_bits_buf(it_bit_buff, 12);
2373 if (it_bit_buff->error) return it_bit_buff->error;
2374
2375 if (true_peak_level == 0) {
2376 loudness_info->true_peak_level_present = 0;
2377 loudness_info->true_peak_level = 0.0f;
2378 } else {
2379 loudness_info->true_peak_level = 20.0f - true_peak_level * 0.03125f;
2380 }
2381
2382 temp = impd_read_bits_buf(it_bit_buff, 6);
2383 if (it_bit_buff->error) return it_bit_buff->error;
2384
2385 loudness_info->true_peak_level_measurement_system = (temp >> 2) & 0xf;
2386 loudness_info->true_peak_level_reliability = temp & 3;
2387 }
2388
2389 loudness_info->measurement_count = impd_read_bits_buf(it_bit_buff, 4);
2390 if (it_bit_buff->error) return it_bit_buff->error;
2391
2392 for (i = 0; i < loudness_info->measurement_count; i++) {
2393 err = impd_parse_loudness_measure(it_bit_buff,
2394 &(loudness_info->loudness_measure[i]));
2395 if (err) return (err);
2396 }
2397
2398 return (0);
2399 }
2400