libxaac-sys 0.1.0

/******************************************************************************
 *                                                                            *
 * 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 <string.h>
#include <math.h>

#include "ixheaac_type_def.h"
#include "ixheaac_constants.h"
#include "ixheaace_aac_constants.h"
#include "ixheaac_basic_ops32.h"
#include "ixheaac_basic_ops16.h"
#include "ixheaac_basic_ops40.h"
#include "ixheaac_error_standards.h"
#include "ixheaace_error_codes.h"

#include "ixheaace_bitbuffer.h"
#include "ixheaace_sbr_def.h"
#include "iusace_esbr_inter_tes.h"
#include "iusace_esbr_rom.h"

VOID ixheaace_init_esbr_inter_tes(ixheaace_str_inter_tes_params *pstr_tes_enc,
                                  WORD32 sbr_ratio_index) {
  WORD32 ts;
  WORD32 memset_sz = IXHEAACE_QMF_CHANNELS * sizeof(pstr_tes_enc->qmf_buf_real[0][0]);

  switch (sbr_ratio_index) {
    case USAC_SBR_RATIO_INDEX_2_1:
      pstr_tes_enc->op_delay = 6;
      pstr_tes_enc->codec_delay = 32;
      pstr_tes_enc->sbr_ratio_index = sbr_ratio_index;
      break;
    case USAC_SBR_RATIO_INDEX_4_1:
      pstr_tes_enc->op_delay = 6 * 2;
      pstr_tes_enc->codec_delay = 64;
      pstr_tes_enc->sbr_ratio_index = sbr_ratio_index;
      break;
  }

  memset(&pstr_tes_enc->bw_array_prev[0], 0,
         IXHEAACE_MAX_NUM_PATCHES * sizeof(pstr_tes_enc->bw_array_prev[0]));
  memset(&pstr_tes_enc->inv_filt_mode_prev[0], 0,
         IXHEAACE_MAX_NUM_NOISE_VALUES * sizeof(pstr_tes_enc->inv_filt_mode_prev[0]));

  for (ts = 0;
       ts < pstr_tes_enc->op_delay + pstr_tes_enc->codec_delay + IXHEAACE_SBR_HF_ADJ_OFFSET;
       ts++) {
    memset(pstr_tes_enc->qmf_buf_real[ts], 0, memset_sz);
    memset(pstr_tes_enc->qmf_buf_imag[ts], 0, memset_sz);
  }
  return;
}

static VOID ixheaace_apply_inter_tes(FLOAT32 *qmf_real1, FLOAT32 *qmf_imag1, FLOAT32 *qmf_real,
                                     FLOAT32 *qmf_imag, WORD32 num_sample, WORD32 sub_band_start,
                                     WORD32 num_subband, WORD32 gamma_idx) {
  WORD32 sub_band_end = sub_band_start + num_subband;
  FLOAT32 subsample_power_high[IXHEAACE_TIMESLOT_BUFFER_SIZE],
      subsample_power_low[IXHEAACE_TIMESLOT_BUFFER_SIZE];
  FLOAT32 total_power_high = 0.0f;
  FLOAT32 total_power_low = 0.0f, total_power_high_after = 1.0e-6f;
  FLOAT32 gain[IXHEAACE_TIMESLOT_BUFFER_SIZE];
  FLOAT32 gain_adj, gain_adj_2;
  FLOAT32 gamma = ixheaace_gamma_tab[gamma_idx];
  WORD32 i, j;
  WORD32 memcpy_sz = sub_band_start * sizeof(FLOAT32);

  if (gamma > 0) {
    for (i = 0; i < num_sample; i++) {
      memcpy(&qmf_real[IXHEAACE_QMF_CHANNELS * i], &qmf_real1[IXHEAACE_QMF_CHANNELS * i],
             memcpy_sz);
      memcpy(&qmf_imag[IXHEAACE_QMF_CHANNELS * i], &qmf_imag1[IXHEAACE_QMF_CHANNELS * i],
             memcpy_sz);
    }

    for (i = 0; i < num_sample; i++) {
      j = 0;
      subsample_power_low[i] = 0.0f;
      while (j < sub_band_start) {
        subsample_power_low[i] +=
            qmf_real[IXHEAACE_QMF_CHANNELS * i + j] * qmf_real[IXHEAACE_QMF_CHANNELS * i + j];
        subsample_power_low[i] +=
            qmf_imag[IXHEAACE_QMF_CHANNELS * i + j] * qmf_imag[IXHEAACE_QMF_CHANNELS * i + j];
        j++;
      }
      subsample_power_high[i] = 0.0f;
      while (j < sub_band_end) {
        subsample_power_high[i] +=
            qmf_real[IXHEAACE_QMF_CHANNELS * i + j] * qmf_real[IXHEAACE_QMF_CHANNELS * i + j];
        subsample_power_high[i] +=
            qmf_imag[IXHEAACE_QMF_CHANNELS * i + j] * qmf_imag[IXHEAACE_QMF_CHANNELS * i + j];
        j++;
      }
      total_power_low += subsample_power_low[i];
      total_power_high += subsample_power_high[i];
    }

    for (i = 0; i < num_sample; i++) {
      gain[i] =
          (FLOAT32)(sqrt(subsample_power_low[i] * num_sample / (total_power_low + 1.0e-6f)));
      gain[i] = (FLOAT32)(1.0f + gamma * (gain[i] - 1.0f));

      if (gain[i] < 0.2f) {
        gain[i] = 0.2f;
      }

      subsample_power_high[i] *= gain[i] * gain[i];
      total_power_high_after += subsample_power_high[i];
    }

    gain_adj_2 = total_power_high / total_power_high_after;
    gain_adj = (FLOAT32)(sqrt(gain_adj_2));

    for (i = 0; i < num_sample; i++) {
      gain[i] *= gain_adj;

      j = sub_band_start;
      while (j < sub_band_end) {
        qmf_real[IXHEAACE_QMF_CHANNELS * i + j] *= gain[i];
        qmf_imag[IXHEAACE_QMF_CHANNELS * i + j] *= gain[i];
        j++;
      }
    }
  }
}

static WORD32 ixheaace_inter_tes_sound_activity(FLOAT32 qmf_real[][IXHEAACE_QMF_CHANNELS],
                                                FLOAT32 qmf_imag[][IXHEAACE_QMF_CHANNELS],
                                                FLOAT32 energy[], WORD32 len, WORD32 start,
                                                WORD32 stop, WORD32 *is_transient) {
  WORD32 snd_act = 0, ts, idx;
  FLOAT32 ene_min = MAX_FLT_VAL, ene_max = 0.0f;

  for (ts = 0; ts < len; ts++) {
    idx = start;
    while (idx < stop) {
      energy[ts] += (qmf_real[ts][idx] * qmf_real[ts][idx]);
      energy[ts] += (qmf_imag[ts][idx] * qmf_imag[ts][idx]);
      idx++;
    }

    if (energy[ts] > ene_max) {
      ene_max = energy[ts];
    }
    if (energy[ts] < ene_min) {
      ene_min = energy[ts];
    }
  }

  snd_act = (ene_max > IXHEAACE_ESBR_TES_ENERGY_MAX_THR) ? 1 : 0;

  if ((ene_max / (ene_min + 1.0e-6f)) > 20) {
    *is_transient = 1;
  } else {
    *is_transient = 0;
  }
  return snd_act;
}

static WORD16 ixheaace_find_closest_entry(WORD32 goal_sb, WORD16 *ptr_master_tab,
                                          WORD16 num_mf_bands, WORD16 direction) {
  WORD32 index;

  if (goal_sb <= ptr_master_tab[0]) return ptr_master_tab[0];

  if (goal_sb >= ptr_master_tab[num_mf_bands]) return ptr_master_tab[num_mf_bands];

  if (direction) {
    index = 0;
    while (ptr_master_tab[index] < goal_sb) {
      index++;
    }
  } else {
    index = num_mf_bands;
    while (ptr_master_tab[index] > goal_sb) {
      index--;
    }
  }

  return ptr_master_tab[index];
}

static VOID ixheaace_esbr_calc_co_variance(ixheaace_str_auto_corr_ele *pstr_auto_corr,
                                           FLOAT32 ptr_vec_x_real[][IXHEAACE_QMF_CHANNELS],
                                           FLOAT32 ptr_vec_x_imag[][IXHEAACE_QMF_CHANNELS],
                                           WORD32 bd, WORD32 len) {
  WORD32 j = 0;

  FLOAT32 xr_j;
  FLOAT32 xr_j_minus_1 = ptr_vec_x_real[j - 1][bd];
  FLOAT32 xr_j_minus_2 = ptr_vec_x_real[j - 2][bd];

  FLOAT32 xi_j;
  FLOAT32 xi_j_minus_1 = ptr_vec_x_imag[j - 1][bd];
  FLOAT32 xi_j_minus_2 = ptr_vec_x_imag[j - 2][bd];

  memset(pstr_auto_corr, 0, sizeof(ixheaace_str_auto_corr_ele));

  for (j = 0; j < len; j++) {
    xr_j = ptr_vec_x_real[j][bd];
    xi_j = ptr_vec_x_imag[j][bd];

    pstr_auto_corr->phi_0_1_real += xr_j * xr_j_minus_1 + xi_j * xi_j_minus_1;

    pstr_auto_corr->phi_0_1_imag += xi_j * xr_j_minus_1 - xr_j * xi_j_minus_1;

    pstr_auto_corr->phi_0_2_real += xr_j * xr_j_minus_2 + xi_j * xi_j_minus_2;

    pstr_auto_corr->phi_0_2_imag += xi_j * xr_j_minus_2 - xr_j * xi_j_minus_2;

    pstr_auto_corr->phi_1_1 += xr_j_minus_1 * xr_j_minus_1 + xi_j_minus_1 * xi_j_minus_1;

    pstr_auto_corr->phi_1_2_real += xr_j_minus_1 * xr_j_minus_2 + xi_j_minus_1 * xi_j_minus_2;

    pstr_auto_corr->phi_1_2_imag += xi_j_minus_1 * xr_j_minus_2 - xr_j_minus_1 * xi_j_minus_2;

    pstr_auto_corr->phi_2_2 += xr_j_minus_2 * xr_j_minus_2 + xi_j_minus_2 * xi_j_minus_2;

    xr_j_minus_2 = xr_j_minus_1;
    xr_j_minus_1 = xr_j;

    xi_j_minus_2 = xi_j_minus_1;
    xi_j_minus_1 = xi_j;
  }

  pstr_auto_corr->det = pstr_auto_corr->phi_1_1 * pstr_auto_corr->phi_2_2 -
                        (pstr_auto_corr->phi_1_2_real * pstr_auto_corr->phi_1_2_real +
                         pstr_auto_corr->phi_1_2_imag * pstr_auto_corr->phi_1_2_imag) *
                            IXHEAACE_SBR_HF_RELAXATION_PARAM;
}

static VOID ixheaace_gausssolve(WORD32 n, FLOAT32 ptr_a[][IXHEAACE_MAXDEG + 1], FLOAT32 ptr_b[],
                                FLOAT32 ptr_y[]) {
  WORD32 i, j, k, imax;
  FLOAT32 v;

  for (i = 0; i < n; i++) {
    imax = i;
    k = i + 1;
    while (k < n) {
      if (fabs(ptr_a[k][i]) > fabs(ptr_a[imax][i])) {
        imax = k;
      }
      k++;
    }
    if (imax != i) {
      v = ptr_b[imax];
      ptr_b[imax] = ptr_b[i];
      ptr_b[i] = v;
      j = i;
      while (j < n) {
        v = ptr_a[imax][j];
        ptr_a[imax][j] = ptr_a[i][j];
        ptr_a[i][j] = v;
        j++;
      }
    }

    v = ptr_a[i][i];

    ptr_b[i] /= v;
    for (j = i; j < n; j++) {
      ptr_a[i][j] /= v;
    }

    for (k = i + 1; k < n; k++) {
      v = ptr_a[k][i];
      ptr_b[k] -= v * ptr_b[i];
      for (j = i + 1; j < n; j++) {
        ptr_a[k][j] -= v * ptr_a[i][j];
      }
    }
  }

  for (i = n - 1; i >= 0; i--) {
    ptr_y[i] = ptr_b[i];
    for (j = i + 1; j < n; j++) {
      ptr_y[i] -= ptr_a[i][j] * ptr_y[j];
    }
  }
}

static VOID ixheaace_polyfit(WORD32 n, FLOAT32 ptr_y[], FLOAT32 ptr_p[]) {
  WORD32 i, j, k;
  FLOAT32 ptr_a[IXHEAACE_MAXDEG + 1][IXHEAACE_MAXDEG + 1] = {{0}};
  FLOAT32 ptr_b[IXHEAACE_MAXDEG + 1] = {0};
  FLOAT32 v[2 * IXHEAACE_MAXDEG + 1];

  for (k = 0; k < n; k++) {
    v[0] = 1.0;
    for (i = 1; i <= 2 * IXHEAACE_MAXDEG; i++) {
      v[i] = k * v[i - 1];
    }

    for (i = 0; i <= IXHEAACE_MAXDEG; i++) {
      ptr_b[i] += v[IXHEAACE_MAXDEG - i] * ptr_y[k];
      for (j = 0; j <= IXHEAACE_MAXDEG; j++) {
        ptr_a[i][j] += v[2 * IXHEAACE_MAXDEG - i - j];
      }
    }
  }

  ixheaace_gausssolve(IXHEAACE_MAXDEG + 1, ptr_a, ptr_b, ptr_p);
}

static VOID ixheaace_esbr_chirp_fac_calc(WORD32 *ptr_inv_filt_mode,
                                         WORD32 *ptr_inv_filt_mode_prev, WORD32 num_if_bands,
                                         FLOAT32 *ptr_bw_array, FLOAT32 *ptr_bw_array_prev) {
  WORD32 i;

  for (i = 0; i < num_if_bands; i++) {
    ptr_bw_array[i] = ixheaace_new_bw_tab[ptr_inv_filt_mode_prev[i]][ptr_inv_filt_mode[i]];

    if (ptr_bw_array[i] < ptr_bw_array_prev[i]) {
      ptr_bw_array[i] = 0.75000f * ptr_bw_array[i] + 0.25000f * ptr_bw_array_prev[i];
    } else {
      ptr_bw_array[i] = 0.90625f * ptr_bw_array[i] + 0.09375f * ptr_bw_array_prev[i];
    }

    if (ptr_bw_array[i] < 0.015625) {
      ptr_bw_array[i] = 0;
    }
  }
}

static VOID ixheaace_pre_processing(FLOAT32 ptr_src_buf_real[][IXHEAACE_QMF_CHANNELS],
                                    FLOAT32 ptr_src_buf_imag[][IXHEAACE_QMF_CHANNELS],
                                    FLOAT32 ptr_gain_vector[], WORD32 num_bands,
                                    WORD32 start_sample, WORD32 end_sample) {
  WORD32 k, i;
  FLOAT32 poly_coeff[4];
  FLOAT32 mean_enrg = 0;
  FLOAT32 low_env_slope[IXHEAACE_QMF_CHANNELS];
  FLOAT32 low_env[IXHEAACE_QMF_CHANNELS];
  FLOAT32 a0;
  FLOAT32 a1;
  FLOAT32 a2;
  FLOAT32 a3;

  for (k = 0; k < num_bands; k++) {
    FLOAT32 temp = 0;
    for (i = start_sample; i < end_sample; i++) {
      temp += ptr_src_buf_real[i][k] * ptr_src_buf_real[i][k] +
              ptr_src_buf_imag[i][k] * ptr_src_buf_imag[i][k];
    }
    temp /= (end_sample - start_sample);
    low_env[k] = (FLOAT32)(10 * log10(temp + 1));
    mean_enrg += low_env[k];
  }
  mean_enrg /= num_bands;

  ixheaace_polyfit(num_bands, low_env, poly_coeff);

  a0 = poly_coeff[0];
  a1 = poly_coeff[1];
  a2 = poly_coeff[2];
  a3 = poly_coeff[3];
  for (k = 0; k < num_bands; k++) {
    low_env_slope[k] = a3 + a2 * k + a1 * k * k + a0 * k * k * k;
  }

  for (i = 0; i < num_bands; i++) {
    ptr_gain_vector[i] = (FLOAT32)pow(10, (mean_enrg - low_env_slope[i]) / 20.0f);
  }
}

static IA_ERRORCODE ixheaace_generate_hf(FLOAT32 ptr_src_buf_real[][64],
                                         FLOAT32 ptr_src_buf_imag[][64],
                                         FLOAT32 ptr_ph_vocod_buf_real[][64],
                                         FLOAT32 ptr_ph_vocod_buf_imag[][64],
                                         FLOAT32 ptr_dst_buf_real[][64],
                                         FLOAT32 ptr_dst_buf_imag[][64],
                                         ixheaace_str_inter_tes_params *pstr_tes_enc) {
  WORD32 bw_index, i, k, k2, patch = 0;
  WORD32 co_var_len;
  WORD32 start_sample, end_sample, goal_sb;
  WORD32 sb, source_start_band, patch_stride, num_bands_in_patch;
  WORD32 hbe_flag = 0;
  FLOAT32 a0r, a0i, a1r, a1i;
  FLOAT32 ptr_bw_array[IXHEAACE_MAX_NUM_PATCHES] = {0};

  ixheaace_str_auto_corr_ele str_auto_corr;

  WORD16 *ptr_invf_band_tbl = &pstr_tes_enc->invf_band_tbl[1];
  WORD32 num_if_bands = pstr_tes_enc->num_if_bands;
  WORD32 sub_band_start = pstr_tes_enc->sub_band_start;
  WORD16 *ptr_master_tab = pstr_tes_enc->f_master_tbl;
  WORD32 num_mf_bands = pstr_tes_enc->num_mf_bands;
  WORD32 *ptr_inv_filt_mode = pstr_tes_enc->inv_filt_mode;
  WORD32 *ptr_inv_filt_mode_prev = pstr_tes_enc->inv_filt_mode_prev;
  WORD32 sbr_patching_mode = 1;
  WORD32 pre_proc_flag = 0;
  WORD32 fs = pstr_tes_enc->out_fs;
  WORD32 cov_count;
  WORD32 lsb = ptr_master_tab[0];
  WORD32 usb = ptr_master_tab[num_mf_bands];
  WORD32 memset_sz = (IXHEAACE_QMF_CHANNELS - usb) * sizeof(FLOAT32);
  WORD32 xover_offset = sub_band_start - ptr_master_tab[0];
  FLOAT32 bw = 0.0f;
  FLOAT32 fac = 0.0f;
  FLOAT32 gain;
  FLOAT32 ptr_gain_vector[64];
  WORD32 slope_length = 0;
  WORD32 first_slot_offset = pstr_tes_enc->border_vec[0];
  WORD32 end_slot_offs = 0;
  FLOAT32 *ptr_bw_array_prev = pstr_tes_enc->bw_array_prev;

  end_slot_offs = pstr_tes_enc->border_vec[pstr_tes_enc->num_env] - 16;

  switch (pstr_tes_enc->sbr_ratio_index) {
    case USAC_SBR_RATIO_INDEX_2_1:
      start_sample = first_slot_offset * 2;
      end_sample = 32 + end_slot_offs * 2;
      co_var_len = 38;
      break;
    case USAC_SBR_RATIO_INDEX_4_1:
      start_sample = first_slot_offset * 4;
      end_sample = 64 + end_slot_offs * 4;
      co_var_len = 76;
      break;
    default:
      start_sample = first_slot_offset * 2;
      end_sample = 32 + end_slot_offs * 2;
      co_var_len = 38;
      break;
  }

  if (pre_proc_flag) {
    ixheaace_pre_processing(ptr_src_buf_real, ptr_src_buf_imag, ptr_gain_vector,
                            ptr_master_tab[0], start_sample, end_sample);
  }

  ixheaace_esbr_chirp_fac_calc(ptr_inv_filt_mode, ptr_inv_filt_mode_prev, num_if_bands,
                               ptr_bw_array, ptr_bw_array_prev);

  for (i = start_sample; i < end_sample; i++) {
    memset(ptr_dst_buf_real[i] + usb, 0, memset_sz);
    memset(ptr_dst_buf_imag[i] + usb, 0, memset_sz);
  }

  if (sbr_patching_mode || !hbe_flag) {
    FLOAT32 alpha_real[IXHEAACE_QMF_CHANNELS][2] = {{0}},
            alpha_imag[IXHEAACE_QMF_CHANNELS][2] = {{0}};
    cov_count = ptr_master_tab[0];

    for (k = 1; k < cov_count; k++) {
      ixheaace_esbr_calc_co_variance(&str_auto_corr, &ptr_src_buf_real[0], &ptr_src_buf_imag[0],
                                     k, co_var_len);
      if (str_auto_corr.det == 0.0f) {
        alpha_real[k][1] = alpha_imag[k][1] = 0;
      } else {
        fac = 1.0f / str_auto_corr.det;
        alpha_real[k][1] = (str_auto_corr.phi_0_1_real * str_auto_corr.phi_1_2_real -
                            str_auto_corr.phi_0_1_imag * str_auto_corr.phi_1_2_imag -
                            str_auto_corr.phi_0_2_real * str_auto_corr.phi_1_1) *
                           fac;
        alpha_imag[k][1] = (str_auto_corr.phi_0_1_imag * str_auto_corr.phi_1_2_real +
                            str_auto_corr.phi_0_1_real * str_auto_corr.phi_1_2_imag -
                            str_auto_corr.phi_0_2_imag * str_auto_corr.phi_1_1) *
                           fac;
      }

      if (str_auto_corr.phi_1_1 == 0) {
        alpha_real[k][0] = alpha_imag[k][0] = 0;
      } else {
        fac = 1.0f / str_auto_corr.phi_1_1;
        alpha_real[k][0] =
            -(str_auto_corr.phi_0_1_real + alpha_real[k][1] * str_auto_corr.phi_1_2_real +
              alpha_imag[k][1] * str_auto_corr.phi_1_2_imag) *
            fac;
        alpha_imag[k][0] =
            -(str_auto_corr.phi_0_1_imag + alpha_imag[k][1] * str_auto_corr.phi_1_2_real -
              alpha_real[k][1] * str_auto_corr.phi_1_2_imag) *
            fac;
      }

      if ((alpha_real[k][0] * alpha_real[k][0] + alpha_imag[k][0] * alpha_imag[k][0] >= 16.0f) ||
          (alpha_real[k][1] * alpha_real[k][1] + alpha_imag[k][1] * alpha_imag[k][1] >= 16.0f)) {
        alpha_real[k][0] = 0.0f;
        alpha_imag[k][0] = 0.0f;
        alpha_real[k][1] = 0.0f;
        alpha_imag[k][1] = 0.0f;
      }
    }

    goal_sb = (WORD32)(2.048e6f / fs + 0.5f);
    {
      WORD32 index;
      if (goal_sb < ptr_master_tab[num_mf_bands]) {
        for (index = 0; (ptr_master_tab[index] < goal_sb); index++)
          goal_sb = ptr_master_tab[index];
      } else {
        goal_sb = ptr_master_tab[num_mf_bands];
      }
    }

    source_start_band = xover_offset + 1;

    sb = lsb + xover_offset;

    patch = 0;
    while (sb < usb) {
      if (IXHEAACE_MAX_NUM_PATCHES <= patch) {
        return IA_EXHEAACE_EXE_NONFATAL_ESBR_INVALID_NUM_PATCH;
      }

      num_bands_in_patch = goal_sb - sb;

      if (num_bands_in_patch + source_start_band >= lsb) {
        patch_stride = sb - source_start_band;
        patch_stride = patch_stride & ~1;
        num_bands_in_patch = lsb - (sb - patch_stride);
        num_bands_in_patch = ixheaace_find_closest_entry(sb + num_bands_in_patch, ptr_master_tab,
                                                         (WORD16)(num_mf_bands), 0) -
                             (WORD32)(sb);
      }

      patch_stride = num_bands_in_patch + sb - lsb;
      patch_stride = (patch_stride + 1) & ~1;

      source_start_band = 1;

      if (goal_sb - (sb + num_bands_in_patch) < 3) {
        goal_sb = usb;
      }

      if ((num_bands_in_patch < 3) && (patch > 0) && (sb + num_bands_in_patch == usb)) {
        for (i = start_sample + slope_length; i < end_sample + slope_length; i++) {
          for (k2 = sb; k2 < sb + num_bands_in_patch; k2++) {
            if (k2 < 0 || k2 >= 64) {
              break;
            }
            ptr_dst_buf_real[i][k2] = 0.0f;
            ptr_dst_buf_imag[i][k2] = 0.0f;
          }
        }
        break;
      }

      if (num_bands_in_patch <= 0) {
        continue;
      }

      for (k2 = sb; k2 < sb + num_bands_in_patch; k2++) {
        k = k2 - patch_stride;
        bw_index = 0;
        while (k2 >= ptr_invf_band_tbl[bw_index]) {
          bw_index++;
          if (bw_index >= IXHEAACE_MAX_NOISE_COEFFS) {
            return IA_EXHEAACE_EXE_NONFATAL_ESBR_INVALID_BANDWIDTH_INDEX;
          }
        }

        if (bw_index >= IXHEAACE_MAX_NUM_PATCHES) {
          return IA_EXHEAACE_EXE_NONFATAL_ESBR_INVALID_BANDWIDTH_INDEX;
        }
        bw = ptr_bw_array[bw_index];

        a0r = bw * alpha_real[k][0];
        a0i = bw * alpha_imag[k][0];
        bw *= bw;
        a1r = bw * alpha_real[k][1];
        a1i = bw * alpha_imag[k][1];

        if (pre_proc_flag) {
          gain = ptr_gain_vector[k];
        } else {
          gain = 1.0f;
        }

        for (i = start_sample + slope_length; i < end_sample + slope_length; i++) {
          ptr_dst_buf_real[i][k2] = ptr_src_buf_real[i][k] * gain;

          ptr_dst_buf_imag[i][k2] = ptr_src_buf_imag[i][k] * gain;

          if (bw > 0.0f) {
            ptr_dst_buf_real[i][k2] +=
                (a0r * ptr_src_buf_real[i - 1][k] - a0i * ptr_src_buf_imag[i - 1][k] +
                 a1r * ptr_src_buf_real[i - 2][k] - a1i * ptr_src_buf_imag[i - 2][k]) *
                gain;
            ptr_dst_buf_imag[i][k2] +=
                (a0i * ptr_src_buf_real[i - 1][k] + a0r * ptr_src_buf_imag[i - 1][k] +
                 a1i * ptr_src_buf_real[i - 2][k] + a1r * ptr_src_buf_imag[i - 2][k]) *
                gain;
          }
        }
      }
      sb += num_bands_in_patch;
      patch++;
    }
  }

  if (hbe_flag && !sbr_patching_mode) {
    FLOAT32 alpha_real[2], alpha_imag[2];

    bw_index = 0, patch = 1;
    if (NULL == ptr_ph_vocod_buf_real || NULL == ptr_ph_vocod_buf_imag) {
      return IA_EXHEAACE_EXE_NONFATAL_ESBR_INVALID_VOCOD_BUF;
    }

    for (k2 = sub_band_start; k2 < ptr_master_tab[num_mf_bands]; k2++) {
      ixheaace_esbr_calc_co_variance(&str_auto_corr, &ptr_ph_vocod_buf_real[0],
                                     &ptr_ph_vocod_buf_imag[0], k2, co_var_len);

      if (str_auto_corr.det == 0.0f) {
        alpha_real[1] = alpha_imag[1] = 0;
      } else {
        fac = 1.0f / str_auto_corr.det;
        alpha_real[1] = (str_auto_corr.phi_0_1_real * str_auto_corr.phi_1_2_real -
                         str_auto_corr.phi_0_1_imag * str_auto_corr.phi_1_2_imag -
                         str_auto_corr.phi_0_2_real * str_auto_corr.phi_1_1) *
                        fac;
        alpha_imag[1] = (str_auto_corr.phi_0_1_imag * str_auto_corr.phi_1_2_real +
                         str_auto_corr.phi_0_1_real * str_auto_corr.phi_1_2_imag -
                         str_auto_corr.phi_0_2_imag * str_auto_corr.phi_1_1) *
                        fac;
      }

      if (str_auto_corr.phi_1_1 == 0) {
        alpha_real[0] = alpha_imag[0] = 0;
      } else {
        fac = 1.0f / str_auto_corr.phi_1_1;
        alpha_real[0] =
            -(str_auto_corr.phi_0_1_real + alpha_real[1] * str_auto_corr.phi_1_2_real +
              alpha_imag[1] * str_auto_corr.phi_1_2_imag) *
            fac;
        alpha_imag[0] =
            -(str_auto_corr.phi_0_1_imag + alpha_imag[1] * str_auto_corr.phi_1_2_real -
              alpha_real[1] * str_auto_corr.phi_1_2_imag) *
            fac;
      }

      if (alpha_real[0] * alpha_real[0] + alpha_imag[0] * alpha_imag[0] >= 16.0f ||
          alpha_real[1] * alpha_real[1] + alpha_imag[1] * alpha_imag[1] >= 16.0f) {
        alpha_real[0] = 0.0f;
        alpha_imag[0] = 0.0f;
        alpha_real[1] = 0.0f;
        alpha_imag[1] = 0.0f;
      }

      while (k2 >= ptr_invf_band_tbl[bw_index]) {
        bw_index++;
        if (bw_index >= IXHEAACE_MAX_NOISE_COEFFS) {
          return IA_EXHEAACE_EXE_NONFATAL_ESBR_INVALID_BANDWIDTH_INDEX;
        }
      }

      if (bw_index >= IXHEAACE_MAX_NUM_PATCHES) {
        return IA_EXHEAACE_EXE_NONFATAL_ESBR_INVALID_BANDWIDTH_INDEX;
      }
      bw = ptr_bw_array[bw_index];

      a0r = bw * alpha_real[0];
      a0i = bw * alpha_imag[0];
      bw *= bw;
      a1r = bw * alpha_real[1];
      a1i = bw * alpha_imag[1];

      if (bw > 0.0f) {
        for (i = start_sample; i < end_sample; i++) {
          FLOAT32 real1, imag1, real2, imag2;

          real1 = ptr_ph_vocod_buf_real[i - 1][k2];
          imag1 = ptr_ph_vocod_buf_imag[i - 1][k2];
          real2 = ptr_ph_vocod_buf_real[i - 2][k2];
          imag2 = ptr_ph_vocod_buf_imag[i - 2][k2];
          ptr_dst_buf_real[i][k2] = ptr_ph_vocod_buf_real[i][k2] +
                                    ((a0r * real1 - a0i * imag1) + (a1r * real2 - a1i * imag2));
          ptr_dst_buf_imag[i][k2] = ptr_ph_vocod_buf_imag[i][k2] +
                                    ((a0i * real1 + a0r * imag1) + (a1i * real2 + a1r * imag2));
        }
      } else {
        for (i = start_sample; i < end_sample; i++) {
          ptr_dst_buf_real[i][k2] = ptr_ph_vocod_buf_real[i][k2];
          ptr_dst_buf_imag[i][k2] = ptr_ph_vocod_buf_imag[i][k2];
        }
      }
    }
  }
  if (patch >= (IXHEAACE_MAX_NUM_PATCHES + 1)) {
    return IA_EXHEAACE_EXE_NONFATAL_ESBR_INVALID_NUM_PATCH;
  }
  for (i = 0; i < num_if_bands; i++) {
    ptr_bw_array_prev[i] = ptr_bw_array[i];
  }
  return IA_NO_ERROR;
}

IA_ERRORCODE ixheaace_process_inter_tes(ixheaace_str_inter_tes_params *pstr_tes_enc,
                                        WORD8 *ptr_scr) {
  WORD32 gi = 0, env, tes_enable = 0, ts, bd, start_ts, stop_ts;
  WORD32 is_sound_activity[IXHEAACE_MAX_ENVELOPES] = {0},
         is_transient[IXHEAACE_MAX_ENVELOPES] = {0};
  WORD32 tes_shape_mode = 0;
  WORD32 num_samples, num_bands;
  WORD32 len;
  IA_ERRORCODE status = IA_NO_ERROR;
  FLOAT32 energy_high[64] = {0};
  FLOAT32 energy[64] = {0};
  FLOAT32 gamma[IXHEAACE_ESBR_NUM_GAMMA_IDXS] = {0};
  FLOAT32 gamma_min = MAX_FLT_VAL;
  ixheaace_str_inter_tes_scr *tes_scr = (ixheaace_str_inter_tes_scr *)ptr_scr;
  num_bands = pstr_tes_enc->sub_band_end - pstr_tes_enc->sub_band_start;

  for (env = 0; env < pstr_tes_enc->num_env; env++) {
    tes_shape_mode = 0;
    len = 2 * (pstr_tes_enc->border_vec[env + 1] - pstr_tes_enc->border_vec[env]);
    is_sound_activity[env] = ixheaace_inter_tes_sound_activity(
        &pstr_tes_enc
             ->qmf_buf_real[IXHEAACE_SBR_HF_ADJ_OFFSET + 2 * pstr_tes_enc->border_vec[env]],
        &pstr_tes_enc
             ->qmf_buf_imag[IXHEAACE_SBR_HF_ADJ_OFFSET + 2 * pstr_tes_enc->border_vec[env]],
        &energy_high[IXHEAACE_SBR_HF_ADJ_OFFSET + 2 * pstr_tes_enc->border_vec[env]], len,
        pstr_tes_enc->sub_band_start, pstr_tes_enc->sub_band_end, &is_transient[env]);
    if (1 == is_transient[env] && 1 == is_sound_activity[env]) {
      tes_enable = 1;
    }
  }

  if (1 == tes_enable) {
    status = ixheaace_generate_hf(&pstr_tes_enc->qmf_buf_real[IXHEAACE_SBR_HF_ADJ_OFFSET],
                                  &pstr_tes_enc->qmf_buf_imag[IXHEAACE_SBR_HF_ADJ_OFFSET], NULL,
                                  NULL, &tes_scr->dst_qmf_r[IXHEAACE_SBR_HF_ADJ_OFFSET],
                                  &tes_scr->dst_qmf_i[IXHEAACE_SBR_HF_ADJ_OFFSET], pstr_tes_enc);

    if (status) {
      return status;
    }
    for (env = 0; env < pstr_tes_enc->num_env; env++) {
      if ((1 == is_sound_activity[env]) && (1 == is_transient[env])) {
        num_samples = (pstr_tes_enc->border_vec[env + 1] - pstr_tes_enc->border_vec[env]) * 2;
        start_ts = IXHEAACE_SBR_HF_ADJ_OFFSET + pstr_tes_enc->border_vec[env] * 2;
        stop_ts = start_ts + num_samples;

        for (gi = 0; gi < IXHEAACE_ESBR_NUM_GAMMA_IDXS; gi++) {
          ixheaace_apply_inter_tes(
              &tes_scr
                   ->dst_qmf_r[IXHEAACE_SBR_HF_ADJ_OFFSET + 2 * pstr_tes_enc->border_vec[env]][0],
              &tes_scr
                   ->dst_qmf_i[IXHEAACE_SBR_HF_ADJ_OFFSET + 2 * pstr_tes_enc->border_vec[env]][0],
              &pstr_tes_enc->qmf_buf_real[IXHEAACE_SBR_HF_ADJ_OFFSET +
                                          2 * pstr_tes_enc->border_vec[env]][0],
              &pstr_tes_enc->qmf_buf_imag[IXHEAACE_SBR_HF_ADJ_OFFSET +
                                          2 * pstr_tes_enc->border_vec[env]][0],
              num_samples, pstr_tes_enc->sub_band_start, num_bands, gi);
          for (ts = start_ts; ts < stop_ts; ts++) {
            energy[ts] = 0.0f;
            for (bd = pstr_tes_enc->sub_band_start; bd < pstr_tes_enc->sub_band_end; bd++) {
              energy[ts] += tes_scr->dst_qmf_r[ts][bd] * tes_scr->dst_qmf_r[ts][bd];
              energy[ts] += tes_scr->dst_qmf_i[ts][bd] * tes_scr->dst_qmf_i[ts][bd];
            }
            gamma[gi] += (FLOAT32)fabs(energy[ts] - energy_high[ts]) /
                         (FLOAT32)(pow((energy_high[ts] + 1e-6f), 0.9f));
          }
          if (gamma[gi] < gamma_min) {
            gamma_min = gamma[gi];
            tes_shape_mode = gi;
          }
        }
      }

      if (tes_shape_mode > 0) {
        pstr_tes_enc->bs_tes_shape[env] = 1;
        pstr_tes_enc->bs_tes_shape_mode[env] = tes_shape_mode;
      } else {
        pstr_tes_enc->bs_tes_shape[env] = 0;
        pstr_tes_enc->bs_tes_shape_mode[env] = 0;
      }
    }
  } else {
    for (env = 0; env < pstr_tes_enc->num_env; env++) {
      pstr_tes_enc->bs_tes_shape[env] = 0;
      pstr_tes_enc->bs_tes_shape_mode[env] = 0;
    }
  }
  return status;
}