decoder/drc_src/impd_drc_eq.c

/******************************************************************************
 *
 * 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 <stdlib.h>
#include <math.h>
#include <string.h>
#include "impd_type_def.h"
#include "impd_drc_extr_delta_coded_info.h"
#include "impd_drc_common.h"
#include "impd_drc_struct.h"
#include "impd_drc_interface.h"
#include "impd_drc_gain_dec.h"
#include "impd_drc_eq.h"

#define CONFIG_REAL_POLE 0
#define CONFIG_COMPLEX_POLE 1
#define CONFIG_REAL_ZERO_RADIUS_ONE 2
#define CONFIG_REAL_ZERO 3
#define CONFIG_GENERIC_ZERO 4

#define STEP_RATIO_F_LO 20.0f
#define STEP_RATIO_F_HI 24000.0f
#define STEP_RATIO_EQ_NODE_COUNT_MAX 33

#define FILTER_ELEMENT_FORMAT_POLE_ZERO 0
#define FILTER_ELEMENT_FORMAT_FIR 1

#ifndef M_PI
#define M_PI (3.14159265358979323846)
#endif

WORD32 impd_derive_subband_center_freq(WORD32 eq_subband_gain_count,
                                       WORD32 eq_subband_gain_format,
                                       FLOAT32 sample_rate,
                                       FLOAT32* subband_center_freq) {
  WORD32 i;
  FLOAT32 width, offset;
  switch (eq_subband_gain_format) {
    case GAINFORMAT_QMF32:
    case GAINFORMAT_QMF64:
    case GAINFORMAT_QMF128:
    case GAINFORMAT_UNIFORM:
      width = 0.5f * sample_rate / (FLOAT32)eq_subband_gain_count;
      offset = 0.5f * width;
      for (i = 0; i < eq_subband_gain_count; i++) {
        subband_center_freq[i] = offset;
        offset = offset + width;
      }
      break;
    case GAINFORMAT_QMFHYBRID39:
    case GAINFORMAT_QMFHYBRID71:
    case GAINFORMAT_QMFHYBRID135:
      return (UNEXPECTED_ERROR);
      break;
    default:
      break;
  }
  return (0);
}

VOID impd_calc_fir_filt_response(WORD32 fir_order, WORD32 fir_symmetry,
                                 FLOAT32* coeff, FLOAT32 frequency_radian,
                                 FLOAT32* response) {
  WORD32 m;
  FLOAT32 sum = 0.0f;
  WORD32 o2;

  if ((fir_order & 0x1) == 0) {
    o2 = fir_order / 2;
    if (fir_symmetry == 0) {
      /*ITTIAM: sum is been over written after the loop
                None of the conformance streams with us entering this function*/
      for (m = 1; m <= o2; m++) {
        sum += coeff[o2 - m] * (FLOAT32)cos(m * frequency_radian);
      }
      sum += sum;
      sum = coeff[o2];
    } else {
      for (m = 1; m <= o2; m++) {
        sum += coeff[o2 - m] * (FLOAT32)sin(m * frequency_radian);
      }
      sum += sum;
    }
  } else {
    o2 = (fir_order + 1) / 2;
    if (fir_symmetry == 0) {
      for (m = 1; m <= o2; m++) {
        sum += coeff[o2 - m] * (FLOAT32)cos((m - 0.5f) * frequency_radian);
      }
    } else {
      for (m = 1; m <= o2; m++) {
        sum += coeff[o2 - m] * (FLOAT32)sin((m - 0.5f) * frequency_radian);
      }
    }
    sum += sum;
  }
  *response = sum;
  return;
}

VOID impd_calc_filt_ele_response(ia_unique_td_filt_element* element,
                                 FLOAT32 frequency_radian, FLOAT32* response) {
  WORD32 i;
  FLOAT32 part_response, radius, angle_radian;
  FLOAT64 total_response = 1.0;

  if (element->eq_filter_format == FILTER_ELEMENT_FORMAT_POLE_ZERO) {
    for (i = 0; i < element->bs_real_zero_radius_one_count; i++) {
      part_response =
          1.0f + 1.0f -
          2.0f * 1.0f *
              (FLOAT32)cos(frequency_radian - (FLOAT32)element->zero_sign[i]);
      total_response *= part_response;
    }
    for (i = 0; i < element->real_zero_count; i++) {
      if (element->real_zero_radius[i] < 0.0f) {
        radius = -element->real_zero_radius[i];
        angle_radian = (FLOAT32)M_PI;
      } else {
        radius = element->real_zero_radius[i];
        angle_radian = 0.0f;
      }
      part_response =
          1.0f + radius * radius -
          2.0f * radius * (FLOAT32)cos(frequency_radian - angle_radian);
      total_response *= part_response;
      part_response =
          1.0f + radius * radius -
          2.0f * radius * (FLOAT32)cos(frequency_radian - angle_radian);
      total_response *= part_response;
    }

    total_response = sqrt(total_response);

    for (i = 0; i < element->generic_zero_count; i++) {
      radius = element->generic_zero_radius[i];
      part_response =
          1.0f + radius * radius -
          2.0f * radius *
              (FLOAT32)cos(frequency_radian - element->generic_zero_angle[i]);
      total_response *= part_response;
      part_response =
          1.0f + radius * radius -
          2.0f * radius *
              (FLOAT32)cos(frequency_radian - element->generic_zero_angle[i]);
      total_response *= part_response;
    }
    for (i = 0; i < element->real_pole_count; i++) {
      if (element->real_pole_radius[i] < 0.0f) {
        radius = -element->real_pole_radius[i];
        angle_radian = (FLOAT32)(-M_PI);
      } else {
        radius = element->real_pole_radius[i];
        angle_radian = 0.0f;
      }
      part_response =
          1 / (1.0f + radius * radius -
               2.0f * radius * (FLOAT32)cos(frequency_radian - angle_radian));
      total_response *= part_response;
    }
    for (i = 0; i < element->cmplx_pole_count; i++) {
      part_response =
          1 /
          (1.0f + element->real_pole_radius[i] * element->real_pole_radius[i] -
           2.0f * element->real_pole_radius[i] *
               (FLOAT32)cos(frequency_radian - element->complex_pole_angle[i]));
      total_response *= part_response * part_response;
    }
  } else {
    impd_calc_fir_filt_response(element->fir_filt_order, element->fir_symmetry,
                                element->fir_coeff, frequency_radian,
                                &part_response);

    total_response *= part_response;
  }
  *response = (FLOAT32)total_response;
  return;
}

VOID impd_calc_filt_block_response(
    ia_unique_td_filt_element* unique_td_filt_ele,
    ia_filt_block_struct* str_filter_block, FLOAT32 frequency_radian,
    FLOAT32* response) {
  WORD32 i;
  FLOAT32 part_response;
  FLOAT64 total_response = 1.0;
  for (i = 0; i < str_filter_block->filter_element_count; i++) {
    ia_filt_ele_struct* str_filter_element =
        &str_filter_block->str_filter_element[i];

    impd_calc_filt_ele_response(
        &(unique_td_filt_ele[str_filter_element->filt_ele_idx]),
        frequency_radian, &part_response);
    total_response *= part_response;

    if (str_filter_element->filt_ele_gain_flag == 1) {
      total_response *= pow(10.0f, 0.05f * str_filter_element->filt_ele_gain);
    }
  }
  *response = (FLOAT32)total_response;
  return;
}

