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