/******************************************************************************
 *
 * Copyright (C) 2018 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 <stdlib.h>
#include <math.h>
#include <stdio.h>
#include <string.h>

#include "impd_type_def.h"
#include "impd_drc_peak_limiter.h"

#ifndef max
#define max(a, b) (((a) > (b)) ? (a) : (b))
#endif
#ifndef min
#define min(a, b) (((a) < (b)) ? (a) : (b))
#endif

WORD32 impd_peak_limiter_init(ia_drc_peak_limiter_struct *peak_limiter,
                              FLOAT32 attack_time, FLOAT32 release_time,
                              FLOAT32 limit_threshold, UWORD32 num_channels,
                              UWORD32 sample_rate, FLOAT32 *buffer) {
  UWORD32 attack;
  attack = (UWORD32)(attack_time * sample_rate / 1000);

  if (attack < 1) return 0;

  peak_limiter->max_buf = buffer;
  peak_limiter->delayed_input = buffer + attack * 4 + 32;

  peak_limiter->delayed_input_index = 0;
  peak_limiter->attack_time = attack_time;
  peak_limiter->release_time = release_time;
  peak_limiter->attack_time_samples = attack;
  peak_limiter->attack_constant = (FLOAT32)pow(0.1, 1.0 / (attack + 1));
  peak_limiter->release_constant =
      (FLOAT32)pow(0.1, 1.0 / (release_time * sample_rate / 1000 + 1));
  peak_limiter->limit_threshold = limit_threshold;
  peak_limiter->num_channels = num_channels;
  peak_limiter->sample_rate = sample_rate;
  peak_limiter->min_gain = 1.0f;
  peak_limiter->limiter_on = 1;
  peak_limiter->pre_smoothed_gain = 1.0f;
  peak_limiter->gain_modified = 1.0f;

  return 0;
}

VOID impd_peak_limiter_reinit(ia_drc_peak_limiter_struct *peak_limiter) {
  if (peak_limiter) {
    peak_limiter->delayed_input_index = 0;
    peak_limiter->pre_smoothed_gain = 1.0f;
    peak_limiter->gain_modified = 1.0f;
    peak_limiter->min_gain = 1.0f;
    memset(peak_limiter->max_buf, 0,
           (peak_limiter->attack_time_samples + 1) * sizeof(FLOAT32));
    memset(peak_limiter->delayed_input, 0, peak_limiter->attack_time_samples *
                                               peak_limiter->num_channels *
                                               sizeof(FLOAT32));
  }

  return;
}

VOID impd_limiter_process(ia_drc_peak_limiter_struct *peak_limiter,
                          FLOAT32 *samples, UWORD32 frame_len) {
  UWORD32 i, j;
  FLOAT32 tmp, gain;
  FLOAT32 min_gain = 1;
  FLOAT32 maximum, sectionMaximum;
  UWORD32 num_channels = peak_limiter->num_channels;
  UWORD32 attack_time_samples = peak_limiter->attack_time_samples;
  FLOAT32 attack_constant = peak_limiter->attack_constant;
  FLOAT32 release_constant = peak_limiter->release_constant;
  FLOAT32 limit_threshold = peak_limiter->limit_threshold;
  FLOAT32 *max_buf = peak_limiter->max_buf;
  FLOAT32 gain_modified = peak_limiter->gain_modified;
  FLOAT32 *delayed_input = peak_limiter->delayed_input;
  UWORD32 delayed_input_index = peak_limiter->delayed_input_index;
  FLOAT64 pre_smoothed_gain = peak_limiter->pre_smoothed_gain;

  if (peak_limiter->limiter_on || (FLOAT32)pre_smoothed_gain < 1.0f) {
    for (i = 0; i < frame_len; i++) {
      tmp = 0.0f;
      for (j = 0; j < num_channels; j++) {
        tmp = max(tmp, (FLOAT32)fabs(samples[i * num_channels + j]));
      }

      for (j = attack_time_samples; j > 0; j--) {
        max_buf[j] = max_buf[j - 1];
      }
      max_buf[0] = tmp;
      sectionMaximum = tmp;
      for (j = 1; j < (attack_time_samples + 1); j++) {
        if (max_buf[j] > sectionMaximum) sectionMaximum = max_buf[j];
      }
      maximum = sectionMaximum;

      if (maximum > limit_threshold) {
        gain = limit_threshold / maximum;
      } else {
        gain = 1;
      }

      if (gain < pre_smoothed_gain) {
        gain_modified =
            min(gain_modified,
                (gain - 0.1f * (FLOAT32)pre_smoothed_gain) * 1.11111111f);
      } else {
        gain_modified = gain;
      }

      if (gain_modified < pre_smoothed_gain) {
        pre_smoothed_gain =
            attack_constant * (pre_smoothed_gain - gain_modified) +
            gain_modified;
        pre_smoothed_gain = max(pre_smoothed_gain, gain);
      } else {
        pre_smoothed_gain =
            release_constant * (pre_smoothed_gain - gain_modified) +
            gain_modified;
      }

      gain = (FLOAT32)pre_smoothed_gain;

      for (j = 0; j < num_channels; j++) {
        tmp = delayed_input[delayed_input_index * num_channels + j];
        delayed_input[delayed_input_index * num_channels + j] =
            samples[i * num_channels + j];

        tmp *= gain;
        if (tmp > limit_threshold)
          tmp = limit_threshold;
        else if (tmp < -limit_threshold)
          tmp = -limit_threshold;

        samples[i * num_channels + j] = tmp;
      }

      delayed_input_index++;
      if (delayed_input_index >= attack_time_samples) delayed_input_index = 0;

      if (gain < min_gain) min_gain = gain;
    }
  } else {
    for (i = 0; i < frame_len; i++) {
      for (j = 0; j < num_channels; j++) {
        tmp = delayed_input[delayed_input_index * num_channels + j];
        delayed_input[delayed_input_index * num_channels + j] =
            samples[i * num_channels + j];
        samples[i * num_channels + j] = tmp;
      }

      delayed_input_index++;
      if (delayed_input_index >= attack_time_samples) delayed_input_index = 0;
    }
  }

  peak_limiter->gain_modified = gain_modified;
  peak_limiter->delayed_input_index = delayed_input_index;
  peak_limiter->pre_smoothed_gain = pre_smoothed_gain;
  peak_limiter->min_gain = min_gain;

  return;
}