WORD32 impd_calc_subband_gains_td_cascade(
    ia_unique_td_filt_element* unique_td_filt_ele,
    ia_filt_block_struct* str_filter_block,
    ia_td_filter_cascade_struct* str_td_filter_cascade,
    WORD32 eq_subband_gain_format, WORD32 eq_ch_group_count,
    FLOAT32 sample_rate, WORD32 eq_frame_size_subband,
    ia_subband_filt_struct* subband_filt) {
  WORD32 i, err = 0, g, b;
  FLOAT32 response, frequency_radian;
  FLOAT32 subband_center_freq[256];
  FLOAT64 total_response;

  WORD32 eq_subband_gain_count = subband_filt->coeff_count;

  err = impd_derive_subband_center_freq(eq_subband_gain_count,
                                        eq_subband_gain_format, sample_rate,
                                        subband_center_freq);
  if (err) return (err);

  for (g = 0; g < eq_ch_group_count; g++) {
    for (b = 0; b < eq_subband_gain_count; b++) {
      total_response =
          pow(10.0f, 0.05f * str_td_filter_cascade->eq_cascade_gain[g]);
      frequency_radian =
          (FLOAT32)(2.0f * M_PI * subband_center_freq[b] / sample_rate);
      for (i = 0;
           i <
           str_td_filter_cascade->str_filter_block_refs[g].filter_block_count;
           i++) {
        impd_calc_filt_block_response(
            unique_td_filt_ele,
            &(str_filter_block[str_td_filter_cascade->str_filter_block_refs[g]
                                   .filter_block_index[i]]),
            frequency_radian, &response);
        total_response *= response;
      }
      subband_filt[g].subband_coeff[b] = (FLOAT32)total_response;
    }
    subband_filt[g].eq_frame_size_subband = eq_frame_size_subband;
  }
  return (0);
}

VOID impd_add_cascade(ia_cascade_align_group_struct* pstr_cascade_align_grp,
                      WORD32 c1, WORD32 c2, WORD32* done) {
  WORD32 m, n;

  *done = 0;
  for (m = 0; m < pstr_cascade_align_grp->member_count; m++) {
    if (pstr_cascade_align_grp->member_idx[m] == c1) {
      for (n = 0; n < pstr_cascade_align_grp->member_count; n++) {
        if (pstr_cascade_align_grp->member_idx[n] == c2) {
          *done = 1;
        }
      }
      if (*done == 0) {
        pstr_cascade_align_grp
            ->member_idx[pstr_cascade_align_grp->member_count] = c2;
        pstr_cascade_align_grp->member_count++;
        *done = 1;
      }
    }
  }
  return;
}

VOID impd_calc_cascade_align_groups(
    WORD32 eq_ch_group_count, WORD32 eq_phase_alignment_present,
    WORD32 eq_phase_alignment[][EQ_CHANNEL_GROUP_COUNT_MAX],
    WORD32* cascade_align_grp_cnt,
    ia_cascade_align_group_struct* pstr_cascade_align_grp) {
  WORD32 i, k, g, group_count, done;

  group_count = 0;

  if (eq_phase_alignment_present == 0) {
    if (eq_ch_group_count > 1) {
      for (i = 0; i < eq_ch_group_count; i++) {
        pstr_cascade_align_grp[group_count].member_idx[i] = i;
      }
      pstr_cascade_align_grp[group_count].member_count = eq_ch_group_count;
      group_count = 1;
    }
  } else {
    for (i = 0; i < eq_ch_group_count; i++) {
      for (k = i + 1; k < eq_ch_group_count; k++) {
        if (eq_phase_alignment[i][k] == 1) {
          done = 0;
          for (g = 0; g < group_count; g++) {
            impd_add_cascade(&pstr_cascade_align_grp[g], i, k, &done);

            if (done == 0) {
              impd_add_cascade(&pstr_cascade_align_grp[g], k, i, &done);
            }
          }
          if (done == 0) {
            pstr_cascade_align_grp[group_count].member_idx[0] = i;
            pstr_cascade_align_grp[group_count].member_idx[1] = k;
            pstr_cascade_align_grp[group_count].member_count = 2;
            group_count++;
          }
        }
      }
    }
  }
  *cascade_align_grp_cnt = group_count;
  return;
}

VOID impd_calc_phase_filt_params(
    WORD32 config, FLOAT32 radius, FLOAT32 angle,
    ia_ph_alignment_filt_struct* ph_alignment_filt) {
  WORD32 channel;
  FLOAT32 zReal, zImag;
  FLOAT32 prod;
  WORD32 section = ph_alignment_filt->section_count;
  ia_filt_sect_struct* filt_section = &ph_alignment_filt->filt_section[section];
  switch (config) {
    case CONFIG_REAL_POLE:
      ph_alignment_filt->gain *= (-radius);
      filt_section->a1 = -radius;
      filt_section->a2 = 0.0f;
      filt_section->b1 = -1.0f / radius;
      filt_section->b2 = 0.0f;
      ph_alignment_filt->section_count++;
      break;
    case CONFIG_COMPLEX_POLE:
      zReal = radius * (FLOAT32)cos(M_PI * angle);
      zImag = radius * (FLOAT32)sin(M_PI * angle);
      prod = zReal * zReal + zImag * zImag;
      ph_alignment_filt->gain *= prod;
      filt_section->a1 = -2.0f * zReal;
      filt_section->a2 = prod;
      filt_section->b1 = -2.0f * zReal / prod;
      filt_section->b2 = 1.0f / prod;
      ph_alignment_filt->section_count++;
      break;
    default:
      break;
  }
  for (channel = 0; channel < EQ_CHANNEL_COUNT_MAX; channel++) {
    filt_section->filt_sect_state[channel].in_state_1 = 0.0f;
    filt_section->filt_sect_state[channel].in_state_2 = 0.0f;
    filt_section->filt_sect_state[channel].out_state_1 = 0.0f;
    filt_section->filt_sect_state[channel].out_state_2 = 0.0f;
  }

  return;
}

VOID impd_calc_phase_filt_delay(
    ia_unique_td_filt_element* element,
    ia_ph_alignment_filt_struct* ph_alignment_filt) {
  WORD32 i, delay = 0, channel;
  if (element->eq_filter_format == FILTER_ELEMENT_FORMAT_POLE_ZERO) {
    if (element->bs_real_zero_radius_one_count == 0) {
      delay = element->real_zero_count + 2 * element->generic_zero_count -
              element->real_pole_count - 2 * element->cmplx_pole_count;
      delay = max(0, delay);
      ph_alignment_filt->validity_flag = 1;
    }
  }
  ph_alignment_filt->audio_delay.delay = delay;
  for (channel = 0; channel < EQ_CHANNEL_COUNT_MAX; channel++) {
    for (i = 0; i < delay; i++) {
      ph_alignment_filt->audio_delay.state[channel][i] = 0.0f;
    }
  }

  return;
}

