xref: /aosp_15_r20/external/libxaac/encoder/ixheaace_block_switch.c (revision 15dc779a375ca8b5125643b829a8aa4b70d7f451)

/******************************************************************************
 *                                                                            *
 * 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];
        }
      }
    }
  }
}