/****************************************************************************** * * Copyright (C) 2018 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at: * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. * ***************************************************************************** * Originally developed and contributed by Ittiam Systems Pvt. Ltd, Bangalore */ #include <stdio.h> #include <string.h> #include <math.h> #include "impd_type_def.h" #include "impd_drc_bitbuffer.h" #include "impd_drc_extr_delta_coded_info.h" #include "impd_drc_common.h" #include "impd_drc_struct.h" #include "impd_drc_parser.h" #include "impd_drc_filter_bank.h" #include "impd_drc_rom.h" static VOID impd_parametric_drc_ffwd_init_drc_curve_params( WORD32 drc_characteristic, ia_parametric_drc_type_feed_forward_struct* str_parametric_drc_type_feed_forward) { WORD32* node_level = str_parametric_drc_type_feed_forward->node_level; WORD32* node_gain = str_parametric_drc_type_feed_forward->node_gain; switch (drc_characteristic) { case 7: str_parametric_drc_type_feed_forward->node_count = 5; node_level[0] = -22; node_gain[0] = 6; node_level[1] = -10; node_gain[1] = 0; node_level[2] = 10; node_gain[2] = 0; node_level[3] = 20; node_gain[3] = -5; node_level[4] = 40; node_gain[4] = -24; break; case 8: str_parametric_drc_type_feed_forward->node_count = 5; node_level[0] = -12; node_gain[0] = 6; node_level[1] = 0; node_gain[1] = 0; node_level[2] = 5; node_gain[2] = 0; node_level[3] = 15; node_gain[3] = -5; node_level[4] = 35; node_gain[4] = -24; break; case 9: str_parametric_drc_type_feed_forward->node_count = 4; node_level[0] = -34; node_gain[0] = 12; node_level[1] = -10; node_gain[1] = 0; node_level[2] = 10; node_gain[2] = 0; node_level[3] = 40; node_gain[3] = -15; break; case 10: str_parametric_drc_type_feed_forward->node_count = 5; node_level[0] = -24; node_gain[0] = 12; node_level[1] = 0; node_gain[1] = 0; node_level[2] = 5; node_gain[2] = 0; node_level[3] = 15; node_gain[3] = -5; node_level[4] = 35; node_gain[4] = -24; break; case 11: str_parametric_drc_type_feed_forward->node_count = 5; node_level[0] = -19; node_gain[0] = 15; node_level[1] = 0; node_gain[1] = 0; node_level[2] = 5; node_gain[2] = 0; node_level[3] = 15; node_gain[3] = -5; node_level[4] = 35; node_gain[4] = -24; break; default: str_parametric_drc_type_feed_forward->disable_paramteric_drc = 1; } return; } static VOID impd_parametric_drc_ffwd_init_drc_gain_smooth_params( WORD32 drc_characteristic, ia_parametric_drc_type_feed_forward_struct* str_parametric_drc_type_feed_forward) { str_parametric_drc_type_feed_forward->gain_smooth_attack_time_slow = 100; str_parametric_drc_type_feed_forward->gain_smooth_time_fast_present = 1; str_parametric_drc_type_feed_forward->gain_smooth_attack_time_fast = 10; str_parametric_drc_type_feed_forward->gain_smooth_threshold_present = 1; str_parametric_drc_type_feed_forward->gain_smooth_hold_off_count_present = 1; str_parametric_drc_type_feed_forward->gain_smooth_hold_off = 10; switch (drc_characteristic) { case 7: case 8: case 9: str_parametric_drc_type_feed_forward->gain_smooth_release_time_slow = 3000; str_parametric_drc_type_feed_forward->gain_smooth_release_time_fast = 1000; str_parametric_drc_type_feed_forward->gain_smooth_attack_threshold = 15; str_parametric_drc_type_feed_forward->gain_smooth_rel_threshold = 20; break; case 10: str_parametric_drc_type_feed_forward->gain_smooth_release_time_slow = 10000; str_parametric_drc_type_feed_forward->gain_smooth_release_time_fast = 1000; str_parametric_drc_type_feed_forward->gain_smooth_attack_threshold = 15; str_parametric_drc_type_feed_forward->gain_smooth_rel_threshold = 20; break; case 11: str_parametric_drc_type_feed_forward->gain_smooth_release_time_slow = 1000; str_parametric_drc_type_feed_forward->gain_smooth_release_time_fast = 200; str_parametric_drc_type_feed_forward->gain_smooth_attack_threshold = 10; str_parametric_drc_type_feed_forward->gain_smooth_rel_threshold = 10; break; default: str_parametric_drc_type_feed_forward->gain_smooth_release_time_slow = 3000; str_parametric_drc_type_feed_forward->gain_smooth_release_time_fast = 1000; str_parametric_drc_type_feed_forward->gain_smooth_attack_threshold = 15; str_parametric_drc_type_feed_forward->gain_smooth_rel_threshold = 20; break; } return; } static WORD32 impd_parse_parametric_drc_ffwd( ia_bit_buf_struct* it_bit_buff, WORD32 parametric_drc_frame_size, ia_parametric_drc_type_feed_forward_struct* str_parametric_drc_type_feed_forward) { WORD32 i = 0, tmp = 0; // WORD32 err = 0; str_parametric_drc_type_feed_forward->disable_paramteric_drc = 0; tmp = impd_read_bits_buf(it_bit_buff, 3); if (it_bit_buff->error) return it_bit_buff->error; str_parametric_drc_type_feed_forward->level_estim_k_weighting_type = (tmp >> 1) & 3; str_parametric_drc_type_feed_forward->level_estim_integration_time_present = tmp & 1; if (str_parametric_drc_type_feed_forward ->level_estim_integration_time_present) { tmp = impd_read_bits_buf(it_bit_buff, 6); if (it_bit_buff->error) return it_bit_buff->error; str_parametric_drc_type_feed_forward->level_estim_integration_time = (tmp + 1) * parametric_drc_frame_size; } else { str_parametric_drc_type_feed_forward->level_estim_integration_time = parametric_drc_frame_size; } str_parametric_drc_type_feed_forward->drc_curve_definition_type = impd_read_bits_buf(it_bit_buff, 1); if (it_bit_buff->error) return it_bit_buff->error; if (str_parametric_drc_type_feed_forward->drc_curve_definition_type == 0) { str_parametric_drc_type_feed_forward->drc_characteristic = impd_read_bits_buf(it_bit_buff, 7); if (it_bit_buff->error) return it_bit_buff->error; impd_parametric_drc_ffwd_init_drc_curve_params( str_parametric_drc_type_feed_forward->drc_characteristic, str_parametric_drc_type_feed_forward); } else { str_parametric_drc_type_feed_forward->drc_characteristic = 0; tmp = impd_read_bits_buf(it_bit_buff, 15); if (it_bit_buff->error) return it_bit_buff->error; str_parametric_drc_type_feed_forward->node_count = ((tmp >> 12) & 3) + 2; str_parametric_drc_type_feed_forward->node_level[0] = -11 - ((tmp >> 6) & 0x3f); str_parametric_drc_type_feed_forward->node_gain[0] = (tmp & 0x3f) - 39; for (i = 1; i < str_parametric_drc_type_feed_forward->node_count; i++) { tmp = impd_read_bits_buf(it_bit_buff, 11); if (it_bit_buff->error) return it_bit_buff->error; str_parametric_drc_type_feed_forward->node_level[i] = str_parametric_drc_type_feed_forward->node_level[i - 1] + 1 + ((tmp >> 6) & 0x1f); str_parametric_drc_type_feed_forward->node_gain[i] = (tmp & 0x3f) - 39; } } impd_parametric_drc_ffwd_init_drc_gain_smooth_params( str_parametric_drc_type_feed_forward->drc_characteristic, str_parametric_drc_type_feed_forward); str_parametric_drc_type_feed_forward->drc_gain_smooth_parameters_present = impd_read_bits_buf(it_bit_buff, 1); if (it_bit_buff->error) return it_bit_buff->error; if (str_parametric_drc_type_feed_forward ->drc_gain_smooth_parameters_present) { tmp = impd_read_bits_buf(it_bit_buff, 17); if (it_bit_buff->error) return it_bit_buff->error; str_parametric_drc_type_feed_forward->gain_smooth_attack_time_slow = ((tmp >> 9) & 0xff) * 5; str_parametric_drc_type_feed_forward->gain_smooth_release_time_slow = ((tmp >> 1) & 0xff) * 40; str_parametric_drc_type_feed_forward->gain_smooth_time_fast_present = tmp & 1; if (str_parametric_drc_type_feed_forward->gain_smooth_time_fast_present) { tmp = impd_read_bits_buf(it_bit_buff, 17); if (it_bit_buff->error) return it_bit_buff->error; str_parametric_drc_type_feed_forward->gain_smooth_attack_time_fast = ((tmp >> 9) & 0xff) * 5; str_parametric_drc_type_feed_forward->gain_smooth_release_time_fast = ((tmp >> 1) & 0xff) * 20; str_parametric_drc_type_feed_forward->gain_smooth_threshold_present = tmp & 1; if (str_parametric_drc_type_feed_forward->gain_smooth_threshold_present) { str_parametric_drc_type_feed_forward->gain_smooth_attack_threshold = impd_read_bits_buf(it_bit_buff, 5); if (it_bit_buff->error) return it_bit_buff->error; if (str_parametric_drc_type_feed_forward ->gain_smooth_attack_threshold == 31) { str_parametric_drc_type_feed_forward->gain_smooth_attack_threshold = 1000; } str_parametric_drc_type_feed_forward->gain_smooth_rel_threshold = impd_read_bits_buf(it_bit_buff, 5); if (it_bit_buff->error) return it_bit_buff->error; if (str_parametric_drc_type_feed_forward->gain_smooth_rel_threshold == 31) { str_parametric_drc_type_feed_forward->gain_smooth_rel_threshold = 1000; } } } else { str_parametric_drc_type_feed_forward->gain_smooth_attack_time_fast = str_parametric_drc_type_feed_forward->gain_smooth_attack_time_slow; str_parametric_drc_type_feed_forward->gain_smooth_release_time_fast = str_parametric_drc_type_feed_forward->gain_smooth_release_time_slow; } str_parametric_drc_type_feed_forward->gain_smooth_hold_off_count_present = impd_read_bits_buf(it_bit_buff, 1); if (it_bit_buff->error) return it_bit_buff->error; if (str_parametric_drc_type_feed_forward ->gain_smooth_hold_off_count_present) { str_parametric_drc_type_feed_forward->gain_smooth_hold_off = impd_read_bits_buf(it_bit_buff, 7); if (it_bit_buff->error) return it_bit_buff->error; } } return 0; } static WORD32 impd_parse_parametric_drc_lim( ia_bit_buf_struct* it_bit_buff, ia_parametric_drc_lim_struct* parametric_drc_lim) { // WORD32 err = 0; WORD32 tmp = 0; parametric_drc_lim->disable_paramteric_drc = 0; parametric_drc_lim->parametric_lim_threshold_present = impd_read_bits_buf(it_bit_buff, 1); if (it_bit_buff->error) return it_bit_buff->error; if (parametric_drc_lim->parametric_lim_threshold_present) { tmp = impd_read_bits_buf(it_bit_buff, 8); if (it_bit_buff->error) return it_bit_buff->error; parametric_drc_lim->parametric_lim_threshold = -tmp * 0.125f; } else { parametric_drc_lim->parametric_lim_threshold = PARAM_DRC_TYPE_LIM_THRESHOLD_DEFAULT; } parametric_drc_lim->parametric_lim_release_present = impd_read_bits_buf(it_bit_buff, 1); if (it_bit_buff->error) return it_bit_buff->error; if (parametric_drc_lim->parametric_lim_release_present) { tmp = impd_read_bits_buf(it_bit_buff, 8); if (it_bit_buff->error) return it_bit_buff->error; parametric_drc_lim->parametric_lim_release = tmp * 10; } else { parametric_drc_lim->parametric_lim_release = PARAM_DRC_TYPE_LIM_RELEASE_DEFAULT; } parametric_drc_lim->parametric_lim_attack = PARAM_DRC_TYPE_LIM_ATTACK_DEFAULT; parametric_drc_lim->drc_characteristic = 0; return 0; } WORD32 impd_parametric_drc_parse_gain_set_params( ia_bit_buf_struct* it_bit_buff, ia_drc_config* drc_config, ia_parametric_drc_gain_set_params_struct* str_parametric_drc_gain_set_params) { WORD32 i = 0, bsDrcInputLoudness = 0, bs_channel_weight = 0, temp; // WORD32 err = 0; temp = impd_read_bits_buf(it_bit_buff, 7); if (it_bit_buff->error) return it_bit_buff->error; str_parametric_drc_gain_set_params->parametric_drc_id = (temp >> 3) & 0xf; str_parametric_drc_gain_set_params->side_chain_config_type = temp & 7; if (str_parametric_drc_gain_set_params->side_chain_config_type) { temp = impd_read_bits_buf(it_bit_buff, 8); if (it_bit_buff->error) return it_bit_buff->error; str_parametric_drc_gain_set_params->downmix_id = (temp >> 1) & 0x7f; str_parametric_drc_gain_set_params->level_estim_channel_weight_format = temp & 1; if (str_parametric_drc_gain_set_params->downmix_id == ID_FOR_BASE_LAYOUT) { str_parametric_drc_gain_set_params->ch_count_from_dwnmix_id = drc_config->channel_layout.base_channel_count; } else if (str_parametric_drc_gain_set_params->downmix_id == ID_FOR_ANY_DOWNMIX) { str_parametric_drc_gain_set_params->ch_count_from_dwnmix_id = 1; } else { for (i = 0; i < drc_config->dwnmix_instructions_count; i++) { if (str_parametric_drc_gain_set_params->downmix_id == drc_config->dwnmix_instructions[i].downmix_id) break; } if (i == drc_config->dwnmix_instructions_count) { /* dwnmix_instructions not found */ return (UNEXPECTED_ERROR); } str_parametric_drc_gain_set_params->ch_count_from_dwnmix_id = drc_config->dwnmix_instructions[i].target_channel_count; } for (i = 0; i < str_parametric_drc_gain_set_params->ch_count_from_dwnmix_id; i++) { if (str_parametric_drc_gain_set_params ->level_estim_channel_weight_format == 0) { str_parametric_drc_gain_set_params->level_estim_ch_weight[i] = (FLOAT32)impd_read_bits_buf(it_bit_buff, 1); if (it_bit_buff->error) return it_bit_buff->error; } else { bs_channel_weight = impd_read_bits_buf(it_bit_buff, 4); if (it_bit_buff->error) return it_bit_buff->error; str_parametric_drc_gain_set_params->level_estim_ch_weight[i] = (FLOAT32)pow(10.0f, 0.05f * channel_weight[bs_channel_weight]); } } } else { str_parametric_drc_gain_set_params->downmix_id = 0; str_parametric_drc_gain_set_params->ch_count_from_dwnmix_id = 0; } str_parametric_drc_gain_set_params->drc_input_loudness_present = impd_read_bits_buf(it_bit_buff, 1); if (it_bit_buff->error) return it_bit_buff->error; if (str_parametric_drc_gain_set_params->drc_input_loudness_present) { bsDrcInputLoudness = impd_read_bits_buf(it_bit_buff, 8); if (it_bit_buff->error) return it_bit_buff->error; str_parametric_drc_gain_set_params->drc_input_loudness = -57.75f + bsDrcInputLoudness * 0.25f; } return 0; } static WORD32 impd_parametric_drc_gen_virtual_gain_sets( ia_drc_config* drc_config) { WORD32 i = 0, j = 0, c1 = -1, c0 = -1, parametric_drc_id = 0, drc_characteristic = 0; ia_uni_drc_coeffs_struct* str_p_loc_drc_coefficients_uni_drc; ia_parametric_drc_instructions_struct* str_parametric_drc_instructions; ia_drc_coeff_parametric_drc_struct* str_drc_coeff_param_drc = &(drc_config->str_drc_config_ext.str_drc_coeff_param_drc); for (i = 0; i < drc_config->drc_coefficients_drc_count; i++) { if (drc_config->str_p_loc_drc_coefficients_uni_drc[i].drc_location == str_drc_coeff_param_drc->drc_location) { if (drc_config->str_p_loc_drc_coefficients_uni_drc[i].version == 0) { c0 = i; } else { c1 = i; } } } if (c1 >= 0) { str_p_loc_drc_coefficients_uni_drc = &(drc_config->str_p_loc_drc_coefficients_uni_drc[c1]); } else if (c0 >= 0) { str_p_loc_drc_coefficients_uni_drc = &(drc_config->str_p_loc_drc_coefficients_uni_drc[c0]); } else { str_p_loc_drc_coefficients_uni_drc = &drc_config->str_p_loc_drc_coefficients_uni_drc [drc_config->drc_coefficients_drc_count]; str_p_loc_drc_coefficients_uni_drc->version = 1; str_p_loc_drc_coefficients_uni_drc->drc_location = str_drc_coeff_param_drc->drc_location; str_p_loc_drc_coefficients_uni_drc->drc_frame_size_present = 0; str_p_loc_drc_coefficients_uni_drc->gain_set_count = 0; str_p_loc_drc_coefficients_uni_drc->gain_set_count_plus = 0; str_p_loc_drc_coefficients_uni_drc->drc_characteristic_left_present = 0; str_p_loc_drc_coefficients_uni_drc->drc_characteristic_right_present = 0; str_p_loc_drc_coefficients_uni_drc->shape_filters_present = 0; str_p_loc_drc_coefficients_uni_drc->gain_sequence_count = 0; drc_config->drc_coefficients_drc_count += 1; } str_p_loc_drc_coefficients_uni_drc->gain_set_count_plus = str_p_loc_drc_coefficients_uni_drc->gain_set_count + str_drc_coeff_param_drc->parametric_drc_gain_set_count; for (i = str_p_loc_drc_coefficients_uni_drc->gain_set_count; i < str_p_loc_drc_coefficients_uni_drc->gain_set_count_plus; i++) { str_p_loc_drc_coefficients_uni_drc->gain_set_params[i].band_count = 1; parametric_drc_id = drc_config->str_drc_config_ext.str_drc_coeff_param_drc .str_parametric_drc_gain_set_params [i - str_p_loc_drc_coefficients_uni_drc->gain_set_count] .parametric_drc_id; for (j = 0; j < drc_config->str_drc_config_ext.parametric_drc_instructions_count; j++) { if (parametric_drc_id == drc_config->str_drc_config_ext.str_parametric_drc_instructions[j] .parametric_drc_id) break; } if (j == drc_config->str_drc_config_ext.parametric_drc_instructions_count) { /* str_parametric_drc_instructions not found */ return (UNEXPECTED_ERROR); } str_parametric_drc_instructions = &drc_config->str_drc_config_ext.str_parametric_drc_instructions[j]; drc_characteristic = 0; if (str_parametric_drc_instructions->parametric_drc_preset_id_present) { drc_characteristic = str_parametric_drc_instructions->drc_characteristic; } else if (str_parametric_drc_instructions->parametric_drc_type == PARAM_DRC_TYPE_FF) { if (str_parametric_drc_instructions->str_parametric_drc_type_feed_forward .drc_curve_definition_type == 0) { drc_characteristic = str_parametric_drc_instructions ->str_parametric_drc_type_feed_forward.drc_characteristic; } } if (drc_characteristic != 0) { str_p_loc_drc_coefficients_uni_drc->gain_set_params[i] .gain_params[0] .drc_characteristic_present = 1; str_p_loc_drc_coefficients_uni_drc->gain_set_params[i] .gain_params[0] .drc_characteristic_format_is_cicp = 1; str_p_loc_drc_coefficients_uni_drc->gain_set_params[i] .gain_params[0] .drc_characteristic = drc_characteristic; } else { str_p_loc_drc_coefficients_uni_drc->gain_set_params[i] .gain_params[0] .drc_characteristic_present = 0; str_p_loc_drc_coefficients_uni_drc->gain_set_params[i] .gain_params[0] .drc_characteristic_format_is_cicp = 0; str_p_loc_drc_coefficients_uni_drc->gain_set_params[i] .gain_params[0] .drc_characteristic = 0; } } return 0; } static WORD32 impd_parametic_drc_parse_coeff( ia_bit_buf_struct* it_bit_buff, ia_drc_config* drc_config, ia_drc_coeff_parametric_drc_struct* str_drc_coeff_param_drc) { WORD32 i = 0, err = 0, code = 0, mu = 0, nu = 0, temp; temp = impd_read_bits_buf(it_bit_buff, 5); if (it_bit_buff->error) return it_bit_buff->error; str_drc_coeff_param_drc->drc_location = (temp >> 1) & 0xf; str_drc_coeff_param_drc->parametric_drc_frame_size_format = temp & 1; if (str_drc_coeff_param_drc->parametric_drc_frame_size) { code = impd_read_bits_buf(it_bit_buff, 15); if (it_bit_buff->error) return it_bit_buff->error; str_drc_coeff_param_drc->parametric_drc_frame_size = code + 1; } else { code = impd_read_bits_buf(it_bit_buff, 4); if (it_bit_buff->error) return it_bit_buff->error; str_drc_coeff_param_drc->parametric_drc_frame_size = 1 << code; } str_drc_coeff_param_drc->parametric_drc_delay_max_present = impd_read_bits_buf(it_bit_buff, 1); if (str_drc_coeff_param_drc->parametric_drc_delay_max_present) { temp = impd_read_bits_buf(it_bit_buff, 8); if (it_bit_buff->error) return it_bit_buff->error; mu = (temp >> 3) & 0x1f; nu = temp & 3; str_drc_coeff_param_drc->parametric_drc_delay_max = 16 * mu * (1 << nu); } temp = impd_read_bits_buf(it_bit_buff, 7); if (it_bit_buff->error) return it_bit_buff->error; str_drc_coeff_param_drc->reset_parametric_drc = (temp >> 6) & 1; str_drc_coeff_param_drc->parametric_drc_gain_set_count = temp & 0x3f; for (i = 0; i < str_drc_coeff_param_drc->parametric_drc_gain_set_count; i++) { err = impd_parametric_drc_parse_gain_set_params( it_bit_buff, drc_config, &(str_drc_coeff_param_drc->str_parametric_drc_gain_set_params[i])); if (err) return (err); } return 0; } static WORD32 impd_parse_parametric_drc_instructions( ia_bit_buf_struct* it_bit_buff, WORD32 parametric_drc_frame_size, ia_parametric_drc_instructions_struct* str_parametric_drc_instructions) { WORD32 i = 0, err = 0, temp; WORD32 bit_size_len, bit_size, other_bit; str_parametric_drc_instructions->drc_characteristic = 0; str_parametric_drc_instructions->disable_paramteric_drc = 0; temp = impd_read_bits_buf(it_bit_buff, 5); if (it_bit_buff->error) return it_bit_buff->error; str_parametric_drc_instructions->parametric_drc_id = (temp >> 1) & 0xf; str_parametric_drc_instructions->parametric_drc_look_ahead_flag = temp & 1; if (str_parametric_drc_instructions->parametric_drc_look_ahead_flag) { str_parametric_drc_instructions->parametric_drc_look_ahead = impd_read_bits_buf(it_bit_buff, 7); if (it_bit_buff->error) return it_bit_buff->error; } else { str_parametric_drc_instructions->parametric_drc_look_ahead = 0; } str_parametric_drc_instructions->parametric_drc_preset_id_present = impd_read_bits_buf(it_bit_buff, 1); if (it_bit_buff->error) return it_bit_buff->error; if (str_parametric_drc_instructions->parametric_drc_preset_id_present) { str_parametric_drc_instructions->parametric_drc_preset_id = impd_read_bits_buf(it_bit_buff, 7); if (it_bit_buff->error) return it_bit_buff->error; switch (str_parametric_drc_instructions->parametric_drc_preset_id) { case 0: case 1: case 2: case 3: case 4: str_parametric_drc_instructions->drc_characteristic = str_parametric_drc_instructions->parametric_drc_preset_id + 7; str_parametric_drc_instructions->parametric_drc_type = PARAM_DRC_TYPE_FF; str_parametric_drc_instructions->str_parametric_drc_type_feed_forward .level_estim_k_weighting_type = 2; str_parametric_drc_instructions->str_parametric_drc_type_feed_forward .level_estim_integration_time = parametric_drc_frame_size; impd_parametric_drc_ffwd_init_drc_curve_params( str_parametric_drc_instructions->drc_characteristic, &str_parametric_drc_instructions ->str_parametric_drc_type_feed_forward); impd_parametric_drc_ffwd_init_drc_gain_smooth_params( str_parametric_drc_instructions->drc_characteristic, &str_parametric_drc_instructions ->str_parametric_drc_type_feed_forward); break; default: str_parametric_drc_instructions->disable_paramteric_drc = 1; break; } } else { str_parametric_drc_instructions->parametric_drc_type = impd_read_bits_buf(it_bit_buff, 3); if (it_bit_buff->error) return it_bit_buff->error; if (str_parametric_drc_instructions->parametric_drc_type == PARAM_DRC_TYPE_FF) { err = impd_parse_parametric_drc_ffwd( it_bit_buff, parametric_drc_frame_size, &(str_parametric_drc_instructions ->str_parametric_drc_type_feed_forward)); if (err) return (err); str_parametric_drc_instructions->disable_paramteric_drc = str_parametric_drc_instructions->str_parametric_drc_type_feed_forward .disable_paramteric_drc; str_parametric_drc_instructions->drc_characteristic = str_parametric_drc_instructions->str_parametric_drc_type_feed_forward .drc_characteristic; } else if (str_parametric_drc_instructions->parametric_drc_type == PARAM_DRC_TYPE_LIM) { err = impd_parse_parametric_drc_lim( it_bit_buff, &(str_parametric_drc_instructions->parametric_drc_lim)); if (err) return (err); str_parametric_drc_instructions->disable_paramteric_drc = str_parametric_drc_instructions->parametric_drc_lim .disable_paramteric_drc; str_parametric_drc_instructions->drc_characteristic = str_parametric_drc_instructions->parametric_drc_lim .drc_characteristic; if (str_parametric_drc_instructions->parametric_drc_look_ahead_flag) { str_parametric_drc_instructions->parametric_drc_lim .parametric_lim_attack = str_parametric_drc_instructions->parametric_drc_look_ahead; } } else { bit_size_len = impd_read_bits_buf(it_bit_buff, 3) + 4; if (it_bit_buff->error) return it_bit_buff->error; bit_size = impd_read_bits_buf(it_bit_buff, bit_size_len); if (it_bit_buff->error) return it_bit_buff->error; str_parametric_drc_instructions->len_bit_size = bit_size + 1; switch (str_parametric_drc_instructions->parametric_drc_type) { default: str_parametric_drc_instructions->disable_paramteric_drc = 1; for (i = 0; i < str_parametric_drc_instructions->len_bit_size; i++) { other_bit = impd_read_bits_buf(it_bit_buff, 1); if (it_bit_buff->error) return it_bit_buff->error; } break; } } } return 0; } WORD32 impd_parse_loud_info_set_ext_eq( ia_bit_buf_struct* it_bit_buff, ia_drc_loudness_info_set_struct* loudness_info_set) { WORD32 err, i, offset, version = 1, temp; WORD32 loudness_info_v1_album_cnt, loudness_info_v1_cnt; temp = impd_read_bits_buf(it_bit_buff, 12); if (it_bit_buff->error) return it_bit_buff->error; loudness_info_v1_album_cnt = (temp >> 6) & 0x3f; loudness_info_v1_cnt = temp & 0x3f; offset = loudness_info_set->loudness_info_album_count; loudness_info_set->loudness_info_album_count += loudness_info_v1_album_cnt; for (i = 0; i < loudness_info_v1_album_cnt; i++) { err = impd_parse_loudness_info( it_bit_buff, version, &loudness_info_set->str_loudness_info_album[i + offset]); if (err) return (err); } offset = loudness_info_set->loudness_info_count; loudness_info_set->loudness_info_count += loudness_info_v1_cnt; for (i = 0; i < loudness_info_v1_cnt; i++) { err = impd_parse_loudness_info( it_bit_buff, version, &loudness_info_set->loudness_info[i + offset]); if (err) return (err); } return (0); } WORD32 impd_parse_ch_layout(ia_bit_buf_struct* it_bit_buff, ia_drc_params_bs_dec_struct* ia_drc_params_struct, ia_channel_layout_struct* channel_layout) { // WORD32 err = 0; WORD32 i; channel_layout->base_channel_count = impd_read_bits_buf(it_bit_buff, 7); if (it_bit_buff->error) return it_bit_buff->error; if (ia_drc_params_struct->lfe_channel_map_count != -1 && channel_layout->base_channel_count != ia_drc_params_struct->lfe_channel_map_count) { return (UNEXPECTED_ERROR); } channel_layout->layout_signaling_present = impd_read_bits_buf(it_bit_buff, 1); if (it_bit_buff->error) return it_bit_buff->error; if (channel_layout->layout_signaling_present) { channel_layout->defined_layout = impd_read_bits_buf(it_bit_buff, 8); if (it_bit_buff->error) return it_bit_buff->error; if (channel_layout->defined_layout == 0) { for (i = 0; i < channel_layout->base_channel_count; i++) { channel_layout->speaker_position[i] = impd_read_bits_buf(it_bit_buff, 7); if (it_bit_buff->error) return it_bit_buff->error; if (channel_layout->speaker_position[i] == 3 || channel_layout->speaker_position[i] == 26) { ia_drc_params_struct->lfe_channel_map[i] = 1; } else { ia_drc_params_struct->lfe_channel_map[i] = 0; } } } } return (0); } WORD32 impd_parse_dwnmix_instructions( ia_bit_buf_struct* it_bit_buff, WORD32 version, ia_drc_params_bs_dec_struct* ia_drc_params_struct, ia_channel_layout_struct* channel_layout, ia_downmix_instructions_struct* dwnmix_instructions) { // WORD32 err = 0; WORD32 i, j, k, temp; temp = impd_read_bits_buf(it_bit_buff, 23); if (it_bit_buff->error) return it_bit_buff->error; dwnmix_instructions->downmix_id = (temp >> 16) & 0x7f; dwnmix_instructions->target_channel_count = (temp >> 9) & 0x7f; dwnmix_instructions->target_layout = (temp >> 1) & 0xff; dwnmix_instructions->downmix_coefficients_present = temp & 1; if (dwnmix_instructions->downmix_coefficients_present) { if (version == 0) { WORD32 dmix_coeff; k = 0; for (i = 0; i < dwnmix_instructions->target_channel_count; i++) { for (j = 0; j < channel_layout->base_channel_count; j++) { dmix_coeff = impd_read_bits_buf(it_bit_buff, 4); if (it_bit_buff->error) return it_bit_buff->error; if (ia_drc_params_struct->lfe_channel_map[j]) { dwnmix_instructions->downmix_coefficient[k] = (FLOAT32)pow(10.0f, 0.05f * dwnmix_coeff_lfe[dmix_coeff]); } else { dwnmix_instructions->downmix_coefficient[k] = (FLOAT32)pow(10.0f, 0.05f * dwnmix_coeff[dmix_coeff]); } k++; } } } else { WORD32 dmix_coeff_v1, bs_dmix_offset; FLOAT32 a, b, dmix_offset, sum; bs_dmix_offset = impd_read_bits_buf(it_bit_buff, 4); if (it_bit_buff->error) return it_bit_buff->error; k = 0; for (i = 0; i < dwnmix_instructions->target_channel_count; i++) { for (j = 0; j < channel_layout->base_channel_count; j++) { dmix_coeff_v1 = impd_read_bits_buf(it_bit_buff, 5); if (it_bit_buff->error) return it_bit_buff->error; dwnmix_instructions->downmix_coefficient[k] = dwnmix_coeff_v1[dmix_coeff_v1]; k++; } } switch (bs_dmix_offset) { case 0: dmix_offset = 0.0f; break; case 1: a = 20.0f * (FLOAT32)log10( (FLOAT32)dwnmix_instructions->target_channel_count / (FLOAT32)channel_layout->base_channel_count); dmix_offset = 0.5f * (FLOAT32)floor(0.5f + a); break; case 2: a = 20.0f * (FLOAT32)log10( (FLOAT32)dwnmix_instructions->target_channel_count / (FLOAT32)channel_layout->base_channel_count); dmix_offset = 0.5f * (FLOAT32)floor(0.5f + 2.0f * a); break; case 3: sum = 0.0f; for (k = 0; k < dwnmix_instructions->target_channel_count * channel_layout->base_channel_count; k++) { sum += (FLOAT32)pow( 10.0f, 0.1f * dwnmix_instructions->downmix_coefficient[k]); } b = 10.0f * (FLOAT32)log10(sum); dmix_offset = 0.5f * (FLOAT32)floor(0.5f + 2.0f * b); break; default: return (BITSTREAM_ERROR); break; } for (k = 0; k < dwnmix_instructions->target_channel_count * channel_layout->base_channel_count; k++) { dwnmix_instructions->downmix_coefficient[k] = (FLOAT32)pow( 10.0f, 0.05f * (dwnmix_instructions->downmix_coefficient[k] + dmix_offset)); } } } return (0); } VOID impd_drc_gen_instructions_for_drc_off(ia_drc_config* drc_config) { WORD32 i, k, s; ia_drc_instructions_struct* str_drc_instruction_str; s = -1; k = drc_config->drc_instructions_uni_drc_count; str_drc_instruction_str = &(drc_config->str_drc_instruction_str[k]); memset(str_drc_instruction_str, 0, sizeof(ia_drc_instructions_struct)); str_drc_instruction_str->drc_set_id = s; s--; str_drc_instruction_str->downmix_id[0] = ID_FOR_BASE_LAYOUT; str_drc_instruction_str->dwnmix_id_count = 1; str_drc_instruction_str->drc_apply_to_dwnmix = 0; str_drc_instruction_str->depends_on_drc_set_present = 0; str_drc_instruction_str->no_independent_use = 0; str_drc_instruction_str->gain_element_count = 0; for (i = 1; i < drc_config->dwnmix_instructions_count + 1; i++) { str_drc_instruction_str = &(drc_config->str_drc_instruction_str[k + i]); memset(str_drc_instruction_str, 0, sizeof(ia_drc_instructions_struct)); str_drc_instruction_str->drc_set_id = s; s--; str_drc_instruction_str->drc_set_complexity_level = 0; str_drc_instruction_str->requires_eq = 0; str_drc_instruction_str->downmix_id[0] = drc_config->dwnmix_instructions[i - 1].downmix_id; str_drc_instruction_str->dwnmix_id_count = 1; str_drc_instruction_str->drc_apply_to_dwnmix = 0; str_drc_instruction_str->depends_on_drc_set_present = 0; str_drc_instruction_str->no_independent_use = 0; str_drc_instruction_str->gain_element_count = 0; } drc_config->drc_instructions_count_plus = drc_config->drc_instructions_uni_drc_count + drc_config->dwnmix_instructions_count + 1; return; } WORD32 impd_parse_drc_config_ext(ia_bit_buf_struct* it_bit_buff, ia_drc_params_bs_dec_struct* ia_drc_params_struct, ia_drc_config* drc_config, ia_drc_config_ext* str_drc_config_ext) { WORD32 err = 0, i, k; WORD32 bit_size_len, ext_size_bits, bit_size, other_bit; k = 0; str_drc_config_ext->drc_config_ext_type[k] = impd_read_bits_buf(it_bit_buff, 4); if (it_bit_buff->error) return it_bit_buff->error; while (str_drc_config_ext->drc_config_ext_type[k] != UNIDRCCONFEXT_TERM) { bit_size_len = impd_read_bits_buf(it_bit_buff, 4); if (it_bit_buff->error) return it_bit_buff->error; ext_size_bits = bit_size_len + 4; bit_size = impd_read_bits_buf(it_bit_buff, ext_size_bits); if (it_bit_buff->error) return it_bit_buff->error; str_drc_config_ext->ext_bit_size[k] = bit_size + 1; switch (str_drc_config_ext->drc_config_ext_type[k]) { case UNIDRCCONFEXT_PARAM_DRC: str_drc_config_ext->parametric_drc_present = 1; err = impd_parametic_drc_parse_coeff( it_bit_buff, drc_config, &(str_drc_config_ext->str_drc_coeff_param_drc)); if (err) return (err); str_drc_config_ext->parametric_drc_instructions_count = impd_read_bits_buf(it_bit_buff, 4); if (it_bit_buff->error) return it_bit_buff->error; for (i = 0; i < str_drc_config_ext->parametric_drc_instructions_count; i++) { err = impd_parse_parametric_drc_instructions( it_bit_buff, str_drc_config_ext->str_drc_coeff_param_drc .parametric_drc_frame_size, &(str_drc_config_ext->str_parametric_drc_instructions[i])); if (err) return (err); } break; case UNIDRCCONFEXT_V1: str_drc_config_ext->drc_extension_v1_present = 1; err = impd_parse_drc_ext_v1(it_bit_buff, ia_drc_params_struct, drc_config, str_drc_config_ext); if (err) return (err); break; default: for (i = 0; i < str_drc_config_ext->ext_bit_size[k]; i++) { other_bit = impd_read_bits_buf(it_bit_buff, 1); if (it_bit_buff->error) return it_bit_buff->error; } break; } k++; str_drc_config_ext->drc_config_ext_type[k] = impd_read_bits_buf(it_bit_buff, 4); if (it_bit_buff->error) return it_bit_buff->error; } return (0); } static WORD32 impd_parse_split_drc_characteristic( ia_bit_buf_struct* it_bit_buff, const WORD32 side, ia_split_drc_characteristic_struct* split_drc_characteristic) { // WORD32 err = 0; WORD32 i, temp; split_drc_characteristic->characteristic_format = impd_read_bits_buf(it_bit_buff, 1); if (it_bit_buff->error) return it_bit_buff->error; if (split_drc_characteristic->characteristic_format == 0) { WORD32 bsGain, bsIoRatio, bsExp; bsGain = impd_read_bits_buf(it_bit_buff, 6); if (it_bit_buff->error) return it_bit_buff->error; if (side == LEFT_SIDE) { split_drc_characteristic->gain = (FLOAT32)bsGain; } else { split_drc_characteristic->gain = (FLOAT32)-bsGain; } temp = impd_read_bits_buf(it_bit_buff, 8); if (it_bit_buff->error) return it_bit_buff->error; bsIoRatio = (temp >> 4) & 0xf; bsExp = temp & 0xf; split_drc_characteristic->in_out_ratio = 0.05f + 0.15f * bsIoRatio; if (bsExp < 15) { split_drc_characteristic->exp = 1.0f + 2.0f * bsExp; } else { split_drc_characteristic->exp = 1000.0f; } split_drc_characteristic->flip_sign = impd_read_bits_buf(it_bit_buff, 1); if (it_bit_buff->error) return it_bit_buff->error; } else { WORD32 char_node_cnt, node_level_delta, node_gain; char_node_cnt = impd_read_bits_buf(it_bit_buff, 2); if (it_bit_buff->error) return it_bit_buff->error; split_drc_characteristic->characteristic_node_count = char_node_cnt + 1; split_drc_characteristic->node_level[0] = DRC_INPUT_LOUDNESS_TARGET; split_drc_characteristic->node_gain[0] = 0.0f; for (i = 1; i <= split_drc_characteristic->characteristic_node_count; i++) { node_level_delta = impd_read_bits_buf(it_bit_buff, 5); if (it_bit_buff->error) return it_bit_buff->error; if (side == LEFT_SIDE) { split_drc_characteristic->node_level[i] = split_drc_characteristic->node_level[i - 1] - (1.0f + node_level_delta); } else { split_drc_characteristic->node_level[i] = split_drc_characteristic->node_level[i - 1] + (1.0f + node_level_delta); } node_gain = impd_read_bits_buf(it_bit_buff, 8); if (it_bit_buff->error) return it_bit_buff->error; split_drc_characteristic->node_gain[i] = 0.5f * node_gain - 64.0f; } } return (0); } WORD32 impd_drc_gen_instructions_derived_data( ia_drc_config* drc_config, ia_drc_params_bs_dec_struct* ia_drc_params_struct, ia_drc_instructions_struct* str_drc_instruction_str) { WORD32 n, g; ia_uni_drc_coeffs_struct* str_p_loc_drc_coefficients_uni_drc = NULL; ia_drc_coeff_parametric_drc_struct* str_drc_coeff_param_drc = NULL; WORD32 gain_element_count = 0; for (n = 0; n < drc_config->drc_coefficients_drc_count; n++) { if (drc_config->str_p_loc_drc_coefficients_uni_drc[n].drc_location == str_drc_instruction_str->drc_location) break; } if ((n == drc_config->drc_coefficients_drc_count) && (drc_config->drc_coefficients_drc_count > 0)) { return -1; } str_p_loc_drc_coefficients_uni_drc = &(drc_config->str_p_loc_drc_coefficients_uni_drc[n]); if (drc_config->drc_config_ext_present && drc_config->str_drc_config_ext.parametric_drc_present && drc_config->str_drc_config_ext.str_drc_coeff_param_drc.drc_location == str_drc_instruction_str->drc_location) { str_drc_coeff_param_drc = &drc_config->str_drc_config_ext.str_drc_coeff_param_drc; } for (g = 0; g < str_drc_instruction_str->num_drc_ch_groups; g++) { WORD32 seq = str_drc_instruction_str->gain_set_index_for_channel_group[g]; if (seq != -1 && (drc_config->drc_coefficients_drc_count == 0 || seq >= str_p_loc_drc_coefficients_uni_drc->gain_set_count)) { str_drc_instruction_str->ch_group_parametric_drc_flag[g] = 1; if (drc_config->drc_coefficients_drc_count != 0) { seq = seq - str_p_loc_drc_coefficients_uni_drc->gain_set_count; } str_drc_instruction_str->gain_set_idx_of_ch_group_parametric_drc[g] = seq; if (str_drc_coeff_param_drc == NULL || seq >= str_drc_coeff_param_drc->parametric_drc_gain_set_count) { /* parametric drc gain set not available */ return (EXTERNAL_ERROR); } str_drc_instruction_str->gain_interpolation_type_for_channel_group[g] = 1; str_drc_instruction_str->time_delta_min_for_channel_group[g] = str_drc_coeff_param_drc->parametric_drc_frame_size; str_drc_instruction_str->time_alignment_for_channel_group[g] = 0; } else { str_drc_instruction_str->ch_group_parametric_drc_flag[g] = 0; } if (str_drc_instruction_str->ch_group_parametric_drc_flag[g] == 0) { if (seq >= str_p_loc_drc_coefficients_uni_drc->gain_set_count) { return -1; } str_drc_instruction_str->gain_interpolation_type_for_channel_group[g] = str_p_loc_drc_coefficients_uni_drc->gain_set_params[seq] .gain_interpolation_type; if (str_p_loc_drc_coefficients_uni_drc->gain_set_params[seq] .time_delt_min_flag) { str_drc_instruction_str->time_delta_min_for_channel_group[g] = str_p_loc_drc_coefficients_uni_drc->gain_set_params[seq] .time_delt_min_val; } else { str_drc_instruction_str->time_delta_min_for_channel_group[g] = ia_drc_params_struct->delta_tmin_default; } str_drc_instruction_str->time_alignment_for_channel_group[g] = str_p_loc_drc_coefficients_uni_drc->gain_set_params[seq] .time_alignment; } } if (str_drc_instruction_str->drc_set_effect & (EFFECT_BIT_DUCK_OTHER | EFFECT_BIT_DUCK_SELF)) { str_drc_instruction_str->gain_element_count = str_drc_instruction_str->num_drc_ch_groups; } else { for (g = 0; g < str_drc_instruction_str->num_drc_ch_groups; g++) { if (str_drc_instruction_str->ch_group_parametric_drc_flag[g] == 1) { gain_element_count++; str_drc_instruction_str->band_count_of_ch_group[g] = 1; } else { WORD32 seq, band_count; seq = str_drc_instruction_str->gain_set_index_for_channel_group[g]; band_count = str_p_loc_drc_coefficients_uni_drc->gain_set_params[seq].band_count; str_drc_instruction_str->band_count_of_ch_group[g] = band_count; gain_element_count += band_count; } } str_drc_instruction_str->gain_element_count = gain_element_count; } return (0); } WORD32 impd_parse_drc_config(ia_bit_buf_struct* it_bit_buff, ia_drc_params_bs_dec_struct* ia_drc_params_struct, ia_drc_config* drc_config) { WORD32 i, err = 0, temp; WORD32 version = 0; drc_config->sample_rate_present = impd_read_bits_buf(it_bit_buff, 1); if (it_bit_buff->error) return it_bit_buff->error; if (drc_config->sample_rate_present == 1) { WORD32 bssample_rate; bssample_rate = impd_read_bits_buf(it_bit_buff, 18); if (it_bit_buff->error) return it_bit_buff->error; drc_config->sampling_rate = bssample_rate + 1000; } temp = impd_read_bits_buf(it_bit_buff, 8); if (it_bit_buff->error) return it_bit_buff->error; drc_config->dwnmix_instructions_count = (temp >> 1) & 0x7f; drc_config->drc_description_basic_present = temp & 1; if (drc_config->drc_description_basic_present == 1) { temp = impd_read_bits_buf(it_bit_buff, 7); if (it_bit_buff->error) return it_bit_buff->error; drc_config->drc_coefficients_basic_count = (temp >> 4) & 7; drc_config->drc_instructions_basic_count = temp & 0xf; } else { drc_config->drc_coefficients_basic_count = 0; drc_config->drc_instructions_basic_count = 0; } temp = impd_read_bits_buf(it_bit_buff, 9); if (it_bit_buff->error) return it_bit_buff->error; drc_config->drc_coefficients_drc_count = (temp >> 6) & 7; drc_config->drc_instructions_uni_drc_count = temp & 0x3f; err = impd_parse_ch_layout(it_bit_buff, ia_drc_params_struct, &drc_config->channel_layout); if (err) return (err); for (i = 0; i < drc_config->dwnmix_instructions_count; i++) { err = impd_parse_dwnmix_instructions( it_bit_buff, version, ia_drc_params_struct, &drc_config->channel_layout, &(drc_config->dwnmix_instructions[i])); if (err) return (err); } for (i = 0; i < drc_config->drc_coefficients_basic_count; i++) { temp = impd_read_bits_buf(it_bit_buff, 11); if (it_bit_buff->error) return it_bit_buff->error; drc_config->str_drc_coefficients_basic[i].drc_location = (temp >> 7) & 0xf; drc_config->str_drc_coefficients_basic[i].drc_characteristic = temp & 0x3f; } for (i = 0; i < drc_config->drc_instructions_basic_count; i++) { err = impd_drc_parse_instructions_basic( it_bit_buff, &(drc_config->str_drc_instructions_basic[i])); if (err) return (err); } for (i = 0; i < drc_config->drc_coefficients_drc_count; i++) { err = impd_drc_parse_coeff( it_bit_buff, version, ia_drc_params_struct, &(drc_config->str_p_loc_drc_coefficients_uni_drc[i])); if (err) return (err); } for (i = 0; i < drc_config->drc_instructions_uni_drc_count; i++) { err = impd_parse_drc_instructions_uni_drc( it_bit_buff, version, drc_config, &(drc_config->str_drc_instruction_str[i])); if (err) return (err); } drc_config->drc_config_ext_present = impd_read_bits_buf(it_bit_buff, 1); if (it_bit_buff->error) return it_bit_buff->error; if (drc_config->drc_config_ext_present == 1) { err = impd_parse_drc_config_ext(it_bit_buff, ia_drc_params_struct, drc_config, &(drc_config->str_drc_config_ext)); if (err) return (err); } if (drc_config->str_drc_config_ext.parametric_drc_present) { err = impd_parametric_drc_gen_virtual_gain_sets(drc_config); if (err) return (err); } for (i = 0; i < drc_config->drc_instructions_uni_drc_count; i++) { err = impd_drc_gen_instructions_derived_data( drc_config, ia_drc_params_struct, &(drc_config->str_drc_instruction_str[i])); if (err) return (err); } impd_drc_gen_instructions_for_drc_off(drc_config); return (0); } WORD32 impd_dec_method_value(ia_bit_buf_struct* it_bit_buff, WORD32 method_def, FLOAT32* method_val) { // WORD32 err = 0; WORD32 tmp; FLOAT32 val; switch (method_def) { case METHOD_DEFINITION_UNKNOWN_OTHER: case METHOD_DEFINITION_PROGRAM_LOUDNESS: case METHOD_DEFINITION_ANCHOR_LOUDNESS: case METHOD_DEFINITION_MAX_OF_LOUDNESS_RANGE: case METHOD_DEFINITION_MOMENTARY_LOUDNESS_MAX: case METHOD_DEFINITION_SHORT_TERM_LOUDNESS_MAX: tmp = impd_read_bits_buf(it_bit_buff, 8); if (it_bit_buff->error) return it_bit_buff->error; val = -57.75f + tmp * 0.25f; break; case METHOD_DEFINITION_LOUDNESS_RANGE: tmp = impd_read_bits_buf(it_bit_buff, 8); if (it_bit_buff->error) return it_bit_buff->error; if (tmp == 0) val = 0.0f; else if (tmp <= 128) val = tmp * 0.25f; else if (tmp <= 204) val = 0.5f * tmp - 32.0f; else val = tmp - 134.0f; break; case METHOD_DEFINITION_MIXING_LEVEL: tmp = impd_read_bits_buf(it_bit_buff, 5); if (it_bit_buff->error) return it_bit_buff->error; val = tmp + 80.0f; break; case METHOD_DEFINITION_ROOM_TYPE: tmp = impd_read_bits_buf(it_bit_buff, 2); if (it_bit_buff->error) return it_bit_buff->error; val = (FLOAT32)tmp; break; case METHOD_DEFINITION_SHORT_TERM_LOUDNESS: tmp = impd_read_bits_buf(it_bit_buff, 8); if (it_bit_buff->error) return it_bit_buff->error; val = -116.f + tmp * 0.5f; break; default: return -1; break; } *method_val = val; return 0; } WORD32 impd_parse_loudness_info_set( ia_bit_buf_struct* it_bit_buff, ia_drc_loudness_info_set_struct* loudness_info_set) { WORD32 err = 0, i, version = 0, offset, temp; WORD32 loudness_info_album_count, loudness_info_count; temp = impd_read_bits_buf(it_bit_buff, 12); if (it_bit_buff->error) return it_bit_buff->error; loudness_info_album_count = (temp >> 6) & 0x3f; loudness_info_count = temp & 0x3f; offset = loudness_info_set->loudness_info_album_count; loudness_info_set->loudness_info_album_count += loudness_info_album_count; for (i = 0; i < loudness_info_set->loudness_info_album_count; i++) { err = impd_parse_loudness_info( it_bit_buff, version, &(loudness_info_set->str_loudness_info_album[i + offset])); if (err) return (err); } offset = loudness_info_set->loudness_info_count; loudness_info_set->loudness_info_count += loudness_info_count; for (i = 0; i < loudness_info_set->loudness_info_count; i++) { err = impd_parse_loudness_info( it_bit_buff, version, &(loudness_info_set->loudness_info[i + offset])); if (err) return (err); } loudness_info_set->loudness_info_set_ext_present = impd_read_bits_buf(it_bit_buff, 1); if (it_bit_buff->error) return it_bit_buff->error; if (loudness_info_set->loudness_info_set_ext_present == 1) { err = impd_parse_loudness_info_set_ext(it_bit_buff, loudness_info_set); if (err) return (err); } return (0); } WORD32 impd_parse_gain_set_params_characteristics(ia_bit_buf_struct* it_bit_buff, WORD32 version, ia_gain_params_struct* gain_params) { // WORD32 err = 0; WORD32 temp; if (version == 0) { gain_params->drc_characteristic = impd_read_bits_buf(it_bit_buff, 7); if (it_bit_buff->error) return it_bit_buff->error; if (gain_params->drc_characteristic > 0) { gain_params->drc_characteristic_present = 1; gain_params->drc_characteristic_format_is_cicp = 1; } else { gain_params->drc_characteristic_present = 0; } } else { gain_params->drc_characteristic_present = impd_read_bits_buf(it_bit_buff, 1); if (it_bit_buff->error) return it_bit_buff->error; if (gain_params->drc_characteristic_present) { gain_params->drc_characteristic_format_is_cicp = impd_read_bits_buf(it_bit_buff, 1); if (it_bit_buff->error) return it_bit_buff->error; if (gain_params->drc_characteristic_format_is_cicp) { gain_params->drc_characteristic = impd_read_bits_buf(it_bit_buff, 7); if (it_bit_buff->error) return it_bit_buff->error; } else { temp = impd_read_bits_buf(it_bit_buff, 8); if (it_bit_buff->error) return it_bit_buff->error; gain_params->drc_characteristic_left_index = (temp >> 4) & 0xf; gain_params->drc_characteristic_right_index = temp & 0xf; } } } return (0); } WORD32 impd_parse_loudness_measure(ia_bit_buf_struct* it_bit_buff, ia_loudness_measure_struct* loudness_measure) { WORD32 err = 0, temp; loudness_measure->method_def = impd_read_bits_buf(it_bit_buff, 4); if (it_bit_buff->error) return it_bit_buff->error; err = impd_dec_method_value(it_bit_buff, loudness_measure->method_def, &(loudness_measure->method_val)); if (err) return err; temp = impd_read_bits_buf(it_bit_buff, 6); if (it_bit_buff->error) return it_bit_buff->error; loudness_measure->measurement_system = (temp >> 2) & 0xf; loudness_measure->reliability = temp & 3; return (0); } WORD32 impd_dec_gain_modifiers(ia_bit_buf_struct* it_bit_buff, WORD32 version, WORD32 band_count, ia_gain_modifiers_struct* pstr_gain_modifiers) { // WORD32 err = 0; WORD32 sign, temp; if (version > 0) { WORD32 b; for (b = 0; b < band_count; b++) { pstr_gain_modifiers->target_characteristic_left_present[b] = impd_read_bits_buf(it_bit_buff, 1); if (it_bit_buff->error) return it_bit_buff->error; if (pstr_gain_modifiers->target_characteristic_left_present[b]) { pstr_gain_modifiers->target_characteristic_left_index[b] = impd_read_bits_buf(it_bit_buff, 4); if (it_bit_buff->error) return it_bit_buff->error; } pstr_gain_modifiers->target_characteristic_right_present[b] = impd_read_bits_buf(it_bit_buff, 1); if (it_bit_buff->error) return it_bit_buff->error; if (pstr_gain_modifiers->target_characteristic_right_present[b]) { pstr_gain_modifiers->target_characteristic_right_index[b] = impd_read_bits_buf(it_bit_buff, 4); if (it_bit_buff->error) return it_bit_buff->error; } pstr_gain_modifiers->gain_scaling_flag[b] = impd_read_bits_buf(it_bit_buff, 1); if (it_bit_buff->error) return it_bit_buff->error; if (pstr_gain_modifiers->gain_scaling_flag[b]) { temp = impd_read_bits_buf(it_bit_buff, 8); if (it_bit_buff->error) return it_bit_buff->error; pstr_gain_modifiers->attn_scaling[b] = ((temp >> 4) & 0xf) * 0.125f; pstr_gain_modifiers->ampl_scaling[b] = (temp & 0xf) * 0.125f; } pstr_gain_modifiers->gain_offset_flag[b] = impd_read_bits_buf(it_bit_buff, 1); if (it_bit_buff->error) return it_bit_buff->error; if (pstr_gain_modifiers->gain_offset_flag[b]) { FLOAT32 gain_offset; temp = impd_read_bits_buf(it_bit_buff, 6); if (it_bit_buff->error) return it_bit_buff->error; sign = ((temp >> 5) & 1); gain_offset = (1 + (temp & 0x1f)) * 0.25f; if (sign) { gain_offset = -gain_offset; } pstr_gain_modifiers->gain_offset[b] = gain_offset; } } if (band_count == 1) { pstr_gain_modifiers->shape_filter_flag = impd_read_bits_buf(it_bit_buff, 1); if (it_bit_buff->error) return it_bit_buff->error; if (pstr_gain_modifiers->shape_filter_flag) { pstr_gain_modifiers->shape_filter_idx = impd_read_bits_buf(it_bit_buff, 4); if (it_bit_buff->error) return it_bit_buff->error; } } } else if (version == 0) { WORD32 b, gain_scaling_flag, gain_offset_flag; FLOAT32 attn_scaling = 1.0f, ampl_scaling = 1.0f, gain_offset = 0.0f; gain_scaling_flag = impd_read_bits_buf(it_bit_buff, 1); if (it_bit_buff->error) return it_bit_buff->error; if (gain_scaling_flag) { temp = impd_read_bits_buf(it_bit_buff, 8); if (it_bit_buff->error) return it_bit_buff->error; attn_scaling = ((temp >> 4) & 0xf) * 0.125f; ampl_scaling = (temp & 0xf) * 0.125f; } gain_offset_flag = impd_read_bits_buf(it_bit_buff, 1); if (it_bit_buff->error) return it_bit_buff->error; if (gain_offset_flag) { temp = impd_read_bits_buf(it_bit_buff, 6); if (it_bit_buff->error) return it_bit_buff->error; sign = ((temp >> 5) & 1); gain_offset = (1 + (temp & 0x1f)) * 0.25f; if (sign) { gain_offset = -gain_offset; } } for (b = 0; b < band_count; b++) { pstr_gain_modifiers->target_characteristic_left_present[b] = 0; pstr_gain_modifiers->target_characteristic_right_present[b] = 0; pstr_gain_modifiers->gain_scaling_flag[b] = gain_scaling_flag; pstr_gain_modifiers->attn_scaling[b] = attn_scaling; pstr_gain_modifiers->ampl_scaling[b] = ampl_scaling; pstr_gain_modifiers->gain_offset_flag[b] = gain_offset_flag; pstr_gain_modifiers->gain_offset[b] = gain_offset; } pstr_gain_modifiers->shape_filter_flag = 0; } return (0); } WORD32 impd_parse_gain_set_params(ia_bit_buf_struct* it_bit_buff, WORD32 version, WORD32* gain_seq_idx, ia_gain_set_params_struct* gain_set_params) { WORD32 err = 0, i, temp; temp = impd_read_bits_buf(it_bit_buff, 6); if (it_bit_buff->error) return it_bit_buff->error; gain_set_params->gain_coding_profile = (temp >> 4) & 3; gain_set_params->gain_interpolation_type = (temp >> 3) & 1; gain_set_params->full_frame = (temp >> 2) & 1; gain_set_params->time_alignment = (temp >> 1) & 1; gain_set_params->time_delt_min_flag = temp & 1; if (gain_set_params->time_delt_min_flag) { WORD32 time_delta_min; time_delta_min = impd_read_bits_buf(it_bit_buff, 11); if (it_bit_buff->error) return it_bit_buff->error; gain_set_params->time_delt_min_val = time_delta_min + 1; } if (gain_set_params->gain_coding_profile == GAIN_CODING_PROFILE_CONSTANT) { gain_set_params->band_count = 1; *gain_seq_idx = (*gain_seq_idx) + 1; } else { gain_set_params->band_count = impd_read_bits_buf(it_bit_buff, 4); if (it_bit_buff->error) return it_bit_buff->error; if (gain_set_params->band_count > 1) { gain_set_params->drc_band_type = impd_read_bits_buf(it_bit_buff, 1); if (it_bit_buff->error) return it_bit_buff->error; } for (i = 0; i < gain_set_params->band_count; i++) { if (version == 0) { *gain_seq_idx = (*gain_seq_idx) + 1; } else { WORD32 indexPresent; indexPresent = impd_read_bits_buf(it_bit_buff, 1); if (it_bit_buff->error) return it_bit_buff->error; if (indexPresent) { WORD32 bsIndex; bsIndex = impd_read_bits_buf(it_bit_buff, 6); if (it_bit_buff->error) return it_bit_buff->error; *gain_seq_idx = bsIndex; } else { *gain_seq_idx = (*gain_seq_idx) + 1; } } gain_set_params->gain_params[i].gain_seq_idx = *gain_seq_idx; err = impd_parse_gain_set_params_characteristics( it_bit_buff, version, &(gain_set_params->gain_params[i])); if (err) return (err); } if (gain_set_params->drc_band_type) { for (i = 1; i < gain_set_params->band_count; i++) { gain_set_params->gain_params[i].crossover_freq_idx = impd_read_bits_buf(it_bit_buff, 4); if (it_bit_buff->error) return it_bit_buff->error; } } else { for (i = 1; i < gain_set_params->band_count; i++) { gain_set_params->gain_params[i].start_subband_index = impd_read_bits_buf(it_bit_buff, 10); if (it_bit_buff->error) return it_bit_buff->error; } } } return (0); } WORD32 impd_sel_drc_coeff( ia_drc_config* drc_config, WORD32 location, ia_uni_drc_coeffs_struct** str_p_loc_drc_coefficients_uni_drc) { WORD32 n; WORD32 c1 = -1; WORD32 c0 = -1; for (n = 0; n < drc_config->drc_coefficients_drc_count; n++) { if (drc_config->str_p_loc_drc_coefficients_uni_drc[n].drc_location == location) { if (drc_config->str_p_loc_drc_coefficients_uni_drc[n].version == 0) { c0 = n; } else { c1 = n; } } } if (c1 >= 0) { *str_p_loc_drc_coefficients_uni_drc = &(drc_config->str_p_loc_drc_coefficients_uni_drc[c1]); } else if (c0 >= 0) { *str_p_loc_drc_coefficients_uni_drc = &(drc_config->str_p_loc_drc_coefficients_uni_drc[c0]); } else { *str_p_loc_drc_coefficients_uni_drc = NULL; } return (0); } WORD32 impd_parse_loudness_info_set_ext( ia_bit_buf_struct* it_bit_buff, ia_drc_loudness_info_set_struct* loudness_info_set) { WORD32 err = 0, i, k; WORD32 bit_size_len, ext_size_bits, bit_size, other_bit; k = 0; loudness_info_set->str_loudness_info_set_ext.loudness_info_set_ext_type[k] = impd_read_bits_buf(it_bit_buff, 4); if (it_bit_buff->error) return it_bit_buff->error; while (loudness_info_set->str_loudness_info_set_ext .loudness_info_set_ext_type[k] != UNIDRCLOUDEXT_TERM) { bit_size_len = impd_read_bits_buf(it_bit_buff, 4); if (it_bit_buff->error) return it_bit_buff->error; ext_size_bits = bit_size_len + 4; bit_size = impd_read_bits_buf(it_bit_buff, ext_size_bits); if (it_bit_buff->error) return it_bit_buff->error; loudness_info_set->str_loudness_info_set_ext.ext_bit_size[k] = bit_size + 1; switch (loudness_info_set->str_loudness_info_set_ext .loudness_info_set_ext_type[k]) { case UNIDRCLOUDEXT_EQ: err = impd_parse_loud_info_set_ext_eq(it_bit_buff, loudness_info_set); if (err) return (err); break; default: for (i = 0; i < loudness_info_set->str_loudness_info_set_ext.ext_bit_size[k]; i++) { other_bit = impd_read_bits_buf(it_bit_buff, 1); if (it_bit_buff->error) return it_bit_buff->error; } break; } k++; loudness_info_set->str_loudness_info_set_ext.loudness_info_set_ext_type[k] = impd_read_bits_buf(it_bit_buff, 4); if (it_bit_buff->error) return it_bit_buff->error; } return (0); } WORD32 impd_drc_parse_coeff( ia_bit_buf_struct* it_bit_buff, WORD32 version, ia_drc_params_bs_dec_struct* ia_drc_params_struct, ia_uni_drc_coeffs_struct* str_p_loc_drc_coefficients_uni_drc) { WORD32 err = 0, i, drc_frame_size, temp; WORD32 gain_seq_idx = -1; str_p_loc_drc_coefficients_uni_drc->version = version; if (version == 0) { WORD32 gain_sequence_count = 0; temp = impd_read_bits_buf(it_bit_buff, 5); if (it_bit_buff->error) return it_bit_buff->error; str_p_loc_drc_coefficients_uni_drc->drc_location = (temp >> 1) & 0xf; str_p_loc_drc_coefficients_uni_drc->drc_frame_size_present = temp & 1; if (str_p_loc_drc_coefficients_uni_drc->drc_frame_size_present == 1) { drc_frame_size = impd_read_bits_buf(it_bit_buff, 15); if (it_bit_buff->error) return it_bit_buff->error; str_p_loc_drc_coefficients_uni_drc->drc_frame_size = drc_frame_size + 1; } str_p_loc_drc_coefficients_uni_drc->drc_characteristic_left_present = 0; str_p_loc_drc_coefficients_uni_drc->drc_characteristic_right_present = 0; str_p_loc_drc_coefficients_uni_drc->shape_filters_present = 0; str_p_loc_drc_coefficients_uni_drc->gain_set_count = impd_read_bits_buf(it_bit_buff, 6); if (it_bit_buff->error) return it_bit_buff->error; str_p_loc_drc_coefficients_uni_drc->gain_set_count_plus = str_p_loc_drc_coefficients_uni_drc->gain_set_count; for (i = 0; i < str_p_loc_drc_coefficients_uni_drc->gain_set_count; i++) { err = impd_parse_gain_set_params( it_bit_buff, version, &gain_seq_idx, &(str_p_loc_drc_coefficients_uni_drc->gain_set_params[i])); if (err) return (err); if (str_p_loc_drc_coefficients_uni_drc->gain_set_params[i] .time_delt_min_flag) { if (str_p_loc_drc_coefficients_uni_drc->gain_set_params[i] .time_delt_min_val > ia_drc_params_struct->drc_frame_size) { /* drc time interval too big */ return (PARAM_ERROR); } str_p_loc_drc_coefficients_uni_drc->gain_set_params[i] .num_gain_max_values = ia_drc_params_struct->drc_frame_size / str_p_loc_drc_coefficients_uni_drc->gain_set_params[i] .time_delt_min_val; err = impd_init_tbls( str_p_loc_drc_coefficients_uni_drc->gain_set_params[i] .num_gain_max_values, &(str_p_loc_drc_coefficients_uni_drc->gain_set_params[i] .str_tables)); if (err) return (err); } gain_sequence_count += str_p_loc_drc_coefficients_uni_drc->gain_set_params[i].band_count; } str_p_loc_drc_coefficients_uni_drc->gain_sequence_count = gain_sequence_count; } else { ia_shape_filter_block_params_struct* pstr_shape_filter_block_params; for (i = 0; i < SEQUENCE_COUNT_MAX; i++) { str_p_loc_drc_coefficients_uni_drc ->gain_set_params_index_for_gain_sequence[i] = -1; } temp = impd_read_bits_buf(it_bit_buff, 5); if (it_bit_buff->error) return it_bit_buff->error; str_p_loc_drc_coefficients_uni_drc->drc_location = (temp >> 1) & 0xf; str_p_loc_drc_coefficients_uni_drc->drc_frame_size_present = temp & 1; if (str_p_loc_drc_coefficients_uni_drc->drc_frame_size_present == 1) { drc_frame_size = impd_read_bits_buf(it_bit_buff, 15); if (it_bit_buff->error) return it_bit_buff->error; str_p_loc_drc_coefficients_uni_drc->drc_frame_size = drc_frame_size + 1; } str_p_loc_drc_coefficients_uni_drc->drc_characteristic_left_present = impd_read_bits_buf(it_bit_buff, 1); if (it_bit_buff->error) return it_bit_buff->error; if (str_p_loc_drc_coefficients_uni_drc->drc_characteristic_left_present == 1) { str_p_loc_drc_coefficients_uni_drc->characteristic_left_count = impd_read_bits_buf(it_bit_buff, 4); if (it_bit_buff->error) return it_bit_buff->error; for (i = 1; i <= str_p_loc_drc_coefficients_uni_drc->characteristic_left_count; i++) { err = impd_parse_split_drc_characteristic( it_bit_buff, LEFT_SIDE, &(str_p_loc_drc_coefficients_uni_drc ->str_split_characteristic_left[i])); if (err) return (err); } } str_p_loc_drc_coefficients_uni_drc->drc_characteristic_right_present = impd_read_bits_buf(it_bit_buff, 1); if (it_bit_buff->error) return it_bit_buff->error; if (str_p_loc_drc_coefficients_uni_drc->drc_characteristic_right_present == 1) { str_p_loc_drc_coefficients_uni_drc->characteristic_right_count = impd_read_bits_buf(it_bit_buff, 4); if (it_bit_buff->error) return it_bit_buff->error; for (i = 1; i <= str_p_loc_drc_coefficients_uni_drc->characteristic_right_count; i++) { err = impd_parse_split_drc_characteristic( it_bit_buff, RIGHT_SIDE, &(str_p_loc_drc_coefficients_uni_drc ->str_split_characteristic_right[i])); if (err) return (err); } } str_p_loc_drc_coefficients_uni_drc->shape_filters_present = impd_read_bits_buf(it_bit_buff, 1); if (it_bit_buff->error) return it_bit_buff->error; if (str_p_loc_drc_coefficients_uni_drc->shape_filters_present == 1) { str_p_loc_drc_coefficients_uni_drc->shape_num_filter = impd_read_bits_buf(it_bit_buff, 4); if (it_bit_buff->error) return it_bit_buff->error; for (i = 1; i <= str_p_loc_drc_coefficients_uni_drc->shape_num_filter; i++) { pstr_shape_filter_block_params = &(str_p_loc_drc_coefficients_uni_drc ->str_shape_filter_block_params[i]); pstr_shape_filter_block_params->lf_cut_filter_present = impd_read_bits_buf(it_bit_buff, 1); if (it_bit_buff->error) return it_bit_buff->error; if (pstr_shape_filter_block_params->lf_cut_filter_present == 1) { temp = impd_read_bits_buf(it_bit_buff, 5); if (it_bit_buff->error) return it_bit_buff->error; pstr_shape_filter_block_params->str_lf_cut_params.corner_freq_index = (temp >> 2) & 7; pstr_shape_filter_block_params->str_lf_cut_params .filter_strength_index = temp & 3; } pstr_shape_filter_block_params->lf_boost_filter_present = impd_read_bits_buf(it_bit_buff, 1); if (it_bit_buff->error) return it_bit_buff->error; if (pstr_shape_filter_block_params->lf_boost_filter_present == 1) { temp = impd_read_bits_buf(it_bit_buff, 5); if (it_bit_buff->error) return it_bit_buff->error; pstr_shape_filter_block_params->str_lf_boost_params .corner_freq_index = (temp >> 2) & 7; pstr_shape_filter_block_params->str_lf_boost_params .filter_strength_index = temp & 3; } pstr_shape_filter_block_params->hf_cut_filter_present = impd_read_bits_buf(it_bit_buff, 1); if (it_bit_buff->error) return it_bit_buff->error; if (pstr_shape_filter_block_params->hf_cut_filter_present == 1) { temp = impd_read_bits_buf(it_bit_buff, 5); if (it_bit_buff->error) return it_bit_buff->error; pstr_shape_filter_block_params->str_hfCutParams.corner_freq_index = (temp >> 2) & 7; pstr_shape_filter_block_params->str_hfCutParams .filter_strength_index = temp & 3; } pstr_shape_filter_block_params->hf_boost_filter_present = impd_read_bits_buf(it_bit_buff, 1); if (it_bit_buff->error) return it_bit_buff->error; if (pstr_shape_filter_block_params->hf_boost_filter_present == 1) { temp = impd_read_bits_buf(it_bit_buff, 5); if (it_bit_buff->error) return it_bit_buff->error; pstr_shape_filter_block_params->str_hf_boost_params .corner_freq_index = (temp >> 2) & 7; pstr_shape_filter_block_params->str_hf_boost_params .filter_strength_index = temp & 3; } } } temp = impd_read_bits_buf(it_bit_buff, 12); if (it_bit_buff->error) return it_bit_buff->error; str_p_loc_drc_coefficients_uni_drc->gain_sequence_count = (temp >> 6) & 0x3f; str_p_loc_drc_coefficients_uni_drc->gain_set_count = temp & 0x3f; str_p_loc_drc_coefficients_uni_drc->gain_set_count_plus = str_p_loc_drc_coefficients_uni_drc->gain_set_count; for (i = 0; i < str_p_loc_drc_coefficients_uni_drc->gain_set_count; i++) { err = impd_parse_gain_set_params( it_bit_buff, version, &gain_seq_idx, &(str_p_loc_drc_coefficients_uni_drc->gain_set_params[i])); if (err) return (err); if (str_p_loc_drc_coefficients_uni_drc->gain_set_params[i] .time_delt_min_flag) { if (str_p_loc_drc_coefficients_uni_drc->gain_set_params[i] .time_delt_min_val > ia_drc_params_struct->drc_frame_size) { /* drc time interval too big */ return (PARAM_ERROR); } str_p_loc_drc_coefficients_uni_drc->gain_set_params[i] .num_gain_max_values = ia_drc_params_struct->drc_frame_size / str_p_loc_drc_coefficients_uni_drc->gain_set_params[i] .time_delt_min_val; err = impd_init_tbls( str_p_loc_drc_coefficients_uni_drc->gain_set_params[i] .num_gain_max_values, &(str_p_loc_drc_coefficients_uni_drc->gain_set_params[i] .str_tables)); if (err) return (err); } } for (i = 0; i < str_p_loc_drc_coefficients_uni_drc->gain_set_count; i++) { WORD32 b; for (b = 0; b < str_p_loc_drc_coefficients_uni_drc->gain_set_params[i].band_count; b++) { str_p_loc_drc_coefficients_uni_drc ->gain_set_params_index_for_gain_sequence [str_p_loc_drc_coefficients_uni_drc->gain_set_params[i] .gain_params[b] .gain_seq_idx] = i; } } } return (0); } WORD32 impd_drc_parse_instructions_basic( ia_bit_buf_struct* it_bit_buff, ia_drc_instructions_basic_struct* str_drc_instructions_basic) { // WORD32 err = 0; WORD32 i, limiter_peak_target, temp; WORD32 additional_dmix_id_present, additional_dmix_id_cnt; temp = impd_read_bits_buf(it_bit_buff, 18); if (it_bit_buff->error) return it_bit_buff->error; str_drc_instructions_basic->drc_set_id = (temp >> 12) & 0x3f; str_drc_instructions_basic->drc_location = (temp >> 8) & 0xf; str_drc_instructions_basic->downmix_id[0] = (temp >> 1) & 0x7f; additional_dmix_id_present = temp & 1; str_drc_instructions_basic->dwnmix_id_count = 1; if (additional_dmix_id_present) { additional_dmix_id_cnt = impd_read_bits_buf(it_bit_buff, 3); if (it_bit_buff->error) return it_bit_buff->error; for (i = 0; i < additional_dmix_id_cnt; i++) { str_drc_instructions_basic->downmix_id[i + 1] = impd_read_bits_buf(it_bit_buff, 7); if (it_bit_buff->error) return it_bit_buff->error; } str_drc_instructions_basic->dwnmix_id_count = 1 + additional_dmix_id_cnt; } str_drc_instructions_basic->drc_set_effect = impd_read_bits_buf(it_bit_buff, 16); if (it_bit_buff->error) return it_bit_buff->error; if ((str_drc_instructions_basic->drc_set_effect & (EFFECT_BIT_DUCK_OTHER | EFFECT_BIT_DUCK_SELF)) == 0) { str_drc_instructions_basic->limiter_peak_target_present = impd_read_bits_buf(it_bit_buff, 1); if (it_bit_buff->error) return it_bit_buff->error; if (str_drc_instructions_basic->limiter_peak_target_present) { limiter_peak_target = impd_read_bits_buf(it_bit_buff, 8); if (it_bit_buff->error) return it_bit_buff->error; str_drc_instructions_basic->limiter_peak_target = -limiter_peak_target * 0.125f; } } str_drc_instructions_basic->drc_set_target_loudness_present = impd_read_bits_buf(it_bit_buff, 1); if (it_bit_buff->error) return it_bit_buff->error; str_drc_instructions_basic->drc_set_target_loudness_value_upper = 0; str_drc_instructions_basic->drc_set_target_loudness_value_lower = -63; if (str_drc_instructions_basic->drc_set_target_loudness_present == 1) { WORD32 bsDrcSetTargetLoudnessValueUpper, bsDrcSetTargetLoudnessValueLower; bsDrcSetTargetLoudnessValueUpper = impd_read_bits_buf(it_bit_buff, 6); if (it_bit_buff->error) return it_bit_buff->error; str_drc_instructions_basic->drc_set_target_loudness_value_upper = bsDrcSetTargetLoudnessValueUpper - 63; str_drc_instructions_basic->drc_set_target_loudness_value_lower_present = impd_read_bits_buf(it_bit_buff, 1); if (it_bit_buff->error) return it_bit_buff->error; if (str_drc_instructions_basic ->drc_set_target_loudness_value_lower_present == 1) { bsDrcSetTargetLoudnessValueLower = impd_read_bits_buf(it_bit_buff, 6); if (it_bit_buff->error) return it_bit_buff->error; str_drc_instructions_basic->drc_set_target_loudness_value_lower = bsDrcSetTargetLoudnessValueLower - 63; } } return (0); } WORD32 impd_dec_ducking_scaling(ia_bit_buf_struct* it_bit_buff, WORD32* ducking_scaling_flag, FLOAT32* p_ducking_scaling) { WORD32 ducking_scaling_present, ducking_scaling, sigma, mu; ducking_scaling_present = impd_read_bits_buf(it_bit_buff, 1); if (it_bit_buff->error) return it_bit_buff->error; if (ducking_scaling_present == 0) { *ducking_scaling_flag = 0; *p_ducking_scaling = 1.0f; } else { *ducking_scaling_flag = 1; ducking_scaling = impd_read_bits_buf(it_bit_buff, 4); if (it_bit_buff->error) return it_bit_buff->error; sigma = ducking_scaling >> 3; mu = ducking_scaling & 0x7; if (sigma == 0) { *p_ducking_scaling = 1.0f + 0.125f * (1.0f + mu); } else { *p_ducking_scaling = 1.0f - 0.125f * (1.0f + mu); } } return (0); } WORD32 impd_parse_drc_instructions_uni_drc( ia_bit_buf_struct* it_bit_buff, WORD32 version, ia_drc_config* drc_config, ia_drc_instructions_struct* str_drc_instruction_str) { WORD32 err = 0, i, n, k, g, c, limiter_peak_target, idx; WORD32 additional_dmix_id_present, additional_dmix_id_cnt; ia_uni_drc_coeffs_struct* str_p_loc_drc_coefficients_uni_drc = NULL; WORD32 ch_cnt; WORD32 unique_idx[MAX_CHANNEL_COUNT]; FLOAT32 unique_scaling[MAX_CHANNEL_COUNT]; WORD32 match; WORD32 dmix_id_present; WORD32 repeat_parameters, repeat_parameters_cnt; WORD32 ducking_sequence; FLOAT32 factor; str_drc_instruction_str->drc_set_id = impd_read_bits_buf(it_bit_buff, 6); if (it_bit_buff->error) return it_bit_buff->error; if (version == 0) { str_drc_instruction_str->drc_set_complexity_level = DRC_COMPLEXITY_LEVEL_MAX; } else { str_drc_instruction_str->drc_set_complexity_level = impd_read_bits_buf(it_bit_buff, 4); if (it_bit_buff->error) return it_bit_buff->error; } str_drc_instruction_str->drc_location = impd_read_bits_buf(it_bit_buff, 4); if (it_bit_buff->error) return it_bit_buff->error; dmix_id_present = 1; if (version >= 1) { dmix_id_present = impd_read_bits_buf(it_bit_buff, 1); if (it_bit_buff->error) return it_bit_buff->error; } if (dmix_id_present == 1) { str_drc_instruction_str->downmix_id[0] = impd_read_bits_buf(it_bit_buff, 7); if (it_bit_buff->error) return it_bit_buff->error; if (version >= 1) { str_drc_instruction_str->drc_apply_to_dwnmix = impd_read_bits_buf(it_bit_buff, 1); if (it_bit_buff->error) return it_bit_buff->error; } if (version == 0) { if (str_drc_instruction_str->downmix_id[0] == 0) { str_drc_instruction_str->drc_apply_to_dwnmix = 0; } else { str_drc_instruction_str->drc_apply_to_dwnmix = 1; } } additional_dmix_id_present = impd_read_bits_buf(it_bit_buff, 1); if (it_bit_buff->error) return it_bit_buff->error; if (additional_dmix_id_present) { additional_dmix_id_cnt = impd_read_bits_buf(it_bit_buff, 3); if (it_bit_buff->error) return it_bit_buff->error; for (i = 0; i < additional_dmix_id_cnt; i++) { str_drc_instruction_str->downmix_id[i + 1] = impd_read_bits_buf(it_bit_buff, 7); if (it_bit_buff->error) return it_bit_buff->error; } str_drc_instruction_str->dwnmix_id_count = 1 + additional_dmix_id_cnt; } else { str_drc_instruction_str->dwnmix_id_count = 1; } } else { str_drc_instruction_str->downmix_id[0] = 0; str_drc_instruction_str->dwnmix_id_count = 1; } str_drc_instruction_str->drc_set_effect = impd_read_bits_buf(it_bit_buff, 16); if (it_bit_buff->error) return it_bit_buff->error; if ((str_drc_instruction_str->drc_set_effect & (EFFECT_BIT_DUCK_OTHER | EFFECT_BIT_DUCK_SELF)) == 0) { str_drc_instruction_str->limiter_peak_target_present = impd_read_bits_buf(it_bit_buff, 1); if (it_bit_buff->error) return it_bit_buff->error; if (str_drc_instruction_str->limiter_peak_target_present) { limiter_peak_target = impd_read_bits_buf(it_bit_buff, 8); if (it_bit_buff->error) return it_bit_buff->error; str_drc_instruction_str->limiter_peak_target = -limiter_peak_target * 0.125f; } } str_drc_instruction_str->drc_set_target_loudness_present = impd_read_bits_buf(it_bit_buff, 1); if (it_bit_buff->error) return it_bit_buff->error; str_drc_instruction_str->drc_set_target_loudness_value_upper = 0; str_drc_instruction_str->drc_set_target_loudness_value_lower = -63; if (str_drc_instruction_str->drc_set_target_loudness_present == 1) { WORD32 bsDrcSetTargetLoudnessValueUpper, bsDrcSetTargetLoudnessValueLower; bsDrcSetTargetLoudnessValueUpper = impd_read_bits_buf(it_bit_buff, 6); if (it_bit_buff->error) return it_bit_buff->error; str_drc_instruction_str->drc_set_target_loudness_value_upper = bsDrcSetTargetLoudnessValueUpper - 63; str_drc_instruction_str->drc_set_target_loudness_value_lower_present = impd_read_bits_buf(it_bit_buff, 1); if (it_bit_buff->error) return it_bit_buff->error; if (str_drc_instruction_str->drc_set_target_loudness_value_lower_present == 1) { bsDrcSetTargetLoudnessValueLower = impd_read_bits_buf(it_bit_buff, 6); if (it_bit_buff->error) return it_bit_buff->error; str_drc_instruction_str->drc_set_target_loudness_value_lower = bsDrcSetTargetLoudnessValueLower - 63; } } str_drc_instruction_str->depends_on_drc_set_present = impd_read_bits_buf(it_bit_buff, 1); if (it_bit_buff->error) return it_bit_buff->error; str_drc_instruction_str->no_independent_use = 0; if (str_drc_instruction_str->depends_on_drc_set_present) { str_drc_instruction_str->depends_on_drc_set = impd_read_bits_buf(it_bit_buff, 6); if (it_bit_buff->error) return it_bit_buff->error; } else { str_drc_instruction_str->no_independent_use = impd_read_bits_buf(it_bit_buff, 1); if (it_bit_buff->error) return it_bit_buff->error; } if (version == 0) { str_drc_instruction_str->requires_eq = 0; } else { str_drc_instruction_str->requires_eq = impd_read_bits_buf(it_bit_buff, 1); if (it_bit_buff->error) return it_bit_buff->error; } err = impd_sel_drc_coeff(drc_config, str_drc_instruction_str->drc_location, &str_p_loc_drc_coefficients_uni_drc); if (err) return (err); ch_cnt = drc_config->channel_layout.base_channel_count; for (c = 0; c < MAX_CHANNEL_COUNT; c++) { unique_idx[c] = -10; unique_scaling[c] = -10.0f; } if (str_drc_instruction_str->drc_set_effect & (EFFECT_BIT_DUCK_OTHER | EFFECT_BIT_DUCK_SELF)) { c = 0; while (c < ch_cnt) { WORD32 bs_gain_set_idx; bs_gain_set_idx = impd_read_bits_buf(it_bit_buff, 6); if (it_bit_buff->error) return it_bit_buff->error; str_drc_instruction_str->gain_set_index[c] = bs_gain_set_idx - 1; impd_dec_ducking_scaling( it_bit_buff, &(str_drc_instruction_str->str_ducking_modifiers_for_channel[c] .ducking_scaling_flag), &(str_drc_instruction_str->str_ducking_modifiers_for_channel[c] .ducking_scaling)); c++; repeat_parameters = impd_read_bits_buf(it_bit_buff, 1); if (it_bit_buff->error) return it_bit_buff->error; if (repeat_parameters == 1) { repeat_parameters_cnt = impd_read_bits_buf(it_bit_buff, 5); if (it_bit_buff->error) return it_bit_buff->error; repeat_parameters_cnt += 1; for (k = 0; k < repeat_parameters_cnt; k++) { str_drc_instruction_str->gain_set_index[c] = str_drc_instruction_str->gain_set_index[c - 1]; str_drc_instruction_str->str_ducking_modifiers_for_channel[c] .ducking_scaling_flag = str_drc_instruction_str->str_ducking_modifiers_for_channel[c - 1] .ducking_scaling_flag; str_drc_instruction_str->str_ducking_modifiers_for_channel[c] .ducking_scaling = str_drc_instruction_str->str_ducking_modifiers_for_channel[c - 1] .ducking_scaling; c++; } } } if (c > ch_cnt) { return (UNEXPECTED_ERROR); } ducking_sequence = -1; g = 0; if (str_drc_instruction_str->drc_set_effect & EFFECT_BIT_DUCK_OTHER) { for (c = 0; c < ch_cnt; c++) { match = 0; idx = str_drc_instruction_str->gain_set_index[c]; factor = str_drc_instruction_str->str_ducking_modifiers_for_channel[c] .ducking_scaling; if (idx < 0) { for (n = 0; n < g; n++) { if (unique_scaling[n] == factor) { match = 1; str_drc_instruction_str->channel_group_of_ch[c] = n; break; } } if (match == 0) { unique_idx[g] = idx; unique_scaling[g] = factor; str_drc_instruction_str->channel_group_of_ch[c] = g; g++; } } else { if ((ducking_sequence > 0) && (ducking_sequence != idx)) { /* drc for ducking can have only one ducking sequence */ return (UNEXPECTED_ERROR); } ducking_sequence = idx; str_drc_instruction_str->channel_group_of_ch[c] = -1; } } str_drc_instruction_str->num_drc_ch_groups = g; if (ducking_sequence == -1) { /* ducking sequence not found */ return (UNEXPECTED_ERROR); } } else if (str_drc_instruction_str->drc_set_effect & EFFECT_BIT_DUCK_SELF) { for (c = 0; c < ch_cnt; c++) { match = 0; idx = str_drc_instruction_str->gain_set_index[c]; factor = str_drc_instruction_str->str_ducking_modifiers_for_channel[c] .ducking_scaling; if (idx >= 0) { for (n = 0; n < g; n++) { if ((unique_idx[n] == idx) && (unique_scaling[n] == factor)) { match = 1; str_drc_instruction_str->channel_group_of_ch[c] = n; break; } } if (match == 0) { unique_idx[g] = idx; unique_scaling[g] = factor; str_drc_instruction_str->channel_group_of_ch[c] = g; g++; } } else { str_drc_instruction_str->channel_group_of_ch[c] = -1; } } str_drc_instruction_str->num_drc_ch_groups = g; } for (g = 0; g < str_drc_instruction_str->num_drc_ch_groups; g++) { WORD32 set = (str_drc_instruction_str->drc_set_effect & EFFECT_BIT_DUCK_OTHER) ? ducking_sequence : unique_idx[g]; str_drc_instruction_str->gain_set_index_for_channel_group[g] = set; str_drc_instruction_str->str_ducking_modifiers_for_channel_group[g] .ducking_scaling = unique_scaling[g]; if (unique_scaling[g] != 1.0f) { str_drc_instruction_str->str_ducking_modifiers_for_channel_group[g] .ducking_scaling_flag = 1; } else { str_drc_instruction_str->str_ducking_modifiers_for_channel_group[g] .ducking_scaling_flag = 0; } str_drc_instruction_str->band_count_of_ch_group[g] = 1; } } else { if (((version == 0) || (str_drc_instruction_str->drc_apply_to_dwnmix != 0)) && (str_drc_instruction_str->downmix_id[0] != 0) && (str_drc_instruction_str->downmix_id[0] != ID_FOR_ANY_DOWNMIX) && (str_drc_instruction_str->dwnmix_id_count == 1)) { for (i = 0; i < drc_config->dwnmix_instructions_count; i++) { if (str_drc_instruction_str->downmix_id[0] == drc_config->dwnmix_instructions[i].downmix_id) break; } if (i == drc_config->dwnmix_instructions_count) { /* dwnmix_instructions not found */ return (UNEXPECTED_ERROR); } ch_cnt = drc_config->dwnmix_instructions[i].target_channel_count; } else if (((version == 0) || (str_drc_instruction_str->drc_apply_to_dwnmix != 0)) && ((str_drc_instruction_str->downmix_id[0] == ID_FOR_ANY_DOWNMIX) || (str_drc_instruction_str->dwnmix_id_count > 1))) { ch_cnt = 1; } c = 0; while (c < ch_cnt) { WORD32 bs_gain_set_idx; WORD32 repeat_gain_set_idx, repeat_gain_set_idx_cnt, temp; temp = impd_read_bits_buf(it_bit_buff, 7); if (it_bit_buff->error) return it_bit_buff->error; bs_gain_set_idx = (temp >> 1) & 0x7f; repeat_gain_set_idx = temp & 1; str_drc_instruction_str->gain_set_index[c] = bs_gain_set_idx - 1; c++; if (repeat_gain_set_idx == 1) { repeat_gain_set_idx_cnt = impd_read_bits_buf(it_bit_buff, 5); if (it_bit_buff->error) return it_bit_buff->error; repeat_gain_set_idx_cnt += 1; for (k = 0; k < repeat_gain_set_idx_cnt; k++) { str_drc_instruction_str->gain_set_index[c] = bs_gain_set_idx - 1; c++; } } } if (c > ch_cnt) { return (UNEXPECTED_ERROR); } g = 0; if ((str_drc_instruction_str->downmix_id[0] == ID_FOR_ANY_DOWNMIX) || (str_drc_instruction_str->dwnmix_id_count > 1)) { WORD32 idx = str_drc_instruction_str->gain_set_index[0]; if (idx >= 0) { unique_idx[0] = idx; g = 1; } } else { for (c = 0; c < ch_cnt; c++) { WORD32 idx = str_drc_instruction_str->gain_set_index[c]; match = 0; if (idx >= 0) { for (n = 0; n < g; n++) { if (unique_idx[n] == idx) { match = 1; str_drc_instruction_str->channel_group_of_ch[c] = n; break; } } if (match == 0) { unique_idx[g] = idx; str_drc_instruction_str->channel_group_of_ch[c] = g; g++; } } else { str_drc_instruction_str->channel_group_of_ch[c] = -1; } } } str_drc_instruction_str->num_drc_ch_groups = g; for (g = 0; g < str_drc_instruction_str->num_drc_ch_groups; g++) { WORD32 set, band_count; set = unique_idx[g]; str_drc_instruction_str->gain_set_index_for_channel_group[g] = set; if (str_p_loc_drc_coefficients_uni_drc != NULL && set < str_p_loc_drc_coefficients_uni_drc->gain_set_count) { band_count = str_p_loc_drc_coefficients_uni_drc->gain_set_params[set].band_count; } else { band_count = 1; } err = impd_dec_gain_modifiers( it_bit_buff, version, band_count, &(str_drc_instruction_str->str_gain_modifiers_of_ch_group[g])); if (err) return (err); } } return (0); } WORD32 impd_parse_loudness_info(ia_bit_buf_struct* it_bit_buff, WORD32 version, ia_loudness_info_struct* loudness_info) { WORD32 err = 0, sample_peak_level, true_peak_level, i, temp; loudness_info->drc_set_id = impd_read_bits_buf(it_bit_buff, 6); if (it_bit_buff->error) return it_bit_buff->error; if (version >= 1) { loudness_info->eq_set_id = impd_read_bits_buf(it_bit_buff, 6); if (it_bit_buff->error) return it_bit_buff->error; } else { loudness_info->eq_set_id = 0; } temp = impd_read_bits_buf(it_bit_buff, 8); if (it_bit_buff->error) return it_bit_buff->error; loudness_info->downmix_id = (temp >> 1) & 0x7f; loudness_info->sample_peak_level_present = temp & 1; if (loudness_info->sample_peak_level_present) { sample_peak_level = impd_read_bits_buf(it_bit_buff, 12); if (it_bit_buff->error) return it_bit_buff->error; if (sample_peak_level == 0) { loudness_info->sample_peak_level_present = 0; loudness_info->sample_peak_level = 0.0f; } else { loudness_info->sample_peak_level = 20.0f - sample_peak_level * 0.03125f; } } loudness_info->true_peak_level_present = impd_read_bits_buf(it_bit_buff, 1); if (it_bit_buff->error) return it_bit_buff->error; if (loudness_info->true_peak_level_present) { true_peak_level = impd_read_bits_buf(it_bit_buff, 12); if (it_bit_buff->error) return it_bit_buff->error; if (true_peak_level == 0) { loudness_info->true_peak_level_present = 0; loudness_info->true_peak_level = 0.0f; } else { loudness_info->true_peak_level = 20.0f - true_peak_level * 0.03125f; } temp = impd_read_bits_buf(it_bit_buff, 6); if (it_bit_buff->error) return it_bit_buff->error; loudness_info->true_peak_level_measurement_system = (temp >> 2) & 0xf; loudness_info->true_peak_level_reliability = temp & 3; } loudness_info->measurement_count = impd_read_bits_buf(it_bit_buff, 4); if (it_bit_buff->error) return it_bit_buff->error; for (i = 0; i < loudness_info->measurement_count; i++) { err = impd_parse_loudness_measure(it_bit_buff, &(loudness_info->loudness_measure[i])); if (err) return (err); } return (0); }