VOID impd_calc_phase_filt(ia_unique_td_filt_element* element,
                          WORD32 filt_ele_idx,
                          ia_matching_ph_filt_struct* matching_ph_filt) {
  WORD32 i;

  memset(matching_ph_filt, 0, sizeof(ia_matching_ph_filt_struct));
  matching_ph_filt->gain = 1.0f;

  if (element->eq_filter_format == FILTER_ELEMENT_FORMAT_POLE_ZERO) {
    for (i = 0; i < element->real_pole_count; i++) {
      impd_calc_phase_filt_params(CONFIG_REAL_POLE,
                                  element->real_pole_radius[i], 0.0f,
                                  matching_ph_filt);
    }
    for (i = 0; i < element->cmplx_pole_count; i++) {
      impd_calc_phase_filt_params(
          CONFIG_COMPLEX_POLE, element->complex_pole_radius[i],
          element->complex_pole_angle[i], matching_ph_filt);
    }
  }
  impd_calc_phase_filt_delay(element, matching_ph_filt);

  matching_ph_filt->num_matches_filter = 1;
  matching_ph_filt->matches_filter[0] = filt_ele_idx;

  return;
}

WORD32 impd_calc_filt_params(ia_unique_td_filt_element* element,
                             ia_interm_filt_params_struct* interm_filt_params) {
  FLOAT32 zReal;
  FLOAT32* coeff;
  // WORD32   offset_idx = 0;
  WORD32 i;
  WORD32 param_idx = 0;

  ia_2nd_order_filt_params_struct* pstr_2nd_oder_filt_params =
      &interm_filt_params->ord_2_filt_params_of_zeros[0];

  for (i = 0; i < element->bs_real_zero_radius_one_count; i += 2) {
    FLOAT32 radius = (FLOAT32)element->zero_sign[i + 0];
    FLOAT32 angle = (FLOAT32)element->zero_sign[i + 1];
    FLOAT32 angle1 = radius;
    FLOAT32 angle2 = angle;
    pstr_2nd_oder_filt_params->radius = 1.0f;
    coeff = pstr_2nd_oder_filt_params->coeff;

    if (angle1 != angle2) {
      coeff[0] = 0.0f;
      coeff[1] = -1.0f;
    } else if (angle1 == 1.0f) {
      coeff[0] = -2.0f;
      coeff[1] = 1.0f;
    } else {
      coeff[0] = 2.0f;
      coeff[1] = 1.0f;
    }
    pstr_2nd_oder_filt_params += 1;
    param_idx += 1;
  }
  for (i = 0; i < element->real_zero_count; i++) {
    FLOAT32 radius = element->real_zero_radius[i];
    // FLOAT32  angle  = 0.0f;

    pstr_2nd_oder_filt_params->radius = radius;
    if (fabs(radius) == 1.0f) {
      return (-1);
    } else {
      coeff = pstr_2nd_oder_filt_params->coeff;
      coeff[0] = -(radius + 1.0f / radius);
      coeff[1] = 1.0f;
    }
    pstr_2nd_oder_filt_params += 1;
    param_idx += 1;
  }

  for (i = 0; i < element->generic_zero_count; i++) {
    FLOAT32 radius = element->generic_zero_radius[i];
    FLOAT32 angle = element->generic_zero_angle[i];
    zReal = radius * (FLOAT32)cos(M_PI * angle);
    pstr_2nd_oder_filt_params->radius = radius;
    coeff = pstr_2nd_oder_filt_params->coeff;
    coeff[0] = -2.0f * zReal;
    coeff[1] = radius * radius;

    pstr_2nd_oder_filt_params += 1;

    zReal = (FLOAT32)cos(M_PI * angle) / radius;
    pstr_2nd_oder_filt_params->radius = radius;
    coeff = pstr_2nd_oder_filt_params->coeff;
    coeff[0] = -2.0f * zReal;
    coeff[1] = 1.0f / (radius * radius);

    pstr_2nd_oder_filt_params += 1;

    param_idx += 2;
  }

  interm_filt_params->filter_param_count_of_zeros = param_idx;
  param_idx = 0;

  pstr_2nd_oder_filt_params =
      &interm_filt_params->ord_2_filt_params_of_poles[0];

  for (i = 0; i < element->real_pole_count; i++) {
    FLOAT32 radius = element->real_pole_radius[i];
    pstr_2nd_oder_filt_params->radius = radius;
    coeff = pstr_2nd_oder_filt_params->coeff;
    coeff[0] = -2.0f * radius;
    coeff[1] = radius * radius;
    param_idx += 1;
    pstr_2nd_oder_filt_params += 1;
  }

  for (i = 0; i < element->cmplx_pole_count; i++) {
    FLOAT32 radius = element->complex_pole_radius[i];
    FLOAT32 angle = element->complex_pole_angle[i];

    zReal = radius * (FLOAT32)cos(M_PI * angle);
    pstr_2nd_oder_filt_params->radius = radius;
    coeff = pstr_2nd_oder_filt_params->coeff;
    coeff[0] = -2.0f * zReal;
    coeff[1] = radius * radius;

    pstr_2nd_oder_filt_params += 1;

    pstr_2nd_oder_filt_params->radius = radius;
    pstr_2nd_oder_filt_params->coeff[0] = coeff[0];
    pstr_2nd_oder_filt_params->coeff[1] = coeff[1];

    pstr_2nd_oder_filt_params += 1;
    param_idx += 2;
  }
  interm_filt_params->filter_param_count_of_poles = param_idx;
  return 0;
}

VOID impd_convert_fir_filt_params(WORD32 fir_filt_order, WORD32 fir_symmetry,
                                  FLOAT32* fir_coeff,
                                  ia_fir_filter_struct* fir_filter) {
  WORD32 i, channel;
  FLOAT32* coeff = fir_filter->coeff;

  fir_filter->coeff_count = fir_filt_order + 1;
  for (i = 0; i < fir_filt_order / 2 + 1; i++) {
    coeff[i] = fir_coeff[i];
  }

  if (fir_symmetry == 1) {
    for (i = 0; i < (fir_filt_order + 1) / 2; i++) {
      coeff[fir_filt_order - i] = -coeff[i];
    }

    if ((fir_filt_order & 1) == 0) {
      coeff[fir_filt_order / 2] = 0.0f;
    }
  } else {
    for (i = 0; i < (fir_filt_order + 1) / 2; i++) {
      coeff[fir_filt_order - i] = coeff[i];
    }
  }

  for (channel = 0; channel < EQ_CHANNEL_COUNT_MAX; channel++) {
    for (i = 0; i < fir_filt_order + 1; i++) {
      fir_filter->state[channel][i] = 0.0f;
    }
  }
  return;
}

