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