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

 *                                                                            *

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

#include "ixheaac_constants.h"

#include "ixheaace_error_codes.h"

#include "ixheaac_error_standards.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_common_rom.h"

#include "ixheaace_sbr_header.h"

#include "ixheaace_sbr_def.h"

#include "ixheaace_sbr_freq_scaling.h"

#include "ixheaace_sbr_misc.h"

#include "ixheaace_resampler.h"

#include "ixheaace_sbr_rom.h"

static WORD32 ixheaace_get_start_freq_4_1(WORD32 fs, WORD32 start_freq) {

  WORD32 minimum_k0;

  const WORD32 *ptr_start_offset;

  switch (fs) {

    case 16000:

      minimum_k0 = 12;

      break;

    case 22050:

      minimum_k0 = 9;

      break;

    case 24000:

      minimum_k0 = 8;

      break;

    case 32000:

      minimum_k0 = 8;

      break;

    case 44100:

      minimum_k0 = 6;

      break;

    case 48000:

      minimum_k0 = 5;

      break;

    default:

      minimum_k0 = 5; /* illegal fs */

  }

  switch (fs) {

    case 16000: {

      ptr_start_offset = &ixheaace_start_freq_16k_4_1[0];

    } break;

    case 22050: {

      ptr_start_offset = &ixheaace_start_freq_22k_4_1[0];

    } break;

    case 24000: {

      ptr_start_offset = &ixheaace_start_freq_24k_4_1[0];

    } break;

    case 32000: {

      ptr_start_offset = &ixheaace_start_freq_32k_4_1[0];

    } break;

    case 44100:

    case 48000:

    case 64000: {

      ptr_start_offset = &ixheaace_start_freq_48k_4_1[0];

    } break;

    case 88200:

    case 96000: {

      ptr_start_offset = &ixheaace_start_freq_96k_4_1[0];

    } break;

    default: {

      ptr_start_offset = &ixheaace_start_freq_dflt_4_1[0];

    }

  }

  return (minimum_k0 + ptr_start_offset[start_freq]);

}

static WORD32 ixheaace_get_stop_freq_4_1(WORD32 fs, WORD32 stop_freq) {

  WORD32 result, i;

  WORD32 *v_stop_freq = 0;

  WORD32 k1_min;

  WORD32 v_dstop[13];

  /* counting previous operations */

  switch (fs) {

    case 16000:

      k1_min = 24;

      v_stop_freq = (WORD32 *)&ixheaace_stop_freq_16k_4_1[0];

      break;

    case 22050:

      k1_min = 17;

      v_stop_freq = (WORD32 *)&ixheaace_stop_freq_22k_4_1[0];

      break;

    case 24000:

      k1_min = 16;

      v_stop_freq = (WORD32 *)&ixheaace_stop_freq_24k_4_1[0];

      break;

    case 32000:

      k1_min = 16;

      v_stop_freq = (WORD32 *)&ixheaace_stop_freq_32k_4_1[0];

      break;

    case 44100:

      k1_min = 12;

      v_stop_freq = (WORD32 *)&ixheaace_stop_freq_44k_4_1[0];

      break;

    case 48000:

      k1_min = 11;

      v_stop_freq = (WORD32 *)&ixheaace_stop_freq_48k_4_1[0];

      break;

    default:

      v_stop_freq = (WORD32 *)&ixheaace_stop_freq_32k_4_1[0];

      k1_min = 11; /* illegal fs  */

  }

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

    v_dstop[i] = v_stop_freq[i + 1] - v_stop_freq[i];

  }

  ixheaace_shellsort_int(v_dstop, 13);

  result = k1_min;

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

    result = result + v_dstop[i];

  }

  return result;

}

static WORD32 ixheaace_get_start_freq(WORD32 fs, WORD32 start_freq) {

  WORD32 minimum_k0;

  switch (fs) {

    case 16000:

      minimum_k0 = 24;

      break;

    case 22050:

      minimum_k0 = 17;

      break;

    case 24000:

      minimum_k0 = 16;

      break;

    case 32000:

      minimum_k0 = 16;

      break;

    case 44100:

      minimum_k0 = 12;

      break;

    case 48000:

      minimum_k0 = 11;

      break;

    case 64000:

      minimum_k0 = 10;

      break;

    case 88200:

      minimum_k0 = 7;

      break;

    case 96000:

      minimum_k0 = 7;

      break;

    default:

      minimum_k0 = 11; /* illegal fs */

  }

  switch (fs) {

    case 16000: {

      return (minimum_k0 + vector_offset_16k[start_freq]);

    } break;

    case 22050: {

      return (minimum_k0 + vector_offset_22k[start_freq]);

    } break;

    case 24000: {

      return (minimum_k0 + vector_offset_24k[start_freq]);

    } break;

    case 32000: {

      return (minimum_k0 + vector_offset_32k[start_freq]);

    } break;

    case 44100:

    case 48000:

    case 64000: {

      return (minimum_k0 + vector_offset_44_48_64[start_freq]);

    } break;

    case 88200:

    case 96000: {

      return (minimum_k0 + vector_offset_88_96[start_freq]);

    } break;

    default: {

      return (minimum_k0 + vector_offset_def[start_freq]);

    }

  }

}