WORD32 impd_calc_filt_params_all(
    ia_unique_td_filt_element* element,
    ia_interm_filt_params_struct* interm_filt_params) {
  WORD32 err = 0;

  interm_filt_params->filter_format = element->eq_filter_format;
  if (element->eq_filter_format == FILTER_ELEMENT_FORMAT_POLE_ZERO) {
    err = impd_calc_filt_params(element, interm_filt_params);
    if (err) return err;
  } else {
    interm_filt_params->filter_param_count_of_zeros = 0;
    interm_filt_params->filter_param_count_of_poles = 0;

    impd_convert_fir_filt_params(element->fir_filt_order, element->fir_symmetry,
                                 element->fir_coeff,
                                 &interm_filt_params->fir_filter);
  }
  return (0);
}

VOID impd_calc_eq_filt_elements(
    ia_interm_filt_params_struct* interm_filt_params,
    ia_eq_filt_ele_struct* eq_filt_element) {
  WORD32 i, poles_idx, zeros_idx, pole_order = 0, section, channel;
  WORD32 poles_over[REAL_POLE_COUNT_MAX + COMPLEX_POLE_COUNT_MAX];
  WORD32 zeros_over[REAL_ZERO_COUNT_MAX + COMPLEX_ZERO_COUNT_MAX];
  FLOAT32 max_radius, diff_radius;
  WORD32 coeff_count;
  FLOAT32* coeff;

  for (i = 0; i < REAL_POLE_COUNT_MAX + COMPLEX_POLE_COUNT_MAX; i++) {
    poles_over[i] = 0;
  }
  for (i = 0; i < REAL_ZERO_COUNT_MAX + COMPLEX_ZERO_COUNT_MAX; i++) {
    zeros_over[i] = 0;
  }
  section = 0;
  do {
    max_radius = -1.0;
    poles_idx = -1;
    for (i = 0; i < interm_filt_params->filter_param_count_of_poles; i++) {
      if (poles_over[i] == 0) {
        if (interm_filt_params->filter_format == 0) {
          if (max_radius <
              fabs(interm_filt_params->ord_2_filt_params_of_poles[i].radius)) {
            max_radius = (FLOAT32)fabs(
                interm_filt_params->ord_2_filt_params_of_poles[i].radius);
            poles_idx = i;
            if (interm_filt_params->ord_2_filt_params_of_poles[i].coeff[1] !=
                0.0f) {
              pole_order = 2;
            } else {
              pole_order = 1;
            }
          }
        }
      }
    }
    if (poles_idx >= 0) {
      diff_radius = 10.0f;
      zeros_idx = -1;
      for (i = 0; i < interm_filt_params->filter_param_count_of_zeros; i++) {
        if (zeros_over[i] == 0) {
          if (interm_filt_params->filter_format == 0) {
            if (pole_order == 2) {
              if (interm_filt_params->ord_2_filt_params_of_zeros[i].coeff[1] !=
                  0.0f) {
                if (diff_radius >
                    fabs(fabs(interm_filt_params->ord_2_filt_params_of_zeros[i]
                                  .radius) -
                         max_radius)) {
                  diff_radius = (FLOAT32)fabs(
                      fabs(interm_filt_params->ord_2_filt_params_of_zeros[i]
                               .radius) -
                      max_radius);
                  zeros_idx = i;
                }
              }
            } else {
              if (interm_filt_params->ord_2_filt_params_of_zeros[i].coeff[1] ==
                  0.0f) {
                if (diff_radius >
                    (FLOAT32)(fabs(
                        fabs(interm_filt_params->ord_2_filt_params_of_zeros[i]
                                 .radius) -
                        max_radius))) {
                  diff_radius = (FLOAT32)(fabs(
                      fabs(interm_filt_params->ord_2_filt_params_of_zeros[i]
                               .radius) -
                      max_radius));
                  zeros_idx = i;
                }
              }
            }
          }
        }
      }
      if (zeros_idx == -1) {
        for (i = 0; i < interm_filt_params->filter_param_count_of_zeros; i++) {
          if (zeros_over[i] == 0) {
            if (interm_filt_params->filter_format == 0) {
              if (pole_order == 2) {
                if (interm_filt_params->ord_2_filt_params_of_zeros[i]
                        .coeff[1] == 0.0f) {
                  if (diff_radius >
                      (FLOAT32)(fabs(
                          fabs(interm_filt_params->ord_2_filt_params_of_zeros[i]
                                   .radius) -
                          max_radius))) {
                    diff_radius = (FLOAT32)(fabs(
                        fabs(interm_filt_params->ord_2_filt_params_of_zeros[i]
                                 .radius) -
                        max_radius));
                    zeros_idx = i;
                  }
                }
              } else {
                if (interm_filt_params->ord_2_filt_params_of_zeros[i]
                        .coeff[1] != 0.0f) {
                  if (diff_radius >
                      (FLOAT32)(fabs(
                          fabs(interm_filt_params->ord_2_filt_params_of_zeros[i]
                                   .radius) -
                          max_radius))) {
                    diff_radius = (FLOAT32)(fabs(
                        fabs(interm_filt_params->ord_2_filt_params_of_zeros[i]
                                 .radius) -
                        max_radius));
                    zeros_idx = i;
                  }
                }
              }
            }
          }
        }
      }
      eq_filt_element->pstr_pole_zero_filt.filt_section[section].a1 =
          interm_filt_params->ord_2_filt_params_of_poles[poles_idx].coeff[0];
      eq_filt_element->pstr_pole_zero_filt.filt_section[section].a2 =
          interm_filt_params->ord_2_filt_params_of_poles[poles_idx].coeff[1];
      if (zeros_idx >= 0) {
        eq_filt_element->pstr_pole_zero_filt.filt_section[section].b1 =
            interm_filt_params->ord_2_filt_params_of_zeros[zeros_idx].coeff[0];
        eq_filt_element->pstr_pole_zero_filt.filt_section[section].b2 =
            interm_filt_params->ord_2_filt_params_of_zeros[zeros_idx].coeff[1];
      } else {
        eq_filt_element->pstr_pole_zero_filt.filt_section[section].b1 = 0.0f;
        eq_filt_element->pstr_pole_zero_filt.filt_section[section].b2 = 0.0f;
        eq_filt_element->pstr_pole_zero_filt.audio_delay.delay++;
      }
      for (channel = 0; channel < EQ_CHANNEL_COUNT_MAX; channel++) {
        eq_filt_element->pstr_pole_zero_filt.filt_section[section]
            .filt_sect_state[channel]
            .in_state_1 = 0.0f;
        eq_filt_element->pstr_pole_zero_filt.filt_section[section]
            .filt_sect_state[channel]
            .in_state_2 = 0.0f;
        eq_filt_element->pstr_pole_zero_filt.filt_section[section]
            .filt_sect_state[channel]
            .out_state_1 = 0.0f;
        eq_filt_element->pstr_pole_zero_filt.filt_section[section]
            .filt_sect_state[channel]
            .out_state_2 = 0.0f;
      }
      if (zeros_idx >= 0) zeros_over[zeros_idx] = 1;
      if (poles_idx >= 0) poles_over[poles_idx] = 1;
      section++;
    }
  } while (poles_idx >= 0);

  eq_filt_element->pstr_pole_zero_filt.section_count = section;

  coeff_count = 1;
  coeff = eq_filt_element->pstr_pole_zero_filt.fir_filter.coeff;
  coeff[0] = 1.0f;
  for (i = 0; i < interm_filt_params->filter_param_count_of_zeros; i++) {
    if (zeros_over[i] == 0) {
      if (interm_filt_params->filter_format == 0) {
        WORD32 k;
        FLOAT32 b1, b2;
        b1 = interm_filt_params->ord_2_filt_params_of_zeros[i].coeff[0];
        b2 = interm_filt_params->ord_2_filt_params_of_zeros[i].coeff[1];

        coeff_count += 2;
        k = coeff_count - 1;
        coeff[k] = b2 * coeff[k - 2];
        k--;
        if (k > 1) {
          coeff[k] = b1 * coeff[k - 1] + b2 * coeff[k - 2];
          k--;
          for (; k > 1; k--) {
            coeff[k] += b1 * coeff[k - 1] + b2 * coeff[k - 2];
          }
          coeff[1] += b1 * coeff[0];
        } else {
          coeff[1] = b1 * coeff[0];
        }
      }
    }
    zeros_over[i] = 1;
  }
  if (coeff_count > 1) {
    eq_filt_element->pstr_pole_zero_filt.filt_coeffs_flag = 1;
    eq_filt_element->pstr_pole_zero_filt.fir_filter.coeff_count = coeff_count;
  } else {
    eq_filt_element->pstr_pole_zero_filt.filt_coeffs_flag = 0;
    eq_filt_element->pstr_pole_zero_filt.fir_filter.coeff_count = 0;
  }

  return;
}

