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