path: root/decoder/drc_src/impd_drc_gain_dec.c

/******************************************************************************
 *
 * 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 <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#include "impd_type_def.h"
#include "impd_drc_extr_delta_coded_info.h"
#include "impd_drc_common.h"
#include "impd_drc_struct.h"
#include "impd_drc_interface.h"
#include "impd_drc_filter_bank.h"
#include "impd_drc_gain_dec.h"
#include "impd_parametric_drc_dec.h"
#include "impd_drc_multi_band.h"
#include "impd_drc_process_audio.h"
#include "impd_drc_eq.h"
#include "impd_drc_gain_decoder.h"

extern  ia_cicp_sigmoid_characteristic_param_struct pstr_cicp_sigmoid_characteristic_param[];

WORD32 impd_gain_db_to_lin (ia_interp_params_struct* interp_params_str,
          WORD32          drc_band,
          FLOAT32         in_param_db_gain,
          FLOAT32         in_param_db_slope,
          FLOAT32*        out_param_lin_gain,
          FLOAT32*        out_param_lin_slope)
{

    FLOAT32 loc_db_gain = in_param_db_gain;
    FLOAT32 gain_ratio = 1.0;

    ia_gain_modifiers_struct*  pstr_gain_modifiers = interp_params_str->pstr_gain_modifiers;
    if (interp_params_str->gain_modification_flag) {

        if ((interp_params_str->characteristic_index > 0) && (loc_db_gain != 0.0f)){

            gain_ratio = 1.0f;
        }


        if (loc_db_gain < 0.0f) {
            gain_ratio *= interp_params_str->compress;
        }
        else {
            gain_ratio *= interp_params_str->boost;
        }
    }
    if (pstr_gain_modifiers->gain_scaling_flag[drc_band] == 1) {
        if (loc_db_gain < 0.0) {
            gain_ratio *= pstr_gain_modifiers->attn_scaling[drc_band];
        }
        else {
            gain_ratio *= pstr_gain_modifiers->ampl_scaling[drc_band];
        }
    }
    if ((interp_params_str->pstr_ducking_modifiers->ducking_scaling_flag == 1) && (interp_params_str->ducking_flag == 1)) {
        gain_ratio *= interp_params_str->pstr_ducking_modifiers->ducking_scaling;
    }

    {
        *out_param_lin_gain = (FLOAT32)pow(2.0, (FLOAT64)(gain_ratio * loc_db_gain / 6.0f));
        *out_param_lin_slope = SLOPE_FACTOR_DB_TO_LINEAR * gain_ratio * *out_param_lin_gain * in_param_db_slope;

        if (pstr_gain_modifiers->gain_offset_flag[drc_band] == 1) {
            *out_param_lin_gain *= (FLOAT32)pow(2.0, (FLOAT64)(pstr_gain_modifiers->gain_offset[drc_band]/6.0f));
        }
        if ((interp_params_str->limiter_peak_target_present == 1)  && (interp_params_str->clipping_flag == 1)) {
            *out_param_lin_gain *= (FLOAT32)pow(2.0, max(0.0, -interp_params_str->limiter_peak_target - interp_params_str->loudness_normalization_gain_db)/6.0);
            if (*out_param_lin_gain >= 1.0) {
                *out_param_lin_gain = 1.0;
                *out_param_lin_slope = 0.0;
            }
        }
    }
    return (0);
}







WORD32
impd_compressor_io_sigmoid(ia_split_drc_characteristic_struct* split_drc_characteristic,
                     FLOAT32 in_db_level,
                     FLOAT32* out_db_gain)
{
    FLOAT32 tmp;
    FLOAT32 in_out_ratio = split_drc_characteristic->in_out_ratio;
    FLOAT32 gainDbLimit = split_drc_characteristic->gain;
    FLOAT32 exp = split_drc_characteristic->exp;

    tmp = (DRC_INPUT_LOUDNESS_TARGET - in_db_level) * in_out_ratio;
    if (exp < 1000.0f) {
        FLOAT32 x = tmp/gainDbLimit;
        if (x < 0.0f)
        {
            return(UNEXPECTED_ERROR);
        }
        *out_db_gain = (FLOAT32)(tmp / pow(1.0f + pow(x, exp), 1.0f/exp));
    } else {
        *out_db_gain = tmp;
    }
    if (split_drc_characteristic->flip_sign == 1) {
        *out_db_gain = - *out_db_gain;
    }
    return (0);
}

WORD32
impd_compressor_io_sigmoid_inv(ia_split_drc_characteristic_struct* split_drc_characteristic,
                             FLOAT32 loc_db_gain,
                             FLOAT32* in_level)
{
    FLOAT32 in_out_ratio = split_drc_characteristic->in_out_ratio;
    FLOAT32 gainDbLimit = split_drc_characteristic->gain;
    FLOAT32 exp = split_drc_characteristic->exp;
    FLOAT32 tmp = loc_db_gain;

    if (split_drc_characteristic->flip_sign == 1) {
        tmp = - loc_db_gain;
    }
    if (exp < 1000.0f) {
        FLOAT32 x = tmp/gainDbLimit;
        if (x < 0.0f)
        {
            return(UNEXPECTED_ERROR);
        }
        tmp = (FLOAT32)(tmp / pow(1.0f - pow(x, exp), 1.0f / exp));
    }
    *in_level = DRC_INPUT_LOUDNESS_TARGET - tmp / in_out_ratio;

    return(0);
}

WORD32
impd_compressor_io_nodes_lt(ia_split_drc_characteristic_struct* split_drc_characteristic,
                       FLOAT32 in_db_level,
                       FLOAT32 *out_db_gain)
{
    WORD32 n;
    FLOAT32 w;
    FLOAT32* node_level = split_drc_characteristic->node_level;
    FLOAT32* node_gain = split_drc_characteristic->node_gain;

    if (in_db_level > DRC_INPUT_LOUDNESS_TARGET)
    {
        return (UNEXPECTED_ERROR);
    }
    for (n=1; n<=split_drc_characteristic->characteristic_node_count; n++) {
        if ((in_db_level <= node_level[n-1]) && (in_db_level > node_level[n])) {
            w = (node_level[n]- in_db_level)/(node_level[n]-node_level[n-1]);
            *out_db_gain =(FLOAT32) (w * node_gain[n-1] + (1.0-w) * node_gain[n]);
        }
    }
    *out_db_gain = node_gain[split_drc_characteristic->characteristic_node_count];
    return (0);
}

WORD32
impd_compressor_io_nodes_rt(ia_split_drc_characteristic_struct* split_drc_characteristic,
                        FLOAT32 in_db_level,
                        FLOAT32 *out_db_gain)
{
    WORD32 n;
    FLOAT32 w;
    FLOAT32* node_level = split_drc_characteristic->node_level;
    FLOAT32* node_gain = split_drc_characteristic->node_gain;

    if (in_db_level < DRC_INPUT_LOUDNESS_TARGET)
    {
        return (UNEXPECTED_ERROR);
    }
    for (n=1; n<=split_drc_characteristic->characteristic_node_count; n++) {
        if ((in_db_level >= node_level[n-1]) && (in_db_level < node_level[n])) {
            w =(FLOAT32) (node_level[n]- in_db_level)/(node_level[n]-node_level[n-1]);
            *out_db_gain = (FLOAT32)(w * node_gain[n-1] + (1.0-w) * node_gain[n]);
        }
    }
    *out_db_gain = (node_gain[split_drc_characteristic->characteristic_node_count]);
    return (0);
}


WORD32
impd_compressor_io_nodes_inverse(ia_split_drc_characteristic_struct* split_drc_characteristic,
                           FLOAT32 loc_db_gain,
                           FLOAT32 *in_level)
{
    WORD32 n;
    FLOAT32 w;
    FLOAT32* node_level = split_drc_characteristic->node_level;
    FLOAT32* node_gain = split_drc_characteristic->node_gain;
    WORD32 node_count = split_drc_characteristic->characteristic_node_count;

    if (node_gain[1] < 0.0f) {
        if (loc_db_gain <= node_gain[node_count]) {
            *in_level = node_level[node_count];
        }
        else {
            if (loc_db_gain >= 0.0f) {
                *in_level = DRC_INPUT_LOUDNESS_TARGET;
            }
            else {
                for (n=1; n<=node_count; n++) {
                    if ((loc_db_gain <= node_gain[n-1]) && (loc_db_gain > node_gain[n])) {
                        w = (node_gain[n]-loc_db_gain)/(node_gain[n]-node_gain[n-1]);
                        *in_level =(FLOAT32) (w * node_level[n-1] + (1.0-w) * node_level[n]);
                    }
                }
            }
        }
    }
    else {
        if (loc_db_gain >= node_gain[node_count]) {
            *in_level = node_level[node_count];
        }
        else {
            if (loc_db_gain <= 0.0f) {
                *in_level = DRC_INPUT_LOUDNESS_TARGET;
            }
            else {
                for (n=1; n<=node_count; n++) {
                    if ((loc_db_gain >= node_gain[n-1]) && (loc_db_gain < node_gain[n])) {
                        w = (FLOAT32)(node_gain[n]-loc_db_gain)/(node_gain[n]-node_gain[n-1]);
                        *in_level =(FLOAT32) (w * node_level[n-1] + (1.0-w) * node_level[n]);
                    }
                }
            }
        }
    }
    return (0);
}


WORD32
impd_map_gain (
         ia_split_drc_characteristic_struct* split_drc_characteristic_source,
         ia_split_drc_characteristic_struct* split_drc_characteristic_target,
         FLOAT32 gain_in_db,
         FLOAT32* gain_out_db)
{
    FLOAT32 inLevel;
    WORD32 err = 0;

    switch (split_drc_characteristic_source->characteristic_format) {
        case CHARACTERISTIC_SIGMOID:
            err = impd_compressor_io_sigmoid_inv(split_drc_characteristic_source, gain_in_db, &inLevel);
            if (err) return (err);
            break;
        case CHARACTERISTIC_NODES:
            err = impd_compressor_io_nodes_inverse(split_drc_characteristic_source, gain_in_db, &inLevel);
            if (err) return (err);
            break;
        case CHARACTERISTIC_PASS_THRU:
            inLevel = gain_in_db;
            break;
        default:
            return(UNEXPECTED_ERROR);
            break;
    }
    switch (split_drc_characteristic_target->characteristic_format) {
        case CHARACTERISTIC_SIGMOID:
            err = impd_compressor_io_sigmoid(split_drc_characteristic_target, inLevel, gain_out_db);
            if (err) return (err);
            break;
        case CHARACTERISTIC_NODES:
            if (inLevel < DRC_INPUT_LOUDNESS_TARGET) {
                err = impd_compressor_io_nodes_lt(split_drc_characteristic_target, inLevel, gain_out_db);
                if (err) return (err);
            }
            else {
                err = impd_compressor_io_nodes_rt(split_drc_characteristic_target, inLevel, gain_out_db);
                if (err) return (err);
            }
            break;
        case CHARACTERISTIC_PASS_THRU:
            *gain_out_db = inLevel;
            break;
        default:
            break;
    }
    return (0);
}

WORD32
impd_conv_to_linear_domain (ia_interp_params_struct* interp_params_str,
           WORD32     drc_band,
          FLOAT32       in_param_db_gain,
          FLOAT32       in_param_db_slope,
          FLOAT32*        out_param_lin_gain,
          FLOAT32*        out_param_lin_slope)
{
    WORD32 err = 0;
    FLOAT32 loc_db_gain = in_param_db_gain;
    FLOAT32 gain_ratio = 1.0;
    FLOAT32 mapped_db_gain;
    ia_gain_modifiers_struct*  pstr_gain_modifiers = interp_params_str->pstr_gain_modifiers;
    if (interp_params_str->gain_modification_flag) {
        ia_split_drc_characteristic_struct* split_drc_characteristic_source;

        WORD32 slopeIsNegative;

        if (interp_params_str->drc_characteristic_present) {
            if (interp_params_str->drc_source_characteristic_cicp_format)
            {

            }
            else {
                slopeIsNegative = 0;
                split_drc_characteristic_source = interp_params_str->split_source_characteristic_left;
                if (split_drc_characteristic_source->characteristic_format == 0)
                {
                    slopeIsNegative = 1;
                }
                else
                {
                    if (split_drc_characteristic_source->node_gain[1] > 0.0f) {
                        slopeIsNegative = 1;
                    }
                }
                if (loc_db_gain == 0.0f) {
                    if (((pstr_gain_modifiers->target_characteristic_left_present[drc_band] == 1) &&
                        (interp_params_str->split_target_characteristic_left->characteristic_format == CHARACTERISTIC_PASS_THRU)) ||
                        ((pstr_gain_modifiers->target_characteristic_right_present[drc_band] == 1) &&
                         (interp_params_str->split_target_characteristic_right->characteristic_format == CHARACTERISTIC_PASS_THRU)))
                    {
                        mapped_db_gain = DRC_INPUT_LOUDNESS_TARGET;
                        loc_db_gain = DRC_INPUT_LOUDNESS_TARGET;
                    }
                }
                else
                {
                    if (((loc_db_gain > 0.0f) && (slopeIsNegative == 1)) || ((loc_db_gain < 0.0f) && (slopeIsNegative == 0)))
                    {
                        if (pstr_gain_modifiers->target_characteristic_left_present[drc_band] == 1)
                        {
                            err = impd_map_gain(split_drc_characteristic_source, interp_params_str->split_target_characteristic_left, loc_db_gain, &mapped_db_gain);
                            if (err) return (err);
                            gain_ratio = mapped_db_gain / loc_db_gain;
                        }

                    }
                    else if (((loc_db_gain < 0.0f) && (slopeIsNegative == 1)) || ((loc_db_gain > 0.0f) && (slopeIsNegative == 0)))
                    {
                        if (pstr_gain_modifiers->target_characteristic_right_present[drc_band] == 1)
                        {
                            split_drc_characteristic_source = interp_params_str->split_source_characteristic_right;
                            err = impd_map_gain(split_drc_characteristic_source, interp_params_str->split_target_characteristic_right, loc_db_gain, &mapped_db_gain);
                            if (err) return (err);
                            gain_ratio = mapped_db_gain / loc_db_gain;
                        }
                    }
                }
            }
        }

        if (loc_db_gain < 0.0f) {
            gain_ratio *= interp_params_str->compress;
        }
        else {
            gain_ratio *= interp_params_str->boost;
        }
    }
    if (pstr_gain_modifiers->gain_scaling_flag[drc_band] == 1) {
        if (loc_db_gain < 0.0) {
            gain_ratio *= pstr_gain_modifiers->attn_scaling[drc_band];
        }
        else {
            gain_ratio *= pstr_gain_modifiers->ampl_scaling[drc_band];
        }
    }
    if ((interp_params_str->pstr_ducking_modifiers->ducking_scaling_flag == 1) && (interp_params_str->ducking_flag == 1)) {
        gain_ratio *= interp_params_str->pstr_ducking_modifiers->ducking_scaling;
    }

    if (interp_params_str->interpolation_loud_eq == 1)
    {
        *out_param_lin_gain = gain_ratio * loc_db_gain + pstr_gain_modifiers->gain_offset[drc_band];
        *out_param_lin_slope = 0.0f;
    }
    else
    {
        *out_param_lin_gain = (FLOAT32)pow(2.0, (FLOAT64)(gain_ratio * loc_db_gain / 6.0f));
        *out_param_lin_slope = SLOPE_FACTOR_DB_TO_LINEAR * gain_ratio * *out_param_lin_gain * in_param_db_slope;

        if (pstr_gain_modifiers->gain_offset_flag[drc_band] == 1) {
            *out_param_lin_gain *= (FLOAT32)pow(2.0, (FLOAT64)(pstr_gain_modifiers->gain_offset[drc_band]/6.0f));
        }
        if ((interp_params_str->limiter_peak_target_present == 1)  && (interp_params_str->clipping_flag == 1)) {
            *out_param_lin_gain *= (FLOAT32)pow(2.0, max(0.0, -interp_params_str->limiter_peak_target - interp_params_str->loudness_normalization_gain_db)/6.0);
            if (*out_param_lin_gain >= 1.0) {
                *out_param_lin_gain = 1.0;
                *out_param_lin_slope = 0.0;
            }
        }
    }
    return (0);
}

WORD32 impd_interpolate_drc_gain(ia_interp_params_struct* interp_params_str,
                                        WORD32   drc_band,
                                        WORD32   gain_step_tdomain,
                                        FLOAT32  gain0,
                                        FLOAT32  gain1,
                                        FLOAT32  slope0,
                                        FLOAT32  slope1,
                                        FLOAT32* result)
{
    WORD32 err = 0;
    WORD32 n;
    FLOAT32 k1, k2, a, b, c, d;
    FLOAT32 slope_t1;
    FLOAT32 slope_t2;
    FLOAT32 gain_t1;
    FLOAT32 gain_t2;

    WORD32 cubic_interpolation = 1;
    WORD32 node_inser;
    FLOAT32 node_inser_float;

    if (gain_step_tdomain <= 0)
    {
        return (UNEXPECTED_ERROR);
    }

    if (interp_params_str->gain_interpolation_type == GAIN_INTERPOLATION_TYPE_SPLINE) {
        err = impd_conv_to_linear_domain(interp_params_str, drc_band, gain0, slope0, &gain_t1, &slope_t1);
        if (err)
            return (err);
        err = impd_conv_to_linear_domain (interp_params_str, drc_band, gain1, slope1, &gain_t2, &slope_t2);
        if (err)
            return (err);

        slope_t1 = slope_t1/(FLOAT32) interp_params_str->delta_tmin;
        slope_t2 = slope_t2/(FLOAT32) interp_params_str->delta_tmin;
        if ((FLOAT32)fabs((FLOAT64)slope_t1) > (FLOAT32)fabs((FLOAT64)slope_t2)) {
            node_inser_float = 2.0f * (gain_t2 - gain_t1 - slope_t2 * gain_step_tdomain) /
            (slope_t1 - slope_t2);
            node_inser = (WORD32) (0.5f + node_inser_float);
            if ((node_inser >= 0) && (node_inser < gain_step_tdomain)) {
                cubic_interpolation = 0;

                result[0] = gain_t1;
                result[gain_step_tdomain] = gain_t2;

                a = 0.5f*(slope_t2 - slope_t1) / node_inser_float;
                b = slope_t1;
                c = gain_t1;
                for (n=1; n<node_inser; n++) {
                    FLOAT32 t = (FLOAT32) n;
                    result[n] = (a * t + b ) * t + c;
                    result[n] = max(0.0f, result[n]);
                }
                a = slope_t2;
                b = gain_t2;
                for (   ; n<gain_step_tdomain; n++) {
                    FLOAT32 t = (FLOAT32) (n - gain_step_tdomain);
                    result[n] = a * t + b;
                }
            }
        }
        else if ((FLOAT32)fabs((FLOAT64)slope_t1) < (FLOAT32)fabs((FLOAT64)slope_t2))
        {
            node_inser_float = 2.0f * (gain_t1 - gain_t2 + slope_t1 * gain_step_tdomain) /
            (slope_t1 - slope_t2);
            node_inser_float = gain_step_tdomain - node_inser_float;
            node_inser = (WORD32) (0.5f + node_inser_float);
            if ((node_inser >= 0) && (node_inser < gain_step_tdomain)) {
                cubic_interpolation = 0;

                result[0] = gain_t1;
                result[gain_step_tdomain] = gain_t2;

                a = slope_t1;
                b = gain_t1;
                for (n=1; n<node_inser; n++) {
                    FLOAT32 t = (FLOAT32) n;
                    result[n] = a * t + b;
                }
                a = (slope_t2 - slope_t1) / (2.0f * (gain_step_tdomain - node_inser_float));
                b = - slope_t2;
                c = gain_t2;
                for (   ; n<gain_step_tdomain; n++) {
                    FLOAT32 t = (FLOAT32) (gain_step_tdomain-n);
                    result[n] = (a * t + b ) * t + c;
                    result[n] = max(0.0f, result[n]);
                }
            }
        }

        if (cubic_interpolation == 1)
        {
            FLOAT32 gain_step_inv = 1.0f / (FLOAT32)gain_step_tdomain;
            FLOAT32 gain_step_inv2 = gain_step_inv * gain_step_inv;

            k1 = (gain_t2 - gain_t1) * gain_step_inv2;
            k2 = slope_t2 + slope_t1;

            a = gain_step_inv * (gain_step_inv * k2 - 2.0f * k1);
            b = 3.0f * k1 - gain_step_inv * (k2 + slope_t1);
            c = slope_t1;
            d = gain_t1;

            result[0] = gain_t1;
            result[gain_step_tdomain] = gain_t2;
            for (n=1; n<gain_step_tdomain; n++) {
                FLOAT32 t = (FLOAT32) n;
                result[n] = (((a * t + b ) * t + c ) * t ) + d;
                result[n] = max(0.0f, result[n]);
            }
        }
    }
    else{

        err = impd_conv_to_linear_domain(interp_params_str, drc_band, gain1, slope1, &gain_t2, &slope_t2);
        if (err)
            return (err);

        a = 0;
        b = gain_t2;

        result[0] = gain_t2;
        result[gain_step_tdomain] = gain_t2;
        for (n=1; n<gain_step_tdomain; n++) {
            FLOAT32 t = (FLOAT32) n;
            result[n] = a * t + b;
        }
    }
    return 0;
}

WORD32
impd_advance_buf(WORD32 drc_frame_size,
              ia_gain_buffer_struct* pstr_gain_buf)
{
    WORD32 n;
    ia_interp_buf_struct* buf_interpolation;

    for (n=0; n<pstr_gain_buf->buf_interpolation_count; n++)
    {
        buf_interpolation = &(pstr_gain_buf->buf_interpolation[n]);
        buf_interpolation->prev_node = buf_interpolation->str_node;
        buf_interpolation->prev_node.time -= drc_frame_size;
        memmove(buf_interpolation->lpcm_gains, buf_interpolation->lpcm_gains + drc_frame_size, sizeof(FLOAT32) * (drc_frame_size + MAX_SIGNAL_DELAY));
    }
    return(0);
}
WORD32
impd_concatenate_segments(WORD32 drc_frame_size,
                    WORD32 drc_band,
                    ia_interp_params_struct* interp_params_str,
                    ia_spline_nodes_struct* str_spline_nodes,
                    ia_interp_buf_struct* buf_interpolation)
{
    WORD32 timePrev, duration, n, err = 0;
    FLOAT32 loc_db_gain = 0.0f, prev_db_gain, slope = 0.0f, slopePrev;

    timePrev = buf_interpolation->prev_node.time;
    prev_db_gain = buf_interpolation->prev_node.loc_db_gain;
    slopePrev = buf_interpolation->prev_node.slope;
    for (n=0; n<str_spline_nodes->num_nodes; n++)
    {
        duration = str_spline_nodes->str_node[n].time - timePrev;
        loc_db_gain = str_spline_nodes->str_node[n].loc_db_gain;
        slope = str_spline_nodes->str_node[n].slope;

        err = impd_interpolate_drc_gain(interp_params_str,
                                 drc_band,
                                 duration,
                                 prev_db_gain,
                                 loc_db_gain,
                                 slopePrev,
                                 slope,
                                 buf_interpolation->lpcm_gains + MAX_SIGNAL_DELAY + drc_frame_size + timePrev);
        if (err) return (err);

        timePrev = str_spline_nodes->str_node[n].time;
        prev_db_gain = loc_db_gain;
        slopePrev = slope;
    }

    buf_interpolation->str_node.loc_db_gain = loc_db_gain;
    buf_interpolation->str_node.slope = slope;
    buf_interpolation->str_node.time = timePrev;


    return(0);
}

WORD32
impd_get_drc_gain (ia_drc_gain_dec_struct*  p_drc_gain_dec_structs,
            ia_drc_config*                  pstr_drc_config,
            ia_drc_gain_struct*              pstr_drc_gain,
            FLOAT32                      compress,
            FLOAT32                      boost,
            WORD32                       characteristic_index,
            FLOAT32                      loudness_normalization_gain_db,
            WORD32                       sel_drc_index,
            ia_drc_gain_buffers_struct*                  drc_gain_buffers)
{
    ia_drc_params_struct* ia_drc_params_struct = &(p_drc_gain_dec_structs->ia_drc_params_struct);
    WORD32 drc_instructions_index = ia_drc_params_struct->sel_drc_array[sel_drc_index].drc_instructions_index;
    if (drc_instructions_index >= 0)
    {
        WORD32 b, g, gainElementIndex, err = 0;
        WORD32 parametricDrcInstanceIndex = 0;
        ia_interp_params_struct interp_params_str = {0};

        ia_drc_instructions_struct* str_drc_instruction_str = &(pstr_drc_config->str_drc_instruction_str[drc_instructions_index]);
        WORD32 drc_set_effect = str_drc_instruction_str->drc_set_effect;
        WORD32 num_drc_ch_groups = str_drc_instruction_str->num_drc_ch_groups;
        ia_uni_drc_coeffs_struct* str_p_loc_drc_coefficients_uni_drc = NULL;
        WORD32 drc_coeff_idx = ia_drc_params_struct->sel_drc_array[sel_drc_index].drc_coeff_idx;
        if (drc_coeff_idx >= 0)
        {
            str_p_loc_drc_coefficients_uni_drc = &(pstr_drc_config->str_p_loc_drc_coefficients_uni_drc[drc_coeff_idx]);
            interp_params_str.interpolation_loud_eq = 0;
        }
        else
        {
            return (UNEXPECTED_ERROR);
        }

        interp_params_str.loudness_normalization_gain_db = loudness_normalization_gain_db;
        interp_params_str.characteristic_index = characteristic_index;
        interp_params_str.compress = compress;
        interp_params_str.boost = boost;
        interp_params_str.limiter_peak_target_present = str_drc_instruction_str->limiter_peak_target_present;
        interp_params_str.limiter_peak_target = str_drc_instruction_str->limiter_peak_target;

        if ( ((drc_set_effect & (EFFECT_BIT_DUCK_OTHER | EFFECT_BIT_DUCK_SELF)) == 0) && (drc_set_effect != EFFECT_BIT_FADE) && (drc_set_effect != EFFECT_BIT_CLIPPING))
        {
            interp_params_str.gain_modification_flag = 1;
        }
        else
        {
            interp_params_str.gain_modification_flag = 0;
        }
        if (drc_set_effect & (EFFECT_BIT_DUCK_OTHER | EFFECT_BIT_DUCK_SELF))
        {
            interp_params_str.ducking_flag = 1;
        }
        else
        {
            interp_params_str.ducking_flag = 0;
        }
        if (drc_set_effect == EFFECT_BIT_CLIPPING)
        {
            interp_params_str.clipping_flag = 1;
        }
        else
        {
            interp_params_str.clipping_flag = 0;
        }

        err = impd_advance_buf(ia_drc_params_struct->drc_frame_size, &(drc_gain_buffers->pstr_gain_buf[sel_drc_index]));
        if (err) return (err);

        gainElementIndex = 0;
        for(g=0; g<num_drc_ch_groups; g++)
        {
            WORD32 gainSet = 0;
            WORD32 num_drc_bands = 0;
            interp_params_str.gain_interpolation_type = str_drc_instruction_str->gain_interpolation_type_for_channel_group[g];
            interp_params_str.delta_tmin = str_drc_instruction_str->time_delta_min_for_channel_group[g];
            interp_params_str.pstr_ducking_modifiers = &(str_drc_instruction_str->str_ducking_modifiers_for_channel_group[g]);
            interp_params_str.pstr_gain_modifiers = &(str_drc_instruction_str->str_gain_modifiers_of_ch_group[g]);
            if (str_drc_instruction_str->ch_group_parametric_drc_flag[g] == 0) {
                gainSet = str_drc_instruction_str->gain_set_index_for_channel_group[g];
                num_drc_bands = str_drc_instruction_str->band_count_of_ch_group[g];
                for(b=0; b<num_drc_bands; b++)
                {
                    ia_gain_params_struct* gain_params = &(str_p_loc_drc_coefficients_uni_drc->gain_set_params[gainSet].gain_params[b]);
                    WORD32 seq                                                 = gain_params->gain_seq_idx;
                    interp_params_str.drc_characteristic_present            = gain_params->drc_characteristic_present;
                    interp_params_str.drc_source_characteristic_cicp_format = gain_params->drc_characteristic_format_is_cicp;
                    interp_params_str.source_drc_characteristic             = gain_params->drc_characteristic;
                    interp_params_str.split_source_characteristic_left       = &(str_p_loc_drc_coefficients_uni_drc->str_split_characteristic_left [gain_params->drc_characteristic_left_index]);
                    interp_params_str.split_source_characteristic_right      = &(str_p_loc_drc_coefficients_uni_drc->str_split_characteristic_right[gain_params->drc_characteristic_right_index]);
                    interp_params_str.split_target_characteristic_left       = &(str_p_loc_drc_coefficients_uni_drc->str_split_characteristic_left [interp_params_str.pstr_gain_modifiers->target_characteristic_left_index[b]]);
                    interp_params_str.split_target_characteristic_right      = &(str_p_loc_drc_coefficients_uni_drc->str_split_characteristic_right[interp_params_str.pstr_gain_modifiers->target_characteristic_right_index[b]]);
                    err = impd_concatenate_segments (ia_drc_params_struct->drc_frame_size,
                                               b,
                                               &interp_params_str,
                                               &(pstr_drc_gain->drc_gain_sequence[seq].str_spline_nodes[0]),
                                               &(drc_gain_buffers->pstr_gain_buf[sel_drc_index].buf_interpolation[gainElementIndex]));
                    if (err) return (err);
                    gainElementIndex++;
                }
            } else {
                if (ia_drc_params_struct->sub_band_domain_mode == SUBBAND_DOMAIN_MODE_OFF && !(p_drc_gain_dec_structs->parametricdrc_params.str_parametric_drc_instance_params[parametricDrcInstanceIndex].parametric_drc_type == PARAM_DRC_TYPE_LIM)) {
                    err = impd_parametric_drc_instance_process (p_drc_gain_dec_structs->audio_in_out_buf.audio_in_out_buf,
                                                        NULL,
                                                        NULL,
                                                        &p_drc_gain_dec_structs->parametricdrc_params,
                                                        &p_drc_gain_dec_structs->parametricdrc_params.str_parametric_drc_instance_params[parametricDrcInstanceIndex]);
                    if (err) return (err);

                    err = impd_concatenate_segments(ia_drc_params_struct->drc_frame_size,
                                              0,
                                              &interp_params_str,
                                              &p_drc_gain_dec_structs->parametricdrc_params.str_parametric_drc_instance_params[parametricDrcInstanceIndex].str_spline_nodes,
                                              &(drc_gain_buffers->pstr_gain_buf[sel_drc_index].buf_interpolation[gainElementIndex]));
                    if (err) return (err);
                } else if (ia_drc_params_struct->sub_band_domain_mode == SUBBAND_DOMAIN_MODE_OFF && p_drc_gain_dec_structs->parametricdrc_params.str_parametric_drc_instance_params[parametricDrcInstanceIndex].parametric_drc_type == PARAM_DRC_TYPE_LIM) {
                    FLOAT32* lpcm_gains = (drc_gain_buffers->pstr_gain_buf[sel_drc_index].buf_interpolation[gainElementIndex]).lpcm_gains + MAX_SIGNAL_DELAY;
                    err = impd_parametric_lim_type_drc_process(p_drc_gain_dec_structs->audio_in_out_buf.audio_in_out_buf,
                                                      loudness_normalization_gain_db,
                                                      &p_drc_gain_dec_structs->parametricdrc_params.str_parametric_drc_instance_params[parametricDrcInstanceIndex].str_parametric_drc_type_lim_params,
                                                      lpcm_gains);
                    if (err) return (err);
                } else if (ia_drc_params_struct->sub_band_domain_mode != SUBBAND_DOMAIN_MODE_OFF && !(p_drc_gain_dec_structs->parametricdrc_params.str_parametric_drc_instance_params[parametricDrcInstanceIndex].parametric_drc_type == PARAM_DRC_TYPE_LIM)) {
                    err = impd_parametric_drc_instance_process (NULL,
                                                        p_drc_gain_dec_structs->audio_in_out_buf.audio_real_buff,
                                                        p_drc_gain_dec_structs->audio_in_out_buf.audio_imag_buff,
                                                        &p_drc_gain_dec_structs->parametricdrc_params,
                                                        &p_drc_gain_dec_structs->parametricdrc_params.str_parametric_drc_instance_params[parametricDrcInstanceIndex]);
                    if (err) return (err);

                    err = impd_concatenate_segments(ia_drc_params_struct->drc_frame_size,
                                              0,
                                              &interp_params_str,
                                              &p_drc_gain_dec_structs->parametricdrc_params.str_parametric_drc_instance_params[parametricDrcInstanceIndex].str_spline_nodes,
                                              &(drc_gain_buffers->pstr_gain_buf[sel_drc_index].buf_interpolation[gainElementIndex]));
                    if (err) return (err);

    } else {
                    return (UNEXPECTED_ERROR);
    }
                gainElementIndex++;
                parametricDrcInstanceIndex++;
    }
        }
    }
    return (0);
}