static WORD32 ixheaace_get_stop_freq(WORD32 fs, WORD32 stop_freq) {

  WORD32 result, i;

  WORD32 *v_stop_freq = 0;

  WORD32 k1_min;

  WORD32 v_dstop[13];

  switch (fs) {

    case 16000:

      k1_min = ixheaace_stop_freq_16k[0];

      v_stop_freq = (WORD32 *)&ixheaace_stop_freq_16k[0];

      break;

    case 22050:

      k1_min = ixheaace_stop_freq_22k[0];

      v_stop_freq = (WORD32 *)&ixheaace_stop_freq_22k[0];

      break;

    case 24000:

      k1_min = ixheaace_stop_freq_24k[0];

      v_stop_freq = (WORD32 *)&ixheaace_stop_freq_24k[0];

      break;

    case 32000:

      k1_min = 32;

      v_stop_freq = (WORD32 *)vector_stop_freq_32;

      break;

    case 44100:

      k1_min = 23;

      v_stop_freq = (WORD32 *)vector_stop_freq_44;

      break;

    case 48000:

      k1_min = 21;

      v_stop_freq = (WORD32 *)vector_stop_freq_48;

      break;

    default:

      v_stop_freq = (WORD32 *)vector_stop_freq_32;

      k1_min = 21; /* illegal fs  */

  }

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

    v_dstop[i] = v_stop_freq[i + 1] - v_stop_freq[i];

  }

  ixheaace_shellsort_int(v_dstop, 13);

  result = k1_min;

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

    result = result + v_dstop[i];

  }

  return result;

}

static WORD32 ixheaace_get_usac_stop_freq(WORD32 fs, WORD32 stop_freq)

{

  WORD32 result, i;

  WORD32 *v_stop_freq = 0;

  WORD32 k1_min;

  WORD32 v_dstop[13];

  switch (fs)

  {

  case 16000:

    k1_min = ixheaace_usac_stop_freq_16k[0];

    v_stop_freq = (WORD32 *)&ixheaace_usac_stop_freq_16k[0];

    break;

  case 22050:

    k1_min = ixheaace_usac_stop_freq_22k[0];

    v_stop_freq = (WORD32 *)&ixheaace_usac_stop_freq_22k[0];

    break;

  case 24000:

    k1_min = ixheaace_usac_stop_freq_24k[0];

    v_stop_freq = (WORD32 *)&ixheaace_usac_stop_freq_24k[0];

    break;

  case 32000:

    k1_min = 32;

    v_stop_freq = (WORD32 *)vector_stop_freq_32;

    break;

  case 44100:

    k1_min = 23;

    v_stop_freq = (WORD32 *)vector_stop_freq_44;

    break;

  case 48000:

    k1_min = 21;

    v_stop_freq = (WORD32 *)vector_stop_freq_48;

    break;

  default:

    v_stop_freq = (WORD32 *)vector_stop_freq_32;

    k1_min = 21; /* illegal fs  */

  }

  for (i = 0; i <= 12; i++)

  {

    v_dstop[i] = v_stop_freq[i + 1] - v_stop_freq[i];

  }

  ixheaace_shellsort_int(v_dstop, 13);

  result = k1_min;

  for (i = 0; i < stop_freq; i++)

  {

    result = result + v_dstop[i];

  }

  return result;

}

WORD32

ixheaace_get_sbr_start_freq_raw(WORD32 start_freq, WORD32 qmf_bands, WORD32 fs) {

  WORD32 result;

  if (start_freq < 0 || start_freq > 15) {

    return -1;

  }

  result = ixheaace_get_start_freq(fs, start_freq);

  result = (result * fs / qmf_bands + 1) >> 1;

  return result;

}

