1439 lines
60 KiB
C
1439 lines
60 KiB
C
/******************************************************************************
|
|
* *
|
|
* Copyright (C) 2023 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 <math.h>
|
|
#include <string.h>
|
|
#include "ixheaac_type_def.h"
|
|
#include "ixheaac_error_standards.h"
|
|
#include "ixheaace_error_codes.h"
|
|
|
|
#include "impd_drc_common_enc.h"
|
|
#include "impd_drc_uni_drc.h"
|
|
#include "impd_drc_uni_drc_eq.h"
|
|
|
|
static IA_ERRORCODE impd_drc_derive_subband_center_freq(const WORD32 eq_subband_gain_count,
|
|
const WORD32 eq_subband_gain_format,
|
|
const FLOAT32 audio_sample_rate,
|
|
FLOAT32 *ptr_subband_center_freq) {
|
|
LOOPIDX idx;
|
|
FLOAT32 width, offset;
|
|
|
|
switch (eq_subband_gain_format) {
|
|
case GAINFORMAT_QMF32:
|
|
case GAINFORMAT_QMF64:
|
|
case GAINFORMAT_QMF128:
|
|
case GAINFORMAT_UNIFORM:
|
|
width = 0.5f * audio_sample_rate / (FLOAT32)eq_subband_gain_count;
|
|
offset = 0.5f * width;
|
|
for (idx = 0; idx < eq_subband_gain_count; idx++) {
|
|
ptr_subband_center_freq[idx] = idx * width + offset;
|
|
}
|
|
break;
|
|
case GAINFORMAT_QMFHYBRID39:
|
|
case GAINFORMAT_QMFHYBRID71:
|
|
case GAINFORMAT_QMFHYBRID135:
|
|
return IA_EXHEAACE_CONFIG_FATAL_DRC_UNSUPPORTED_CONFIG;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return IA_NO_ERROR;
|
|
}
|
|
|
|
static VOID impd_drc_derive_zero_response(const FLOAT32 radius, const FLOAT32 angle_radian,
|
|
const FLOAT32 frequency_radian, FLOAT32 *response) {
|
|
*response =
|
|
(FLOAT32)(1.0f + radius * radius - 2.0f * radius * cos(frequency_radian - angle_radian));
|
|
}
|
|
|
|
static VOID impd_drc_derive_pole_response(const FLOAT32 radius, const FLOAT32 angle_radian,
|
|
const FLOAT32 frequency_radian, FLOAT32 *response) {
|
|
*response =
|
|
(FLOAT32)(1.0f + radius * radius - 2.0f * radius * cos(frequency_radian - angle_radian));
|
|
*response = 1.0f / *response;
|
|
}
|
|
|
|
static VOID impd_drc_derive_fir_filter_response(const WORD32 fir_order, const WORD32 fir_symmetry,
|
|
const FLOAT32 *ptr_fir_coeff,
|
|
const FLOAT32 frequency_radian,
|
|
FLOAT32 *response) {
|
|
LOOPIDX idx;
|
|
WORD32 order_2;
|
|
FLOAT32 sum = 0.0f;
|
|
|
|
if ((fir_order & 0x1) != 0) {
|
|
order_2 = (fir_order + 1) / 2;
|
|
if (fir_symmetry != 0) {
|
|
for (idx = 1; idx <= order_2; idx++) {
|
|
sum += (FLOAT32)(ptr_fir_coeff[order_2 - idx] * sin((idx - 0.5f) * frequency_radian));
|
|
}
|
|
} else {
|
|
for (idx = 1; idx <= order_2; idx++) {
|
|
sum += (FLOAT32)(ptr_fir_coeff[order_2 - idx] * cos((idx - 0.5f) * frequency_radian));
|
|
}
|
|
}
|
|
sum *= 2.0f;
|
|
} else {
|
|
order_2 = fir_order / 2;
|
|
if (fir_symmetry != 0) {
|
|
for (idx = 1; idx <= order_2; idx++) {
|
|
sum += (FLOAT32)(ptr_fir_coeff[order_2 - idx] * sin(idx * frequency_radian));
|
|
}
|
|
sum *= 2.0f;
|
|
} else {
|
|
sum = ptr_fir_coeff[order_2];
|
|
}
|
|
}
|
|
|
|
*response = sum;
|
|
}
|
|
|
|
static VOID impd_drc_derive_filter_element_response(
|
|
ia_drc_unique_td_filter_element_struct *pstr_unique_td_filter_element,
|
|
const FLOAT32 frequency_radian, FLOAT32 *response) {
|
|
LOOPIDX idx;
|
|
FLOAT32 response_part, radius, angle_radian;
|
|
FLOAT64 combined_response = 1.0;
|
|
|
|
if (pstr_unique_td_filter_element->eq_filter_format != FILTER_ELEMENT_FORMAT_POLE_ZERO) {
|
|
impd_drc_derive_fir_filter_response(pstr_unique_td_filter_element->fir_filter_order,
|
|
pstr_unique_td_filter_element->fir_symmetry,
|
|
pstr_unique_td_filter_element->fir_coefficient,
|
|
frequency_radian, &response_part);
|
|
combined_response *= response_part;
|
|
} else {
|
|
for (idx = 0; idx < pstr_unique_td_filter_element->real_zero_radius_one_count; idx++) {
|
|
impd_drc_derive_zero_response(1.0f,
|
|
(FLOAT32)(M_PI)*pstr_unique_td_filter_element->zero_sign[idx],
|
|
frequency_radian, &response_part);
|
|
combined_response *= response_part;
|
|
}
|
|
for (idx = 0; idx < pstr_unique_td_filter_element->real_zero_count; idx++) {
|
|
if (pstr_unique_td_filter_element->real_zero_radius[idx] >= 0.0f) {
|
|
radius = pstr_unique_td_filter_element->real_zero_radius[idx];
|
|
angle_radian = 0.0f;
|
|
} else {
|
|
radius = -pstr_unique_td_filter_element->real_zero_radius[idx];
|
|
angle_radian = (FLOAT32)(M_PI);
|
|
}
|
|
impd_drc_derive_zero_response(radius, angle_radian, frequency_radian, &response_part);
|
|
combined_response *= response_part;
|
|
impd_drc_derive_zero_response(1.0f / radius, angle_radian, frequency_radian,
|
|
&response_part);
|
|
combined_response *= response_part;
|
|
}
|
|
|
|
combined_response = sqrt(combined_response);
|
|
|
|
for (idx = 0; idx < pstr_unique_td_filter_element->generic_zero_count; idx++) {
|
|
radius = pstr_unique_td_filter_element->generic_zero_radius[idx];
|
|
|
|
impd_drc_derive_zero_response(
|
|
radius, (FLOAT32)(M_PI)*pstr_unique_td_filter_element->generic_zero_angle[idx],
|
|
frequency_radian, &response_part);
|
|
combined_response *= response_part;
|
|
|
|
impd_drc_derive_zero_response(
|
|
1.0f / radius, (FLOAT32)(M_PI)*pstr_unique_td_filter_element->generic_zero_angle[idx],
|
|
frequency_radian, &response_part);
|
|
combined_response *= response_part;
|
|
}
|
|
for (idx = 0; idx < pstr_unique_td_filter_element->real_pole_count; idx++) {
|
|
if (pstr_unique_td_filter_element->real_pole_radius[idx] >= 0.0f) {
|
|
radius = pstr_unique_td_filter_element->real_pole_radius[idx];
|
|
angle_radian = 0.0f;
|
|
} else {
|
|
radius = -pstr_unique_td_filter_element->real_pole_radius[idx];
|
|
angle_radian = (FLOAT32)(-M_PI);
|
|
}
|
|
impd_drc_derive_pole_response(radius, angle_radian, frequency_radian, &response_part);
|
|
combined_response *= response_part;
|
|
}
|
|
for (idx = 0; idx < pstr_unique_td_filter_element->complex_pole_count; idx++) {
|
|
impd_drc_derive_pole_response(
|
|
pstr_unique_td_filter_element->real_pole_radius[idx],
|
|
(FLOAT32)(M_PI)*pstr_unique_td_filter_element->complex_pole_angle[idx],
|
|
frequency_radian, &response_part);
|
|
combined_response *= response_part * response_part;
|
|
}
|
|
}
|
|
|
|
*response = (FLOAT32)combined_response;
|
|
}
|
|
|
|
static VOID impd_drc_derive_filter_block_response(
|
|
ia_drc_unique_td_filter_element_struct *pstr_unique_td_filter_element,
|
|
ia_drc_filter_block_struct *pstr_filter_block, const FLOAT32 frequency_radian,
|
|
FLOAT32 *response) {
|
|
LOOPIDX idx;
|
|
FLOAT32 response_part;
|
|
FLOAT64 combined_response = 1.0;
|
|
ia_drc_filter_element_struct *pstr_filter_element;
|
|
|
|
for (idx = 0; idx < pstr_filter_block->filter_element_count; idx++) {
|
|
pstr_filter_element = &pstr_filter_block->filter_element[idx];
|
|
impd_drc_derive_filter_element_response(
|
|
&(pstr_unique_td_filter_element[pstr_filter_element->filter_element_index]),
|
|
frequency_radian, &response_part);
|
|
combined_response *= response_part;
|
|
|
|
if (pstr_filter_element->filter_element_gain_present == 1) {
|
|
combined_response *= pow(10.0f, 0.05f * pstr_filter_element->filter_element_gain);
|
|
}
|
|
}
|
|
|
|
*response = (FLOAT32)combined_response;
|
|
}
|
|
|
|
static IA_ERRORCODE impd_drc_derive_subband_gains_from_td_cascade(
|
|
ia_drc_unique_td_filter_element_struct *pstr_unique_td_filter_element,
|
|
ia_drc_filter_block_struct *pstr_filter_block,
|
|
ia_drc_td_filter_cascade_struct *pstr_td_filter_cascade, const WORD32 eq_subband_gain_format,
|
|
const WORD32 eq_channel_group_count, const FLOAT32 audio_sample_rate,
|
|
const WORD32 eq_frame_size_subband, ia_drc_subband_filter_struct *pstr_subband_filter,
|
|
VOID *ptr_scratch) {
|
|
IA_ERRORCODE err_code = IA_NO_ERROR;
|
|
LOOPIDX i, j, k;
|
|
WORD32 eq_subband_gain_count = pstr_subband_filter->coeff_count;
|
|
FLOAT32 response_part, frequency_radian;
|
|
FLOAT32 *ptr_subband_center_freq = (FLOAT32 *)ptr_scratch;
|
|
FLOAT64 combined_response;
|
|
|
|
err_code = impd_drc_derive_subband_center_freq(eq_subband_gain_count, eq_subband_gain_format,
|
|
audio_sample_rate, ptr_subband_center_freq);
|
|
if (err_code & IA_FATAL_ERROR) {
|
|
return err_code;
|
|
}
|
|
|
|
for (i = 0; i < eq_channel_group_count; i++) {
|
|
for (j = 0; j < eq_subband_gain_count; j++) {
|
|
combined_response = pow(10.0f, 0.05f * pstr_td_filter_cascade->eq_cascade_gain[i]);
|
|
frequency_radian = 2.0f * (FLOAT32)M_PI * ptr_subband_center_freq[j] / audio_sample_rate;
|
|
|
|
for (k = 0; k < pstr_td_filter_cascade->str_filter_block_refs[i].filter_block_count; k++) {
|
|
impd_drc_derive_filter_block_response(
|
|
pstr_unique_td_filter_element,
|
|
&(pstr_filter_block[pstr_td_filter_cascade->str_filter_block_refs[i]
|
|
.filter_block_index[k]]),
|
|
frequency_radian, &response_part);
|
|
combined_response *= response_part;
|
|
}
|
|
pstr_subband_filter[i].subband_coeff[j] = (FLOAT32)combined_response;
|
|
}
|
|
pstr_subband_filter[i].eq_frame_size_subband = eq_frame_size_subband;
|
|
}
|
|
|
|
return err_code;
|
|
}
|
|
|
|
static VOID impd_drc_check_presence_and_add_cascade(
|
|
ia_drc_cascade_alignment_group_struct *pstr_cascade_alignment_group, const WORD32 index_c1,
|
|
const WORD32 index_c2, WORD32 *done) {
|
|
LOOPIDX i, j;
|
|
|
|
*done = 0;
|
|
for (i = 0; i < pstr_cascade_alignment_group->member_count; i++) {
|
|
if (pstr_cascade_alignment_group->member_index[i] == index_c1) {
|
|
for (j = 0; j < pstr_cascade_alignment_group->member_count; j++) {
|
|
if (pstr_cascade_alignment_group->member_index[j] == index_c2) {
|
|
*done = 1;
|
|
}
|
|
}
|
|
if (*done == 0) {
|
|
pstr_cascade_alignment_group->member_index[pstr_cascade_alignment_group->member_count] =
|
|
index_c2;
|
|
pstr_cascade_alignment_group->member_count++;
|
|
*done = 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static VOID impd_drc_derive_cascade_alignment_groups(
|
|
const WORD32 eq_channel_group_count, const WORD32 eq_phase_alignment_present,
|
|
const WORD32 eq_phase_alignment[EQ_MAX_CHANNEL_GROUP_COUNT][EQ_MAX_CHANNEL_GROUP_COUNT],
|
|
WORD32 *cascade_alignment_group_count,
|
|
ia_drc_cascade_alignment_group_struct *pstr_cascade_alignment_group) {
|
|
LOOPIDX i, j, k;
|
|
WORD32 group_count = 0, done;
|
|
|
|
if (eq_phase_alignment_present != 0) {
|
|
for (i = 0; i < eq_channel_group_count; i++) {
|
|
for (j = i + 1; j < eq_channel_group_count; j++) {
|
|
if (eq_phase_alignment[i][j] == 1) {
|
|
done = 0;
|
|
for (k = 0; k < group_count; k++) {
|
|
impd_drc_check_presence_and_add_cascade(&pstr_cascade_alignment_group[k], i, j,
|
|
&done);
|
|
if (done == 0) {
|
|
impd_drc_check_presence_and_add_cascade(&pstr_cascade_alignment_group[k], j, i,
|
|
&done);
|
|
}
|
|
}
|
|
if (done == 0) {
|
|
pstr_cascade_alignment_group[group_count].member_count = 2;
|
|
pstr_cascade_alignment_group[group_count].member_index[0] = i;
|
|
pstr_cascade_alignment_group[group_count].member_index[1] = j;
|
|
group_count++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
if (eq_channel_group_count > 1) {
|
|
for (i = 0; i < eq_channel_group_count; i++) {
|
|
pstr_cascade_alignment_group[group_count].member_index[i] = i;
|
|
}
|
|
pstr_cascade_alignment_group[group_count].member_count = eq_channel_group_count;
|
|
group_count = 1;
|
|
}
|
|
}
|
|
|
|
*cascade_alignment_group_count = group_count;
|
|
}
|
|
|
|
static IA_ERRORCODE impd_drc_derive_allpass_chain(
|
|
ia_drc_filter_cascade_t_domain_struct *pstr_filter_cascade_t_domain,
|
|
ia_drc_allpass_chain_struct *pstr_allpass_chain) {
|
|
LOOPIDX i, j;
|
|
WORD32 allpass_count = 0;
|
|
|
|
for (i = 0; i < pstr_filter_cascade_t_domain->block_count; i++) {
|
|
ia_drc_eq_filter_element_struct *pstr_eq_filter_element =
|
|
&pstr_filter_cascade_t_domain->str_eq_filter_block[i].str_eq_filter_element[0];
|
|
|
|
if (pstr_filter_cascade_t_domain->str_eq_filter_block[i]
|
|
.str_matching_phase_filter_element_0.is_valid != 1) {
|
|
return IA_EXHEAACE_CONFIG_FATAL_DRC_INVALID_CONFIG;
|
|
} else {
|
|
pstr_allpass_chain->str_matching_phase_filter[allpass_count] =
|
|
pstr_filter_cascade_t_domain->str_eq_filter_block[i]
|
|
.str_matching_phase_filter_element_0;
|
|
allpass_count++;
|
|
}
|
|
|
|
for (j = 0; j < pstr_eq_filter_element->phase_alignment_filter_count; j++) {
|
|
if (pstr_eq_filter_element->str_phase_alignment_filter[j].is_valid != 1) {
|
|
return IA_EXHEAACE_CONFIG_FATAL_DRC_INVALID_CONFIG;
|
|
} else {
|
|
pstr_allpass_chain->str_matching_phase_filter[allpass_count] =
|
|
pstr_eq_filter_element->str_phase_alignment_filter[j];
|
|
allpass_count++;
|
|
}
|
|
}
|
|
}
|
|
pstr_allpass_chain->allpass_count = allpass_count;
|
|
|
|
return IA_NO_ERROR;
|
|
}
|
|
|
|
static VOID impd_drc_add_allpass_filter_chain(
|
|
ia_drc_allpass_chain_struct *pstr_allpass_chain,
|
|
ia_drc_filter_cascade_t_domain_struct *pstr_filter_cascade_t_domain) {
|
|
LOOPIDX idx;
|
|
|
|
for (idx = 0; idx < pstr_allpass_chain->allpass_count; idx++) {
|
|
pstr_filter_cascade_t_domain
|
|
->str_phase_alignment_filter[pstr_filter_cascade_t_domain->phase_alignment_filter_count +
|
|
idx] = pstr_allpass_chain->str_matching_phase_filter[idx];
|
|
}
|
|
pstr_filter_cascade_t_domain->phase_alignment_filter_count += pstr_allpass_chain->allpass_count;
|
|
}
|
|
|
|
static IA_ERRORCODE impd_drc_phase_align_cascade_group(
|
|
const WORD32 cascade_alignment_group_count,
|
|
ia_drc_cascade_alignment_group_struct *pstr_cascade_alignment_group,
|
|
ia_drc_filter_cascade_t_domain_struct *pstr_filter_cascade_t_domain, VOID *ptr_scratch,
|
|
WORD32 *scratch_used) {
|
|
IA_ERRORCODE err_code = IA_NO_ERROR;
|
|
LOOPIDX i, j, k;
|
|
WORD32 cascade_index;
|
|
ia_drc_allpass_chain_struct *pstr_allpass_chain =
|
|
(ia_drc_allpass_chain_struct *)((pUWORD8)(ptr_scratch)) + *scratch_used;
|
|
|
|
for (i = 0; i < cascade_alignment_group_count; i++) {
|
|
for (j = 0; j < pstr_cascade_alignment_group[i].member_count; j++) {
|
|
cascade_index = pstr_cascade_alignment_group[i].member_index[j];
|
|
|
|
err_code = impd_drc_derive_allpass_chain(&pstr_filter_cascade_t_domain[cascade_index],
|
|
&pstr_allpass_chain[j]);
|
|
if (err_code & IA_FATAL_ERROR) {
|
|
return err_code;
|
|
}
|
|
pstr_allpass_chain[j].matches_cascade_index = cascade_index;
|
|
}
|
|
for (j = 0; j < pstr_cascade_alignment_group[i].member_count; j++) {
|
|
cascade_index = pstr_cascade_alignment_group[i].member_index[j];
|
|
for (k = 0; k < pstr_cascade_alignment_group[i].member_count; k++) {
|
|
if (cascade_index != pstr_allpass_chain[k].matches_cascade_index) {
|
|
impd_drc_add_allpass_filter_chain(&pstr_allpass_chain[k],
|
|
&pstr_filter_cascade_t_domain[cascade_index]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return err_code;
|
|
}
|
|
|
|
static VOID impd_drc_derive_matching_phase_filter_params(
|
|
const WORD32 config, FLOAT32 radius, FLOAT32 angle,
|
|
ia_drc_phase_alignment_filter_struct *pstr_phase_alignment_filter) {
|
|
LOOPIDX idx;
|
|
WORD32 section = pstr_phase_alignment_filter->section_count;
|
|
FLOAT32 z_real, z_imag, product;
|
|
ia_drc_filter_section_struct *pstr_filter_section =
|
|
&pstr_phase_alignment_filter->str_filter_section[section];
|
|
|
|
switch (config) {
|
|
case CONFIG_COMPLEX_POLE:
|
|
z_real = (FLOAT32)(radius * cos((FLOAT32)M_PI * angle));
|
|
z_imag = (FLOAT32)(radius * sin((FLOAT32)M_PI * angle));
|
|
product = z_real * z_real + z_imag * z_imag;
|
|
pstr_phase_alignment_filter->gain *= product;
|
|
pstr_filter_section->var_a1 = -2.0f * z_real;
|
|
pstr_filter_section->var_a2 = product;
|
|
pstr_filter_section->var_b1 = -2.0f * z_real / product;
|
|
pstr_filter_section->var_b2 = 1.0f / product;
|
|
pstr_phase_alignment_filter->section_count++;
|
|
break;
|
|
case CONFIG_REAL_POLE:
|
|
pstr_phase_alignment_filter->gain *= (-radius);
|
|
pstr_filter_section->var_a1 = -radius;
|
|
pstr_filter_section->var_a2 = 0.0f;
|
|
pstr_filter_section->var_b1 = -1.0f / radius;
|
|
pstr_filter_section->var_b2 = 0.0f;
|
|
pstr_phase_alignment_filter->section_count++;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
for (idx = 0; idx < MAX_EQ_CHANNEL_COUNT; idx++) {
|
|
pstr_filter_section->str_filter_section_state[idx].state_in_1 = 0.0f;
|
|
pstr_filter_section->str_filter_section_state[idx].state_out_1 = 0.0f;
|
|
pstr_filter_section->str_filter_section_state[idx].state_in_2 = 0.0f;
|
|
pstr_filter_section->str_filter_section_state[idx].state_out_2 = 0.0f;
|
|
}
|
|
}
|
|
|
|
static VOID impd_drc_derive_matching_phase_filter_delay(
|
|
ia_drc_unique_td_filter_element_struct *pstr_filter_element,
|
|
ia_drc_phase_alignment_filter_struct *pstr_phase_alignment_filter) {
|
|
LOOPIDX i, j;
|
|
WORD32 delay = 0;
|
|
|
|
if (pstr_filter_element->eq_filter_format == FILTER_ELEMENT_FORMAT_POLE_ZERO) {
|
|
if (pstr_filter_element->real_zero_radius_one_count == 0) {
|
|
delay = pstr_filter_element->real_zero_count + 2 * pstr_filter_element->generic_zero_count -
|
|
pstr_filter_element->real_pole_count - 2 * pstr_filter_element->complex_pole_count;
|
|
delay = MAX(0, delay);
|
|
pstr_phase_alignment_filter->is_valid = 1;
|
|
}
|
|
}
|
|
|
|
pstr_phase_alignment_filter->str_audio_delay.delay = delay;
|
|
for (i = 0; i < MAX_EQ_CHANNEL_COUNT; i++) {
|
|
for (j = 0; j < delay; j++) {
|
|
pstr_phase_alignment_filter->str_audio_delay.state[i][j] = 0.0f;
|
|
}
|
|
}
|
|
}
|
|
|
|
static VOID impd_drc_derive_matching_phase_filter(
|
|
ia_drc_unique_td_filter_element_struct *pstr_filter_element, WORD32 filter_element_index,
|
|
ia_drc_matching_phase_filter_struct *pstr_matching_phase_filter) {
|
|
LOOPIDX idx;
|
|
|
|
memset(pstr_matching_phase_filter, 0, sizeof(ia_drc_matching_phase_filter_struct));
|
|
pstr_matching_phase_filter->gain = 1.0f;
|
|
|
|
if (pstr_filter_element->eq_filter_format == FILTER_ELEMENT_FORMAT_POLE_ZERO) {
|
|
for (idx = 0; idx < pstr_filter_element->real_pole_count; idx++) {
|
|
impd_drc_derive_matching_phase_filter_params(CONFIG_REAL_POLE,
|
|
pstr_filter_element->real_pole_radius[idx],
|
|
0.0f, pstr_matching_phase_filter);
|
|
}
|
|
for (idx = 0; idx < pstr_filter_element->complex_pole_count; idx++) {
|
|
impd_drc_derive_matching_phase_filter_params(
|
|
CONFIG_COMPLEX_POLE, pstr_filter_element->complex_pole_radius[idx],
|
|
pstr_filter_element->complex_pole_angle[idx], pstr_matching_phase_filter);
|
|
}
|
|
}
|
|
impd_drc_derive_matching_phase_filter_delay(pstr_filter_element, pstr_matching_phase_filter);
|
|
|
|
pstr_matching_phase_filter->matches_filter_count = 1;
|
|
pstr_matching_phase_filter->matches_filter[0] = filter_element_index;
|
|
}
|
|
|
|
static VOID impd_drc_check_phase_filter_is_equal(
|
|
ia_drc_matching_phase_filter_struct *pstr_matching_phase_filter_1,
|
|
ia_drc_matching_phase_filter_struct *pstr_matching_phase_filter_2, WORD32 *is_equal) {
|
|
LOOPIDX idx;
|
|
|
|
*is_equal = 1;
|
|
if (pstr_matching_phase_filter_1->section_count ==
|
|
pstr_matching_phase_filter_2->section_count) {
|
|
for (idx = 0; idx < pstr_matching_phase_filter_1->section_count; idx++) {
|
|
if ((pstr_matching_phase_filter_1->str_filter_section[idx].var_a1 !=
|
|
pstr_matching_phase_filter_2->str_filter_section[idx].var_a1) ||
|
|
(pstr_matching_phase_filter_1->str_filter_section[idx].var_a2 !=
|
|
pstr_matching_phase_filter_2->str_filter_section[idx].var_a2) ||
|
|
(pstr_matching_phase_filter_1->str_filter_section[idx].var_b1 !=
|
|
pstr_matching_phase_filter_2->str_filter_section[idx].var_b1) ||
|
|
(pstr_matching_phase_filter_1->str_filter_section[idx].var_b2 !=
|
|
pstr_matching_phase_filter_2->str_filter_section[idx].var_b2)) {
|
|
*is_equal = 0;
|
|
break;
|
|
}
|
|
}
|
|
} else {
|
|
*is_equal = 0;
|
|
}
|
|
|
|
if (pstr_matching_phase_filter_1->str_audio_delay.delay !=
|
|
pstr_matching_phase_filter_2->str_audio_delay.delay) {
|
|
*is_equal = 0;
|
|
}
|
|
}
|
|
|
|
static IA_ERRORCODE impd_drc_add_phase_alignment_filter(
|
|
ia_drc_matching_phase_filter_struct *pstr_matching_phase_filter,
|
|
ia_drc_eq_filter_element_struct *pstr_eq_filter_element) {
|
|
if (pstr_matching_phase_filter->is_valid != 1) {
|
|
return IA_EXHEAACE_CONFIG_FATAL_DRC_INVALID_CONFIG;
|
|
} else {
|
|
pstr_eq_filter_element
|
|
->str_phase_alignment_filter[pstr_eq_filter_element->phase_alignment_filter_count] =
|
|
*pstr_matching_phase_filter;
|
|
pstr_eq_filter_element->phase_alignment_filter_count++;
|
|
}
|
|
|
|
return IA_NO_ERROR;
|
|
}
|
|
|
|
static IA_ERRORCODE impd_drc_derive_element_phase_alignment_filters(
|
|
ia_drc_matching_phase_filter_struct *pstr_matching_phase_filter,
|
|
ia_drc_eq_filter_block_struct *pstr_eq_filter_block, VOID *ptr_scratch,
|
|
WORD32 *scratch_used) {
|
|
IA_ERRORCODE err_code = IA_NO_ERROR;
|
|
LOOPIDX i, j, k;
|
|
WORD32 skip, is_equal;
|
|
WORD32 optimized_phase_filter_count;
|
|
WORD32 path_delay_min, path_delay, path_delay_new, path_delay_to_remove;
|
|
|
|
ia_drc_matching_phase_filter_struct *pstr_matching_phase_filter_opt =
|
|
(ia_drc_matching_phase_filter_struct *)((pUWORD8)ptr_scratch) + *scratch_used;
|
|
ia_drc_eq_filter_element_struct *pstr_eq_filter_element;
|
|
|
|
optimized_phase_filter_count = 0;
|
|
for (i = 0; i < pstr_eq_filter_block->element_count; i++) {
|
|
is_equal = 0;
|
|
for (j = 0; j < optimized_phase_filter_count; j++) {
|
|
impd_drc_check_phase_filter_is_equal(&pstr_matching_phase_filter[i],
|
|
&pstr_matching_phase_filter_opt[j], &is_equal);
|
|
if (is_equal == 1) {
|
|
break;
|
|
}
|
|
}
|
|
if (is_equal != 1) {
|
|
pstr_matching_phase_filter_opt[optimized_phase_filter_count] =
|
|
pstr_matching_phase_filter[i];
|
|
optimized_phase_filter_count++;
|
|
} else {
|
|
pstr_matching_phase_filter_opt[j]
|
|
.matches_filter[pstr_matching_phase_filter_opt[j].matches_filter_count] = i;
|
|
pstr_matching_phase_filter_opt[j].matches_filter_count++;
|
|
}
|
|
}
|
|
|
|
for (i = 0; i < pstr_eq_filter_block->element_count; i++) {
|
|
for (j = 0; j < optimized_phase_filter_count; j++) {
|
|
skip = 0;
|
|
for (k = 0; k < pstr_matching_phase_filter_opt[j].matches_filter_count; k++) {
|
|
if (pstr_matching_phase_filter_opt[j].matches_filter[k] == i) {
|
|
skip = 1;
|
|
break;
|
|
}
|
|
}
|
|
if (skip == 0) {
|
|
err_code = impd_drc_add_phase_alignment_filter(
|
|
&pstr_matching_phase_filter_opt[j], &pstr_eq_filter_block->str_eq_filter_element[i]);
|
|
if (err_code & IA_FATAL_ERROR) {
|
|
return err_code;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
path_delay_min = 100000;
|
|
for (i = 0; i < pstr_eq_filter_block->element_count; i++) {
|
|
pstr_eq_filter_element = &pstr_eq_filter_block->str_eq_filter_element[i];
|
|
path_delay = 0;
|
|
for (k = 0; k < pstr_eq_filter_element->phase_alignment_filter_count; k++) {
|
|
path_delay += pstr_eq_filter_element->str_phase_alignment_filter[k].str_audio_delay.delay;
|
|
}
|
|
if (path_delay_min > path_delay) {
|
|
path_delay_min = path_delay;
|
|
}
|
|
}
|
|
if (path_delay_min > 0) {
|
|
for (i = 0; i < pstr_eq_filter_block->element_count; i++) {
|
|
pstr_eq_filter_element = &pstr_eq_filter_block->str_eq_filter_element[i];
|
|
path_delay_to_remove = path_delay_min;
|
|
for (k = 0; k < pstr_eq_filter_element->phase_alignment_filter_count; k++) {
|
|
path_delay = pstr_eq_filter_element->str_phase_alignment_filter[k].str_audio_delay.delay;
|
|
path_delay_new = MAX(0, path_delay - path_delay_to_remove);
|
|
path_delay_to_remove -= path_delay - path_delay_new;
|
|
pstr_eq_filter_element->str_phase_alignment_filter[k].str_audio_delay.delay =
|
|
path_delay_new;
|
|
}
|
|
}
|
|
}
|
|
|
|
return err_code;
|
|
}
|
|
|
|
static IA_ERRORCODE impd_drc_convert_pole_zero_to_filter_params(
|
|
const WORD32 config, FLOAT32 radius, FLOAT32 angle, WORD32 *filter_param_count,
|
|
ia_drc_second_order_filter_params_struct *pstr_second_order_filter_params) {
|
|
FLOAT32 z_real, angle_1, angle_2;
|
|
FLOAT32 *ptr_coeff;
|
|
|
|
switch (config) {
|
|
case CONFIG_REAL_POLE: {
|
|
pstr_second_order_filter_params[0].radius = radius;
|
|
ptr_coeff = pstr_second_order_filter_params[0].coeff;
|
|
ptr_coeff[0] = -2.0f * radius;
|
|
ptr_coeff[1] = radius * radius;
|
|
*filter_param_count = 1;
|
|
} break;
|
|
case CONFIG_COMPLEX_POLE: {
|
|
z_real = (FLOAT32)(radius * cos((FLOAT32)M_PI * angle));
|
|
pstr_second_order_filter_params[0].radius = radius;
|
|
ptr_coeff = pstr_second_order_filter_params[0].coeff;
|
|
ptr_coeff[0] = -2.0f * z_real;
|
|
ptr_coeff[1] = radius * radius;
|
|
pstr_second_order_filter_params[1].radius = radius;
|
|
pstr_second_order_filter_params[1].coeff[0] = ptr_coeff[0];
|
|
pstr_second_order_filter_params[1].coeff[1] = ptr_coeff[1];
|
|
*filter_param_count = 2;
|
|
} break;
|
|
case CONFIG_REAL_ZERO_RADIUS_ONE: {
|
|
angle_1 = radius;
|
|
angle_2 = angle;
|
|
pstr_second_order_filter_params[0].radius = 1.0f;
|
|
ptr_coeff = pstr_second_order_filter_params[0].coeff;
|
|
|
|
if (angle_1 != angle_2) {
|
|
ptr_coeff[0] = 0.0f;
|
|
ptr_coeff[1] = -1.0f;
|
|
} else if (angle_1 == 1.0f) {
|
|
ptr_coeff[0] = -2.0f;
|
|
ptr_coeff[1] = 1.0f;
|
|
} else {
|
|
ptr_coeff[0] = 2.0f;
|
|
ptr_coeff[1] = 1.0f;
|
|
}
|
|
*filter_param_count = 1;
|
|
} break;
|
|
case CONFIG_REAL_ZERO: {
|
|
pstr_second_order_filter_params[0].radius = radius;
|
|
if (fabs(radius) == 1.0f) {
|
|
return IA_EXHEAACE_CONFIG_FATAL_DRC_INVALID_CONFIG;
|
|
} else {
|
|
ptr_coeff = pstr_second_order_filter_params[0].coeff;
|
|
ptr_coeff[0] = -(radius + 1.0f / radius);
|
|
ptr_coeff[1] = 1.0f;
|
|
}
|
|
*filter_param_count = 1;
|
|
} break;
|
|
case CONFIG_GENERIC_ZERO: {
|
|
z_real = (FLOAT32)(radius * cos((FLOAT32)M_PI * angle));
|
|
pstr_second_order_filter_params[0].radius = radius;
|
|
ptr_coeff = pstr_second_order_filter_params[0].coeff;
|
|
ptr_coeff[0] = -2.0f * z_real;
|
|
ptr_coeff[1] = (FLOAT32)(radius * radius);
|
|
z_real = (FLOAT32)(cos((FLOAT32)M_PI * angle) / radius);
|
|
pstr_second_order_filter_params[1].radius = radius;
|
|
ptr_coeff = pstr_second_order_filter_params[1].coeff;
|
|
ptr_coeff[0] = -2.0f * z_real;
|
|
ptr_coeff[1] = 1.0f / (radius * radius);
|
|
*filter_param_count = 2;
|
|
} break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return IA_NO_ERROR;
|
|
}
|
|
|
|
static VOID impd_drc_convert_fir_filter_params(const WORD32 fir_filter_order,
|
|
const WORD32 fir_symmetry,
|
|
FLOAT32 *fir_coefficient,
|
|
ia_drc_fir_filter_struct *pstr_fir_filter) {
|
|
LOOPIDX i, j;
|
|
FLOAT32 *ptr_coeff = pstr_fir_filter->coeff;
|
|
|
|
pstr_fir_filter->coeff_count = fir_filter_order + 1;
|
|
for (i = 0; i < (fir_filter_order / 2 + 1); i++) {
|
|
ptr_coeff[i] = fir_coefficient[i];
|
|
}
|
|
for (i = 0; i < (fir_filter_order + 1) / 2; i++) {
|
|
if (fir_symmetry != 1) {
|
|
ptr_coeff[fir_filter_order - i] = ptr_coeff[i];
|
|
} else {
|
|
ptr_coeff[fir_filter_order - i] = -ptr_coeff[i];
|
|
}
|
|
}
|
|
if ((fir_symmetry == 1) && ((fir_filter_order & 1) == 0)) {
|
|
ptr_coeff[fir_filter_order / 2] = 0.0f;
|
|
}
|
|
for (i = 0; i < MAX_EQ_CHANNEL_COUNT; i++) {
|
|
for (j = 0; j < (fir_filter_order + 1); j++) {
|
|
pstr_fir_filter->state[i][j] = 0.0f;
|
|
}
|
|
}
|
|
}
|
|
|
|
static IA_ERRORCODE impd_drc_derive_pole_zero_filter_params(
|
|
ia_drc_unique_td_filter_element_struct *pstr_filter_element,
|
|
ia_drc_intermediate_filter_params_struct *pstr_intermediate_filter_params) {
|
|
IA_ERRORCODE err_code = IA_NO_ERROR;
|
|
LOOPIDX idx;
|
|
WORD32 param_index, filter_param_count;
|
|
ia_drc_second_order_filter_params_struct *pstr_second_order_filter_params_for_zeros;
|
|
ia_drc_second_order_filter_params_struct *pstr_second_order_filter_params_for_poles;
|
|
|
|
pstr_intermediate_filter_params->filter_format = pstr_filter_element->eq_filter_format;
|
|
if (pstr_filter_element->eq_filter_format != FILTER_ELEMENT_FORMAT_POLE_ZERO) {
|
|
pstr_intermediate_filter_params->filter_param_count_for_zeros = 0;
|
|
pstr_intermediate_filter_params->filter_param_count_for_poles = 0;
|
|
|
|
impd_drc_convert_fir_filter_params(
|
|
pstr_filter_element->fir_filter_order, pstr_filter_element->fir_symmetry,
|
|
pstr_filter_element->fir_coefficient, &pstr_intermediate_filter_params->str_fir_filter);
|
|
} else {
|
|
pstr_second_order_filter_params_for_zeros =
|
|
pstr_intermediate_filter_params->str_second_order_filter_params_for_zeros;
|
|
pstr_second_order_filter_params_for_poles =
|
|
pstr_intermediate_filter_params->str_second_order_filter_params_for_poles;
|
|
|
|
param_index = 0;
|
|
for (idx = 0; idx < pstr_filter_element->real_zero_radius_one_count; idx += 2) {
|
|
err_code = impd_drc_convert_pole_zero_to_filter_params(
|
|
CONFIG_REAL_ZERO_RADIUS_ONE, pstr_filter_element->zero_sign[idx],
|
|
pstr_filter_element->zero_sign[idx + 1], &filter_param_count,
|
|
&(pstr_second_order_filter_params_for_zeros[param_index]));
|
|
if (err_code & IA_FATAL_ERROR) {
|
|
return err_code;
|
|
}
|
|
param_index += filter_param_count;
|
|
}
|
|
for (idx = 0; idx < pstr_filter_element->real_zero_count; idx++) {
|
|
err_code = impd_drc_convert_pole_zero_to_filter_params(
|
|
CONFIG_REAL_ZERO, pstr_filter_element->real_zero_radius[idx], 0.0f, &filter_param_count,
|
|
&(pstr_second_order_filter_params_for_zeros[param_index]));
|
|
if (err_code & IA_FATAL_ERROR) {
|
|
return err_code;
|
|
}
|
|
param_index += filter_param_count;
|
|
}
|
|
for (idx = 0; idx < pstr_filter_element->generic_zero_count; idx++) {
|
|
err_code = impd_drc_convert_pole_zero_to_filter_params(
|
|
CONFIG_GENERIC_ZERO, pstr_filter_element->generic_zero_radius[idx],
|
|
pstr_filter_element->generic_zero_angle[idx], &filter_param_count,
|
|
&(pstr_second_order_filter_params_for_zeros[param_index]));
|
|
if (err_code & IA_FATAL_ERROR) {
|
|
return err_code;
|
|
}
|
|
param_index += filter_param_count;
|
|
}
|
|
pstr_intermediate_filter_params->filter_param_count_for_zeros = param_index;
|
|
|
|
param_index = 0;
|
|
for (idx = 0; idx < pstr_filter_element->real_pole_count; idx++) {
|
|
err_code = impd_drc_convert_pole_zero_to_filter_params(
|
|
CONFIG_REAL_POLE, pstr_filter_element->real_pole_radius[idx], 0.0f, &filter_param_count,
|
|
&(pstr_second_order_filter_params_for_poles[param_index]));
|
|
if (err_code & IA_FATAL_ERROR) {
|
|
return err_code;
|
|
}
|
|
param_index += filter_param_count;
|
|
}
|
|
for (idx = 0; idx < pstr_filter_element->complex_pole_count; idx++) {
|
|
err_code = impd_drc_convert_pole_zero_to_filter_params(
|
|
CONFIG_COMPLEX_POLE, pstr_filter_element->complex_pole_radius[idx],
|
|
pstr_filter_element->complex_pole_angle[idx], &filter_param_count,
|
|
&(pstr_second_order_filter_params_for_poles[param_index]));
|
|
if (err_code & IA_FATAL_ERROR) {
|
|
return err_code;
|
|
}
|
|
param_index += filter_param_count;
|
|
}
|
|
pstr_intermediate_filter_params->filter_param_count_for_poles = param_index;
|
|
}
|
|
|
|
return err_code;
|
|
}
|
|
|
|
static VOID impd_drc_derive_eq_filter_elements(
|
|
ia_drc_intermediate_filter_params_struct *pstr_intermediate_filter_params,
|
|
ia_drc_eq_filter_element_struct *pstr_eq_filter_element, pUWORD8 ptr_scratch) {
|
|
LOOPIDX idx, ch_idx;
|
|
WORD32 poles_index, zeros_index, pole_order = 0, section;
|
|
WORD32 coeff_count, coeff_idx;
|
|
WORD32 *ptr_poles_done = (WORD32 *)ptr_scratch;
|
|
WORD32 *ptr_zeros_done =
|
|
(WORD32 *)(ptr_scratch +
|
|
((REAL_POLE_COUNT_MAX + COMPLEX_POLE_COUNT_MAX) * sizeof(ptr_poles_done[0])));
|
|
FLOAT32 radius_max, radius_diff;
|
|
FLOAT32 temp_b1, temp_b2;
|
|
FLOAT32 *ptr_coeff;
|
|
|
|
for (idx = 0; idx < (REAL_ZERO_COUNT_MAX + COMPLEX_ZERO_COUNT_MAX); idx++) {
|
|
ptr_zeros_done[idx] = 0;
|
|
}
|
|
for (idx = 0; idx < (REAL_POLE_COUNT_MAX + COMPLEX_POLE_COUNT_MAX); idx++) {
|
|
ptr_poles_done[idx] = 0;
|
|
}
|
|
section = 0;
|
|
do {
|
|
poles_index = -1;
|
|
radius_max = -1.0;
|
|
for (idx = 0; idx < pstr_intermediate_filter_params->filter_param_count_for_poles; idx++) {
|
|
if ((ptr_poles_done[idx] == 0) && (pstr_intermediate_filter_params->filter_format == 0)) {
|
|
if (radius_max <
|
|
fabs(pstr_intermediate_filter_params->str_second_order_filter_params_for_poles[idx]
|
|
.radius)) {
|
|
radius_max = (FLOAT32)fabs(
|
|
pstr_intermediate_filter_params->str_second_order_filter_params_for_poles[idx]
|
|
.radius);
|
|
poles_index = idx;
|
|
if (pstr_intermediate_filter_params->str_second_order_filter_params_for_poles[idx]
|
|
.coeff[1] == 0.0f) {
|
|
pole_order = 1;
|
|
} else {
|
|
pole_order = 2;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (poles_index >= 0) {
|
|
radius_diff = 10.0f;
|
|
zeros_index = -1;
|
|
for (idx = 0; idx < pstr_intermediate_filter_params->filter_param_count_for_zeros; idx++) {
|
|
if (ptr_zeros_done[idx] == 0 && pstr_intermediate_filter_params->filter_format == 0) {
|
|
if (pole_order == 2) {
|
|
if (pstr_intermediate_filter_params->str_second_order_filter_params_for_zeros[idx]
|
|
.coeff[1] != 0.0f) {
|
|
if (radius_diff > fabs(fabs(pstr_intermediate_filter_params
|
|
->str_second_order_filter_params_for_zeros[idx]
|
|
.radius) -
|
|
radius_max)) {
|
|
radius_diff =
|
|
(FLOAT32)fabs(fabs(pstr_intermediate_filter_params
|
|
->str_second_order_filter_params_for_zeros[idx]
|
|
.radius) -
|
|
radius_max);
|
|
zeros_index = idx;
|
|
}
|
|
}
|
|
} else {
|
|
if (pstr_intermediate_filter_params->str_second_order_filter_params_for_zeros[idx]
|
|
.coeff[1] == 0.0f) {
|
|
if (radius_diff > fabs(fabs(pstr_intermediate_filter_params
|
|
->str_second_order_filter_params_for_zeros[idx]
|
|
.radius) -
|
|
radius_max)) {
|
|
radius_diff =
|
|
(FLOAT32)fabs(fabs(pstr_intermediate_filter_params
|
|
->str_second_order_filter_params_for_zeros[idx]
|
|
.radius) -
|
|
radius_max);
|
|
zeros_index = idx;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (zeros_index == -1) {
|
|
for (idx = 0; idx < pstr_intermediate_filter_params->filter_param_count_for_zeros;
|
|
idx++) {
|
|
if (ptr_zeros_done[idx] == 0 && pstr_intermediate_filter_params->filter_format == 0) {
|
|
if (pole_order == 2) {
|
|
if (pstr_intermediate_filter_params->str_second_order_filter_params_for_zeros[idx]
|
|
.coeff[1] == 0.0f) {
|
|
if (radius_diff > fabs(fabs(pstr_intermediate_filter_params
|
|
->str_second_order_filter_params_for_zeros[idx]
|
|
.radius) -
|
|
radius_max)) {
|
|
radius_diff =
|
|
(FLOAT32)fabs(fabs(pstr_intermediate_filter_params
|
|
->str_second_order_filter_params_for_zeros[idx]
|
|
.radius) -
|
|
radius_max);
|
|
zeros_index = idx;
|
|
}
|
|
}
|
|
} else {
|
|
if (pstr_intermediate_filter_params->str_second_order_filter_params_for_zeros[idx]
|
|
.coeff[1] != 0.0f) {
|
|
if (radius_diff > fabs(fabs(pstr_intermediate_filter_params
|
|
->str_second_order_filter_params_for_zeros[idx]
|
|
.radius) -
|
|
radius_max)) {
|
|
radius_diff =
|
|
(FLOAT32)fabs(fabs(pstr_intermediate_filter_params
|
|
->str_second_order_filter_params_for_zeros[idx]
|
|
.radius) -
|
|
radius_max);
|
|
zeros_index = idx;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
pstr_eq_filter_element->str_pole_zero_filter.str_filter_section[section].var_a1 =
|
|
pstr_intermediate_filter_params->str_second_order_filter_params_for_poles[poles_index]
|
|
.coeff[0];
|
|
pstr_eq_filter_element->str_pole_zero_filter.str_filter_section[section].var_a2 =
|
|
pstr_intermediate_filter_params->str_second_order_filter_params_for_poles[poles_index]
|
|
.coeff[1];
|
|
if (zeros_index < 0) {
|
|
pstr_eq_filter_element->str_pole_zero_filter.str_filter_section[section].var_b1 = 0.0f;
|
|
pstr_eq_filter_element->str_pole_zero_filter.str_filter_section[section].var_b2 = 0.0f;
|
|
pstr_eq_filter_element->str_pole_zero_filter.str_audio_delay.delay++;
|
|
} else {
|
|
pstr_eq_filter_element->str_pole_zero_filter.str_filter_section[section].var_b1 =
|
|
pstr_intermediate_filter_params->str_second_order_filter_params_for_zeros[zeros_index]
|
|
.coeff[0];
|
|
pstr_eq_filter_element->str_pole_zero_filter.str_filter_section[section].var_b2 =
|
|
pstr_intermediate_filter_params->str_second_order_filter_params_for_zeros[zeros_index]
|
|
.coeff[1];
|
|
}
|
|
for (ch_idx = 0; ch_idx < MAX_EQ_CHANNEL_COUNT; ch_idx++) {
|
|
pstr_eq_filter_element->str_pole_zero_filter.str_filter_section[section]
|
|
.str_filter_section_state[ch_idx]
|
|
.state_in_1 = 0.0f;
|
|
pstr_eq_filter_element->str_pole_zero_filter.str_filter_section[section]
|
|
.str_filter_section_state[ch_idx]
|
|
.state_in_2 = 0.0f;
|
|
pstr_eq_filter_element->str_pole_zero_filter.str_filter_section[section]
|
|
.str_filter_section_state[ch_idx]
|
|
.state_out_1 = 0.0f;
|
|
pstr_eq_filter_element->str_pole_zero_filter.str_filter_section[section]
|
|
.str_filter_section_state[ch_idx]
|
|
.state_out_2 = 0.0f;
|
|
}
|
|
if (zeros_index >= 0) {
|
|
ptr_zeros_done[zeros_index] = 1;
|
|
}
|
|
if (poles_index >= 0) {
|
|
ptr_poles_done[poles_index] = 1;
|
|
}
|
|
section++;
|
|
}
|
|
} while (poles_index >= 0);
|
|
|
|
pstr_eq_filter_element->str_pole_zero_filter.section_count = section;
|
|
|
|
coeff_count = 1;
|
|
ptr_coeff = pstr_eq_filter_element->str_pole_zero_filter.str_fir_filter.coeff;
|
|
ptr_coeff[0] = 1.0f;
|
|
for (idx = 0; idx < pstr_intermediate_filter_params->filter_param_count_for_zeros; idx++) {
|
|
if (ptr_zeros_done[idx] == 0 && pstr_intermediate_filter_params->filter_format == 0) {
|
|
temp_b1 =
|
|
pstr_intermediate_filter_params->str_second_order_filter_params_for_zeros[idx].coeff[0];
|
|
temp_b2 =
|
|
pstr_intermediate_filter_params->str_second_order_filter_params_for_zeros[idx].coeff[1];
|
|
|
|
coeff_count += 2;
|
|
coeff_idx = coeff_count - 1;
|
|
ptr_coeff[coeff_idx] = temp_b2 * ptr_coeff[coeff_idx - 2];
|
|
coeff_idx--;
|
|
if (coeff_idx > 1) {
|
|
ptr_coeff[coeff_idx] =
|
|
temp_b1 * ptr_coeff[coeff_idx - 1] + temp_b2 * ptr_coeff[coeff_idx - 2];
|
|
coeff_idx--;
|
|
for (; coeff_idx > 1; coeff_idx--) {
|
|
ptr_coeff[coeff_idx] +=
|
|
temp_b1 * ptr_coeff[coeff_idx - 1] + temp_b2 * ptr_coeff[coeff_idx - 2];
|
|
}
|
|
ptr_coeff[1] += temp_b1 * ptr_coeff[0];
|
|
} else {
|
|
ptr_coeff[1] = temp_b1 * ptr_coeff[0];
|
|
}
|
|
}
|
|
ptr_zeros_done[idx] = 1;
|
|
}
|
|
if (coeff_count > 1) {
|
|
pstr_eq_filter_element->str_pole_zero_filter.fir_coeffs_present = 1;
|
|
pstr_eq_filter_element->str_pole_zero_filter.str_fir_filter.coeff_count = coeff_count;
|
|
} else {
|
|
pstr_eq_filter_element->str_pole_zero_filter.fir_coeffs_present = 0;
|
|
pstr_eq_filter_element->str_pole_zero_filter.str_fir_filter.coeff_count = 0;
|
|
}
|
|
}
|
|
|
|
static IA_ERRORCODE impd_drc_derive_filter_block(
|
|
ia_drc_unique_td_filter_element_struct *pstr_unique_td_filter_element,
|
|
ia_drc_filter_block_struct *pstr_filter_block,
|
|
ia_drc_eq_filter_block_struct *pstr_eq_filter_block, VOID *ptr_scratch,
|
|
WORD32 *scratch_used) {
|
|
IA_ERRORCODE err_code = IA_NO_ERROR;
|
|
LOOPIDX i, j;
|
|
WORD32 filter_index;
|
|
WORD32 temp_scratch_used = *scratch_used;
|
|
ia_drc_intermediate_filter_params_struct str_intermediate_filter_params;
|
|
ia_drc_eq_filter_element_struct *pstr_eq_filter_element;
|
|
ia_drc_filter_element_struct *pstr_filter_element;
|
|
ia_drc_matching_phase_filter_struct *pstr_matching_phase_filter =
|
|
(ia_drc_matching_phase_filter_struct *)((pUWORD8)(ptr_scratch)) + temp_scratch_used;
|
|
|
|
temp_scratch_used += sizeof(ia_drc_matching_phase_filter_struct) * FILTER_ELEMENT_COUNT_MAX;
|
|
|
|
for (i = 0; i < pstr_filter_block->filter_element_count; i++) {
|
|
if ((pstr_unique_td_filter_element[pstr_filter_block->filter_element[i].filter_element_index]
|
|
.eq_filter_format == FILTER_ELEMENT_FORMAT_FIR) &&
|
|
(pstr_filter_block->filter_element_count > 1)) {
|
|
return IA_EXHEAACE_CONFIG_FATAL_DRC_INVALID_CONFIG;
|
|
}
|
|
}
|
|
for (i = 0; i < pstr_filter_block->filter_element_count; i++) {
|
|
pstr_filter_element = &pstr_filter_block->filter_element[i];
|
|
filter_index = pstr_filter_element->filter_element_index;
|
|
pstr_eq_filter_element = &pstr_eq_filter_block->str_eq_filter_element[i];
|
|
|
|
if (pstr_unique_td_filter_element[filter_index].eq_filter_format ==
|
|
FILTER_ELEMENT_FORMAT_POLE_ZERO) {
|
|
err_code = impd_drc_derive_pole_zero_filter_params(
|
|
&(pstr_unique_td_filter_element[filter_index]), &str_intermediate_filter_params);
|
|
if (err_code & IA_FATAL_ERROR) {
|
|
return err_code;
|
|
}
|
|
|
|
impd_drc_derive_eq_filter_elements(&str_intermediate_filter_params, pstr_eq_filter_element,
|
|
(pUWORD8)(ptr_scratch) + temp_scratch_used);
|
|
pstr_eq_filter_element->format = FILTER_ELEMENT_FORMAT_POLE_ZERO;
|
|
} else {
|
|
impd_drc_convert_fir_filter_params(
|
|
pstr_unique_td_filter_element[filter_index].fir_filter_order,
|
|
pstr_unique_td_filter_element[filter_index].fir_symmetry,
|
|
pstr_unique_td_filter_element[filter_index].fir_coefficient,
|
|
&pstr_eq_filter_element->str_fir_filter);
|
|
pstr_eq_filter_element->format = FILTER_ELEMENT_FORMAT_FIR;
|
|
}
|
|
if (pstr_filter_element->filter_element_gain_present != 1) {
|
|
pstr_eq_filter_element->element_gain_linear = 1.0f;
|
|
} else {
|
|
pstr_eq_filter_element->element_gain_linear =
|
|
(FLOAT32)pow(10.0f, 0.05f * pstr_filter_element->filter_element_gain);
|
|
}
|
|
for (j = 0; j < pstr_unique_td_filter_element[filter_index].real_zero_count; j++) {
|
|
if (pstr_unique_td_filter_element[filter_index].real_zero_radius[j] > 0.0f) {
|
|
pstr_eq_filter_element->element_gain_linear =
|
|
-pstr_eq_filter_element->element_gain_linear;
|
|
}
|
|
}
|
|
impd_drc_derive_matching_phase_filter(&(pstr_unique_td_filter_element[filter_index]), i,
|
|
&pstr_matching_phase_filter[i]);
|
|
}
|
|
pstr_eq_filter_block->str_matching_phase_filter_element_0 = pstr_matching_phase_filter[0];
|
|
pstr_eq_filter_block->element_count = pstr_filter_block->filter_element_count;
|
|
|
|
err_code = impd_drc_derive_element_phase_alignment_filters(
|
|
pstr_matching_phase_filter, pstr_eq_filter_block, ptr_scratch, &temp_scratch_used);
|
|
if (err_code & IA_FATAL_ERROR) {
|
|
return err_code;
|
|
}
|
|
|
|
return err_code;
|
|
}
|
|
|
|
static IA_ERRORCODE impd_drc_derive_cascade_phase_alignment_filters(
|
|
ia_drc_td_filter_cascade_struct *pstr_td_filter_cascade, const WORD32 channel_group_count,
|
|
ia_drc_filter_cascade_t_domain_struct *pstr_filter_cascade_t_domain, VOID *ptr_scratch,
|
|
WORD32 *scratch_used) {
|
|
IA_ERRORCODE err_code = IA_NO_ERROR;
|
|
WORD32 cascade_alignment_group_count = 0;
|
|
ia_drc_cascade_alignment_group_struct *pstr_cascade_alignment_group =
|
|
(ia_drc_cascade_alignment_group_struct *)ptr_scratch;
|
|
*scratch_used +=
|
|
sizeof(ia_drc_cascade_alignment_group_struct) * (EQ_MAX_CHANNEL_GROUP_COUNT / 2);
|
|
|
|
impd_drc_derive_cascade_alignment_groups(
|
|
channel_group_count, pstr_td_filter_cascade->eq_phase_alignment_present,
|
|
(const WORD32(*)[EQ_MAX_CHANNEL_GROUP_COUNT])pstr_td_filter_cascade->eq_phase_alignment,
|
|
&cascade_alignment_group_count, pstr_cascade_alignment_group);
|
|
|
|
if (cascade_alignment_group_count > 0) {
|
|
err_code = impd_drc_phase_align_cascade_group(
|
|
cascade_alignment_group_count, pstr_cascade_alignment_group, pstr_filter_cascade_t_domain,
|
|
ptr_scratch, scratch_used);
|
|
if (err_code & IA_FATAL_ERROR) {
|
|
return err_code;
|
|
}
|
|
}
|
|
|
|
return err_code;
|
|
}
|
|
|
|
static IA_ERRORCODE impd_drc_derive_filter_cascade(
|
|
ia_drc_unique_td_filter_element_struct *pstr_unique_td_filter_element,
|
|
ia_drc_filter_block_struct *pstr_filter_block,
|
|
ia_drc_td_filter_cascade_struct *pstr_td_filter_cascade, WORD32 channel_group_count,
|
|
ia_drc_filter_cascade_t_domain_struct *pstr_filter_cascade_t_domain, VOID *ptr_scratch,
|
|
WORD32 *scratch_used) {
|
|
IA_ERRORCODE err_code = IA_NO_ERROR;
|
|
LOOPIDX i, j;
|
|
|
|
for (i = 0; i < channel_group_count; i++) {
|
|
for (j = 0; j < pstr_td_filter_cascade->str_filter_block_refs[i].filter_block_count; j++) {
|
|
err_code = impd_drc_derive_filter_block(
|
|
pstr_unique_td_filter_element,
|
|
&(pstr_filter_block[pstr_td_filter_cascade->str_filter_block_refs[i]
|
|
.filter_block_index[j]]),
|
|
&(pstr_filter_cascade_t_domain[i].str_eq_filter_block[j]), ptr_scratch, scratch_used);
|
|
if (err_code & IA_FATAL_ERROR) {
|
|
return err_code;
|
|
}
|
|
}
|
|
pstr_filter_cascade_t_domain[i].cascade_gain_linear =
|
|
(FLOAT32)pow(10.0f, 0.05f * pstr_td_filter_cascade->eq_cascade_gain[i]);
|
|
pstr_filter_cascade_t_domain[i].block_count = j;
|
|
}
|
|
|
|
err_code = impd_drc_derive_cascade_phase_alignment_filters(
|
|
pstr_td_filter_cascade, channel_group_count, pstr_filter_cascade_t_domain, ptr_scratch,
|
|
scratch_used);
|
|
if (err_code & IA_FATAL_ERROR) {
|
|
return err_code;
|
|
}
|
|
|
|
return err_code;
|
|
}
|
|
|
|
static VOID impd_drc_derive_subband_eq(
|
|
ia_drc_eq_subband_gain_vector_struct *pstr_eq_subband_gain_vector,
|
|
const WORD32 eq_subband_gain_count, ia_drc_subband_filter_struct *pstr_subband_filter) {
|
|
LOOPIDX idx;
|
|
|
|
for (idx = 0; idx < eq_subband_gain_count; idx++) {
|
|
pstr_subband_filter->subband_coeff[idx] =
|
|
(FLOAT32)pstr_eq_subband_gain_vector->eq_subband_gain[idx];
|
|
}
|
|
pstr_subband_filter->coeff_count = eq_subband_gain_count;
|
|
}
|
|
|
|
static FLOAT32 impd_drc_decode_eq_node_freq(const WORD32 eq_node_freq_index) {
|
|
FLOAT32 eq_node_frequency;
|
|
|
|
eq_node_frequency =
|
|
(FLOAT32)(pow(STEP_RATIO_F_LOW, 1.0f + eq_node_freq_index * STEP_RATIO_COMPUTED));
|
|
|
|
return eq_node_frequency;
|
|
}
|
|
|
|
static FLOAT32 impd_drc_warp_freq_delta(const FLOAT32 f_subband, const FLOAT32 node_frequency_0,
|
|
const WORD32 eq_node_freq_index) {
|
|
FLOAT32 wraped_delta_frequency;
|
|
|
|
wraped_delta_frequency =
|
|
(FLOAT32)((log10(f_subband) / log10(node_frequency_0) - 1.0f) / STEP_RATIO_COMPUTED -
|
|
(FLOAT32)eq_node_freq_index);
|
|
|
|
return wraped_delta_frequency;
|
|
}
|
|
|
|
static VOID impd_drc_interpolate_eq_gain(const WORD32 band_step, const FLOAT32 eq_gain_0,
|
|
const FLOAT32 eq_gain_1, const FLOAT32 eq_slope_0,
|
|
const FLOAT32 eq_slope_1, const FLOAT32 wrap_delta_freq,
|
|
FLOAT32 *interpolated_gain) {
|
|
FLOAT32 k1, k2, val_a, val_b;
|
|
FLOAT32 nodes_per_octave_count = 3.128f;
|
|
FLOAT32 gain_left = eq_gain_0;
|
|
FLOAT32 gain_right = eq_gain_1;
|
|
FLOAT32 slope_left = eq_slope_0 / nodes_per_octave_count;
|
|
FLOAT32 slope_right = eq_slope_1 / nodes_per_octave_count;
|
|
FLOAT32 band_step_inv = (FLOAT32)(1.0 / (FLOAT32)band_step);
|
|
FLOAT32 band_step_inv_square = band_step_inv * band_step_inv;
|
|
|
|
k1 = (gain_right - gain_left) * band_step_inv_square;
|
|
k2 = slope_right + slope_left;
|
|
val_a = (FLOAT32)(band_step_inv * (band_step_inv * k2 - 2.0 * k1));
|
|
val_b = (FLOAT32)(3.0 * k1 - band_step_inv * (k2 + slope_left));
|
|
|
|
*interpolated_gain =
|
|
(((val_a * wrap_delta_freq + val_b) * wrap_delta_freq + slope_left) * wrap_delta_freq) +
|
|
gain_left;
|
|
}
|
|
|
|
static IA_ERRORCODE impd_drc_interpolate_subband_spline(
|
|
ia_drc_eq_subband_gain_spline_struct *pstr_eq_subband_gain_spline,
|
|
const WORD32 eq_subband_gain_count, const WORD32 eq_subband_gain_format,
|
|
const FLOAT32 audio_sample_rate, ia_drc_subband_filter_struct *pstr_subband_filter,
|
|
VOID *ptr_scratch) {
|
|
IA_ERRORCODE err_code = IA_NO_ERROR;
|
|
LOOPIDX i, j;
|
|
WORD32 eq_node_freq_index[32] = {0};
|
|
WORD32 n_eq_nodes = pstr_eq_subband_gain_spline->n_eq_nodes;
|
|
WORD32 eq_node_count_max = 33;
|
|
WORD32 eq_node_index_max = eq_node_count_max - 1;
|
|
WORD32 *ptr_eq_freq_delta = pstr_eq_subband_gain_spline->eq_freq_delta;
|
|
FLOAT32 eq_gain[32] = {0}, eq_node_freq[32] = {0};
|
|
FLOAT32 freq_subband, warped_delta_freq, g_eq_subband_db;
|
|
FLOAT32 eq_gain_initial = pstr_eq_subband_gain_spline->eq_gain_initial;
|
|
FLOAT32 *ptr_subband_center_freq = (FLOAT32 *)ptr_scratch;
|
|
FLOAT32 *ptr_eq_slope = pstr_eq_subband_gain_spline->eq_slope;
|
|
FLOAT32 *ptr_eq_gain_delta = pstr_eq_subband_gain_spline->eq_gain_delta;
|
|
FLOAT32 *ptr_subband_coeff = pstr_subband_filter->subband_coeff;
|
|
|
|
eq_gain[0] = eq_gain_initial;
|
|
eq_node_freq_index[0] = 0;
|
|
eq_node_freq[0] = impd_drc_decode_eq_node_freq(eq_node_freq_index[0]);
|
|
for (i = 1; i < n_eq_nodes; i++) {
|
|
eq_gain[i] = eq_gain[i - 1] + ptr_eq_gain_delta[i];
|
|
eq_node_freq_index[i] = eq_node_freq_index[i - 1] + ptr_eq_freq_delta[i];
|
|
eq_node_freq[i] = impd_drc_decode_eq_node_freq(eq_node_freq_index[i]);
|
|
}
|
|
if ((eq_node_freq[n_eq_nodes - 1] < audio_sample_rate * 0.5f) &&
|
|
(eq_node_freq_index[n_eq_nodes - 1] < eq_node_index_max)) {
|
|
ptr_eq_slope[n_eq_nodes] = 0;
|
|
eq_gain[n_eq_nodes] = eq_gain[n_eq_nodes - 1];
|
|
ptr_eq_freq_delta[n_eq_nodes] = eq_node_index_max - eq_node_freq_index[n_eq_nodes - 1];
|
|
eq_node_freq_index[n_eq_nodes] = eq_node_index_max;
|
|
eq_node_freq[n_eq_nodes] = impd_drc_decode_eq_node_freq(eq_node_freq_index[n_eq_nodes]);
|
|
n_eq_nodes += 1;
|
|
}
|
|
|
|
err_code = impd_drc_derive_subband_center_freq(eq_subband_gain_count, eq_subband_gain_format,
|
|
audio_sample_rate, ptr_subband_center_freq);
|
|
if (err_code & IA_FATAL_ERROR) {
|
|
return err_code;
|
|
}
|
|
|
|
for (i = 0; i < n_eq_nodes - 1; i++) {
|
|
for (j = 0; j < eq_subband_gain_count; j++) {
|
|
freq_subband = MAX(ptr_subband_center_freq[j], eq_node_freq[0]);
|
|
freq_subband = MIN(freq_subband, eq_node_freq[n_eq_nodes - 1]);
|
|
if ((freq_subband >= eq_node_freq[i]) && (freq_subband <= eq_node_freq[i + 1])) {
|
|
warped_delta_freq =
|
|
impd_drc_warp_freq_delta(freq_subband, eq_node_freq[0], eq_node_freq_index[i]);
|
|
impd_drc_interpolate_eq_gain(ptr_eq_freq_delta[i + 1], eq_gain[i], eq_gain[i + 1],
|
|
ptr_eq_slope[i], ptr_eq_slope[i + 1], warped_delta_freq,
|
|
&g_eq_subband_db);
|
|
|
|
ptr_subband_coeff[j] = (FLOAT32)pow(2.0, (FLOAT32)(g_eq_subband_db / 6.0f));
|
|
}
|
|
}
|
|
}
|
|
pstr_subband_filter->coeff_count = eq_subband_gain_count;
|
|
|
|
return err_code;
|
|
}
|
|
|
|
static IA_ERRORCODE impd_drc_derive_subband_gains(
|
|
ia_drc_eq_coefficients_struct *pstr_eq_coefficients, const WORD32 eq_channel_group_count,
|
|
const WORD32 *subband_gains_index, const FLOAT32 audio_sample_rate,
|
|
const WORD32 eq_frame_size_subband, ia_drc_subband_filter_struct *pstr_subband_filter,
|
|
VOID *ptr_scratch) {
|
|
IA_ERRORCODE err_code = IA_NO_ERROR;
|
|
LOOPIDX idx;
|
|
|
|
for (idx = 0; idx < eq_channel_group_count; idx++) {
|
|
if (pstr_eq_coefficients->eq_subband_gain_representation != 1) {
|
|
impd_drc_derive_subband_eq(
|
|
&(pstr_eq_coefficients->str_eq_subband_gain_vector[subband_gains_index[idx]]),
|
|
pstr_eq_coefficients->eq_subband_gain_count, &(pstr_subband_filter[idx]));
|
|
} else {
|
|
err_code = impd_drc_interpolate_subband_spline(
|
|
&(pstr_eq_coefficients->str_eq_subband_gain_spline[subband_gains_index[idx]]),
|
|
pstr_eq_coefficients->eq_subband_gain_count,
|
|
pstr_eq_coefficients->eq_subband_gain_format, audio_sample_rate,
|
|
&(pstr_subband_filter[idx]), ptr_scratch);
|
|
if (err_code & IA_FATAL_ERROR) {
|
|
return err_code;
|
|
}
|
|
}
|
|
pstr_subband_filter[idx].eq_frame_size_subband = eq_frame_size_subband;
|
|
}
|
|
|
|
return err_code;
|
|
}
|
|
|
|
IA_ERRORCODE impd_drc_get_eq_complexity(ia_drc_eq_set_struct *pstr_eq_set,
|
|
WORD32 *eq_complexity_level) {
|
|
LOOPIDX idx_c, idx_b, i, j;
|
|
WORD32 group;
|
|
WORD32 fir_order_complexity = 0;
|
|
WORD32 zero_pole_pair_count_complexity = 0;
|
|
WORD32 subband_filter_complexity = 0;
|
|
FLOAT32 complexity;
|
|
ia_drc_filter_cascade_t_domain_struct *pstr_filter_cascade_t_domain;
|
|
ia_drc_eq_filter_block_struct *pstr_eq_filter_block;
|
|
ia_drc_eq_filter_element_struct *pstr_eq_filter_element;
|
|
|
|
for (idx_c = 0; idx_c < pstr_eq_set->audio_channel_count; idx_c++) {
|
|
group = pstr_eq_set->eq_channel_group_for_channel[idx_c];
|
|
if (group >= 0) {
|
|
switch (pstr_eq_set->domain) {
|
|
case EQ_FILTER_DOMAIN_TIME: {
|
|
pstr_filter_cascade_t_domain = &pstr_eq_set->str_filter_cascade_t_domain[group];
|
|
for (idx_b = 0; idx_b < pstr_filter_cascade_t_domain->block_count; idx_b++) {
|
|
pstr_eq_filter_block = &pstr_filter_cascade_t_domain->str_eq_filter_block[idx_b];
|
|
for (i = 0; i < pstr_eq_filter_block->element_count; i++) {
|
|
pstr_eq_filter_element = &pstr_eq_filter_block->str_eq_filter_element[i];
|
|
switch (pstr_eq_filter_element->format) {
|
|
case FILTER_ELEMENT_FORMAT_POLE_ZERO:
|
|
zero_pole_pair_count_complexity +=
|
|
pstr_eq_filter_element->str_pole_zero_filter.section_count * 2;
|
|
if (pstr_eq_filter_element->str_pole_zero_filter.fir_coeffs_present) {
|
|
fir_order_complexity +=
|
|
pstr_eq_filter_element->str_pole_zero_filter.str_fir_filter.coeff_count -
|
|
1;
|
|
}
|
|
break;
|
|
case FILTER_ELEMENT_FORMAT_FIR:
|
|
fir_order_complexity += pstr_eq_filter_element->str_fir_filter.coeff_count - 1;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
for (j = 0; j < pstr_eq_filter_element->phase_alignment_filter_count; j++) {
|
|
zero_pole_pair_count_complexity +=
|
|
pstr_eq_filter_element->str_phase_alignment_filter[j].section_count * 2;
|
|
}
|
|
}
|
|
}
|
|
for (idx_b = 0; idx_b < pstr_filter_cascade_t_domain->phase_alignment_filter_count;
|
|
idx_b++) {
|
|
zero_pole_pair_count_complexity +=
|
|
pstr_filter_cascade_t_domain->str_phase_alignment_filter[idx_b].section_count * 2;
|
|
}
|
|
} break;
|
|
case EQ_FILTER_DOMAIN_SUBBAND:
|
|
subband_filter_complexity++;
|
|
break;
|
|
case EQ_FILTER_DOMAIN_NONE:
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
complexity = COMPLEXITY_W_SUBBAND_EQ * subband_filter_complexity;
|
|
complexity += COMPLEXITY_W_FIR * fir_order_complexity;
|
|
complexity += COMPLEXITY_W_IIR * zero_pole_pair_count_complexity;
|
|
complexity = (FLOAT32)(log10(complexity / pstr_eq_set->audio_channel_count) / log10(2.0f));
|
|
*eq_complexity_level = (WORD32)MAX(0, ceil(complexity));
|
|
if (*eq_complexity_level > EQ_COMPLEXITY_LEVEL_MAX) {
|
|
return IA_EXHEAACE_CONFIG_FATAL_DRC_INVALID_CONFIG;
|
|
}
|
|
|
|
return IA_NO_ERROR;
|
|
}
|
|
|
|
IA_ERRORCODE impd_drc_derive_eq_set(ia_drc_eq_coefficients_struct *pstr_eq_coefficients,
|
|
ia_drc_eq_instructions_struct *pstr_eq_instructions,
|
|
const FLOAT32 audio_sample_rate, const WORD32 drc_frame_size,
|
|
const WORD32 sub_band_domain_mode,
|
|
ia_drc_eq_set_struct *pstr_eq_set, VOID *ptr_scratch,
|
|
WORD32 *scratch_used) {
|
|
IA_ERRORCODE err_code = IA_NO_ERROR;
|
|
LOOPIDX idx;
|
|
WORD32 eq_frame_size_subband;
|
|
|
|
pstr_eq_set->domain = EQ_FILTER_DOMAIN_NONE;
|
|
|
|
if (sub_band_domain_mode != SUBBAND_DOMAIN_MODE_OFF) {
|
|
switch (sub_band_domain_mode) {
|
|
case SUBBAND_DOMAIN_MODE_STFT256:
|
|
if (pstr_eq_coefficients->eq_subband_gain_count != STFT256_AUDIO_CODEC_SUBBAND_COUNT) {
|
|
return IA_EXHEAACE_CONFIG_FATAL_DRC_INVALID_CONFIG;
|
|
}
|
|
eq_frame_size_subband = drc_frame_size / STFT256_AUDIO_CODEC_SUBBAND_DOWNSAMPLING_FACTOR;
|
|
break;
|
|
case SUBBAND_DOMAIN_MODE_QMF71:
|
|
if (pstr_eq_coefficients->eq_subband_gain_count != QMF71_AUDIO_CODEC_SUBBAND_COUNT) {
|
|
return IA_EXHEAACE_CONFIG_FATAL_DRC_INVALID_CONFIG;
|
|
}
|
|
eq_frame_size_subband = drc_frame_size / QMF71_AUDIO_CODEC_SUBBAND_DOWNSAMPLING_FACTOR;
|
|
break;
|
|
case SUBBAND_DOMAIN_MODE_QMF64:
|
|
if (pstr_eq_coefficients->eq_subband_gain_count != QMF64_AUDIO_CODEC_SUBBAND_COUNT) {
|
|
return IA_EXHEAACE_CONFIG_FATAL_DRC_INVALID_CONFIG;
|
|
}
|
|
eq_frame_size_subband = drc_frame_size / QMF64_AUDIO_CODEC_SUBBAND_DOWNSAMPLING_FACTOR;
|
|
break;
|
|
default:
|
|
return IA_EXHEAACE_CONFIG_FATAL_DRC_INVALID_CONFIG;
|
|
break;
|
|
}
|
|
if (pstr_eq_instructions->subband_gains_present == 1) {
|
|
err_code = impd_drc_derive_subband_gains(
|
|
pstr_eq_coefficients, pstr_eq_instructions->eq_channel_group_count,
|
|
pstr_eq_instructions->subband_gains_index, audio_sample_rate, eq_frame_size_subband,
|
|
pstr_eq_set->str_subband_filter, ptr_scratch);
|
|
if (err_code & IA_FATAL_ERROR) {
|
|
return err_code;
|
|
}
|
|
} else {
|
|
if (pstr_eq_instructions->td_filter_cascade_present == 1) {
|
|
err_code = impd_drc_derive_subband_gains_from_td_cascade(
|
|
pstr_eq_coefficients->str_unique_td_filter_element,
|
|
pstr_eq_coefficients->str_filter_block, &pstr_eq_instructions->str_td_filter_cascade,
|
|
pstr_eq_coefficients->eq_subband_gain_format,
|
|
pstr_eq_instructions->eq_channel_group_count, audio_sample_rate,
|
|
eq_frame_size_subband, pstr_eq_set->str_subband_filter, ptr_scratch);
|
|
if (err_code & IA_FATAL_ERROR) {
|
|
return err_code;
|
|
}
|
|
} else {
|
|
err_code = IA_EXHEAACE_CONFIG_NONFATAL_DRC_MISSING_CONFIG;
|
|
}
|
|
}
|
|
pstr_eq_set->domain |= EQ_FILTER_DOMAIN_SUBBAND;
|
|
} else {
|
|
if (pstr_eq_instructions->td_filter_cascade_present == 1) {
|
|
err_code = impd_drc_derive_filter_cascade(
|
|
pstr_eq_coefficients->str_unique_td_filter_element,
|
|
pstr_eq_coefficients->str_filter_block, &pstr_eq_instructions->str_td_filter_cascade,
|
|
pstr_eq_instructions->eq_channel_group_count, pstr_eq_set->str_filter_cascade_t_domain,
|
|
ptr_scratch, scratch_used);
|
|
if (err_code & IA_FATAL_ERROR) {
|
|
return err_code;
|
|
}
|
|
}
|
|
pstr_eq_set->domain |= EQ_FILTER_DOMAIN_TIME;
|
|
}
|
|
|
|
pstr_eq_set->audio_channel_count = pstr_eq_instructions->eq_channel_count;
|
|
pstr_eq_set->eq_channel_group_count = pstr_eq_instructions->eq_channel_group_count;
|
|
|
|
for (idx = 0; idx < pstr_eq_instructions->eq_channel_count; idx++) {
|
|
pstr_eq_set->eq_channel_group_for_channel[idx] =
|
|
pstr_eq_instructions->eq_channel_group_for_channel[idx];
|
|
}
|
|
|
|
return err_code;
|
|
}
|