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

 *                                                                            *

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

#include "ixheaac_constants.h"

#include "ixheaace_aac_constants.h"

#include "ixheaace_psy_const.h"

#include "ixheaace_tns.h"

#include "ixheaace_tns_params.h"

#include "ixheaace_rom.h"

#include "ixheaace_common_rom.h"

#include "ixheaace_bitbuffer.h"

#include "ixheaac_basic_ops32.h"

#include "ixheaac_basic_ops40.h"

#include "ixheaac_basic_ops.h"

#include "ixheaace_block_switch.h"

#include "iusace_block_switch_struct_def.h"

#include <string.h>

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

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

VOID iaace_init_block_switching(ixheaace_block_switch_control *pstr_blk_switch_ctrl,

                                const WORD32 bit_rate, const WORD32 num_chans) {

  if ((num_chans == 1 && bit_rate > BLK_SWITCH_HIGH_BR_MONO) ||

      (num_chans > 1 && bit_rate / num_chans > BLK_SWITCH_HIGH_BR_STEREO)) {

    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;

  }

  memset(pstr_blk_switch_ctrl->iir_states, 0,

         BLK_SWITCH_FILT_LEN * sizeof(pstr_blk_switch_ctrl->iir_states[0]));

  /* Clear Filtered Window Energies */

  memset(pstr_blk_switch_ctrl->win_energy_filt, 0,

         BLK_SWITCH_WIN * sizeof(pstr_blk_switch_ctrl->win_energy_filt[0][0]));

  memset(pstr_blk_switch_ctrl->win_energy, 0,

         BLK_SWITCH_WIN * sizeof(pstr_blk_switch_ctrl->win_energy[0][0]));

  pstr_blk_switch_ctrl->acc_win_energy = 0;

  pstr_blk_switch_ctrl->win_seq = LONG_WINDOW;

  pstr_blk_switch_ctrl->nxt_win_seq = LONG_WINDOW;

  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;

}

static FLOAT32 iaace_search_max_with_idx(const FLOAT32 *ptr_in, WORD32 *ptr_index, WORD32 len) {

  FLOAT32 max = 0;

  WORD32 i = 0, idx = 0;

  do {

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

      max = ptr_in[i + 1];

      idx = i;

    }

    i++;

  } while (i < len);

  *ptr_index = idx;

  return max;

}

static FLOAT32 iaace_blk_switch_iir_filt(const FLOAT32 input, const FLOAT32 *ptr_iir_coeff,

                                         FLOAT32 *ptr_iir_states) {

  FLOAT32 accu_1, accu_2;

  FLOAT32 out;

  accu_1 = ptr_iir_coeff[1] * (input - ptr_iir_states[0]);

  accu_2 = ptr_iir_coeff[0] * ptr_iir_states[1];

  out = accu_1 - accu_2;

  ptr_iir_states[0] = input;

  ptr_iir_states[1] = out;

  return out;

}

static VOID iaace_calc_window_energy(ixheaace_block_switch_control *pstr_blk_switch_ctrl,

                                     const FLOAT32 *ptr_time_signal, WORD32 ch_increment,

                                     WORD32 win_len) {

  WORD32 i, w;

  FLOAT32 acc_nrg_unfilt, acc_nrg_filt;

  FLOAT32 tmp_nrg_unfilt, tmp_nrg_filt;

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

    acc_nrg_unfilt = 0.0f;

    acc_nrg_filt = 0.0f;

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

      tmp_nrg_unfilt = ptr_time_signal[(win_len * w + i) * ch_increment];

      tmp_nrg_filt = iaace_blk_switch_iir_filt(tmp_nrg_unfilt, iaace_iir_hipass_coeffs,

                                               pstr_blk_switch_ctrl->iir_states);

      acc_nrg_unfilt += (tmp_nrg_unfilt * tmp_nrg_unfilt);

      acc_nrg_filt += (tmp_nrg_filt * tmp_nrg_filt);

    }

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

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

  }

}