static WORD32 ixheaace_number_of_bands(WORD32 b_p_o, WORD32 start, WORD32 stop,

                                       FLOAT32 warp_fac) {

  WORD32 result = 0;

  result = (WORD32)(b_p_o * log((FLOAT32)(stop) / start) / (2.0 * log(2.0) * warp_fac) + 0.5);

  result <<= 1;

  return result;

}

static VOID ixheaace_calc_bands(WORD32 *ptr_diff, WORD32 start, WORD32 stop, WORD32 num_bands) {

  WORD32 i;

  WORD32 previous;

  WORD32 current;

  previous = start;

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

    current = (WORD32)((start * pow((FLOAT32)stop / start, (FLOAT32)i / num_bands)) + 0.5f);

    ptr_diff[i - 1] = current - previous;

    previous = current;

  }

}

static VOID ixheaace_modify_bands(WORD32 max_band_previous, WORD32 *ptr_diff, WORD32 length) {

  WORD32 change = max_band_previous - ptr_diff[0];

  if (change > (ptr_diff[length - 1] - ptr_diff[0]) / 2) {

    change = (ptr_diff[length - 1] - ptr_diff[0]) / 2;

  }

  ptr_diff[0] += change;

  ptr_diff[length - 1] -= change;

  ixheaace_shellsort_int(ptr_diff, length);

}

static VOID ixheaace_cum_sum(WORD32 start_value, WORD32 *ptr_diff, WORD32 length,

                             UWORD8 *ptr_start_adress) {

  WORD32 i;

  ptr_start_adress[0] = (UWORD8)start_value;

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

    ptr_start_adress[i] = ptr_start_adress[i - 1] + (UWORD8)ptr_diff[i - 1];

  }

}

IA_ERRORCODE

ixheaace_find_start_and_stop_band(const WORD32 sampling_freq, const WORD32 num_channels,

                                  const WORD32 start_freq, const WORD32 stop_freq,

                                  const ixheaace_sr_mode sample_rate_mode, WORD32 *ptr_k0,

                                  WORD32 *ptr_k2, WORD32 sbr_ratio_idx,

                                  ixheaace_sbr_codec_type sbr_codec) {

  switch (sbr_codec) {

    case USAC_SBR: {

      if (sbr_ratio_idx == USAC_SBR_RATIO_INDEX_4_1) {

        *ptr_k0 = ixheaace_get_start_freq_4_1(sampling_freq, start_freq);

      } else {

        *ptr_k0 = ixheaace_get_start_freq(sampling_freq, start_freq);

      }

      break;

    }

    default: {

      *ptr_k0 = ixheaace_get_start_freq(sampling_freq, start_freq);

      break;

    }

  }

  if ((sample_rate_mode == 1) && (sampling_freq * num_channels < 2 * *ptr_k0 * sampling_freq)) {

    return IA_EXHEAACE_INIT_FATAL_SBR_INVALID_SAMPLERATE_MODE;

  }

  if (stop_freq < 14) {

    switch (sbr_codec) {

      case USAC_SBR: {

        if (USAC_SBR_RATIO_INDEX_4_1 == sbr_ratio_idx) {

          *ptr_k2 = ixheaace_get_stop_freq_4_1(sampling_freq, stop_freq);

        } else {

          *ptr_k2 = ixheaace_get_usac_stop_freq(sampling_freq, stop_freq);

        }

        break;

      }

      default: {

        *ptr_k2 = ixheaace_get_stop_freq(sampling_freq, stop_freq);

        break;

      }

    }

  }

  else {

    *ptr_k2 = (stop_freq == 14 ? 2 * *ptr_k0 : 3 * *ptr_k0);

  }

  if (*ptr_k2 > num_channels) {

    *ptr_k2 = num_channels;

  }

  if (sbr_codec == USAC_SBR) {

    if (sbr_ratio_idx == USAC_SBR_RATIO_INDEX_4_1) {

      if (((*ptr_k2 - *ptr_k0) > MAXIMUM_FREQ_COEFFS_USAC) || (*ptr_k2 <= *ptr_k0)) {

        return IA_EXHEAACE_INIT_FATAL_SBR_INVALID_FREQ_COEFFS;

      }

      if ((2 * sampling_freq == 44100) && ((*ptr_k2 - *ptr_k0) > MAXIMUM_FREQ_COEFFS_USAC)) {

        return IA_EXHEAACE_INIT_FATAL_SBR_INVALID_FREQ_COEFFS;

      }

      if ((2 * sampling_freq >= 48000) && ((*ptr_k2 - *ptr_k0) > MAXIMUM_FREQ_COEFFS_USAC)) {

        return IA_EXHEAACE_INIT_FATAL_SBR_INVALID_FREQ_COEFFS;

      }

    } else {

      if (sampling_freq <= 32000) {

        if ((*ptr_k2 - *ptr_k0) > MAXIMUM_FREQ_COEFFS_LE32KHZ) {

          return IA_EXHEAACE_INIT_FATAL_SBR_INVALID_FREQ_COEFFS;

        }

      } else if (sampling_freq == 44100) {

        if ((*ptr_k2 - *ptr_k0) > MAXIMUM_FREQ_COEFFS_EQ44KHZ) {

          return IA_EXHEAACE_INIT_FATAL_SBR_INVALID_FREQ_COEFFS;

        }

      } else if (sampling_freq >= 48000) {

        if ((*ptr_k2 - *ptr_k0) > MAXIMUM_FREQ_COEFFS_GE48KHZ) {

          return IA_EXHEAACE_INIT_FATAL_SBR_INVALID_FREQ_COEFFS;

        }

      } else {

        return IA_EXHEAACE_INIT_FATAL_SBR_INVALID_FREQ_COEFFS;

      }

    }

  } else {

    if (sampling_freq <= 32000) {

      if ((*ptr_k2 - *ptr_k0) > MAXIMUM_FREQ_COEFFS_LE32KHZ) {

        return IA_EXHEAACE_INIT_FATAL_SBR_INVALID_FREQ_COEFFS;

      }

    } else if (sampling_freq == 44100) {

      if ((*ptr_k2 - *ptr_k0) > MAXIMUM_FREQ_COEFFS_EQ44KHZ) {

        return IA_EXHEAACE_INIT_FATAL_SBR_INVALID_FREQ_COEFFS;

      }

    } else if (sampling_freq >= 48000) {

      if ((*ptr_k2 - *ptr_k0) > MAXIMUM_FREQ_COEFFS_GE48KHZ) {

        return IA_EXHEAACE_INIT_FATAL_SBR_INVALID_FREQ_COEFFS;

      }

    } else {

      return IA_EXHEAACE_INIT_FATAL_SBR_INVALID_FREQ_COEFFS;

    }

  }

  if ((*ptr_k2 - *ptr_k0) < 0) {

    return IA_EXHEAACE_INIT_FATAL_SBR_INVALID_FREQ_COEFFS;

  }

  return IA_NO_ERROR;

}