WORD32 impd_calc_filt_block(ia_unique_td_filt_element* unique_td_filt_ele,
                            ia_filt_block_struct* str_filter_block,
                            ia_eq_filt_block_struct* pstr_eq_filt_block) {
  WORD32 i, k, err;
  ia_interm_filt_params_struct interm_filt_params;
  ia_matching_ph_filt_struct matching_ph_filt[FILTER_ELEMENT_COUNT_MAX];

  for (i = 0; i < str_filter_block->filter_element_count; i++) {
    if ((unique_td_filt_ele[str_filter_block->str_filter_element[i]
                                .filt_ele_idx]
             .eq_filter_format == FILTER_ELEMENT_FORMAT_FIR) &&
        (str_filter_block->filter_element_count > 1)) {
      return (-1);
    }
  }
  for (i = 0; i < str_filter_block->filter_element_count; i++) {
    ia_eq_filt_ele_struct* eq_filt_element =
        &pstr_eq_filt_block->eq_filt_element[i];
    ia_filt_ele_struct* str_filter_element =
        &str_filter_block->str_filter_element[i];
    WORD32 filterIndex = str_filter_element->filt_ele_idx;

    if (unique_td_filt_ele[filterIndex].eq_filter_format ==
        FILTER_ELEMENT_FORMAT_POLE_ZERO) {
      err = impd_calc_filt_params_all(&(unique_td_filt_ele[filterIndex]),
                                      &interm_filt_params);
      if (err) return (err);

      impd_calc_eq_filt_elements(&interm_filt_params, eq_filt_element);

      eq_filt_element->format = FILTER_ELEMENT_FORMAT_POLE_ZERO;
    } else {
      impd_convert_fir_filt_params(
          unique_td_filt_ele[filterIndex].fir_filt_order,
          unique_td_filt_ele[filterIndex].fir_symmetry,
          unique_td_filt_ele[filterIndex].fir_coeff,
          &eq_filt_element->fir_filter);

      eq_filt_element->format = FILTER_ELEMENT_FORMAT_FIR;
    }
    if (str_filter_element->filt_ele_gain_flag == 1) {
      eq_filt_element->elementGainLinear =
          (FLOAT32)(pow(10.0f, 0.05f * str_filter_element->filt_ele_gain));
    } else {
      eq_filt_element->elementGainLinear = 1.0f;
    }
    for (k = 0; k < unique_td_filt_ele[filterIndex].real_zero_count; k++) {
      if (unique_td_filt_ele[filterIndex].real_zero_radius[k] > 0.0f) {
        eq_filt_element->elementGainLinear =
            -eq_filt_element->elementGainLinear;
      }
    }
    impd_calc_phase_filt(&(unique_td_filt_ele[filterIndex]), i,
                         &matching_ph_filt[i]);
  }
  pstr_eq_filt_block->element_count = str_filter_block->filter_element_count;

  pstr_eq_filt_block->matching_ph_filt_ele_0 = matching_ph_filt[0];

  return (0);
}

VOID impd_calc_cascade_phase_align_filt(
    ia_td_filter_cascade_struct* str_td_filter_cascade, WORD32 ch_group_cnt) {
  // WORD32 err = 0;
  WORD32 cascade_align_grp_cnt = 0;
  ia_cascade_align_group_struct
      pstr_cascade_align_grp[EQ_CHANNEL_GROUP_COUNT_MAX / 2];

  impd_calc_cascade_align_groups(
      ch_group_cnt, str_td_filter_cascade->eq_phase_alignment_present,
      str_td_filter_cascade->eq_phase_alignment, &cascade_align_grp_cnt,
      pstr_cascade_align_grp);
  return;
}

WORD32 impd_calc_filt_cascade(
    ia_unique_td_filt_element* unique_td_filt_ele,
    ia_filt_block_struct* str_filter_block,
    ia_td_filter_cascade_struct* str_td_filter_cascade, WORD32 ch_group_cnt,
    ia_filt_cascade_td_struct filt_cascade_td[]) {
  WORD32 i, err, g;

  for (g = 0; g < ch_group_cnt; g++) {
    for (i = 0;
         i < str_td_filter_cascade->str_filter_block_refs[g].filter_block_count;
         i++) {
      err = impd_calc_filt_block(
          unique_td_filt_ele,
          &(str_filter_block[str_td_filter_cascade->str_filter_block_refs[g]
                                 .filter_block_index[i]]),
          &(filt_cascade_td[g].pstr_eq_filt_block[i]));
      if (err) return (err);
    }
    filt_cascade_td[g].block_count = i;
    filt_cascade_td[g].cascade_gain_linear = (FLOAT32)(
        pow(10.0f, 0.05f * str_td_filter_cascade->eq_cascade_gain[g]));
  }

  impd_calc_cascade_phase_align_filt(str_td_filter_cascade, ch_group_cnt);
  return (0);
}

VOID impd_calc_subband_eq(ia_eq_subband_gain_vector* str_eq_subband_gain_vector,
                          WORD32 eq_subband_gain_count,
                          ia_subband_filt_struct* subband_filt) {
  WORD32 i;

  for (i = 0; i < eq_subband_gain_count; i++) {
    subband_filt->subband_coeff[i] =
        str_eq_subband_gain_vector->eq_subband_gain[i];
  }
  subband_filt->coeff_count = eq_subband_gain_count;
  return;
}