VOID iaace_block_switching(ixheaace_block_switch_control *pstr_blk_switch_ctrl,

                           const FLOAT32 *ptr_time_signal, WORD32 frame_length,

                           WORD32 num_chans) {

  WORD32 win_idx;

  FLOAT32 tmp_nrg_1, tmp_nrg_2;

  FLOAT32 prev_win_nrg, max_nrg;

  memset(pstr_blk_switch_ctrl->group_len, 0,

         TRANS_FAC * sizeof(pstr_blk_switch_ctrl->group_len[0]));

  pstr_blk_switch_ctrl->max_win_energy =

      iaace_search_max_with_idx(&pstr_blk_switch_ctrl->win_energy[0][BLK_SWITCH_WIN - 1],

                                &pstr_blk_switch_ctrl->attack_idx, BLK_SWITCH_WIN);

  pstr_blk_switch_ctrl->attack_idx = pstr_blk_switch_ctrl->last_attack_idx;

  pstr_blk_switch_ctrl->total_groups_cnt = MAXIMUM_NO_OF_GROUPS;

  memcpy(pstr_blk_switch_ctrl->group_len,

         iaace_suggested_grouping_table[pstr_blk_switch_ctrl->attack_idx],

         MAXIMUM_NO_OF_GROUPS * sizeof(pstr_blk_switch_ctrl->group_len[0]));

  memcpy(pstr_blk_switch_ctrl->win_energy[0], pstr_blk_switch_ctrl->win_energy[1],

         BLK_SWITCH_WIN * sizeof(pstr_blk_switch_ctrl->win_energy[0][0]));

  memcpy(pstr_blk_switch_ctrl->win_energy_filt[0], pstr_blk_switch_ctrl->win_energy_filt[1],

         BLK_SWITCH_WIN * sizeof(pstr_blk_switch_ctrl->win_energy_filt[0][0]));

  iaace_calc_window_energy(

      pstr_blk_switch_ctrl, ptr_time_signal, num_chans,

      (frame_length == FRAME_LEN_960 ? FRAME_LEN_SHORT_120 : FRAME_LEN_SHORT_128));

  pstr_blk_switch_ctrl->attack = FALSE;

  max_nrg = 0.0f;

  prev_win_nrg = pstr_blk_switch_ctrl->win_energy_filt[0][BLK_SWITCH_WIN - 1];

  for (win_idx = 0; win_idx < BLK_SWITCH_WIN; win_idx++) {

    tmp_nrg_1 = iaace_fmult(ONE_MINUS_ACC_WINDOW_NRG_FAC, pstr_blk_switch_ctrl->acc_win_energy);

    tmp_nrg_2 = iaace_fmult(ACC_WINDOW_NRG_FAC, prev_win_nrg);

    pstr_blk_switch_ctrl->acc_win_energy = iaace_fadd(tmp_nrg_1, tmp_nrg_2);

    tmp_nrg_1 = iaace_fmult(pstr_blk_switch_ctrl->win_energy_filt[1][win_idx],

                            pstr_blk_switch_ctrl->inv_attack_ratio);

    if (tmp_nrg_1 > pstr_blk_switch_ctrl->acc_win_energy) {

      pstr_blk_switch_ctrl->attack = TRUE;

      pstr_blk_switch_ctrl->last_attack_idx = win_idx;

    }

    prev_win_nrg = pstr_blk_switch_ctrl->win_energy_filt[1][win_idx];

    max_nrg = MAX(prev_win_nrg, max_nrg);

  }

  if (max_nrg < MIN_ATTACK_NRG) {

    pstr_blk_switch_ctrl->attack = FALSE;

  }

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

    if (pstr_blk_switch_ctrl->attack_idx == (TRANS_FAC - 1)) {

      pstr_blk_switch_ctrl->attack = TRUE;

    }

    pstr_blk_switch_ctrl->lastattack = FALSE;

  } else {

    pstr_blk_switch_ctrl->lastattack = pstr_blk_switch_ctrl->attack;

  }

  pstr_blk_switch_ctrl->win_seq = pstr_blk_switch_ctrl->nxt_win_seq;

  pstr_blk_switch_ctrl->nxt_win_seq =

      (pstr_blk_switch_ctrl->attack == 1) ? SHORT_WINDOW : LONG_WINDOW;

  if (pstr_blk_switch_ctrl->nxt_win_seq == SHORT_WINDOW) {

    if (pstr_blk_switch_ctrl->win_seq == LONG_WINDOW) {

      pstr_blk_switch_ctrl->win_seq = START_WINDOW;

    } else if (pstr_blk_switch_ctrl->win_seq == STOP_WINDOW) {

      pstr_blk_switch_ctrl->win_seq = SHORT_WINDOW;

      pstr_blk_switch_ctrl->total_groups_cnt = 3;

      pstr_blk_switch_ctrl->group_len[0] = 3;

      pstr_blk_switch_ctrl->group_len[1] = 3;

      pstr_blk_switch_ctrl->group_len[2] = 2;

    }

  }

  if (pstr_blk_switch_ctrl->nxt_win_seq == LONG_WINDOW &&

      pstr_blk_switch_ctrl->win_seq == SHORT_WINDOW) {

    pstr_blk_switch_ctrl->nxt_win_seq = STOP_WINDOW;

  }

}