IA_ERRORCODE

ixheaace_update_freq_scale(UWORD8 *ptr_k_master, WORD32 *ptr_num_bands, const WORD32 k0,

                           const WORD32 k2, const WORD32 freq_scale, const WORD32 alter_scale,

                           ixheaace_sr_mode sbr_rate)

{

  IA_ERRORCODE err_code = IA_NO_ERROR;

  WORD32 b_p_o = 0;

  WORD32 dk = 0;

  FLOAT32 warp;

  WORD32 k1 = 0, i;

  WORD32 num_bands0;

  WORD32 num_bands1;

  WORD32 diff_tot[IXHEAACE_MAXIMUM_OCTAVE + IXHEAACE_MAXIMUM_SECOND_REGION] = {0};

  WORD32 *diff0 = diff_tot;

  WORD32 *diff1 = diff_tot + IXHEAACE_MAXIMUM_OCTAVE;

  WORD32 k2_achived;

  WORD32 k2_diff;

  WORD32 incr = 0;

  switch (freq_scale) {

    case 1:

      b_p_o = 12;

      break;

    case 2:

      b_p_o = 10;

      break;

    case 3:

      b_p_o = 8;

      break;

  }

  if (freq_scale > 0) {

    if (alter_scale == 0) {

      warp = 1.0f;

    } else {

      warp = 1.3f;

    }

    if (IXHEAACE_QUAD_RATE == sbr_rate) {

      if (k0 < b_p_o) {

        b_p_o = (k0 >> 1) * 2;

      }

    }

    if (4 * k2 >= 9 * k0) {

      k1 = 2 * k0;

      num_bands0 = ixheaace_number_of_bands(b_p_o, k0, k1, 1.0f);

      num_bands1 = ixheaace_number_of_bands(b_p_o, k1, k2, warp);

      ixheaace_calc_bands(diff0, k0, k1, num_bands0);

      ixheaace_shellsort_int(diff0, num_bands0);

      if (diff0[0] == 0) {

        return IA_EXHEAACE_INIT_FATAL_SBR_INVALID_NUM_BANDS;

      }

      ixheaace_cum_sum(k0, diff0, num_bands0, ptr_k_master);

      ixheaace_calc_bands(diff1, k1, k2, num_bands1);

      ixheaace_shellsort_int(diff1, num_bands1);

      if (diff0[num_bands0 - 1] > diff1[0]) {

        ixheaace_modify_bands(diff0[num_bands0 - 1], diff1, num_bands1);

      }

      ixheaace_cum_sum(k1, diff1, num_bands1, &ptr_k_master[num_bands0]);

      *ptr_num_bands = num_bands0 + num_bands1;

    } else {

      k1 = k2;

      num_bands0 = ixheaace_number_of_bands(b_p_o, k0, k1, 1.0f);

      ixheaace_calc_bands(diff0, k0, k1, num_bands0);

      ixheaace_shellsort_int(diff0, num_bands0);

      if (diff0[0] == 0) {

        return IA_EXHEAACE_INIT_FATAL_SBR_INVALID_NUM_BANDS;

      }

      ixheaace_cum_sum(k0, diff0, num_bands0, ptr_k_master);

      *ptr_num_bands = num_bands0;

    }

  } else {

    if (alter_scale == 0) {

      dk = 1;

      num_bands0 = 2 * ((k2 - k0) / 2);

    } else {

      dk = 2;

      num_bands0 = 2 * (((k2 - k0) / dk + 1) / 2);

    }

    k2_achived = k0 + num_bands0 * dk;

    k2_diff = k2 - k2_achived;

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

      diff_tot[i] = dk;

    }

    if (k2_diff < 0) {

      incr = 1;

      i = 0;

    }

    if (k2_diff > 0) {

      incr = -1;

      i = num_bands0 - 1;

    }

    while (k2_diff != 0) {

      if (i < 0) break;

      diff_tot[i] = diff_tot[i] - incr;

      i = i + incr;

      k2_diff = k2_diff + incr;

    }

    ixheaace_cum_sum(k0, diff_tot, num_bands0, ptr_k_master);

    *ptr_num_bands = num_bands0;

  }

  if (*ptr_num_bands < 1) {

    return IA_EXHEAACE_INIT_FATAL_SBR_INVALID_NUM_BANDS;

  }

  if (sbr_rate == IXHEAACE_QUAD_RATE) {

    for (i = 1; i < *ptr_num_bands; i++) {

      if (!(ptr_k_master[i] - ptr_k_master[i - 1] <= k0 - 2)) {

        return IA_EXHEAACE_INIT_FATAL_SBR_INVALID_NUM_BANDS;

      }

    }

  }

  return err_code;

}