FLOAT32 impd_decode_eq_node_freq(WORD32 eq_node_freq_idx) {
  /*((FLOAT32)((log10(STEP_RATIO_F_HI) / log10(STEP_RATIO_F_LO) - 1.0f) /
   * (STEP_RATIO_EQ_NODE_COUNT_MAX - 1.0f)))*/
  FLOAT32 step_ratio = 0.0739601809794f;
  return (
      (FLOAT32)(pow(STEP_RATIO_F_LO, 1.0f + eq_node_freq_idx * step_ratio)));
}

FLOAT32 impd_calc_warp_freq_delta(FLOAT32 fsubband, FLOAT32 node_freq,
                                  WORD32 eq_node_freq_idx) {
  /*((FLOAT32)((log10(STEP_RATIO_F_HI) / log10(STEP_RATIO_F_LO) - 1.0f) /
   * (STEP_RATIO_EQ_NODE_COUNT_MAX - 1.0f)))*/
  FLOAT32 step_ratio = 0.0739601809794f;
  return ((FLOAT32)((log10(fsubband) / log10(node_freq) - 1.0f) / step_ratio -
                    (FLOAT32)eq_node_freq_idx));
}

VOID impd_interpolate_eq_gain(WORD32 band_step, FLOAT32 left_gain,
                              FLOAT32 right_gain, FLOAT32 left_slope,
                              FLOAT32 right_slope, FLOAT32 f,
                              FLOAT32* interpolated_gain) {
  FLOAT32 k1, k2, a, b, c, d;
  FLOAT32 inv_band_step = (FLOAT32)(1.0 / (FLOAT32)band_step);
  FLOAT32 inv_band_step_sqr = inv_band_step * inv_band_step;
  k1 = (right_gain - left_gain) * inv_band_step_sqr;
  left_slope = (FLOAT32)(left_slope / 3.128f);
  right_slope = (FLOAT32)(right_slope / 3.128f);

  k2 = right_slope + left_slope;
  a = inv_band_step * (inv_band_step * k2 - 2.0f * k1);
  b = 3.0f * k1 - inv_band_step * (k2 + left_slope);
  c = left_slope;
  d = left_gain;
  *interpolated_gain = (((a * f + b) * f + c) * f) + d;
  return;
}

WORD32 impd_interpolate_subband_spline(
    ia_eq_subband_gain_spline_struct* str_eq_subband_gain_spline,
    WORD32 eq_subband_gain_count, WORD32 eq_subband_gain_format,
    FLOAT32 sample_rate, ia_subband_filt_struct* subband_filt) {
  WORD32 b, n, err;

  FLOAT32 eq_gain[32];
  WORD32 eq_node_freq_idx[32];
  FLOAT32 eq_node_freq[32];
  FLOAT32 subband_center_freq[256];
  WORD32 num_eq_nodes = str_eq_subband_gain_spline->num_eq_nodes;

  FLOAT32* eq_slope = str_eq_subband_gain_spline->eq_slope;
  WORD32* eq_freq_delta = str_eq_subband_gain_spline->eq_freq_delta;
  FLOAT32 eq_gain_initial = str_eq_subband_gain_spline->eq_gain_initial;
  FLOAT32* eq_gain_delta = str_eq_subband_gain_spline->eq_gain_delta;

  FLOAT32* subband_coeff = subband_filt->subband_coeff;
  WORD32 max_eq_node_idx = 32;

  eq_gain[0] = eq_gain_initial;
  eq_node_freq_idx[0] = 0;
  eq_node_freq[0] = impd_decode_eq_node_freq(eq_node_freq_idx[0]);
  for (n = 1; n < num_eq_nodes; n++) {
    eq_gain[n] = eq_gain[n - 1] + eq_gain_delta[n];
    eq_node_freq_idx[n] = eq_node_freq_idx[n - 1] + eq_freq_delta[n];
    eq_node_freq[n] = impd_decode_eq_node_freq(eq_node_freq_idx[n]);
  }
  if ((eq_node_freq[num_eq_nodes - 1] < sample_rate * 0.5f) &&
      (eq_node_freq_idx[num_eq_nodes - 1] < max_eq_node_idx)) {
    eq_slope[num_eq_nodes] = 0;
    eq_gain[num_eq_nodes] = eq_gain[num_eq_nodes - 1];
    eq_freq_delta[num_eq_nodes] =
        max_eq_node_idx - eq_node_freq_idx[num_eq_nodes - 1];
    eq_node_freq_idx[num_eq_nodes] = max_eq_node_idx;
    eq_node_freq[num_eq_nodes] =
        impd_decode_eq_node_freq(eq_node_freq_idx[num_eq_nodes]);
    num_eq_nodes += 1;
  }

  err = impd_derive_subband_center_freq(eq_subband_gain_count,
                                        eq_subband_gain_format, sample_rate,
                                        subband_center_freq);
  if (err) return (err);

  for (n = 0; n < num_eq_nodes - 1; n++) {
    for (b = 0; b < eq_subband_gain_count; b++) {
      FLOAT32 fSub;
      fSub = max(subband_center_freq[b], eq_node_freq[0]);
      fSub = min(fSub, eq_node_freq[num_eq_nodes - 1]);
      if ((fSub >= eq_node_freq[n]) && (fSub <= eq_node_freq[n + 1])) {
        FLOAT32 warpedDeltaFreq = impd_calc_warp_freq_delta(
            fSub, eq_node_freq[0], eq_node_freq_idx[n]);
        FLOAT32 gEqSubbandDb;
        impd_interpolate_eq_gain(eq_freq_delta[n + 1], eq_gain[n],
                                 eq_gain[n + 1], eq_slope[n], eq_slope[n + 1],
                                 warpedDeltaFreq, &gEqSubbandDb);

        subband_coeff[b] = (FLOAT32)pow(2.0, gEqSubbandDb / 6.0f);
      }
    }
  }
  subband_filt->coeff_count = eq_subband_gain_count;
  return (0);
}

WORD32 impd_calc_subband_gains(ia_eq_coeff_struct* str_eq_coeff,
                               WORD32 eq_ch_group_count,
                               WORD32* subband_gains_index, FLOAT32 sample_rate,
                               WORD32 eq_frame_size_subband,
                               ia_subband_filt_struct* subband_filt) {
  WORD32 g, err;
  WORD32 eq_subband_gain_representation =
      str_eq_coeff->eq_subband_gain_representation;
  WORD32 eq_subband_gain_count = str_eq_coeff->eq_subband_gain_count;
  WORD32 eq_subband_gain_format = str_eq_coeff->eq_subband_gain_format;

  for (g = 0; g < eq_ch_group_count; g++) {
    if (eq_subband_gain_representation == 1) {
      err = impd_interpolate_subband_spline(
          &(str_eq_coeff->str_eq_subband_gain_spline[subband_gains_index[g]]),
          eq_subband_gain_count, eq_subband_gain_format, sample_rate,
          &(subband_filt[g]));
      if (err) return (err);
    } else {
      impd_calc_subband_eq(
          &(str_eq_coeff->str_eq_subband_gain_vector[subband_gains_index[g]]),
          eq_subband_gain_count, &(subband_filt[g]));
    }
    subband_filt[g].eq_frame_size_subband = eq_frame_size_subband;
  }
  return (0);
}

