/******************************************************************************

 *                                                                            *

 * 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 "iusace_type_def.h"

#include "ixheaace_mps_common_define.h"

#include "iusace_cnst.h"

#include "iusace_block_switch_const.h"

#include "iusace_block_switch_struct_def.h"

#include "iusace_rom.h"

static FLOAT32 iusace_fmult(FLOAT32 a, FLOAT32 b) { return (a * b); }

static FLOAT32 iusace_fadd(FLOAT32 a, FLOAT32 b) { return (a + b); }

VOID iusace_init_block_switching(ia_block_switch_ctrl *pstr_blk_switch_ctrl,

                                 const WORD32 bit_rate, const WORD32 num_chans) {

  WORD32 i, w;

  if ((num_chans == 1 && bit_rate > 24000) || (num_chans > 1 && bit_rate / num_chans > 16000)) {

    pstr_blk_switch_ctrl->inv_attack_ratio = INV_ATTACK_RATIO_HIGH_BR;

  } else {

    pstr_blk_switch_ctrl->inv_attack_ratio = INV_ATTACK_RATIO_LOW_BR;

  }

  for (i = 0; i < BLK_SWITCH_FILT_LEN; i++) {

    pstr_blk_switch_ctrl->iir_states[i] = 0;

  }

  /* Clear Filtered Window Energies */

  for (w = 0; w < MAX_SHORT_WINDOWS; w++) {

    pstr_blk_switch_ctrl->win_energy_filt[0][w] = 0;

    pstr_blk_switch_ctrl->win_energy_filt[1][w] = 0;

    pstr_blk_switch_ctrl->win_energy[0][w] = 0;

    pstr_blk_switch_ctrl->win_energy[1][w] = 0;

  }

  pstr_blk_switch_ctrl->acc_win_energy = 0;

  pstr_blk_switch_ctrl->window_seq = ONLY_LONG_SEQUENCE;

  pstr_blk_switch_ctrl->next_win_seq = ONLY_LONG_SEQUENCE;

  pstr_blk_switch_ctrl->attack = 0;

  pstr_blk_switch_ctrl->lastattack = 0;

  pstr_blk_switch_ctrl->attack_idx = 0;

  pstr_blk_switch_ctrl->last_attack_idx = 0;

  return;

}

static FLOAT32 iusace_srch_max_with_idx(const FLOAT32 *ptr_in, WORD32 *index) {

  FLOAT32 max;

  WORD32 i, idx;

  max = 0;

  idx = 0;

  for (i = 0; i < MAX_SHORT_WINDOWS; i++) {

    if (ptr_in[i + 1] > max) {

      max = ptr_in[i + 1];

      idx = i;

    }

  }

  *index = idx;

  return max;

}

static VOID iusace_blk_switch_iir_filt(const FLOAT32 *ptr_in, const FLOAT32 *ptr_iir_coeff,

                                       const WORD32 w, FLOAT32 *ptr_iir_states,

                                       FLOAT32 *energy_accu, WORD32 block_len) {

  FLOAT32 accu1;

  WORD32 i;

  FLOAT32 accu_unfilt = 0.0f;

  FLOAT32 accu_filt = 0.0f;

  FLOAT32 accu2, temp2, temp1;

  FLOAT32 state0 = ptr_iir_states[0];

  FLOAT32 state1 = ptr_iir_states[1];

  FLOAT32 coeff0 = ptr_iir_coeff[0];

  FLOAT32 coeff1 = ptr_iir_coeff[1];

  const FLOAT32 *p_time_signal = &ptr_in[(block_len * w)];

  for (i = 0; i < block_len; i++) {

    accu2 = iusace_fmult(state0, coeff1);

    accu1 = iusace_fmult(state1, coeff0);

    accu1 += accu2;

    state0 = p_time_signal[i];

    state1 = iusace_fmult(state0, coeff1);

    state1 = (state1 - accu1);

    temp1 = iusace_fmult(state0, state0);

    temp2 = iusace_fmult(state1, state1);

    accu_unfilt = iusace_fadd(accu_unfilt, temp1);

    accu_filt = iusace_fadd(accu_filt, temp2);

  }

  energy_accu[0] = accu_unfilt;

  energy_accu[1] = accu_filt;

  ptr_iir_states[0] = state0;

  ptr_iir_states[1] = state1;

  return;

}

