xref: /aosp_15_r20/external/libxaac/encoder/ixheaace_nf.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 <float.h>
#include <string.h>
#include <math.h>
#include "iusace_cnst.h"
#include "iusace_type_def.h"
#include "ixheaac_constants.h"
#include "iusace_bitbuffer.h"
#include "iusace_tns_usac.h"
#include "iusace_fd_quant.h"
#include "ixheaac_basic_ops32.h"
#include "ixheaac_basic_ops40.h"
#include "ixheaac_basic_ops.h"
#include "ixheaace_nf.h"

static VOID iusace_noise_filling_limiter(FLOAT64 *energy, FLOAT64 *ptr_spec,
                                         WORD32 *ptr_quant_spec, WORD32 n0_by_4,
                                         WORD32 *ptr_sfb_offset, WORD32 sb, WORD32 cntr,
                                         FLOAT64 *ptr_highest_tone) {
  WORD32 n, i;
  FLOAT64 tone_energy;
  FLOAT64 tot_tone_energy = 0.0;

  if (!n0_by_4) return;
  if (cntr <= n0_by_4) return;

  memset(ptr_highest_tone, 0, n0_by_4 * sizeof(*ptr_highest_tone));

  /* finds the n0_by_4 strongest bins */
  for (i = ptr_sfb_offset[sb]; i < ptr_sfb_offset[sb + 1]; i++) {
    if (!ptr_quant_spec[i]) {
      tone_energy = ptr_spec[i] * ptr_spec[i];

      for (n = 0; n < n0_by_4; n++) {
        if (tone_energy > ptr_highest_tone[n]) {
          memmove(ptr_highest_tone + 1 + n, ptr_highest_tone + n,
                  (n0_by_4 - n - 1) * sizeof(*ptr_highest_tone));
          ptr_highest_tone[n] = tone_energy;
          break;
        }
      }
    }
  }
  /* remove the contribution of the highest_tone components */
  for (n = 0; n < n0_by_4; n++) tot_tone_energy += ptr_highest_tone[n];

  FLOAT64 diff = *energy - tot_tone_energy;
  //If the difference is within 1% of total energy, no need to send any energy
  if (diff < 0.01*(*energy))
  {
    *energy = 0.0;
  }
  else
  {
    *energy = diff;
  }

  /* add the average component energy */
  *energy += n0_by_4 * (*energy) / (cntr - n0_by_4);
  return;
}

VOID iusace_noise_filling(WORD32 *noise_level, WORD32 *noise_offset, FLOAT64 *ptr_quant_spec,
                          ia_usac_quant_info_struct *pstr_quant_info, WORD32 *ptr_sfb_offset,
                          WORD32 max_sfb, WORD32 window_size_samples, WORD32 num_window_groups,
                          const WORD32 *ptr_window_group_length,
                          WORD32 noise_filling_start_offset, FLOAT64 *ptr_scratch_buf) {
  FLOAT64 energy;
  FLOAT64 noise_level_temp;
  FLOAT64 noise_offset_temp;

  FLOAT64 sum_sfb_on, sum_sfb_off;
  FLOAT64 e_sfb_on, e_sfb_off;

  WORD32 n0;
  WORD32 start_sfb, sfb, i;
  WORD32 band_quantized_to_zero;

  FLOAT64 alpha = 0.15; /* prudence factor */
  WORD32 grp = 0;

  e_sfb_on = 1e-6;
  e_sfb_off = 1e-6;

  sum_sfb_on = 1e-6;
  sum_sfb_off = 1e-6;

  *noise_offset = 0;
  *noise_level = 0;

  for (sfb = 0; sfb < max_sfb; sfb++) {
    if (ptr_sfb_offset[sfb + 1] > noise_filling_start_offset) break;
  }
  start_sfb = sfb;
  for (grp = 0; grp < num_window_groups; grp++) {
    WORD32 grp_win = 0;
    for (sfb = start_sfb; sfb < max_sfb; sfb++) {
      band_quantized_to_zero = 1;
      for (grp_win = 0; grp_win < ptr_window_group_length[grp]; grp_win++) {
        WORD32 offset = grp_win * window_size_samples;
        energy = 0;
        n0 = 0;
        for (i = ptr_sfb_offset[sfb]; i < ptr_sfb_offset[sfb + 1]; i++) {
          /* calculate energy if the quantized value is non zero */
          if (!pstr_quant_info->quant_degroup[offset + i]) {
            energy += ptr_quant_spec[offset + i] * ptr_quant_spec[offset + i];
            n0++;
          } else {
            /* All quantized values are not zero */
            band_quantized_to_zero = 0;
          }
        }

        /* Remove highest (tonal) contributions */
        iusace_noise_filling_limiter(&energy, &ptr_quant_spec[offset],
                                     &pstr_quant_info->quant_degroup[offset], n0 / 4,
                                     ptr_sfb_offset, sfb, n0, ptr_scratch_buf);

        if (band_quantized_to_zero == 0) {
          e_sfb_on += energy;
          sum_sfb_on += pow(2., 0.5 * pstr_quant_info->scale_factor[sfb] - 50) * n0;
        } else
        /* subband is completely zeroed  */
        {
          e_sfb_off += energy;
          sum_sfb_off += pow(2., 0.5 * pstr_quant_info->scale_factor[sfb] - 58) *
                         (ptr_sfb_offset[sfb + 1] - ptr_sfb_offset[sfb]);
        }
      }
    }
  }

  if (num_window_groups > 1) alpha = alpha * 0.15;

  if (sum_sfb_on) {
    noise_level_temp = 1.5 * (log(alpha * e_sfb_on) - log(sum_sfb_on)) / log(2.0) + 14.0;

    /* quantize to nearest integer */
    *noise_level = (WORD32)(noise_level_temp + 0.5);

    /* noise level limited to quantization range [0,7] */
    *noise_level = MAX(*noise_level, 0);
    *noise_level = MIN(*noise_level, 7);

    if (*noise_level != 0) {
      noise_offset_temp =
          2. * log(alpha * e_sfb_off * sum_sfb_on / sum_sfb_off / e_sfb_on) / log(2.);

      /* quantize to nearest integer */
      *noise_offset = (WORD32)(noise_offset_temp + 0.5);

      /* noise offset limited to quantization range [0,31] */
      *noise_level = *noise_offset <= 0 ? 0 : *noise_level;
      *noise_offset = MIN(*noise_offset, 31);
      *noise_offset = MAX(*noise_offset, 0);
    }
  }
  return;
}