VOID impd_calc_filt_sect_delay(WORD32 section_count,
                               ia_filt_sect_struct* filt_section,
                               FLOAT32* delay) {
  WORD32 i;
  FLOAT32 d = 0.0f;
  for (i = 0; i < section_count; i++) {
    if (filt_section[i].b2 != 0.0f) {
      d += 1.0f;
    } else if (filt_section[i].b1 != 0.0f) {
      d += 0.5f;
    }
  }
  *delay = d;
  return;
}

VOID impd_get_eq_set_delay(ia_eq_set_struct* eq_set, WORD32* cascade_delay) {
  FLOAT32 delay, sect_delay;
  WORD32 k, g, b;

  delay = 0;
  g = eq_set->eq_ch_group_of_channel[0];
  if (g >= 0) {
    switch (eq_set->domain) {
      case EQ_FILTER_DOMAIN_TIME: {
        ia_filt_cascade_td_struct* filt_cascade_td =
            &eq_set->filt_cascade_td[g];
        for (b = 0; b < filt_cascade_td->block_count; b++) {
          ia_eq_filt_ele_struct* eq_filt_element =
              &filt_cascade_td->pstr_eq_filt_block[b].eq_filt_element[0];
          switch (eq_filt_element->format) {
            case FILTER_ELEMENT_FORMAT_POLE_ZERO:
              impd_calc_filt_sect_delay(
                  eq_filt_element->pstr_pole_zero_filt.section_count,
                  eq_filt_element->pstr_pole_zero_filt.filt_section,
                  &sect_delay);
              delay += sect_delay;
              if (eq_filt_element->pstr_pole_zero_filt.filt_coeffs_flag) {
                delay += 0.5f * (eq_filt_element->pstr_pole_zero_filt.fir_filter
                                     .coeff_count -
                                 1);
              }
              break;
            case FILTER_ELEMENT_FORMAT_FIR:
              delay += 0.5f * (eq_filt_element->fir_filter.coeff_count - 1);
              break;
            default:
              break;
          }
          for (k = 0; k < eq_filt_element->num_ph_align_filt; k++) {
            ia_ph_alignment_filt_struct* ph_alignment_filt =
                &eq_filt_element->ph_alignment_filt[k];
            impd_calc_filt_sect_delay(ph_alignment_filt->section_count,
                                      ph_alignment_filt->filt_section,
                                      &sect_delay);
            delay += sect_delay;
          }
        }
        for (b = 0; b < filt_cascade_td->num_ph_align_filt; b++) {
          ia_ph_alignment_filt_struct* ph_alignment_filt =
              &filt_cascade_td->ph_alignment_filt[b];
          impd_calc_filt_sect_delay(ph_alignment_filt->section_count,
                                    ph_alignment_filt->filt_section,
                                    &sect_delay);
          delay += sect_delay;
        }
      } break;
      case EQ_FILTER_DOMAIN_SUBBAND:
      case EQ_FILTER_DOMAIN_NONE:
      default:
        break;
    }
  }
  *cascade_delay = (WORD32)delay;
  return;
}

WORD32 impd_derive_eq_set(ia_eq_coeff_struct* str_eq_coeff,
                          ia_eq_instructions_struct* str_eq_instructions,
                          FLOAT32 sample_rate, WORD32 drc_frame_size,
                          WORD32 sub_band_domain_mode,
                          ia_eq_set_struct* eq_set) {
  WORD32 err, i, eq_frame_size_subband;

  eq_set->domain = EQ_FILTER_DOMAIN_NONE;

  if (sub_band_domain_mode == SUBBAND_DOMAIN_MODE_OFF) {
    if (str_eq_instructions->td_filter_cascade_present == 1) {
      err = impd_calc_filt_cascade(
          str_eq_coeff->unique_td_filt_ele, str_eq_coeff->str_filter_block,
          &str_eq_instructions->str_td_filter_cascade,
          str_eq_instructions->eq_ch_group_count, eq_set->filt_cascade_td);
      if (err) return (err);
    }

    eq_set->domain |= EQ_FILTER_DOMAIN_TIME;
  }
  if (sub_band_domain_mode != SUBBAND_DOMAIN_MODE_OFF) {
    switch (sub_band_domain_mode) {
      case SUBBAND_DOMAIN_MODE_QMF64:
        if (str_eq_coeff->eq_subband_gain_count !=
            AUDIO_CODEC_SUBBAND_COUNT_QMF64) {
          return (-1);
        }
        eq_frame_size_subband =
            drc_frame_size / AUDIO_CODEC_SUBBAND_DOWNSAMPLING_FACTOR_QMF64;
        break;
      case SUBBAND_DOMAIN_MODE_QMF71:
        if (str_eq_coeff->eq_subband_gain_count !=
            AUDIO_CODEC_SUBBAND_COUNT_QMF71) {
          return (-1);
        }
        eq_frame_size_subband =
            drc_frame_size / AUDIO_CODEC_SUBBAND_DOWNSAMPLING_FACTOR_QMF71;
        break;
      case SUBBAND_DOMAIN_MODE_STFT256:
        if (str_eq_coeff->eq_subband_gain_count !=
            AUDIO_CODEC_SUBBAND_COUNT_STFT256) {
          return (-1);
        }
        eq_frame_size_subband =
            drc_frame_size / AUDIO_CODEC_SUBBAND_DOWNSAMPLING_FACTOR_STFT256;
        break;
      default:
        return (-1);
        break;
    }
    if (str_eq_instructions->subband_gains_present == 1) {
      err = impd_calc_subband_gains(
          str_eq_coeff, str_eq_instructions->eq_ch_group_count,
          str_eq_instructions->subband_gains_index, sample_rate,
          eq_frame_size_subband, eq_set->subband_filt);
      if (err) return (err);
    } else {
      if (str_eq_instructions->td_filter_cascade_present == 1) {
        err = impd_calc_subband_gains_td_cascade(
            str_eq_coeff->unique_td_filt_ele, str_eq_coeff->str_filter_block,
            &str_eq_instructions->str_td_filter_cascade,
            str_eq_coeff->eq_subband_gain_format,
            str_eq_instructions->eq_ch_group_count, sample_rate,
            eq_frame_size_subband, eq_set->subband_filt);
        if (err) return (err);
      }
    }
    eq_set->domain |= EQ_FILTER_DOMAIN_SUBBAND;
  }
  eq_set->audio_num_chan = str_eq_instructions->eq_channel_count;
  eq_set->eq_ch_group_count = str_eq_instructions->eq_ch_group_count;

  for (i = 0; i < str_eq_instructions->eq_channel_count; i++) {
    eq_set->eq_ch_group_of_channel[i] =
        str_eq_instructions->eq_ch_group_of_channel[i];
  }

  return (0);
}