VOID iaace_sync_block_switching(ixheaace_block_switch_control *pstr_blk_switch_left_ctrl,

                                ixheaace_block_switch_control *pstr_blk_switch_right_ctrl,

                                const WORD32 num_channels) {

  WORD32 i;

  WORD32 patch_type = LONG_WINDOW;

  if (num_channels == 1) {

    if (pstr_blk_switch_left_ctrl->win_seq != SHORT_WINDOW) {

      pstr_blk_switch_left_ctrl->total_groups_cnt = 1;

      pstr_blk_switch_left_ctrl->group_len[0] = 1;

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

        pstr_blk_switch_left_ctrl->group_len[i] = 0;

      }

    }

  } else {

    /* Stereo */

    patch_type = iaace_synchronized_block_types[patch_type][pstr_blk_switch_left_ctrl->win_seq];

    patch_type = iaace_synchronized_block_types[patch_type][pstr_blk_switch_right_ctrl->win_seq];

    pstr_blk_switch_left_ctrl->win_seq = patch_type;

    pstr_blk_switch_right_ctrl->win_seq = patch_type;

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

      pstr_blk_switch_left_ctrl->total_groups_cnt = 1;

      pstr_blk_switch_right_ctrl->total_groups_cnt = 1;

      pstr_blk_switch_left_ctrl->group_len[0] = 1;

      pstr_blk_switch_right_ctrl->group_len[0] = 1;

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

        pstr_blk_switch_left_ctrl->group_len[i] = 0;

        pstr_blk_switch_right_ctrl->group_len[i] = 0;

      }

    } else { /* tns_data_short Blocks */

      if (pstr_blk_switch_left_ctrl->max_win_energy >

          pstr_blk_switch_right_ctrl->max_win_energy) {

        pstr_blk_switch_right_ctrl->total_groups_cnt =

            pstr_blk_switch_left_ctrl->total_groups_cnt;

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

          pstr_blk_switch_right_ctrl->group_len[i] = pstr_blk_switch_left_ctrl->group_len[i];

        }

      } else {

        pstr_blk_switch_left_ctrl->total_groups_cnt =

            pstr_blk_switch_right_ctrl->total_groups_cnt;

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

          pstr_blk_switch_left_ctrl->group_len[i] = pstr_blk_switch_right_ctrl->group_len[i];

        }

      }

    }

  }

}