static VOID iusace_calc_window_energy(ia_block_switch_ctrl *ptr_blk_switch_ctrl,

                                      const FLOAT32 *ptr_in, FLOAT32 *max, WORD32 ccfl) {

  WORD32 w;

  FLOAT32 energy_accu[2];

  *max = 0.0f;

  for (w = 0; w < MAX_SHORT_WINDOWS; w++) {

    // block length for calculating energy is corecoder frame length / MAX_SHORT_WINDOWS

    iusace_blk_switch_iir_filt(ptr_in, iusace_iir_hipass_coeffs, w,

                               ptr_blk_switch_ctrl->iir_states, &energy_accu[0], ccfl >> 3);

    ptr_blk_switch_ctrl->win_energy[1][w] = energy_accu[0];

    ptr_blk_switch_ctrl->win_energy_filt[1][w] = energy_accu[1];

    if (ptr_blk_switch_ctrl->win_energy_filt[1][w] > *max)

      *max = ptr_blk_switch_ctrl->win_energy_filt[1][w];

  }

  return;

}

VOID iusace_block_switching(ia_block_switch_ctrl *ptr_blk_switch_ctrl, const FLOAT32 *ptr_in,

                            WORD32 ccfl) {

  WORD32 i;

  FLOAT32 temp1, temp2;

  FLOAT32 max;

  FLOAT32 energy, energy_max;

  for (i = 0; i < MAX_SHORT_WINDOWS; i++) {

    ptr_blk_switch_ctrl->group_len[i] = 0;

  }

  ptr_blk_switch_ctrl->max_win_energy =

      iusace_srch_max_with_idx(&ptr_blk_switch_ctrl->win_energy[0][MAX_SHORT_WINDOWS - 1],

                               &ptr_blk_switch_ctrl->attack_idx);

  ptr_blk_switch_ctrl->attack_idx = ptr_blk_switch_ctrl->last_attack_idx;

  ptr_blk_switch_ctrl->tot_grps_cnt = MAXIMUM_NO_OF_GROUPS;

  for (i = 0; i < MAXIMUM_NO_OF_GROUPS; i++) {

    ptr_blk_switch_ctrl->group_len[i] =

        iusace_suggested_grouping_table[ptr_blk_switch_ctrl->attack_idx][i];

  }

  for (i = 0; i < MAX_SHORT_WINDOWS; i++) {

    ptr_blk_switch_ctrl->win_energy[0][i] = ptr_blk_switch_ctrl->win_energy[1][i];

    ptr_blk_switch_ctrl->win_energy_filt[0][i] = ptr_blk_switch_ctrl->win_energy_filt[1][i];

  }

  iusace_calc_window_energy(ptr_blk_switch_ctrl, ptr_in, &max, ccfl);

  ptr_blk_switch_ctrl->attack = FALSE;

  energy_max = 0.0f;

  energy = ptr_blk_switch_ctrl->win_energy_filt[0][MAX_SHORT_WINDOWS - 1];

  for (i = 0; i < MAX_SHORT_WINDOWS; i++) {

    temp1 = iusace_fmult(ONE_MINUS_ACC_WINDOW_NRG_FAC, ptr_blk_switch_ctrl->acc_win_energy);

    temp2 = iusace_fmult(ACC_WINDOW_NRG_FAC, energy);

    ptr_blk_switch_ctrl->acc_win_energy = iusace_fadd(temp1, temp2);

    temp1 = iusace_fmult(ptr_blk_switch_ctrl->win_energy_filt[1][i],

                         ptr_blk_switch_ctrl->inv_attack_ratio);

    if (temp1 > ptr_blk_switch_ctrl->acc_win_energy) {

      ptr_blk_switch_ctrl->attack = TRUE;

      ptr_blk_switch_ctrl->last_attack_idx = i;

    }

    energy = ptr_blk_switch_ctrl->win_energy_filt[1][i];

    if (energy_max < energy) energy_max = energy;

  }

  if (ccfl == LEN_SUPERFRAME_768) {

    energy_max = (energy_max * 4) / 3.0f;

  }

  if (energy_max < USAC_MIN_ATTACK_NRG) {

    ptr_blk_switch_ctrl->attack = FALSE;

  }

  if ((!ptr_blk_switch_ctrl->attack) && (ptr_blk_switch_ctrl->lastattack)) {

    if (ptr_blk_switch_ctrl->attack_idx == MAX_SHORT_WINDOWS - 1) {

      ptr_blk_switch_ctrl->attack = TRUE;

    }

    ptr_blk_switch_ctrl->lastattack = FALSE;

  } else {

    ptr_blk_switch_ctrl->lastattack = ptr_blk_switch_ctrl->attack;

  }

  ptr_blk_switch_ctrl->window_seq = ptr_blk_switch_ctrl->next_win_seq;

  if (ptr_blk_switch_ctrl->attack) {

    ptr_blk_switch_ctrl->next_win_seq = EIGHT_SHORT_SEQUENCE;

  } else {

    ptr_blk_switch_ctrl->next_win_seq = ONLY_LONG_SEQUENCE;

  }

  if (ptr_blk_switch_ctrl->next_win_seq == EIGHT_SHORT_SEQUENCE) {

    if (ptr_blk_switch_ctrl->window_seq == ONLY_LONG_SEQUENCE) {

      ptr_blk_switch_ctrl->window_seq = LONG_START_SEQUENCE;

    }

    if (ptr_blk_switch_ctrl->window_seq == LONG_STOP_SEQUENCE) {

      ptr_blk_switch_ctrl->window_seq = EIGHT_SHORT_SEQUENCE;

      ptr_blk_switch_ctrl->tot_grps_cnt = 3;

      ptr_blk_switch_ctrl->group_len[0] = 3;

      ptr_blk_switch_ctrl->group_len[1] = 3;

      ptr_blk_switch_ctrl->group_len[2] = 2;

    }

  }

  if (ptr_blk_switch_ctrl->next_win_seq == ONLY_LONG_SEQUENCE) {

    if (ptr_blk_switch_ctrl->window_seq == EIGHT_SHORT_SEQUENCE) {

      ptr_blk_switch_ctrl->next_win_seq = LONG_STOP_SEQUENCE;

    }

  }

  return;

}

