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

 *                                                                            *

 * 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 <math.h>

#include <stdlib.h>

#include <string.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_basic_ops.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 "ixheaace_block_switch.h"

#include "ixheaace_psy_data.h"

#include "ixheaace_interface.h"

#include "ixheaace_adjust_threshold_data.h"

#include "ixheaace_dynamic_bits.h"

#include "ixheaace_qc_data.h"

#include "ixheaac_error_standards.h"

#include "ixheaace_stereo_preproc.h"

#include "ixheaace_common_utils.h"

IA_ERRORCODE iaace_init_stereo_pre_processing(ixheaace_stereo_pre_pro_pstr pstr_stereo_pre_pro,

                                        WORD32 no_channels, WORD32 bit_rate, WORD32 sample_rate,

                                        FLOAT32 used_scf_ratio) {

  FLOAT32 bpf = bit_rate * 1024.0f / sample_rate;

  FLOAT32 tmp;

  memset(pstr_stereo_pre_pro, 0, sizeof(ixheaace_stereo_pre_pro_struct));

  if (no_channels == 2) {

    (pstr_stereo_pre_pro)->stereo_attenuation_flag = 1;

    (pstr_stereo_pre_pro)->norm_pe_fac = 230.0f * used_scf_ratio / bpf;

    (pstr_stereo_pre_pro)->impact_factor =

        MIN(1, 400000.0f / (FLOAT32)(bit_rate - sample_rate * sample_rate / 72000.0f));

    (pstr_stereo_pre_pro)->inc_stereo_attenuation = 22050.0f / sample_rate * 400.0f / bpf;

    (pstr_stereo_pre_pro)->dec_stereo_attenuation = 22050.0f / sample_rate * 200.0f / bpf;

    (pstr_stereo_pre_pro)->const_attenuation = 0.0f;

    (pstr_stereo_pre_pro)->stereo_attenuation_max = 12.0f;

    /* energy ratio thresholds (dB) */

    (pstr_stereo_pre_pro)->sm_min = 0.0f;

    (pstr_stereo_pre_pro)->sm_max = 15.0f;

    (pstr_stereo_pre_pro)->lr_min = 10.0f;

    (pstr_stereo_pre_pro)->lr_max = 30.0f;

    /* pe thresholds */

    (pstr_stereo_pre_pro)->pe_crit = 1200.0f;

    (pstr_stereo_pre_pro)->pe_min = 700.0f;

    (pstr_stereo_pre_pro)->pe_impact_max = 100.0f;

    /* init start values */

    (pstr_stereo_pre_pro)->average_freq_energy_l = 0.0f;

    (pstr_stereo_pre_pro)->average_freq_energy_r = 0.0f;

    (pstr_stereo_pre_pro)->average_freq_energy_s = 0.0f;

    (pstr_stereo_pre_pro)->average_freq_energy_m = 0.0f;

    (pstr_stereo_pre_pro)->smoothed_pe_sum_sum = 7000.0f; /* typical start value */

    (pstr_stereo_pre_pro)->avg_s_to_m = -10.0f;           /* typical start value */

    (pstr_stereo_pre_pro)->last_l_to_r = 0.0f;

    (pstr_stereo_pre_pro)->last_nrg_lr = 0.0f;

    tmp = 1.0f - (bpf / 2600.0f);

    tmp = MAX(tmp, 0.0f);

    (pstr_stereo_pre_pro)->stereo_attenuation =

        tmp * (pstr_stereo_pre_pro)->stereo_attenuation_max;

  }

  return IA_NO_ERROR;

}