VOID impd_process_filt_sect(
    ia_filt_sect_struct filt_section[EQ_FILTER_SECTION_COUNT_MAX],
    WORD32 channel, FLOAT32* audio_out, WORD32 section_count) {
  WORD32 i;

  for (i = 0; i < section_count; i++) {
    ia_filt_sect_state_struct* filt_sect_state =
        &filt_section[i].filt_sect_state[channel];
    FLOAT32 audio_in = *audio_out;
    *audio_out = audio_in + filt_section[i].b1 * filt_sect_state->in_state_1 +
                 filt_section[i].b2 * filt_sect_state->in_state_2 -
                 filt_section[i].a1 * filt_sect_state->out_state_1 -
                 filt_section[i].a2 * filt_sect_state->out_state_2;

    filt_sect_state->in_state_2 = filt_sect_state->in_state_1;
    filt_sect_state->in_state_1 = audio_in;
    filt_sect_state->out_state_2 = filt_sect_state->out_state_1;
    filt_sect_state->out_state_1 = *audio_out;
  }
  return;
}

VOID impd_fir_filt_process(ia_fir_filter_struct* fir_filter, WORD32 channel,
                           FLOAT32 audio_in, FLOAT32* audio_out) {
  WORD32 i;
  FLOAT32* coeff = fir_filter->coeff;
  FLOAT32* state = fir_filter->state[channel];
  FLOAT32 sum;
  sum = coeff[0] * audio_in;
  for (i = 1; i < fir_filter->coeff_count; i++) {
    sum += coeff[i] * state[i - 1];
  }
  *audio_out = sum;
  for (i = fir_filter->coeff_count - 2; i > 0; i--) {
    state[i] = state[i - 1];
  }
  state[0] = audio_in;
  return;
}

VOID impd_audio_delay_process(ia_audio_delay_struct* audio_delay,
                              WORD32 channel, FLOAT32 audio_in,
                              FLOAT32* ptr_audio_out) {
  WORD32 i;
  FLOAT32* state = audio_delay->state[channel];
  if (audio_delay->delay > 0) {
    *ptr_audio_out = state[audio_delay->delay - 1];
    for (i = audio_delay->delay - 1; i > 0; i--) {
      state[i] = state[i - 1];
    }
    state[0] = audio_in;
  } else {
    *ptr_audio_out = audio_in;
  }
  return;
}

VOID impd_pole_zero_filt_process(ia_pole_zero_filt_struct* pstr_pole_zero_filt,
                                 WORD32 channel, FLOAT32 audio_in,
                                 FLOAT32* ptr_audio_out) {
  FLOAT32 inp = audio_in;
  FLOAT32 out = inp;

  impd_process_filt_sect(pstr_pole_zero_filt->filt_section, channel, &out,
                         pstr_pole_zero_filt->section_count);
  inp = out;

  if (pstr_pole_zero_filt->filt_coeffs_flag == 1) {
    impd_fir_filt_process(&pstr_pole_zero_filt->fir_filter, channel, inp, &out);
    inp = out;
  }
  impd_audio_delay_process(&pstr_pole_zero_filt->audio_delay, channel, inp,
                           &out);

  *ptr_audio_out = out;
  return;
}

VOID impd_phase_align_filt_process(
    ia_ph_alignment_filt_struct* ph_alignment_filt, WORD32 channel,
    FLOAT32* ptr_audio_out) {
  FLOAT32 audio_in = *ptr_audio_out;
  FLOAT32 inp = audio_in;
  FLOAT32 out = inp;

  impd_process_filt_sect(ph_alignment_filt->filt_section, channel, &out,
                         ph_alignment_filt->section_count);
  inp = out;

  impd_audio_delay_process(&ph_alignment_filt->audio_delay, channel, inp, &out);

  *ptr_audio_out = out * ph_alignment_filt->gain;
  return;
}

VOID impd_eq_filt_element_process(
    ia_eq_filt_block_struct str_eq_filt_block[EQ_FILTER_BLOCK_COUNT_MAX],
    WORD32 channel, FLOAT32 audio_in, FLOAT32* ptr_audio_out,
    WORD32 block_count) {
  WORD32 i;
  FLOAT32 inp = audio_in;
  FLOAT32 out = inp;
  WORD32 k, j;
  WORD32 element_count;
  for (j = 0; j < block_count; j++) {
    FLOAT32 sum = 0.0f;
    element_count = str_eq_filt_block[j].element_count;
    for (k = 0; k < element_count; k++) {
      switch (str_eq_filt_block[j].eq_filt_element[k].format) {
        case FILTER_ELEMENT_FORMAT_POLE_ZERO:
          impd_pole_zero_filt_process(
              &str_eq_filt_block[j].eq_filt_element[k].pstr_pole_zero_filt,
              channel, inp, &out);
          break;
        case FILTER_ELEMENT_FORMAT_FIR:
          impd_fir_filt_process(
              &str_eq_filt_block[j].eq_filt_element[k].fir_filter, channel, inp,
              &out);
          break;
        default:
          break;
      }
      out *= str_eq_filt_block[j].eq_filt_element[k].elementGainLinear;

      for (i = 0; i < str_eq_filt_block[j].eq_filt_element[k].num_ph_align_filt;
           i++) {
        inp = out;
        impd_phase_align_filt_process(
            &str_eq_filt_block[j].eq_filt_element[k].ph_alignment_filt[i],
            channel, &out);
      }
      sum += out;
    }
    inp = sum;
  }
  *ptr_audio_out = inp;
  return;
}

WORD32 impd_process_eq_set_time_domain(ia_eq_set_struct* pstr_eq_set,
                                       WORD32 channel, FLOAT32* ptr_audio_in,
                                       FLOAT32* ptr_audio_out,
                                       WORD32 frame_size) {
  WORD32 i, j, g = 0;

  if (pstr_eq_set == NULL) return 0;

  g = pstr_eq_set->eq_ch_group_of_channel[channel];

  if (g < 0) return 0;

  for (i = 0; i < frame_size; i++) {
    impd_eq_filt_element_process(
        (pstr_eq_set->filt_cascade_td[g].pstr_eq_filt_block), channel,
        ptr_audio_in[i], &ptr_audio_out[i],
        pstr_eq_set->filt_cascade_td[g].block_count);

    for (j = 0; j < pstr_eq_set->filt_cascade_td[g].num_ph_align_filt; j++) {
      impd_phase_align_filt_process(
          &pstr_eq_set->filt_cascade_td[g].ph_alignment_filt[j], channel,
          &ptr_audio_out[i]);
    }

    ptr_audio_out[i] =
        ptr_audio_out[i] * pstr_eq_set->filt_cascade_td[g].cascade_gain_linear;
  }
  return 0;
}