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 WORD32 impd_parse_loud_eq_instructions( 32 ia_bit_buf_struct* it_bit_buff, 33 ia_loud_eq_instructions_struct* loud_eq_instructions); 34 35 WORD32 impd_parse_eq_coefficients(ia_bit_buf_struct* it_bit_buff, 36 ia_eq_coeff_struct* str_eq_coeff); 37 38 WORD32 impd_parse_eq_instructions( 39 ia_bit_buf_struct* it_bit_buff, ia_drc_config* drc_config, 40 ia_eq_instructions_struct* str_eq_instructions); 41 WORD32 impd_dec_initial_gain(ia_bit_buf_struct* it_bit_buff, 42 const WORD32 gain_coding_profile, 43 FLOAT32* initial_gain) { 44 WORD32 sign, magn, bit_2_extract; 45 switch (gain_coding_profile) { 46 case GAIN_CODING_PROFILE_REGULAR: 47 sign = impd_read_bits_buf(it_bit_buff, 1); 48 if (it_bit_buff->error) return it_bit_buff->error; 49 magn = impd_read_bits_buf(it_bit_buff, 8); 50 if (it_bit_buff->error) return it_bit_buff->error; 51 *initial_gain = magn * 0.125f; 52 if (sign) *initial_gain = -*initial_gain; 53 break; 54 case GAIN_CODING_PROFILE_FADING: 55 case GAIN_CODING_PROFILE_CLIPPING: 56 bit_2_extract = 57 (gain_coding_profile == GAIN_CODING_PROFILE_FADING) ? 10 : 8; 58 sign = impd_read_bits_buf(it_bit_buff, 1); 59 if (it_bit_buff->error) return it_bit_buff->error; 60 if (sign == 0) 61 *initial_gain = 0.0f; 62 else { 63 magn = impd_read_bits_buf(it_bit_buff, bit_2_extract); 64 if (it_bit_buff->error) return it_bit_buff->error; 65 *initial_gain = -(magn + 1) * 0.125f; 66 } 67 break; 68 69 case GAIN_CODING_PROFILE_CONSTANT: 70 break; 71 default: 72 return (UNEXPECTED_ERROR); 73 } 74 return (0); 75 } 76 77 WORD32 impd_dec_gains(ia_bit_buf_struct* it_bit_buff, WORD32 no_nodes, 78 WORD32 gain_coding_profile, ia_node_struct* str_node) { 79 WORD32 err = 0, k, e, m; 80 WORD32 bit; 81 WORD32 num_bits_read; 82 WORD32 code; 83 WORD32 code_found; 84 FLOAT32 drc_gain_delta = 0; 85 const ia_delta_gain_code_table_struct* ptr_delta_gain_code_table; 86 WORD32 no_delta_gain_entries; 87 88 err = impd_dec_initial_gain(it_bit_buff, gain_coding_profile, 89 &(str_node[0].loc_db_gain)); 90 if (err) return (err); 91 92 impd_get_delta_gain_code_tbl(gain_coding_profile, &ptr_delta_gain_code_table, 93 &no_delta_gain_entries); 94 for (k = 1; k < no_nodes; k++) { 95 num_bits_read = 0; 96 code = 0; 97 code_found = 0; 98 e = 0; 99 while ((e < no_delta_gain_entries) && (!code_found)) { 100 for (m = 0; m < ptr_delta_gain_code_table[e].size - num_bits_read; m++) { 101 bit = impd_read_bits_buf(it_bit_buff, 1); 102 if (it_bit_buff->error) return it_bit_buff->error; 103 code = (code << 1) + bit; 104 num_bits_read++; 105 } 106 while (num_bits_read == ptr_delta_gain_code_table[e].size) { 107 if (code == ptr_delta_gain_code_table[e].code) { 108 drc_gain_delta = ptr_delta_gain_code_table[e].value; 109 code_found = 1; 110 break; 111 } 112 e++; 113 } 114 } 115 if (code_found == 0) { 116 return (UNEXPECTED_ERROR); 117 } 118 str_node[k].loc_db_gain = str_node[k - 1].loc_db_gain + drc_gain_delta; 119 } 120 return (0); 121 } 122 123 WORD32 impd_dec_slopes(ia_bit_buf_struct* it_bit_buff, WORD32* no_nodes, 124 WORD32 gain_interpolation_type, 125 ia_node_struct* str_node) { 126 WORD32 k, e, bit; 127 WORD32 code; 128 WORD32 code_found; 129 FLOAT32 slope_value = 0; 130 bool end_marker = 0; 131 WORD32 num_bits_read; 132 const ia_slope_code_table_struct* ptr_slope_code_table; 133 WORD32 no_slope_code_entries; 134 135 ptr_slope_code_table = &(slope_code_tbl_entries_by_size[0]); 136 no_slope_code_entries = NUM_SLOPE_TBL_ENTRIES; 137 138 k = 0; 139 while (end_marker != 1) { 140 k++; 141 end_marker = impd_read_bits_buf(it_bit_buff, 1); 142 if (it_bit_buff->error) return it_bit_buff->error; 143 } 144 if (k > NODE_COUNT_MAX) return UNEXPECTED_ERROR; 145 *no_nodes = k; 146 147 if (gain_interpolation_type == GAIN_INTERPOLATION_TYPE_SPLINE) { 148 for (k = 0; k < *no_nodes; k++) { 149 num_bits_read = 0; 150 code = 0; 151 code_found = 0; 152 e = 0; 153 while ((e < no_slope_code_entries) && (!code_found)) { 154 while (num_bits_read < ptr_slope_code_table[e].size) { 155 bit = impd_read_bits_buf(it_bit_buff, 1); 156 if (it_bit_buff->error) return it_bit_buff->error; 157 code = (code << 1) + bit; 158 num_bits_read++; 159 } 160 while (num_bits_read == ptr_slope_code_table[e].size) { 161 if (code == ptr_slope_code_table[e].code) { 162 slope_value = ptr_slope_code_table[e].value; 163 code_found = 1; 164 break; 165 } 166 e++; 167 if (e >= no_slope_code_entries) return UNEXPECTED_ERROR; 168 } 169 } 170 str_node[k].slope = slope_value; 171 } 172 } else { 173 for (k = 0; k < *no_nodes; k++) { 174 str_node[k].slope = 0.0f; 175 } 176 } 177 return (0); 178 } 179 180 WORD32 impd_dec_times(ia_bit_buf_struct* it_bit_buff, 181 ia_tables_struct* str_tables, WORD32 num_nodes, 182 WORD32 delta_tmin, WORD32 drc_frame_size, 183 WORD32 full_frame, WORD32 time_offset, 184 ia_node_struct* str_node) { 185 WORD32 k, e, m; 186 WORD32 bit; 187 WORD32 num_bits_read; 188 WORD32 code; 189 WORD32 code_found = 0; 190 WORD32 time_delta = 0; 191 WORD32 time_offs = time_offset; 192 ia_delta_time_code_table_entry_struct* delta_time_code_table = 193 str_tables->delta_time_code_table; 194 bool frame_end_flag; 195 WORD32 node_time_tmp; 196 bool node_res_flag; 197 WORD32 exit_cnt; 198 if (full_frame == 0) { 199 frame_end_flag = impd_read_bits_buf(it_bit_buff, 1); 200 if (it_bit_buff->error) return it_bit_buff->error; 201 } else { 202 frame_end_flag = 1; 203 } 204 205 if (frame_end_flag == 1) { 206 node_res_flag = 0; 207 for (k = 0; k < num_nodes - 1; k++) { 208 num_bits_read = 0; 209 code = 0; 210 code_found = 0; 211 exit_cnt = 0; 212 e = 1; 213 while ((e < N_DELTA_TIME_CODE_TABLE_ENTRIES_MAX) && (!code_found)) { 214 exit_cnt++; 215 if (exit_cnt > 100000) { 216 return -1; 217 } 218 for (m = 0; m < delta_time_code_table[e].size - num_bits_read; m++) { 219 bit = impd_read_bits_buf(it_bit_buff, 1); 220 if (it_bit_buff->error) return it_bit_buff->error; 221 code = (code << 1) + bit; 222 num_bits_read++; 223 } 224 while (num_bits_read == delta_time_code_table[e].size) { 225 if (code == delta_time_code_table[e].code) { 226 time_delta = delta_time_code_table[e].value; 227 code_found = 1; 228 break; 229 } 230 e++; 231 } 232 } 233 node_time_tmp = time_offs + time_delta * delta_tmin; 234 if (node_time_tmp > drc_frame_size + time_offset) { 235 if (node_res_flag == 0) { 236 str_node[k].time = drc_frame_size + time_offset; 237 node_res_flag = 1; 238 } 239 str_node[k + 1].time = node_time_tmp; 240 } else { 241 str_node[k].time = node_time_tmp; 242 } 243 time_offs = node_time_tmp; 244 } 245 if (node_res_flag == 0) { 246 str_node[k].time = drc_frame_size + time_offset; 247 } 248 } else { 249 for (k = 0; k < num_nodes; k++) { 250 num_bits_read = 0; 251 code = 0; 252 code_found = 0; 253 e = 1; 254 exit_cnt = 0; 255 while ((e < N_DELTA_TIME_CODE_TABLE_ENTRIES_MAX) && (!code_found)) { 256 exit_cnt++; 257 if (exit_cnt > 100000) { 258 return (BITSTREAM_ERROR); 259 } 260 for (m = 0; m < delta_time_code_table[e].size - num_bits_read; m++) { 261 bit = impd_read_bits_buf(it_bit_buff, 1); 262 if (it_bit_buff->error) return it_bit_buff->error; 263 code = (code << 1) + bit; 264 num_bits_read++; 265 } 266 while (num_bits_read == delta_time_code_table[e].size) { 267 if (code == delta_time_code_table[e].code) { 268 time_delta = delta_time_code_table[e].value; 269 code_found = 1; 270 break; 271 } 272 e++; 273 } 274 } 275 time_offs += time_delta * delta_tmin; 276 if (time_offs >= (2 * AUDIO_CODEC_FRAME_SIZE_MAX - drc_frame_size)) 277 return UNEXPECTED_ERROR; 278 str_node[k].time = time_offs; 279 } 280 } 281 return (0); 282 } 283 284 WORD32 impd_drc_uni_gain_read(ia_bit_buf_struct* it_bit_buff, 285 ia_drc_bits_dec_struct* pstr_drc_uni_bs_dec, 286 ia_drc_config* drc_config, 287 ia_drc_gain_struct* pstr_uni_drc_gain) { 288 WORD32 err = 0; 289 WORD32 seq; 290 static WORD32 pkt_loss_frame_cnt = 0; 291 ia_spline_nodes_struct* str_spline_nodes = {0}; 292 293 { 294 WORD32 gain_sequence_count = 295 drc_config->str_p_loc_drc_coefficients_uni_drc[0].gain_sequence_count; 296 297 for (seq = 0; seq < gain_sequence_count; seq++) { 298 WORD32 index = drc_config->str_p_loc_drc_coefficients_uni_drc[0] 299 .gain_set_params_index_for_gain_sequence[seq]; 300 ia_gain_set_params_struct str_gain_set_params = {0}; 301 ia_gain_set_params_struct* gain_set_params = &str_gain_set_params; 302 303 if (index != -1) { 304 gain_set_params = &(drc_config->str_p_loc_drc_coefficients_uni_drc 305 ->gain_set_params[index]); 306 } 307 if (gain_set_params->gain_coding_profile == 308 GAIN_CODING_PROFILE_CONSTANT) { 309 str_spline_nodes = 310 &(pstr_uni_drc_gain->drc_gain_sequence[seq].str_spline_nodes[0]); 311 str_spline_nodes->num_nodes = 1; 312 str_spline_nodes->str_node[0].slope = 0.0; 313 str_spline_nodes->str_node[0].time = 314 (pstr_drc_uni_bs_dec->ia_drc_params_struct).drc_frame_size - 1; 315 str_spline_nodes->str_node[0].loc_db_gain = 0.0f; 316 } else { 317 err = impd_parse_drc_gain_sequence( 318 it_bit_buff, pstr_drc_uni_bs_dec, gain_set_params, 319 &(pstr_uni_drc_gain->drc_gain_sequence[seq])); 320 if (err) return (err); 321 } 322 } 323 } 324 325 if (it_bit_buff->ptr_bit_buf_base == NULL) { 326 pkt_loss_frame_cnt++; 327 328 if (pkt_loss_frame_cnt * 329 (FLOAT32)pstr_drc_uni_bs_dec->ia_drc_params_struct.drc_frame_size / 330 drc_config->sampling_rate > 331 MAXPACKETLOSSTIME) { 332 drc_config->apply_drc = 0; 333 } 334 } else { 335 pstr_uni_drc_gain->uni_drc_gain_ext_flag = 336 impd_read_bits_buf(it_bit_buff, 1); 337 if (it_bit_buff->error) return it_bit_buff->error; 338 if (pstr_uni_drc_gain->uni_drc_gain_ext_flag == 1) { 339 err = impd_parse_uni_drc_gain_ext(it_bit_buff, 340 &(pstr_uni_drc_gain->uni_drc_gain_ext)); 341 if (err) return (err); 342 } 343 pkt_loss_frame_cnt = 0; 344 drc_config->apply_drc = 1; 345 } 346 347 return (0); 348 } 349 350 WORD32 impd_parse_uni_drc_gain_ext( 351 ia_bit_buf_struct* it_bit_buff, 352 ia_uni_drc_gain_ext_struct* uni_drc_gain_ext) { 353 WORD32 k; 354 WORD32 bit_size_len, ext_size_bits, bit_size, other_bit; 355 356 k = 0; 357 uni_drc_gain_ext->uni_drc_gain_ext_type[k] = 358 impd_read_bits_buf(it_bit_buff, 4); 359 if (it_bit_buff->error) return it_bit_buff->error; 360 while (uni_drc_gain_ext->uni_drc_gain_ext_type[k] != UNIDRCGAINEXT_TERM) { 361 if (k >= (EXT_COUNT_MAX - 1)) return UNEXPECTED_ERROR; 362 bit_size_len = impd_read_bits_buf(it_bit_buff, 3); 363 if (it_bit_buff->error) return it_bit_buff->error; 364 ext_size_bits = bit_size_len + 4; 365 366 bit_size = impd_read_bits_buf(it_bit_buff, ext_size_bits); 367 if (it_bit_buff->error) return it_bit_buff->error; 368 uni_drc_gain_ext->ext_bit_size[k] = bit_size + 1; 369 370 other_bit = 371 impd_skip_bits_buf(it_bit_buff, uni_drc_gain_ext->ext_bit_size[k]); 372 if (it_bit_buff->error) return it_bit_buff->error; 373 k++; 374 uni_drc_gain_ext->uni_drc_gain_ext_type[k] = 375 impd_read_bits_buf(it_bit_buff, 4); 376 if (it_bit_buff->error) return it_bit_buff->error; 377 } 378 379 return (0); 380 } 381 382 WORD32 impd_parse_spline_nodes(ia_bit_buf_struct* it_bit_buff, 383 ia_drc_bits_dec_struct* pstr_drc_uni_bs_dec, 384 ia_gain_set_params_struct* gain_set_params, 385 ia_spline_nodes_struct* str_spline_nodes) { 386 WORD32 err = 0; 387 WORD32 time_offset; 388 if (gain_set_params->time_alignment == 0) { 389 time_offset = -1; 390 } else { 391 if (gain_set_params->time_delt_min_flag) { 392 time_offset = -gain_set_params->time_delt_min_val + 393 (gain_set_params->time_delt_min_val - 1) / 2; 394 } else { 395 time_offset = 396 -pstr_drc_uni_bs_dec->ia_drc_params_struct.delta_tmin_default + 397 (pstr_drc_uni_bs_dec->ia_drc_params_struct.delta_tmin_default - 1) / 398 2; 399 } 400 } 401 402 if (it_bit_buff->ptr_bit_buf_base == NULL) { 403 if ((str_spline_nodes->num_nodes < 1) || 404 (str_spline_nodes->num_nodes > NODE_COUNT_MAX)) 405 return UNEXPECTED_ERROR; 406 FLOAT32 prev_db_gain = 407 str_spline_nodes->str_node[str_spline_nodes->num_nodes - 1].loc_db_gain; 408 str_spline_nodes->drc_gain_coding_mode = 0; 409 410 str_spline_nodes->num_nodes = 1; 411 412 if (prev_db_gain < 0) { 413 str_spline_nodes->str_node[0].loc_db_gain = prev_db_gain; 414 } else { 415 str_spline_nodes->str_node[0].loc_db_gain = 0.f; 416 } 417 418 str_spline_nodes->str_node[0].slope = 0.0; 419 str_spline_nodes->str_node[0].time = 420 (pstr_drc_uni_bs_dec->ia_drc_params_struct).drc_frame_size + 421 time_offset; 422 } else { 423 str_spline_nodes->drc_gain_coding_mode = impd_read_bits_buf(it_bit_buff, 1); 424 if (it_bit_buff->error == PROC_COMPLETE) { 425 if ((str_spline_nodes->num_nodes < 1) || 426 (str_spline_nodes->num_nodes > NODE_COUNT_MAX)) 427 return UNEXPECTED_ERROR; 428 str_spline_nodes->drc_gain_coding_mode = 0; 429 str_spline_nodes->str_node[0].slope = 0.0; 430 str_spline_nodes->str_node[0].time = 431 (pstr_drc_uni_bs_dec->ia_drc_params_struct).drc_frame_size + 432 time_offset; 433 str_spline_nodes->str_node[0].loc_db_gain = 434 str_spline_nodes->str_node[str_spline_nodes->num_nodes - 1] 435 .loc_db_gain; 436 str_spline_nodes->num_nodes = 1; 437 } else { 438 if (it_bit_buff->error) return (it_bit_buff->error); 439 } 440 if (str_spline_nodes->drc_gain_coding_mode == 0) { 441 str_spline_nodes->num_nodes = 1; 442 443 err = impd_dec_initial_gain(it_bit_buff, 444 gain_set_params->gain_coding_profile, 445 &(str_spline_nodes->str_node[0].loc_db_gain)); 446 if (err) return (err); 447 448 str_spline_nodes->str_node[0].slope = 0.0; 449 str_spline_nodes->str_node[0].time = 450 (pstr_drc_uni_bs_dec->ia_drc_params_struct).drc_frame_size + 451 time_offset; 452 } else { 453 err = impd_dec_slopes(it_bit_buff, &str_spline_nodes->num_nodes, 454 gain_set_params->gain_interpolation_type, 455 str_spline_nodes->str_node); 456 if (err) return (err); 457 if (gain_set_params->time_delt_min_flag) { 458 err = impd_dec_times( 459 it_bit_buff, &gain_set_params->str_tables, 460 str_spline_nodes->num_nodes, gain_set_params->time_delt_min_val, 461 (pstr_drc_uni_bs_dec->ia_drc_params_struct).drc_frame_size, 462 gain_set_params->full_frame, time_offset, 463 str_spline_nodes->str_node); 464 if (err) return (err); 465 err = impd_dec_gains(it_bit_buff, str_spline_nodes->num_nodes, 466 gain_set_params->gain_coding_profile, 467 str_spline_nodes->str_node); 468 if (err) return (err); 469 } else { 470 err = impd_dec_times( 471 it_bit_buff, &pstr_drc_uni_bs_dec->tables_default, 472 str_spline_nodes->num_nodes, 473 (pstr_drc_uni_bs_dec->ia_drc_params_struct).delta_tmin_default, 474 (pstr_drc_uni_bs_dec->ia_drc_params_struct).drc_frame_size, 475 gain_set_params->full_frame, time_offset, 476 str_spline_nodes->str_node); 477 if (err) return (err); 478 err = impd_dec_gains(it_bit_buff, str_spline_nodes->num_nodes, 479 gain_set_params->gain_coding_profile, 480 str_spline_nodes->str_node); 481 if (err) return (err); 482 } 483 } 484 } 485 return (0); 486 } 487 488 WORD32 impd_parse_drc_gain_sequence( 489 ia_bit_buf_struct* it_bit_buff, ia_drc_bits_dec_struct* pstr_drc_uni_bs_dec, 490 ia_gain_set_params_struct* gain_set_params, 491 ia_drc_gain_sequence_struct* drc_gain_sequence) { 492 WORD32 err = 0, i; 493 WORD32 prev_frame_time_buf[NODE_COUNT_MAX], 494 cur_frame_time_buf[NODE_COUNT_MAX]; 495 WORD32 num_nodes_node_reservoir, num_nodes_cur, k, m; 496 497 if (((pstr_drc_uni_bs_dec->ia_drc_params_struct).delay_mode == 498 DELAY_MODE_LOW_DELAY) && 499 (gain_set_params->full_frame == 0)) { 500 return (PARAM_ERROR); 501 } 502 i = 0; 503 { 504 err = impd_parse_spline_nodes(it_bit_buff, pstr_drc_uni_bs_dec, 505 gain_set_params, 506 &(drc_gain_sequence->str_spline_nodes[i])); 507 if (err) return (err); 508 509 num_nodes_node_reservoir = 0; 510 num_nodes_cur = 0; 511 for (k = 0; k < drc_gain_sequence->str_spline_nodes[i].num_nodes; k++) { 512 if (drc_gain_sequence->str_spline_nodes[i].str_node[k].time >= 513 pstr_drc_uni_bs_dec->ia_drc_params_struct.drc_frame_size) { 514 prev_frame_time_buf[num_nodes_node_reservoir] = 515 drc_gain_sequence->str_spline_nodes[i].str_node[k].time; 516 num_nodes_node_reservoir++; 517 } else { 518 cur_frame_time_buf[num_nodes_cur] = 519 drc_gain_sequence->str_spline_nodes[i].str_node[k].time; 520 num_nodes_cur++; 521 } 522 } 523 for (k = 0; k < num_nodes_node_reservoir; k++) { 524 WORD32 tmp = prev_frame_time_buf[k] - 525 2 * pstr_drc_uni_bs_dec->ia_drc_params_struct.drc_frame_size; 526 if (tmp >= (2 * AUDIO_CODEC_FRAME_SIZE_MAX - 527 pstr_drc_uni_bs_dec->ia_drc_params_struct.drc_frame_size)) 528 return UNEXPECTED_ERROR; 529 drc_gain_sequence->str_spline_nodes[i].str_node[k].time = tmp; 530 } 531 for (m = 0; m < num_nodes_cur; m++, k++) { 532 drc_gain_sequence->str_spline_nodes[i].str_node[k].time = 533 cur_frame_time_buf[m]; 534 } 535 } 536 return (0); 537 } 538 WORD32 impd_parse_drc_ext_v1(ia_bit_buf_struct* it_bit_buff, 539 ia_drc_params_bs_dec_struct* ia_drc_params_struct, 540 ia_drc_config* drc_config, 541 ia_drc_config_ext* str_drc_config_ext) { 542 WORD32 dwnmix_instructions_v1_flag; 543 WORD32 dwnmix_instructions_v1_count; 544 WORD32 drc_coeffs_and_instructions_uni_drc_v1_flag; 545 WORD32 drc_coefficients_uni_drc_v1_count; 546 WORD32 drc_instructions_uni_drc_v1_count; 547 548 WORD32 i = 0, err = 0; 549 const WORD32 version = 1; 550 551 dwnmix_instructions_v1_flag = impd_read_bits_buf(it_bit_buff, 1); 552 if (it_bit_buff->error) return it_bit_buff->error; 553 if (dwnmix_instructions_v1_flag == 1) { 554 dwnmix_instructions_v1_count = impd_read_bits_buf(it_bit_buff, 7); 555 if (it_bit_buff->error) return it_bit_buff->error; 556 if ((dwnmix_instructions_v1_count + drc_config->dwnmix_instructions_count) > 557 DOWNMIX_INSTRUCTION_COUNT_MAX) 558 return UNEXPECTED_ERROR; 559 for (i = 0; i < dwnmix_instructions_v1_count; i++) { 560 err = impd_parse_dwnmix_instructions( 561 it_bit_buff, version, ia_drc_params_struct, 562 &drc_config->channel_layout, 563 &drc_config 564 ->dwnmix_instructions[i + 565 drc_config->dwnmix_instructions_count]); 566 if (err) return (err); 567 } 568 drc_config->dwnmix_instructions_count += dwnmix_instructions_v1_count; 569 } 570 571 drc_coeffs_and_instructions_uni_drc_v1_flag = 572 impd_read_bits_buf(it_bit_buff, 1); 573 if (it_bit_buff->error) return it_bit_buff->error; 574 if (drc_coeffs_and_instructions_uni_drc_v1_flag == 1) { 575 drc_coefficients_uni_drc_v1_count = impd_read_bits_buf(it_bit_buff, 3); 576 if ((drc_coefficients_uni_drc_v1_count + 577 drc_config->drc_coefficients_drc_count) > DRC_COEFF_COUNT_MAX) { 578 return (UNEXPECTED_ERROR); 579 } 580 if (it_bit_buff->error) return it_bit_buff->error; 581 for (i = 0; i < drc_coefficients_uni_drc_v1_count; i++) { 582 err = impd_drc_parse_coeff( 583 it_bit_buff, version, ia_drc_params_struct, 584 &drc_config->str_p_loc_drc_coefficients_uni_drc 585 [i + drc_config->drc_coefficients_drc_count]); 586 if (err) return (err); 587 } 588 drc_config->drc_coefficients_drc_count += drc_coefficients_uni_drc_v1_count; 589 590 drc_instructions_uni_drc_v1_count = impd_read_bits_buf(it_bit_buff, 6); 591 if (it_bit_buff->error) return it_bit_buff->error; 592 if (drc_config->drc_instructions_uni_drc_count + 593 drc_instructions_uni_drc_v1_count > 594 DRC_INSTRUCTIONS_COUNT_MAX) 595 return (UNEXPECTED_ERROR); 596 597 for (i = 0; i < drc_instructions_uni_drc_v1_count; i++) { 598 err = impd_parse_drc_instructions_uni_drc( 599 it_bit_buff, version, drc_config, 600 &drc_config->str_drc_instruction_str 601 [i + drc_config->drc_instructions_uni_drc_count]); 602 if (err) return (err); 603 } 604 drc_config->drc_instructions_uni_drc_count += 605 drc_instructions_uni_drc_v1_count; 606 } 607 608 str_drc_config_ext->loud_eq_instructions_flag = 609 impd_read_bits_buf(it_bit_buff, 1); 610 if (it_bit_buff->error) return it_bit_buff->error; 611 if (str_drc_config_ext->loud_eq_instructions_flag == 1) { 612 str_drc_config_ext->loud_eq_instructions_count = 613 impd_read_bits_buf(it_bit_buff, 4); 614 615 if (it_bit_buff->error) return it_bit_buff->error; 616 if (str_drc_config_ext->loud_eq_instructions_count > 617 LOUD_EQ_INSTRUCTIONS_COUNT_MAX) 618 return UNEXPECTED_ERROR; 619 for (i = 0; i < str_drc_config_ext->loud_eq_instructions_count; i++) { 620 err = impd_parse_loud_eq_instructions( 621 it_bit_buff, &str_drc_config_ext->loud_eq_instructions[i]); 622 if (err) return (err); 623 } 624 } else { 625 str_drc_config_ext->loud_eq_instructions_count = 0; 626 } 627 628 str_drc_config_ext->eq_flag = impd_read_bits_buf(it_bit_buff, 1); 629 if (it_bit_buff->error) return it_bit_buff->error; 630 if (str_drc_config_ext->eq_flag == 1) { 631 err = impd_parse_eq_coefficients(it_bit_buff, 632 &str_drc_config_ext->str_eq_coeff); 633 if (err) return (err); 634 str_drc_config_ext->eq_instructions_count = 635 impd_read_bits_buf(it_bit_buff, 4); 636 if (str_drc_config_ext->eq_instructions_count > EQ_INSTRUCTIONS_COUNT_MAX) 637 return UNEXPECTED_ERROR; 638 if (it_bit_buff->error) return it_bit_buff->error; 639 for (i = 0; i < str_drc_config_ext->eq_instructions_count; i++) { 640 err = impd_parse_eq_instructions( 641 it_bit_buff, drc_config, &str_drc_config_ext->str_eq_instructions[i]); 642 if (err) return (err); 643 } 644 } 645 return 0; 646 } 647 648 WORD32 impd_parse_filt_block(ia_bit_buf_struct* it_bit_buff, 649 ia_filt_block_struct* str_filter_block, 650 WORD32 block_count) { 651 // WORD32 err = 0; 652 WORD32 k, j, temp; 653 ia_filt_ele_struct* str_filter_element; 654 655 for (j = 0; j < block_count; j++) { 656 str_filter_block->filter_element_count = impd_read_bits_buf(it_bit_buff, 6); 657 if (it_bit_buff->error) return it_bit_buff->error; 658 if (str_filter_block->filter_element_count > FILTER_ELEMENT_COUNT_MAX) 659 return UNEXPECTED_ERROR; 660 str_filter_element = &str_filter_block->str_filter_element[0]; 661 for (k = 0; k < str_filter_block->filter_element_count; k++) { 662 temp = impd_read_bits_buf(it_bit_buff, 7); 663 if (it_bit_buff->error) return it_bit_buff->error; 664 665 str_filter_element->filt_ele_idx = (temp & 0x7E) >> 1; 666 if (str_filter_element->filt_ele_idx >= FILTER_ELEMENT_COUNT_MAX) 667 return (UNEXPECTED_ERROR); 668 str_filter_element->filt_ele_gain_flag = temp & 1; 669 ; 670 671 if (str_filter_element->filt_ele_gain_flag) { 672 WORD32 bs_filter_element_gain; 673 bs_filter_element_gain = impd_read_bits_buf(it_bit_buff, 10); 674 if (it_bit_buff->error) return it_bit_buff->error; 675 str_filter_element->filt_ele_gain = 676 bs_filter_element_gain * 0.125f - 96.0f; 677 } 678 679 str_filter_element++; 680 } 681 str_filter_block++; 682 } 683 return (0); 684 } 685 686 WORD32 impd_parse_unique_td_filt_ele( 687 ia_bit_buf_struct* it_bit_buff, 688 ia_unique_td_filt_element* unique_td_filt_ele, 689 WORD32 td_filter_element_count) { 690 WORD32 m, sign, j, temp; 691 FLOAT32 tmp; 692 693 for (j = 0; j < td_filter_element_count; j++) { 694 unique_td_filt_ele->eq_filter_format = impd_read_bits_buf(it_bit_buff, 1); 695 if (it_bit_buff->error) return it_bit_buff->error; 696 697 if (unique_td_filt_ele->eq_filter_format == 0) { 698 WORD32 bs_real_zero_radius, bs_generic_zero_radius, bs_generic_zero_angle; 699 WORD32 bs_real_pole_radius, bs_cmplx_pole_radius, bs_cmplx_pole_angle; 700 WORD32 bs_real_zero_radius_one_count; 701 702 temp = impd_read_bits_buf(it_bit_buff, 23); 703 if (it_bit_buff->error) return it_bit_buff->error; 704 705 bs_real_zero_radius_one_count = (temp >> 20) & 7; 706 707 unique_td_filt_ele->bs_real_zero_radius_one_count = 708 2 * bs_real_zero_radius_one_count; 709 unique_td_filt_ele->real_zero_count = (temp & 0xFC000) >> 14; 710 711 unique_td_filt_ele->generic_zero_count = (temp & 0x3F00) >> 8; 712 713 unique_td_filt_ele->real_pole_count = (temp & 0xF0) >> 4; 714 715 unique_td_filt_ele->cmplx_pole_count = temp & 0xF; 716 717 temp = impd_read_bits_buf( 718 it_bit_buff, unique_td_filt_ele->bs_real_zero_radius_one_count); 719 if (it_bit_buff->error) return it_bit_buff->error; 720 721 for (m = unique_td_filt_ele->bs_real_zero_radius_one_count - 1; m >= 0; 722 m--) { 723 unique_td_filt_ele->zero_sign[m] = (temp & 1); 724 temp = temp >> 1; 725 } 726 727 for (m = 0; m < unique_td_filt_ele->real_zero_count; m++) { 728 temp = impd_read_bits_buf(it_bit_buff, 8); 729 if (it_bit_buff->error) return it_bit_buff->error; 730 731 bs_real_zero_radius = (temp & 0xFE) >> 1; 732 733 sign = temp & 0x01; 734 735 tmp = 1.0f - zero_pole_radius_tbl[bs_real_zero_radius]; 736 737 sign = sign << 1; 738 739 unique_td_filt_ele->real_zero_radius[m] = (1 - sign) * tmp; 740 } 741 for (m = 0; m < unique_td_filt_ele->generic_zero_count; m++) { 742 temp = impd_read_bits_buf(it_bit_buff, 14); 743 if (it_bit_buff->error) return it_bit_buff->error; 744 745 bs_generic_zero_radius = (temp & 0x3F80) >> 7; 746 747 unique_td_filt_ele->generic_zero_radius[m] = 748 1.0f - zero_pole_radius_tbl[bs_generic_zero_radius]; 749 750 bs_generic_zero_angle = (temp & 0x7F); 751 752 unique_td_filt_ele->generic_zero_angle[m] = 753 zero_pole_angle_tbl[bs_generic_zero_angle]; 754 } 755 for (m = 0; m < unique_td_filt_ele->real_pole_count; m++) { 756 temp = impd_read_bits_buf(it_bit_buff, 8); 757 if (it_bit_buff->error) return it_bit_buff->error; 758 759 bs_real_pole_radius = (temp & 0xFE) >> 1; 760 761 sign = temp & 0x01; 762 763 tmp = 1.0f - zero_pole_radius_tbl[bs_real_pole_radius]; 764 765 sign = sign << 1; 766 767 unique_td_filt_ele->real_pole_radius[m] = (1 - sign) * tmp; 768 } 769 for (m = 0; m < unique_td_filt_ele->cmplx_pole_count; m++) { 770 temp = impd_read_bits_buf(it_bit_buff, 14); 771 772 if (it_bit_buff->error) return it_bit_buff->error; 773 774 bs_cmplx_pole_radius = (temp & 0x3F80) >> 7; 775 776 unique_td_filt_ele->complex_pole_radius[m] = 777 1.0f - zero_pole_radius_tbl[bs_cmplx_pole_radius]; 778 779 bs_cmplx_pole_angle = (temp & 0x7F); 780 781 unique_td_filt_ele->complex_pole_angle[m] = 782 zero_pole_angle_tbl[bs_cmplx_pole_angle]; 783 } 784 } else { 785 temp = impd_read_bits_buf(it_bit_buff, 8); 786 if (it_bit_buff->error) return it_bit_buff->error; 787 788 unique_td_filt_ele->fir_filt_order = (temp & 0xFE) >> 1; 789 790 unique_td_filt_ele->fir_symmetry = temp & 0x01; 791 792 for (m = 0; m < unique_td_filt_ele->fir_filt_order / 2 + 1; m++) { 793 WORD32 sign, bs_fir_coeff; 794 FLOAT32 tmp; 795 796 temp = impd_read_bits_buf(it_bit_buff, 11); 797 if (it_bit_buff->error) return it_bit_buff->error; 798 sign = (temp >> 10) & 0x01; 799 800 bs_fir_coeff = temp & 0x03FF; 801 802 tmp = (FLOAT32)pow(10.0f, -0.05f * bs_fir_coeff * 0.0625f); 803 804 sign = sign << 1; 805 806 unique_td_filt_ele->fir_coeff[m] = (1 - sign) * tmp; 807 } 808 } 809 unique_td_filt_ele++; 810 } 811 return (0); 812 } 813 814 WORD32 impd_decode_eq_slope_code(ia_bit_buf_struct* it_bit_buff, 815 FLOAT32* eq_slope, WORD32 num_eq_nodes) { 816 WORD32 bits = 0; 817 WORD32 k; 818 819 for (k = 0; k < num_eq_nodes; k++) { 820 bits = impd_read_bits_buf(it_bit_buff, 1); 821 if (it_bit_buff->error) return it_bit_buff->error; 822 if (bits == 0x1) { 823 *eq_slope = 0.0f; 824 } else { 825 bits = impd_read_bits_buf(it_bit_buff, 4); 826 if (it_bit_buff->error) return it_bit_buff->error; 827 *eq_slope = eq_slope_tbl[bits]; 828 } 829 eq_slope++; 830 } 831 return (0); 832 } 833 834 WORD32 835 impd_decode_gain_initial_code(ia_bit_buf_struct* it_bit_buff, 836 FLOAT32* eq_gain_initial) { 837 WORD32 bits, bits1; 838 839 bits1 = impd_read_bits_buf(it_bit_buff, 2); 840 if (it_bit_buff->error) return it_bit_buff->error; 841 842 switch (bits1) { 843 case 0x0: 844 bits = impd_read_bits_buf(it_bit_buff, 5); 845 if (it_bit_buff->error) return it_bit_buff->error; 846 *eq_gain_initial = 0.5f * bits - 8.0f; 847 break; 848 case 0x1: 849 case 0x2: 850 851 bits = impd_read_bits_buf(it_bit_buff, 4); 852 if (it_bit_buff->error) return it_bit_buff->error; 853 if (bits < 8) { 854 *eq_gain_initial = bits1 * bits - bits1 * 16.0f; 855 } else { 856 *eq_gain_initial = (FLOAT32)bits1 * bits; 857 } 858 break; 859 860 case 0x3: 861 bits = impd_read_bits_buf(it_bit_buff, 3); 862 if (it_bit_buff->error) return it_bit_buff->error; 863 *eq_gain_initial = 4.0f * bits - 64.0f; 864 break; 865 866 default: 867 break; 868 } 869 return (0); 870 } 871 872 WORD32 impd_parse_eq_subband_gain_spline( 873 ia_bit_buf_struct* it_bit_buff, 874 ia_eq_subband_gain_spline_struct* str_eq_subband_gain_spline, 875 WORD32 eq_subband_gains_count) { 876 WORD32 err = 0, eq_nodes_cnt, j, k, bits, *eq_freq_delta; 877 FLOAT32* peq_gain_delta; 878 879 for (j = 0; j < eq_subband_gains_count; j++) { 880 eq_nodes_cnt = impd_read_bits_buf(it_bit_buff, 5); 881 if (it_bit_buff->error) return it_bit_buff->error; 882 883 str_eq_subband_gain_spline->num_eq_nodes = eq_nodes_cnt + 2; 884 885 err = impd_decode_eq_slope_code(it_bit_buff, 886 &(str_eq_subband_gain_spline->eq_slope[0]), 887 str_eq_subband_gain_spline->num_eq_nodes); 888 if (err) return (err); 889 890 eq_freq_delta = &(str_eq_subband_gain_spline->eq_freq_delta[1]); 891 for (k = 1; k < str_eq_subband_gain_spline->num_eq_nodes; k++) { 892 bits = impd_read_bits_buf(it_bit_buff, 4); 893 if (it_bit_buff->error) return it_bit_buff->error; 894 *eq_freq_delta = bits + 1; 895 eq_freq_delta++; 896 } 897 898 err = impd_decode_gain_initial_code( 899 it_bit_buff, &(str_eq_subband_gain_spline->eq_gain_initial)); 900 if (err) return (err); 901 902 peq_gain_delta = &(str_eq_subband_gain_spline->eq_gain_delta[1]); 903 for (k = 1; k < str_eq_subband_gain_spline->num_eq_nodes; k++) { 904 bits = impd_read_bits_buf(it_bit_buff, 5); 905 if (it_bit_buff->error) return it_bit_buff->error; 906 907 *peq_gain_delta = eq_gain_delta_tbl[bits]; 908 peq_gain_delta++; 909 } 910 str_eq_subband_gain_spline++; 911 } 912 return (0); 913 } 914 915 WORD32 impd_parse_eq_subband_gain_vector( 916 ia_bit_buf_struct* it_bit_buff, const WORD32 eq_subband_gain_count, 917 ia_eq_subband_gain_vector* str_eq_subband_gain_vector, 918 WORD32 eq_subband_gains_count) { 919 WORD32 m, k, temp; 920 921 for (k = 0; k < eq_subband_gains_count; k++) { 922 for (m = 0; m < eq_subband_gain_count; m++) { 923 WORD32 sign, bs_eq_subband_gain; 924 temp = impd_read_bits_buf(it_bit_buff, 9); 925 if (it_bit_buff->error) return it_bit_buff->error; 926 927 sign = (temp >> 8) & 1; 928 bs_eq_subband_gain = temp & 0x7F; 929 930 sign = sign << 1; 931 str_eq_subband_gain_vector->eq_subband_gain[m] = 932 ((1 - sign) * bs_eq_subband_gain) * 0.125f; 933 } 934 str_eq_subband_gain_vector++; 935 } 936 return (0); 937 } 938 939 WORD32 impd_parse_eq_coefficients(ia_bit_buf_struct* it_bit_buff, 940 ia_eq_coeff_struct* str_eq_coeff) { 941 WORD32 err = 0; 942 WORD32 eq_gain_cnt, mu, nu, temp; 943 static const WORD32 subband_gain_len_tbl[7] = {0, 32, 39, 64, 71, 128, 135}; 944 945 str_eq_coeff->eq_delay_max_present = impd_read_bits_buf(it_bit_buff, 1); 946 if (it_bit_buff->error) return it_bit_buff->error; 947 948 if (str_eq_coeff->eq_delay_max_present) { 949 mu = impd_read_bits_buf(it_bit_buff, 5); 950 if (it_bit_buff->error) return it_bit_buff->error; 951 nu = impd_read_bits_buf(it_bit_buff, 3); 952 if (it_bit_buff->error) return it_bit_buff->error; 953 str_eq_coeff->eq_delay_max = 16 * mu * (1 << nu); 954 } 955 956 str_eq_coeff->unique_filter_block_count = impd_read_bits_buf(it_bit_buff, 6); 957 if (it_bit_buff->error) return it_bit_buff->error; 958 959 if (str_eq_coeff->unique_filter_block_count > FILTER_BLOCK_COUNT_MAX) { 960 return (UNEXPECTED_ERROR); 961 } 962 963 err = impd_parse_filt_block(it_bit_buff, &(str_eq_coeff->str_filter_block[0]), 964 str_eq_coeff->unique_filter_block_count); 965 if (err) return (err); 966 967 str_eq_coeff->unique_td_filter_element_count = 968 impd_read_bits_buf(it_bit_buff, 6); 969 if (str_eq_coeff->unique_td_filter_element_count > FILTER_ELEMENT_COUNT_MAX) 970 return (UNEXPECTED_ERROR); 971 if (it_bit_buff->error) return it_bit_buff->error; 972 973 err = impd_parse_unique_td_filt_ele( 974 it_bit_buff, &(str_eq_coeff->unique_td_filt_ele[0]), 975 str_eq_coeff->unique_td_filter_element_count); 976 if (err) return (err); 977 978 str_eq_coeff->unique_eq_subband_gains_count = 979 impd_read_bits_buf(it_bit_buff, 6); 980 if (str_eq_coeff->unique_eq_subband_gains_count > 981 UNIQUE_SUBBAND_GAIN_COUNT_MAX) 982 return (UNEXPECTED_ERROR); 983 if (it_bit_buff->error) return it_bit_buff->error; 984 985 if (str_eq_coeff->unique_eq_subband_gains_count > 0) { 986 temp = impd_read_bits_buf(it_bit_buff, 5); 987 if (it_bit_buff->error) return it_bit_buff->error; 988 str_eq_coeff->eq_subband_gain_representation = (temp >> 4) & 0x01; 989 990 str_eq_coeff->eq_subband_gain_format = temp & 0x0F; 991 if ((str_eq_coeff->eq_subband_gain_format > 0) && 992 (str_eq_coeff->eq_subband_gain_format < GAINFORMAT_UNIFORM)) { 993 str_eq_coeff->eq_subband_gain_count = 994 subband_gain_len_tbl[str_eq_coeff->eq_subband_gain_format]; 995 } else { 996 /* Gain format 0 or any value between 7 to 15 is considered as default 997 * case */ 998 eq_gain_cnt = impd_read_bits_buf(it_bit_buff, 8); 999 1000 if (it_bit_buff->error) return it_bit_buff->error; 1001 str_eq_coeff->eq_subband_gain_count = eq_gain_cnt + 1; 1002 1003 if (str_eq_coeff->eq_subband_gain_count > EQ_SUBBAND_GAIN_COUNT_MAX) 1004 return UNEXPECTED_ERROR; 1005 1006 } 1007 1008 if (str_eq_coeff->eq_subband_gain_representation == 1) { 1009 err = impd_parse_eq_subband_gain_spline( 1010 it_bit_buff, &(str_eq_coeff->str_eq_subband_gain_spline[0]), 1011 str_eq_coeff->unique_eq_subband_gains_count); 1012 if (err) return (err); 1013 } else { 1014 err = impd_parse_eq_subband_gain_vector( 1015 it_bit_buff, str_eq_coeff->eq_subband_gain_count, 1016 &(str_eq_coeff->str_eq_subband_gain_vector[0]), 1017 str_eq_coeff->unique_eq_subband_gains_count); 1018 if (err) return (err); 1019 } 1020 } 1021 1022 return (0); 1023 } 1024 1025 WORD32 impd_parser_td_filter_cascade( 1026 ia_bit_buf_struct* it_bit_buff, 1027 ia_eq_instructions_struct* str_eq_instructions, 1028 ia_td_filter_cascade_struct* str_td_filter_cascade) { 1029 // WORD32 err=0, 1030 WORD32 i, ii, k; 1031 WORD32 eq_cascade_gain; 1032 ia_filter_block_refs_struct* str_filter_block_refs = 1033 &(str_td_filter_cascade->str_filter_block_refs[0]); 1034 1035 for (i = 0; i < str_eq_instructions->eq_ch_group_count; i++) { 1036 str_td_filter_cascade->eq_cascade_gain_present[i] = 1037 impd_read_bits_buf(it_bit_buff, 1); 1038 if (it_bit_buff->error) return it_bit_buff->error; 1039 if (str_td_filter_cascade->eq_cascade_gain_present[i]) { 1040 eq_cascade_gain = impd_read_bits_buf(it_bit_buff, 10); 1041 if (it_bit_buff->error) return it_bit_buff->error; 1042 str_td_filter_cascade->eq_cascade_gain[i] = 1043 0.125f * eq_cascade_gain - 96.0f; 1044 } else { 1045 str_td_filter_cascade->eq_cascade_gain[i] = 0.0f; 1046 } 1047 1048 str_filter_block_refs->filter_block_count = 1049 impd_read_bits_buf(it_bit_buff, 4); 1050 if (it_bit_buff->error) return it_bit_buff->error; 1051 if (str_filter_block_refs->filter_block_count > EQ_FILTER_BLOCK_COUNT_MAX) { 1052 return (UNEXPECTED_ERROR); 1053 } 1054 1055 for (ii = 0; ii < str_filter_block_refs->filter_block_count; ii++) { 1056 str_filter_block_refs->filter_block_index[ii] = 1057 impd_read_bits_buf(it_bit_buff, 7); 1058 if (it_bit_buff->error) return it_bit_buff->error; 1059 if (str_filter_block_refs->filter_block_index[ii] >= 1060 FILTER_BLOCK_COUNT_MAX) 1061 return (UNEXPECTED_ERROR); 1062 } 1063 str_filter_block_refs++; 1064 } 1065 1066 str_td_filter_cascade->eq_phase_alignment_present = 1067 impd_read_bits_buf(it_bit_buff, 1); 1068 if (it_bit_buff->error) return it_bit_buff->error; 1069 1070 if (str_td_filter_cascade->eq_phase_alignment_present) { 1071 for (i = 0; i < str_eq_instructions->eq_ch_group_count; i++) { 1072 for (k = i + 1; k < str_eq_instructions->eq_ch_group_count; k++) { 1073 str_td_filter_cascade->eq_phase_alignment[i][k] = 1074 impd_read_bits_buf(it_bit_buff, 1); 1075 if (it_bit_buff->error) return it_bit_buff->error; 1076 } 1077 } 1078 1079 } else { 1080 for (i = 0; i < str_eq_instructions->eq_ch_group_count; i++) { 1081 for (k = i + 1; k < str_eq_instructions->eq_ch_group_count; k++) 1082 str_td_filter_cascade->eq_phase_alignment[i][k] = 1; 1083 } 1084 } 1085 1086 return (0); 1087 } 1088 1089 WORD32 impd_parse_eq_instructions( 1090 ia_bit_buf_struct* it_bit_buff, ia_drc_config* drc_config, 1091 ia_eq_instructions_struct* str_eq_instructions) { 1092 WORD32 i, channel_count, temp; 1093 WORD32 dmix_id_present, additional_dmix_id_present, 1094 additional_dmix_id_cnt = 0; 1095 WORD32 additional_drc_set_id_present, additional_drc_set_id_cnt; 1096 1097 temp = impd_read_bits_buf(it_bit_buff, 11); 1098 if (it_bit_buff->error) return it_bit_buff->error; 1099 1100 str_eq_instructions->eq_set_id = (temp >> 5) & 0x3F; 1101 1102 if (str_eq_instructions->eq_set_id >= EQ_INSTRUCTIONS_COUNT_MAX) 1103 return UNEXPECTED_ERROR; 1104 1105 str_eq_instructions->eq_set_complexity_level = (temp >> 1) & 0x0F; 1106 1107 dmix_id_present = temp & 0x01; 1108 1109 if (dmix_id_present) { 1110 temp = impd_read_bits_buf(it_bit_buff, 9); 1111 if (it_bit_buff->error) return it_bit_buff->error; 1112 1113 str_eq_instructions->downmix_id[0] = (temp >> 2) & 0x7F; 1114 1115 str_eq_instructions->eq_apply_to_downmix = (temp >> 1) & 0x01; 1116 1117 additional_dmix_id_present = temp & 0x01; 1118 1119 if (additional_dmix_id_present) { 1120 additional_dmix_id_cnt = impd_read_bits_buf(it_bit_buff, 7); 1121 if (it_bit_buff->error) return it_bit_buff->error; 1122 1123 if (additional_dmix_id_cnt >= DOWNMIX_ID_COUNT_MAX) 1124 return UNEXPECTED_ERROR; 1125 1126 for (i = 1; i < additional_dmix_id_cnt + 1; i++) { 1127 str_eq_instructions->downmix_id[i] = impd_read_bits_buf(it_bit_buff, 7); 1128 if (it_bit_buff->error) return it_bit_buff->error; 1129 } 1130 } 1131 } else { 1132 str_eq_instructions->downmix_id[0] = 0; 1133 } 1134 1135 str_eq_instructions->dwnmix_id_count = 1 + additional_dmix_id_cnt; 1136 1137 temp = impd_read_bits_buf(it_bit_buff, 7); 1138 if (it_bit_buff->error) return it_bit_buff->error; 1139 1140 str_eq_instructions->drc_set_id[0] = (temp >> 1) & 0x3F; 1141 1142 additional_drc_set_id_present = temp & 0x01; 1143 1144 if (additional_drc_set_id_present) { 1145 additional_drc_set_id_cnt = impd_read_bits_buf(it_bit_buff, 6); 1146 if (it_bit_buff->error) return it_bit_buff->error; 1147 if (additional_drc_set_id_cnt >= DRC_SET_ID_COUNT_MAX) 1148 return UNEXPECTED_ERROR; 1149 1150 for (i = 1; i < additional_drc_set_id_cnt + 1; i++) { 1151 str_eq_instructions->drc_set_id[i] = impd_read_bits_buf(it_bit_buff, 6); 1152 if (it_bit_buff->error) return it_bit_buff->error; 1153 } 1154 } else { 1155 additional_drc_set_id_cnt = 0; 1156 } 1157 str_eq_instructions->drc_set_id_count = 1 + additional_drc_set_id_cnt; 1158 1159 temp = impd_read_bits_buf(it_bit_buff, 17); 1160 if (it_bit_buff->error) return it_bit_buff->error; 1161 1162 str_eq_instructions->eq_set_purpose = (temp >> 1) & 0xFFFF; 1163 1164 str_eq_instructions->depends_on_eq_set_present = temp & 0x01; 1165 1166 if (str_eq_instructions->depends_on_eq_set_present) { 1167 str_eq_instructions->depends_on_eq_set = impd_read_bits_buf(it_bit_buff, 6); 1168 if (it_bit_buff->error) return it_bit_buff->error; 1169 } else { 1170 str_eq_instructions->no_independent_eq_use = 1171 impd_read_bits_buf(it_bit_buff, 1); 1172 if (it_bit_buff->error) return it_bit_buff->error; 1173 } 1174 1175 str_eq_instructions->eq_channel_count = channel_count = 1176 drc_config->channel_layout.base_channel_count; 1177 1178 if ((dmix_id_present == 1) && 1179 (str_eq_instructions->eq_apply_to_downmix == 1) && 1180 (str_eq_instructions->downmix_id[0] != 0) && 1181 (str_eq_instructions->downmix_id[0] != ID_FOR_ANY_DOWNMIX) && 1182 (str_eq_instructions->dwnmix_id_count == 1)) { 1183 for (i = 0; i < drc_config->dwnmix_instructions_count; i++) { 1184 if (str_eq_instructions->downmix_id[0] == 1185 drc_config->dwnmix_instructions[i].downmix_id) 1186 break; 1187 } 1188 if (i == drc_config->dwnmix_instructions_count) { 1189 return UNEXPECTED_ERROR; 1190 } 1191 1192 str_eq_instructions->eq_channel_count = channel_count = 1193 drc_config->dwnmix_instructions[i].target_channel_count; 1194 } else if ((str_eq_instructions->downmix_id[0] == ID_FOR_ANY_DOWNMIX) || 1195 (str_eq_instructions->dwnmix_id_count > 1)) { 1196 channel_count = 1; 1197 } 1198 1199 str_eq_instructions->eq_ch_group_count = 0; 1200 1201 for (i = 0; i < channel_count; i++) { 1202 WORD32 tmp = impd_read_bits_buf(it_bit_buff, 7); 1203 if (it_bit_buff->error) return it_bit_buff->error; 1204 if (tmp >= EQ_CHANNEL_GROUP_COUNT_MAX) return UNEXPECTED_ERROR; 1205 str_eq_instructions->eq_ch_group_of_channel[i] = tmp; 1206 } 1207 { 1208 WORD32 total; 1209 WORD32 groups_used[EQ_CHANNEL_GROUP_COUNT_MAX] = {0}; 1210 for (i = 0; i < channel_count; i++) 1211 groups_used[str_eq_instructions->eq_ch_group_of_channel[i]] = 1; 1212 total = 0; 1213 for (i = 0; i < EQ_CHANNEL_GROUP_COUNT_MAX; i++) 1214 if (groups_used[i]) total++; 1215 str_eq_instructions->eq_ch_group_count = total; 1216 } 1217 1218 if (str_eq_instructions->eq_ch_group_count > EQ_CHANNEL_GROUP_COUNT_MAX) 1219 return (UNEXPECTED_ERROR); 1220 1221 str_eq_instructions->td_filter_cascade_present = 1222 impd_read_bits_buf(it_bit_buff, 1); 1223 if (it_bit_buff->error) return it_bit_buff->error; 1224 1225 if (str_eq_instructions->td_filter_cascade_present) { 1226 WORD32 err = impd_parser_td_filter_cascade( 1227 it_bit_buff, str_eq_instructions, 1228 &(str_eq_instructions->str_td_filter_cascade)); 1229 if (err) return err; 1230 } 1231 1232 str_eq_instructions->subband_gains_present = 1233 impd_read_bits_buf(it_bit_buff, 1); 1234 if (it_bit_buff->error) return it_bit_buff->error; 1235 1236 if (str_eq_instructions->subband_gains_present) { 1237 for (i = 0; i < str_eq_instructions->eq_ch_group_count; i++) { 1238 WORD32 tmp = impd_read_bits_buf(it_bit_buff, 6); 1239 if (it_bit_buff->error) return it_bit_buff->error; 1240 if (tmp >= UNIQUE_SUBBAND_GAIN_COUNT_MAX) return UNEXPECTED_ERROR; 1241 str_eq_instructions->subband_gains_index[i] = tmp; 1242 } 1243 } 1244 1245 str_eq_instructions->eq_transition_duration_present = 1246 impd_read_bits_buf(it_bit_buff, 1); 1247 if (it_bit_buff->error) return it_bit_buff->error; 1248 1249 if (str_eq_instructions->eq_transition_duration_present) { 1250 WORD32 bs_eq_transition_duration; 1251 bs_eq_transition_duration = impd_read_bits_buf(it_bit_buff, 5); 1252 if (it_bit_buff->error) return it_bit_buff->error; 1253 1254 str_eq_instructions->eq_transition_duration = (WORD32)( 1255 0.001f * 1256 (FLOAT32)pow(2.0f, 2.0f + bs_eq_transition_duration * 0.0625f)); 1257 } 1258 return (0); 1259 } 1260 1261 WORD32 impd_parse_loud_eq_instructions( 1262 ia_bit_buf_struct* it_bit_buff, 1263 ia_loud_eq_instructions_struct* loud_eq_instructions) { 1264 WORD32 i, bs_loud_eq_scaling, bs_loud_eq_offset, temp; 1265 WORD32 dmix_id_present, additional_dmix_id_present, 1266 additional_dmix_id_cnt = 0; 1267 WORD32 drc_set_id_present, additional_drc_set_id_present, 1268 additional_drc_set_id_cnt = 0; 1269 WORD32 eq_set_id_present, additional_eq_set_id_present, 1270 additional_eq_set_id_cnt = 0; 1271 1272 temp = impd_read_bits_buf(it_bit_buff, 9); 1273 if (it_bit_buff->error) return it_bit_buff->error; 1274 loud_eq_instructions->loud_eq_set_id = (temp >> 5) & 0x0F; 1275 1276 loud_eq_instructions->drc_location = (temp >> 1) & 0x0F; 1277 1278 dmix_id_present = temp & 0x01; 1279 1280 if (dmix_id_present) { 1281 temp = impd_read_bits_buf(it_bit_buff, 8); 1282 if (it_bit_buff->error) return it_bit_buff->error; 1283 1284 loud_eq_instructions->downmix_id[0] = (temp >> 1) & 0x7F; 1285 1286 additional_dmix_id_present = temp & 0x01; 1287 1288 if (additional_dmix_id_present) { 1289 additional_dmix_id_cnt = impd_read_bits_buf(it_bit_buff, 7); 1290 if (it_bit_buff->error) return it_bit_buff->error; 1291 if (additional_dmix_id_cnt >= DOWNMIX_ID_COUNT_MAX) 1292 return UNEXPECTED_ERROR; 1293 for (i = 1; i < additional_dmix_id_cnt + 1; i++) { 1294 loud_eq_instructions->downmix_id[i] = 1295 impd_read_bits_buf(it_bit_buff, 7); 1296 if (it_bit_buff->error) return it_bit_buff->error; 1297 } 1298 } 1299 } else { 1300 loud_eq_instructions->downmix_id[0] = 0; 1301 } 1302 1303 loud_eq_instructions->dwnmix_id_count = 1 + additional_dmix_id_cnt; 1304 1305 drc_set_id_present = impd_read_bits_buf(it_bit_buff, 1); 1306 if (it_bit_buff->error) return it_bit_buff->error; 1307 1308 if (drc_set_id_present) { 1309 temp = impd_read_bits_buf(it_bit_buff, 7); 1310 if (it_bit_buff->error) return it_bit_buff->error; 1311 1312 loud_eq_instructions->drc_set_id[0] = (temp >> 1) & 0x3F; 1313 1314 additional_drc_set_id_present = temp & 0x01; 1315 1316 if (additional_drc_set_id_present) { 1317 additional_drc_set_id_cnt = impd_read_bits_buf(it_bit_buff, 6); 1318 if (it_bit_buff->error) return it_bit_buff->error; 1319 if ((additional_drc_set_id_cnt >= DRC_SET_ID_COUNT_MAX)) 1320 return UNEXPECTED_ERROR; 1321 1322 for (i = 1; i < additional_drc_set_id_cnt + 1; i++) { 1323 loud_eq_instructions->drc_set_id[i] = 1324 impd_read_bits_buf(it_bit_buff, 6); 1325 if (it_bit_buff->error) return it_bit_buff->error; 1326 } 1327 } 1328 } else { 1329 loud_eq_instructions->drc_set_id[0] = 0; 1330 } 1331 1332 loud_eq_instructions->drc_set_id_count = 1 + additional_drc_set_id_cnt; 1333 1334 eq_set_id_present = impd_read_bits_buf(it_bit_buff, 1); 1335 1336 if (it_bit_buff->error) return it_bit_buff->error; 1337 1338 if (eq_set_id_present) { 1339 temp = impd_read_bits_buf(it_bit_buff, 7); 1340 if (it_bit_buff->error) return it_bit_buff->error; 1341 1342 loud_eq_instructions->eq_set_id[0] = (temp >> 1) & 0x3F; 1343 1344 additional_eq_set_id_present = temp & 0x01; 1345 1346 if (additional_eq_set_id_present) { 1347 additional_eq_set_id_cnt = impd_read_bits_buf(it_bit_buff, 6); 1348 if (it_bit_buff->error) return it_bit_buff->error; 1349 if (additional_eq_set_id_cnt >= EQ_SET_ID_COUNT_MAX) 1350 return UNEXPECTED_ERROR; 1351 for (i = 0; i < additional_eq_set_id_cnt; i++) { 1352 loud_eq_instructions->eq_set_id[i + 1] = 1353 impd_read_bits_buf(it_bit_buff, 6); 1354 if (it_bit_buff->error) return it_bit_buff->error; 1355 } 1356 } 1357 } else { 1358 loud_eq_instructions->eq_set_id[0] = 0; 1359 } 1360 loud_eq_instructions->eq_set_id_count = 1 + additional_eq_set_id_cnt; 1361 1362 temp = impd_read_bits_buf(it_bit_buff, 8); 1363 if (it_bit_buff->error) return it_bit_buff->error; 1364 1365 /* Parsed but unused */ 1366 loud_eq_instructions->loudness_after_drc = (temp >> 7) & 0x01; 1367 1368 /* Parsed but unused */ 1369 loud_eq_instructions->loudness_after_eq = (temp >> 6) & 0x01; 1370 1371 /* Parsed but unused */ 1372 loud_eq_instructions->loud_eq_gain_sequence_count = temp & 0x3F; 1373 1374 if (loud_eq_instructions->loud_eq_gain_sequence_count > 1375 LOUD_EQ_GAIN_SEQUENCE_COUNT_MAX) 1376 return UNEXPECTED_ERROR; 1377 1378 /* Section under for loop, Parsed but unused */ 1379 for (i = 0; i < loud_eq_instructions->loud_eq_gain_sequence_count; i++) { 1380 temp = impd_read_bits_buf(it_bit_buff, 7); 1381 if (it_bit_buff->error) return it_bit_buff->error; 1382 1383 loud_eq_instructions->gain_seq_idx[i] = (temp >> 1) & 0x3F; 1384 1385 loud_eq_instructions->drc_characteristic_format_is_cicp[i] = temp & 0x01; 1386 1387 if (loud_eq_instructions->drc_characteristic_format_is_cicp[i]) { 1388 loud_eq_instructions->drc_characteristic[i] = 1389 impd_read_bits_buf(it_bit_buff, 7); 1390 if (it_bit_buff->error) return it_bit_buff->error; 1391 } else { 1392 temp = impd_read_bits_buf(it_bit_buff, 8); 1393 if (it_bit_buff->error) return it_bit_buff->error; 1394 1395 loud_eq_instructions->drc_characteristic_left_index[i] = 1396 (temp >> 4) & 0x0F; 1397 1398 loud_eq_instructions->drc_characteristic_right_index[i] = temp & 0x0F; 1399 } 1400 1401 temp = impd_read_bits_buf(it_bit_buff, 9); 1402 if (it_bit_buff->error) return it_bit_buff->error; 1403 1404 loud_eq_instructions->frequency_range_index[i] = (temp >> 3) & 0x3F; 1405 1406 bs_loud_eq_scaling = temp & 0x07; 1407 1408 loud_eq_instructions->loud_eq_scaling[i] = 1409 (FLOAT32)pow(2.0f, -0.5f * bs_loud_eq_scaling); 1410 1411 bs_loud_eq_offset = impd_read_bits_buf(it_bit_buff, 5); 1412 if (it_bit_buff->error) return it_bit_buff->error; 1413 1414 loud_eq_instructions->loud_eq_offset[i] = 1.5f * bs_loud_eq_offset - 16.0f; 1415 } 1416 return (0); 1417 } 1418