VOID iaace_apply_stereo_preproc(ixheaace_stereo_pre_pro_pstr pstr_stereo_pre_pro,

                                WORD32 num_channels, ixheaace_element_info *pstr_elem_info,

                                FLOAT32 *ptr_time_data, WORD32 granule_len) {

  FLOAT32 sm_ratio, s_to_m;

  FLOAT32 lr_ratio, l_to_r, delta_l_to_r, delta_nrg;

  FLOAT32 en_impact, pe_impact, pe_norm;

  FLOAT32 att, att_aimed;

  FLOAT32 max_inc, max_dec, swift_factor;

  FLOAT32 delta = 0.1f;

  FLOAT32 fac = pstr_stereo_pre_pro->stereo_attenuation_fac;

  FLOAT32 m_part, upper, div;

  FLOAT32 l_fac, r_fac;

  FLOAT32 L, R;

  WORD32 i;

  if (!pstr_stereo_pre_pro->stereo_attenuation_flag) {

    return;

  }

  m_part = 2.0f * pstr_stereo_pre_pro->average_freq_energy_m * (1.0f - fac * fac);

  upper = pstr_stereo_pre_pro->average_freq_energy_l * (1.0f + fac) +

          pstr_stereo_pre_pro->average_freq_energy_r * (1.0f - fac) - m_part;

  div = pstr_stereo_pre_pro->average_freq_energy_r * (1.0f + fac) +

        pstr_stereo_pre_pro->average_freq_energy_l * (1.0f - fac) - m_part;

  if ((div == 0.0f) || (upper == 0.0f)) {

    l_to_r = pstr_stereo_pre_pro->lr_max;

  } else {

    lr_ratio = (FLOAT32)fabs(upper / div);

    l_to_r = (FLOAT32)fabs(10.0f * log10(lr_ratio));

  }

  /* Calculate delta energy to previous frame */

  delta_nrg = (pstr_stereo_pre_pro->average_freq_energy_l +

               pstr_stereo_pre_pro->average_freq_energy_r + 1.0f) /

              (pstr_stereo_pre_pro->last_nrg_lr + 1.0f);

  delta_nrg = (FLOAT32)(fabs(10.0f * log10(delta_nrg)));

  /* Smooth S/M over time */

  sm_ratio = (pstr_stereo_pre_pro->average_freq_energy_s + 1.0f) /

             (pstr_stereo_pre_pro->average_freq_energy_m + 1.0f);

  s_to_m = (FLOAT32)(10.0f * log10(sm_ratio));

  pstr_stereo_pre_pro->avg_s_to_m =

      delta * s_to_m + (1 - delta) * pstr_stereo_pre_pro->avg_s_to_m;

  en_impact = 1.0f;

  if (pstr_stereo_pre_pro->avg_s_to_m > pstr_stereo_pre_pro->sm_min) {

    if (pstr_stereo_pre_pro->avg_s_to_m > pstr_stereo_pre_pro->sm_max) {

      en_impact = 0.0f;

    } else {

      en_impact = (pstr_stereo_pre_pro->sm_max - pstr_stereo_pre_pro->avg_s_to_m) /

                  (pstr_stereo_pre_pro->sm_max - pstr_stereo_pre_pro->sm_min);

    }

  }

  if (l_to_r > pstr_stereo_pre_pro->lr_min) {

    if (l_to_r > pstr_stereo_pre_pro->lr_max) {

      en_impact = 0.0f;

    } else {

      en_impact *= (pstr_stereo_pre_pro->lr_max - l_to_r) /

                   (pstr_stereo_pre_pro->lr_max - pstr_stereo_pre_pro->lr_min);

    }

  }

  pe_impact = 0.0f;

  pe_norm = pstr_stereo_pre_pro->smoothed_pe_sum_sum * pstr_stereo_pre_pro->norm_pe_fac;

  if (pe_norm > pstr_stereo_pre_pro->pe_min) {

    pe_impact = ((pe_norm - pstr_stereo_pre_pro->pe_min) /

                 (pstr_stereo_pre_pro->pe_crit - pstr_stereo_pre_pro->pe_min));

  }

  pe_impact = MIN(pe_impact, pstr_stereo_pre_pro->pe_impact_max);

  att_aimed = MIN((en_impact * pe_impact * pstr_stereo_pre_pro->impact_factor),

                  pstr_stereo_pre_pro->stereo_attenuation_max);

  /* Only accept changes if they are large enough */

  if ((fabs(att_aimed - pstr_stereo_pre_pro->stereo_attenuation) < 1.0f) && (att_aimed != 0.0f)) {

    att_aimed = pstr_stereo_pre_pro->stereo_attenuation;

  }

  att = att_aimed;

  swift_factor = (6.0f + pstr_stereo_pre_pro->stereo_attenuation) / (10.0f + l_to_r) *

                 MAX(1.0f, 0.2f * delta_nrg);

  delta_l_to_r = MAX(3.0f, l_to_r - pstr_stereo_pre_pro->last_l_to_r);

  max_dec = MIN((delta_l_to_r * delta_l_to_r / 9.0f * swift_factor), 5.0f);

  max_dec *= pstr_stereo_pre_pro->dec_stereo_attenuation;

  max_dec = MIN(max_dec, pstr_stereo_pre_pro->stereo_attenuation * 0.8f);

  delta_l_to_r = MAX(3.0f, pstr_stereo_pre_pro->last_l_to_r - l_to_r);

  max_inc = MIN((delta_l_to_r * delta_l_to_r / 9.0f * swift_factor), 5.0f);

  max_inc *= pstr_stereo_pre_pro->inc_stereo_attenuation;

  att = MIN(att, pstr_stereo_pre_pro->stereo_attenuation + max_inc);

  att = MAX(att, pstr_stereo_pre_pro->stereo_attenuation - max_dec);

  pstr_stereo_pre_pro->stereo_attenuation = (pstr_stereo_pre_pro->const_attenuation == 0)

                                                ? att

                                                : pstr_stereo_pre_pro->const_attenuation;

  /* Perform attenuation of side channel */

  pstr_stereo_pre_pro->stereo_attenuation_fac =

      (FLOAT32)pow(10.0f, 0.05f * (-pstr_stereo_pre_pro->stereo_attenuation));

  l_fac = 0.5f * (1.0f + pstr_stereo_pre_pro->stereo_attenuation_fac);

  r_fac = 0.5f * (1.0f - pstr_stereo_pre_pro->stereo_attenuation_fac);

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

    L = l_fac * ptr_time_data[num_channels * i + pstr_elem_info->channel_index[0]] +

        r_fac * ptr_time_data[num_channels * i + pstr_elem_info->channel_index[1]];

    R = r_fac * ptr_time_data[num_channels * i + pstr_elem_info->channel_index[0]] +

        l_fac * ptr_time_data[num_channels * i + pstr_elem_info->channel_index[1]];

    ptr_time_data[num_channels * i + pstr_elem_info->channel_index[0]] = L;

    ptr_time_data[num_channels * i + pstr_elem_info->channel_index[1]] = R;

  }

  pstr_stereo_pre_pro->last_l_to_r = l_to_r;

  pstr_stereo_pre_pro->last_nrg_lr =

      pstr_stereo_pre_pro->average_freq_energy_l + pstr_stereo_pre_pro->average_freq_energy_r;

}

VOID iaace_update_stereo_pre_process(ixheaace_psy_out_channel **pstr_psy_out,

                                     ixheaace_qc_out_element *pstr_qc_out,

                                     ixheaace_stereo_pre_pro_pstr pstr_stereo_pre_pro,

                                     FLOAT32 weight_pe_fac) {

  if (pstr_stereo_pre_pro->stereo_attenuation_flag) {

    FLOAT32 delta = 0.1f;

    pstr_stereo_pre_pro->average_freq_energy_l = pstr_psy_out[0]->sfb_sum_lr_energy;

    pstr_stereo_pre_pro->average_freq_energy_r = pstr_psy_out[1]->sfb_sum_lr_energy;

    pstr_stereo_pre_pro->average_freq_energy_m = pstr_psy_out[0]->sfb_sum_ms_energy;

    pstr_stereo_pre_pro->average_freq_energy_s = pstr_psy_out[1]->sfb_sum_ms_energy;

    pstr_stereo_pre_pro->smoothed_pe_sum_sum =

        delta * pstr_qc_out->pe * weight_pe_fac +

        (1 - delta) * pstr_stereo_pre_pro->smoothed_pe_sum_sum;

  }

}