VOID iusace_sync_block_switching(ia_block_switch_ctrl *ptr_blk_switch_left_ctrl,

                                 ia_block_switch_ctrl *ptr_blk_switch_right_ctrl) {

  WORD32 i;

  WORD32 patch_type = ONLY_LONG_SEQUENCE;

  patch_type = iusace_synchronized_block_types[patch_type][ptr_blk_switch_left_ctrl->window_seq];

  patch_type = iusace_synchronized_block_types[patch_type][ptr_blk_switch_right_ctrl->window_seq];

  ptr_blk_switch_left_ctrl->window_seq = patch_type;

  ptr_blk_switch_right_ctrl->window_seq = patch_type;

  if (patch_type != EIGHT_SHORT_SEQUENCE) { /* tns_data_long Blocks */

    ptr_blk_switch_left_ctrl->tot_grps_cnt = 1;

    ptr_blk_switch_right_ctrl->tot_grps_cnt = 1;

    ptr_blk_switch_left_ctrl->group_len[0] = 1;

    ptr_blk_switch_right_ctrl->group_len[0] = 1;

    for (i = 1; i < MAX_SHORT_WINDOWS; i++) {

      ptr_blk_switch_left_ctrl->group_len[i] = 0;

      ptr_blk_switch_right_ctrl->group_len[i] = 0;

    }

  } else { /* tns_data_short Blocks */

    if (ptr_blk_switch_left_ctrl->max_win_energy > ptr_blk_switch_right_ctrl->max_win_energy) {

      ptr_blk_switch_right_ctrl->tot_grps_cnt = ptr_blk_switch_left_ctrl->tot_grps_cnt;

      for (i = 0; i < ptr_blk_switch_right_ctrl->tot_grps_cnt; i++) {

        ptr_blk_switch_right_ctrl->group_len[i] = ptr_blk_switch_left_ctrl->group_len[i];

      }

    } else {

      ptr_blk_switch_left_ctrl->tot_grps_cnt = ptr_blk_switch_right_ctrl->tot_grps_cnt;

      for (i = 0; i < ptr_blk_switch_left_ctrl->tot_grps_cnt; i++) {

        ptr_blk_switch_left_ctrl->group_len[i] = ptr_blk_switch_right_ctrl->group_len[i];

      }

    }

  }

  return;

}