| /****************************************************************************** |
| * * |
| * 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 "ixheaac_type_def.h" |
| #include "ixheaacd_cnst.h" |
| #include "ixheaacd_peak_limiter_struct_def.h" |
| #include "ixheaac_constants.h" |
| #include "ixheaac_basic_ops32.h" |
| #include "ixheaac_basic_ops16.h" |
| |
| #define MAX(x, y) ((x) > (y) ? (x) : (y)) |
| #define MIN(x, y) ((x) > (y) ? (y) : (x)) |
| |
| /** |
| * ixheaacd_peak_limiter_init |
| * |
| * \brief Peak Limiter initialization |
| * |
| * \param [in/out] peak_limiter Pointer to peak_limiter struct |
| * \param [in] num_channels Number of ouptut channels |
| * \param [in] sample_rate Sampling rate value |
| * \param [in] buffer Peak limiter buffer of size PEAK_LIM_BUFFER_SIZE |
| * |
| * \return WORD32 |
| * |
| */ |
| WORD32 ixheaacd_peak_limiter_init(ia_peak_limiter_struct *peak_limiter, |
| UWORD32 num_channels, UWORD32 sample_rate, |
| FLOAT32 *buffer, UWORD32 *delay_in_samples) { |
| UWORD32 attack; |
| |
| attack = (UWORD32)(DEFAULT_ATTACK_TIME_MS * sample_rate / 1000); |
| *delay_in_samples = attack; |
| |
| if (attack < 1) return 0; |
| |
| peak_limiter->max_buf = buffer; |
| peak_limiter->max_idx = 0; |
| peak_limiter->cir_buf_pnt = 0; |
| peak_limiter->delayed_input = buffer + attack * 4 + 32; |
| |
| peak_limiter->delayed_input_index = 0; |
| peak_limiter->attack_time = DEFAULT_ATTACK_TIME_MS; |
| peak_limiter->release_time = DEFAULT_RELEASE_TIME_MS; |
| 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 / (DEFAULT_RELEASE_TIME_MS * sample_rate / 1000 + 1)); |
| 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 ixheaacd_peak_limiter_process_float(ia_peak_limiter_struct *peak_limiter, |
| FLOAT32 samples[MAX_NUM_CHANNELS][4096], |
| UWORD32 frame_len) { |
| UWORD32 i, j; |
| FLOAT32 tmp, gain; |
| FLOAT32 min_gain = 1.0f; |
| FLOAT32 maximum; |
| 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 *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; |
| FLOAT32 limit_threshold = PEAK_LIM_THR_FLOAT; |
| |
| if (peak_limiter->limiter_on || (FLOAT32)pre_smoothed_gain) { |
| for (i = 0; i < frame_len; i++) { |
| tmp = 0.0f; |
| for (j = 0; j < num_channels; j++) { |
| tmp = (FLOAT32)MAX(tmp, fabs(samples[j][i])); |
| } |
| max_buf[peak_limiter->cir_buf_pnt] = tmp; |
| |
| if (peak_limiter->max_idx == peak_limiter->cir_buf_pnt) { |
| peak_limiter->max_idx = 0; |
| for (j = 1; j < (attack_time_samples); j++) { |
| if (max_buf[j] > max_buf[peak_limiter->max_idx]) peak_limiter->max_idx = j; |
| } |
| } else if (tmp >= max_buf[peak_limiter->max_idx]) { |
| peak_limiter->max_idx = peak_limiter->cir_buf_pnt; |
| } |
| |
| peak_limiter->cir_buf_pnt++; |
| |
| if (peak_limiter->cir_buf_pnt == (WORD32)(attack_time_samples)) |
| peak_limiter->cir_buf_pnt = 0; |
| maximum = max_buf[peak_limiter->max_idx]; |
| |
| 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[j][i]; |
| |
| tmp *= gain; |
| |
| if (tmp > limit_threshold) |
| tmp = limit_threshold; |
| else if (tmp < -limit_threshold) |
| tmp = -limit_threshold; |
| |
| samples[j][i] = 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[j][i]; |
| samples[j][i] = 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; |
| } |
| |
| /** |
| * ixheaacd_peak_limiter_process |
| * |
| * \brief Peak Limiter process |
| * |
| * \param [in/out] peak_limiter |
| * \param [in] samples |
| * \param [in] frame_len |
| * |
| * \return WORD32 |
| * |
| */ |
| VOID ixheaacd_peak_limiter_process(ia_peak_limiter_struct *peak_limiter, |
| VOID *samples_t, UWORD32 frame_len, |
| UWORD8 *qshift_adj) { |
| UWORD32 i, j; |
| FLOAT32 tmp, gain; |
| FLOAT32 min_gain = 1.0f; |
| FLOAT32 maximum; |
| 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 *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; |
| WORD32 limit_threshold = PEAK_LIM_THR_FIX; |
| |
| WORD32 *samples = (WORD32 *)samples_t; |
| |
| if (peak_limiter->limiter_on || (FLOAT32)pre_smoothed_gain) { |
| for (i = 0; i < frame_len; i++) { |
| tmp = 0.0f; |
| for (j = 0; j < num_channels; j++) { |
| FLOAT32 gain_t = (FLOAT32)(1 << *(qshift_adj + j)); |
| tmp = (FLOAT32)MAX(tmp, fabs((samples[i * num_channels + j] * gain_t))); |
| } |
| max_buf[peak_limiter->cir_buf_pnt] = tmp; |
| |
| if (peak_limiter->max_idx == peak_limiter->cir_buf_pnt) { |
| peak_limiter->max_idx = 0; |
| for (j = 1; j < (attack_time_samples); j++) { |
| if (max_buf[j] > max_buf[peak_limiter->max_idx]) |
| peak_limiter->max_idx = j; |
| } |
| } else if (tmp >= max_buf[peak_limiter->max_idx]) { |
| peak_limiter->max_idx = peak_limiter->cir_buf_pnt; |
| } |
| peak_limiter->cir_buf_pnt++; |
| |
| if (peak_limiter->cir_buf_pnt == (WORD32)(attack_time_samples)) |
| peak_limiter->cir_buf_pnt = 0; |
| maximum = max_buf[peak_limiter->max_idx]; |
| |
| 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++) { |
| WORD64 tmp_fix; |
| tmp = delayed_input[delayed_input_index * num_channels + j]; |
| FLOAT32 gain_t = (FLOAT32)(1 << *(qshift_adj + j)); |
| delayed_input[delayed_input_index * num_channels + j] = |
| samples[i * num_channels + j] * gain_t; |
| |
| tmp *= gain; |
| |
| tmp_fix = (WORD64)tmp; |
| |
| if (tmp_fix > limit_threshold) |
| tmp_fix = limit_threshold; |
| else if (tmp_fix < -limit_threshold) |
| tmp_fix = -limit_threshold; |
| |
| samples[i * num_channels + j] = (WORD32)tmp_fix; |
| } |
| |
| 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]; |
| FLOAT32 gain_t = (FLOAT32)(1 << *(qshift_adj + j)); |
| delayed_input[delayed_input_index * num_channels + j] = |
| samples[i * num_channels + j] * gain_t; |
| samples[i * num_channels + j] = (WORD32)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; |
| } |
| |
| /** |
| * ixheaacd_scale_adjust |
| * |
| * \brief Scale adjust process |
| * |
| * \param [in/out] samples |
| * \param [in] qshift_adj |
| * \param [in] frame_len |
| * |
| * \return WORD32 |
| * |
| */ |
| |
| VOID ixheaacd_scale_adjust(WORD32 *samples, UWORD32 frame_len, |
| WORD8 *qshift_adj, WORD num_channels) { |
| UWORD32 i; |
| WORD32 j; |
| for (i = 0; i < frame_len; i++) { |
| for (j = 0; j < num_channels; j++) { |
| WORD32 gain_t = (WORD32)(1 << *(qshift_adj + j)); |
| samples[i * num_channels + j] = (samples[i * num_channels + j] * gain_t); |
| } |
| } |
| } |