VOID ixheaace_update_high_res(UWORD8 *ptr_hires, WORD32 *ptr_num_hires, UWORD8 *ptr_k_master,

                              WORD32 num_master, WORD32 *ptr_xover_band,

                              ixheaace_sr_mode dr_or_sr, WORD32 num_qmf_ch) {

  WORD32 i;

  WORD32 divider;

  WORD32 max1, max2;

  divider = (dr_or_sr == IXHEAACE_DUAL_RATE) ? 2 : 1;

  if (dr_or_sr == IXHEAACE_QUAD_RATE) {

    divider = 4;

  }

  if ((ptr_k_master[*ptr_xover_band] > (num_qmf_ch / divider)) ||

      (*ptr_xover_band > num_master)) {

    max1 = 0;

    max2 = num_master;

    while ((ptr_k_master[max1 + 1] < (num_qmf_ch / divider)) && ((max1 + 1) < max2)) {

      max1++;

    }

    *ptr_xover_band = max1;

  }

  *ptr_num_hires = num_master - *ptr_xover_band;

  for (i = *ptr_xover_band; i <= num_master; i++) {

    ptr_hires[i - *ptr_xover_band] = ptr_k_master[i];

  }

}

VOID ixheaace_update_low_res(UWORD8 *ptr_lores, WORD32 *ptr_num_lores, UWORD8 *ptr_hires,

                             WORD32 ptr_num_hires) {

  WORD32 i;

  if (ptr_num_hires % 2 == 0) {

    *ptr_num_lores = ptr_num_hires / 2;

    for (i = 0; i <= *ptr_num_lores; i++) {

      ptr_lores[i] = ptr_hires[i * 2];

    }

  } else {

    *ptr_num_lores = (ptr_num_hires + 1) / 2;

    ptr_lores[0] = ptr_hires[0];

    for (i = 1; i <= *ptr_num_lores; i++) {

      ptr_lores[i] = ptr_hires[i * 2 - 1];

    }

  }

}