static void decorrelation(PSContext *ps, float (*out)[32][2], const float (*s)[32][2], int is34)

{

    float power[34][PS_QMF_TIME_SLOTS] = {{0}};

    float transient_gain[34][PS_QMF_TIME_SLOTS];

    float *peak_decay_nrg = ps->peak_decay_nrg;

    float *power_smooth = ps->power_smooth;

    float *peak_decay_diff_smooth = ps->peak_decay_diff_smooth;

    float (*delay)[PS_QMF_TIME_SLOTS + PS_MAX_DELAY][2] = ps->delay;

    float (*ap_delay)[PS_AP_LINKS][PS_QMF_TIME_SLOTS + PS_MAX_AP_DELAY][2] = ps->ap_delay;

    const int8_t *k_to_i = is34 ? k_to_i_34 : k_to_i_20;

    const float peak_decay_factor = 0.76592833836465f;

    const float transient_impact  = 1.5f;

    const float a_smooth          = 0.25f; ///< Smoothing coefficient

    int i, k, m, n;

    int n0 = 0, nL = 32;

    static const int link_delay[] = { 3, 4, 5 };

    static const float a[] = { 0.65143905753106f,

                               0.56471812200776f,

                               0.48954165955695f };



    if (is34 != ps->is34bands_old) {

        memset(ps->peak_decay_nrg,         0, sizeof(ps->peak_decay_nrg));

        memset(ps->power_smooth,           0, sizeof(ps->power_smooth));

        memset(ps->peak_decay_diff_smooth, 0, sizeof(ps->peak_decay_diff_smooth));

        memset(ps->delay,                  0, sizeof(ps->delay));

        memset(ps->ap_delay,               0, sizeof(ps->ap_delay));

    }



    for (n = n0; n < nL; n++) {

        for (k = 0; k < NR_BANDS[is34]; k++) {

            int i = k_to_i[k];

            power[i][n] += s[k][n][0] * s[k][n][0] + s[k][n][1] * s[k][n][1];

        }

    }



    //Transient detection

    for (i = 0; i < NR_PAR_BANDS[is34]; i++) {

        for (n = n0; n < nL; n++) {

            float decayed_peak = peak_decay_factor * peak_decay_nrg[i];

            float denom;

            peak_decay_nrg[i] = FFMAX(decayed_peak, power[i][n]);

            power_smooth[i] += a_smooth * (power[i][n] - power_smooth[i]);

            peak_decay_diff_smooth[i] += a_smooth * (peak_decay_nrg[i] - power[i][n] - peak_decay_diff_smooth[i]);

            denom = transient_impact * peak_decay_diff_smooth[i];

            transient_gain[i][n]   = (denom > power_smooth[i]) ?

                                         power_smooth[i] / denom : 1.0f;

        }

    }



    //Decorrelation and transient reduction

    //                         PS_AP_LINKS - 1

    //                               -----

    //                                | |  Q_fract_allpass[k][m]*z^-link_delay[m] - a[m]*g_decay_slope[k]

    //H[k][z] = z^-2 * phi_fract[k] * | | ----------------------------------------------------------------

    //                                | | 1 - a[m]*g_decay_slope[k]*Q_fract_allpass[k][m]*z^-link_delay[m]

    //                               m = 0

    //d[k][z] (out) = transient_gain_mapped[k][z] * H[k][z] * s[k][z]

    for (k = 0; k < NR_ALLPASS_BANDS[is34]; k++) {

        int b = k_to_i[k];

        float g_decay_slope = 1.f - DECAY_SLOPE * (k - DECAY_CUTOFF[is34]);

        float ag[PS_AP_LINKS];

        g_decay_slope = av_clipf(g_decay_slope, 0.f, 1.f);

        memcpy(delay[k], delay[k]+nL, PS_MAX_DELAY*sizeof(delay[k][0]));

        memcpy(delay[k]+PS_MAX_DELAY, s[k], numQMFSlots*sizeof(delay[k][0]));

        for (m = 0; m < PS_AP_LINKS; m++) {

            memcpy(ap_delay[k][m],   ap_delay[k][m]+numQMFSlots,           5*sizeof(ap_delay[k][m][0]));

            ag[m] = a[m] * g_decay_slope;

        }

        for (n = n0; n < nL; n++) {

            float in_re = delay[k][n+PS_MAX_DELAY-2][0] * phi_fract[is34][k][0] -

                          delay[k][n+PS_MAX_DELAY-2][1] * phi_fract[is34][k][1];

            float in_im = delay[k][n+PS_MAX_DELAY-2][0] * phi_fract[is34][k][1] +

                          delay[k][n+PS_MAX_DELAY-2][1] * phi_fract[is34][k][0];

            for (m = 0; m < PS_AP_LINKS; m++) {

                float a_re                = ag[m] * in_re;

                float a_im                = ag[m] * in_im;

                float link_delay_re       = ap_delay[k][m][n+5-link_delay[m]][0];

                float link_delay_im       = ap_delay[k][m][n+5-link_delay[m]][1];

                float fractional_delay_re = Q_fract_allpass[is34][k][m][0];

                float fractional_delay_im = Q_fract_allpass[is34][k][m][1];

                ap_delay[k][m][n+5][0] = in_re;

                ap_delay[k][m][n+5][1] = in_im;

                in_re = link_delay_re * fractional_delay_re - link_delay_im * fractional_delay_im - a_re;

                in_im = link_delay_re * fractional_delay_im + link_delay_im * fractional_delay_re - a_im;

                ap_delay[k][m][n+5][0] += ag[m] * in_re;

                ap_delay[k][m][n+5][1] += ag[m] * in_im;

            }

            out[k][n][0] = transient_gain[b][n] * in_re;

            out[k][n][1] = transient_gain[b][n] * in_im;

        }

    }

    for (; k < SHORT_DELAY_BAND[is34]; k++) {

        memcpy(delay[k], delay[k]+nL, PS_MAX_DELAY*sizeof(delay[k][0]));

        memcpy(delay[k]+PS_MAX_DELAY, s[k], numQMFSlots*sizeof(delay[k][0]));

        for (n = n0; n < nL; n++) {

            //H = delay 14

            out[k][n][0] = transient_gain[k_to_i[k]][n] * delay[k][n+PS_MAX_DELAY-14][0];

            out[k][n][1] = transient_gain[k_to_i[k]][n] * delay[k][n+PS_MAX_DELAY-14][1];

        }

    }

    for (; k < NR_BANDS[is34]; k++) {

        memcpy(delay[k], delay[k]+nL, PS_MAX_DELAY*sizeof(delay[k][0]));

        memcpy(delay[k]+PS_MAX_DELAY, s[k], numQMFSlots*sizeof(delay[k][0]));

        for (n = n0; n < nL; n++) {

            //H = delay 1

            out[k][n][0] = transient_gain[k_to_i[k]][n] * delay[k][n+PS_MAX_DELAY-1][0];

            out[k][n][1] = transient_gain[k_to_i[k]][n] * delay[k][n+PS_MAX_DELAY-1][1];

        }

    }

}

static void decorrelation(PSContext *ps, float (*out)[32][2], const float (*s)[32][2], int is34)

{

    float power[34][PS_QMF_TIME_SLOTS] = {{0}};

    float transient_gain[34][PS_QMF_TIME_SLOTS];

    float *peak_decay_nrg = ps->peak_decay_nrg;

    float *power_smooth = ps->power_smooth;

    float *peak_decay_diff_smooth = ps->peak_decay_diff_smooth;

    float (*delay)[PS_QMF_TIME_SLOTS + PS_MAX_DELAY][2] = ps->delay;

    float (*ap_delay)[PS_AP_LINKS][PS_QMF_TIME_SLOTS + PS_MAX_AP_DELAY][2] = ps->ap_delay;

    const int8_t *k_to_i = is34 ? k_to_i_34 : k_to_i_20;

    const float peak_decay_factor = 0.76592833836465f;

    const float transient_impact  = 1.5f;

    const float a_smooth          = 0.25f; 

    int i, k, m, n;

    int n0 = 0, nL = 32;

    static const int link_delay[] = { 3, 4, 5 };

    static const float a[] = { 0.65143905753106f,

                               0.56471812200776f,

                               0.48954165955695f };



    if (is34 != ps->is34bands_old) {

        memset(ps->peak_decay_nrg,         0, sizeof(ps->peak_decay_nrg));

        memset(ps->power_smooth,           0, sizeof(ps->power_smooth));

        memset(ps->peak_decay_diff_smooth, 0, sizeof(ps->peak_decay_diff_smooth));

        memset(ps->delay,                  0, sizeof(ps->delay));

        memset(ps->ap_delay,               0, sizeof(ps->ap_delay));

    }



    for (n = n0; n < nL; n++) {

        for (k = 0; k < NR_BANDS[is34]; k++) {

            int i = k_to_i[k];

            power[i][n] += s[k][n][0] * s[k][n][0] + s[k][n][1] * s[k][n][1];

        }

    }



    

    for (i = 0; i < NR_PAR_BANDS[is34]; i++) {

        for (n = n0; n < nL; n++) {

            float decayed_peak = peak_decay_factor * peak_decay_nrg[i];

            float denom;

            peak_decay_nrg[i] = FFMAX(decayed_peak, power[i][n]);

            power_smooth[i] += a_smooth * (power[i][n] - power_smooth[i]);

            peak_decay_diff_smooth[i] += a_smooth * (peak_decay_nrg[i] - power[i][n] - peak_decay_diff_smooth[i]);

            denom = transient_impact * peak_decay_diff_smooth[i];

            transient_gain[i][n]   = (denom > power_smooth[i]) ?

                                         power_smooth[i] / denom : 1.0f;

        }

    }



    

    

    

    

    

    

    

    

    for (k = 0; k < NR_ALLPASS_BANDS[is34]; k++) {

        int b = k_to_i[k];

        float g_decay_slope = 1.f - DECAY_SLOPE * (k - DECAY_CUTOFF[is34]);

        float ag[PS_AP_LINKS];

        g_decay_slope = av_clipf(g_decay_slope, 0.f, 1.f);

        memcpy(delay[k], delay[k]+nL, PS_MAX_DELAY*sizeof(delay[k][0]));

        memcpy(delay[k]+PS_MAX_DELAY, s[k], numQMFSlots*sizeof(delay[k][0]));

        for (m = 0; m < PS_AP_LINKS; m++) {

            memcpy(ap_delay[k][m],   ap_delay[k][m]+numQMFSlots,           5*sizeof(ap_delay[k][m][0]));

            ag[m] = a[m] * g_decay_slope;

        }

        for (n = n0; n < nL; n++) {

            float in_re = delay[k][n+PS_MAX_DELAY-2][0] * phi_fract[is34][k][0] -

                          delay[k][n+PS_MAX_DELAY-2][1] * phi_fract[is34][k][1];

            float in_im = delay[k][n+PS_MAX_DELAY-2][0] * phi_fract[is34][k][1] +

                          delay[k][n+PS_MAX_DELAY-2][1] * phi_fract[is34][k][0];

            for (m = 0; m < PS_AP_LINKS; m++) {

                float a_re                = ag[m] * in_re;

                float a_im                = ag[m] * in_im;

                float link_delay_re       = ap_delay[k][m][n+5-link_delay[m]][0];

                float link_delay_im       = ap_delay[k][m][n+5-link_delay[m]][1];

                float fractional_delay_re = Q_fract_allpass[is34][k][m][0];

                float fractional_delay_im = Q_fract_allpass[is34][k][m][1];

                ap_delay[k][m][n+5][0] = in_re;

                ap_delay[k][m][n+5][1] = in_im;

                in_re = link_delay_re * fractional_delay_re - link_delay_im * fractional_delay_im - a_re;

                in_im = link_delay_re * fractional_delay_im + link_delay_im * fractional_delay_re - a_im;

                ap_delay[k][m][n+5][0] += ag[m] * in_re;

                ap_delay[k][m][n+5][1] += ag[m] * in_im;

            }

            out[k][n][0] = transient_gain[b][n] * in_re;

            out[k][n][1] = transient_gain[b][n] * in_im;

        }

    }

    for (; k < SHORT_DELAY_BAND[is34]; k++) {

        memcpy(delay[k], delay[k]+nL, PS_MAX_DELAY*sizeof(delay[k][0]));

        memcpy(delay[k]+PS_MAX_DELAY, s[k], numQMFSlots*sizeof(delay[k][0]));

        for (n = n0; n < nL; n++) {

            

            out[k][n][0] = transient_gain[k_to_i[k]][n] * delay[k][n+PS_MAX_DELAY-14][0];

            out[k][n][1] = transient_gain[k_to_i[k]][n] * delay[k][n+PS_MAX_DELAY-14][1];

        }

    }

    for (; k < NR_BANDS[is34]; k++) {

        memcpy(delay[k], delay[k]+nL, PS_MAX_DELAY*sizeof(delay[k][0]));

        memcpy(delay[k]+PS_MAX_DELAY, s[k], numQMFSlots*sizeof(delay[k][0]));

        for (n = n0; n < nL; n++) {

            

            out[k][n][0] = transient_gain[k_to_i[k]][n] * delay[k][n+PS_MAX_DELAY-1][0];

            out[k][n][1] = transient_gain[k_to_i[k]][n] * delay[k][n+PS_MAX_DELAY-1][1];

        }

    }

}

static void FUNC_0(PSContext *VAR_0, float (*VAR_1)[32][2], const float (*VAR_2)[32][2], int VAR_3)

{

    float VAR_4[34][PS_QMF_TIME_SLOTS] = {{0}};

    float VAR_5[34][PS_QMF_TIME_SLOTS];

    float *VAR_6 = VAR_0->VAR_6;

    float *VAR_7 = VAR_0->VAR_7;

    float *VAR_8 = VAR_0->VAR_8;

    float (*VAR_9)[PS_QMF_TIME_SLOTS + PS_MAX_DELAY][2] = VAR_0->VAR_9;

    float (*VAR_10)[PS_AP_LINKS][PS_QMF_TIME_SLOTS + PS_MAX_AP_DELAY][2] = VAR_0->VAR_10;

    const int8_t *VAR_11 = VAR_3 ? k_to_i_34 : k_to_i_20;

    const float VAR_12 = 0.76592833836465f;

    const float VAR_13  = 1.5f;

    const float VAR_14          = 0.25f; 

    int VAR_15, VAR_16, VAR_17, VAR_18;

    int VAR_19 = 0, VAR_20 = 32;

    static const int VAR_21[] = { 3, 4, 5 };

    static const float VAR_22[] = { 0.65143905753106f,

                               0.56471812200776f,

                               0.48954165955695f };



    if (VAR_3 != VAR_0->is34bands_old) {

        memset(VAR_0->VAR_6,         0, sizeof(VAR_0->VAR_6));

        memset(VAR_0->VAR_7,           0, sizeof(VAR_0->VAR_7));

        memset(VAR_0->VAR_8, 0, sizeof(VAR_0->VAR_8));

        memset(VAR_0->VAR_9,                  0, sizeof(VAR_0->VAR_9));

        memset(VAR_0->VAR_10,               0, sizeof(VAR_0->VAR_10));

    }



    for (VAR_18 = VAR_19; VAR_18 < VAR_20; VAR_18++) {

        for (VAR_16 = 0; VAR_16 < NR_BANDS[VAR_3]; VAR_16++) {

            int VAR_15 = VAR_11[VAR_16];

            VAR_4[VAR_15][VAR_18] += VAR_2[VAR_16][VAR_18][0] * VAR_2[VAR_16][VAR_18][0] + VAR_2[VAR_16][VAR_18][1] * VAR_2[VAR_16][VAR_18][1];

        }

    }



    

    for (VAR_15 = 0; VAR_15 < NR_PAR_BANDS[VAR_3]; VAR_15++) {

        for (VAR_18 = VAR_19; VAR_18 < VAR_20; VAR_18++) {

            float decayed_peak = VAR_12 * VAR_6[VAR_15];

            float denom;

            VAR_6[VAR_15] = FFMAX(decayed_peak, VAR_4[VAR_15][VAR_18]);

            VAR_7[VAR_15] += VAR_14 * (VAR_4[VAR_15][VAR_18] - VAR_7[VAR_15]);

            VAR_8[VAR_15] += VAR_14 * (VAR_6[VAR_15] - VAR_4[VAR_15][VAR_18] - VAR_8[VAR_15]);

            denom = VAR_13 * VAR_8[VAR_15];

            VAR_5[VAR_15][VAR_18]   = (denom > VAR_7[VAR_15]) ?

                                         VAR_7[VAR_15] / denom : 1.0f;

        }

    }



    

    

    

    

    

    

    

    

    for (VAR_16 = 0; VAR_16 < NR_ALLPASS_BANDS[VAR_3]; VAR_16++) {

        int b = VAR_11[VAR_16];

        float g_decay_slope = 1.f - DECAY_SLOPE * (VAR_16 - DECAY_CUTOFF[VAR_3]);

        float ag[PS_AP_LINKS];

        g_decay_slope = av_clipf(g_decay_slope, 0.f, 1.f);

        memcpy(VAR_9[VAR_16], VAR_9[VAR_16]+VAR_20, PS_MAX_DELAY*sizeof(VAR_9[VAR_16][0]));

        memcpy(VAR_9[VAR_16]+PS_MAX_DELAY, VAR_2[VAR_16], numQMFSlots*sizeof(VAR_9[VAR_16][0]));

        for (VAR_17 = 0; VAR_17 < PS_AP_LINKS; VAR_17++) {

            memcpy(VAR_10[VAR_16][VAR_17],   VAR_10[VAR_16][VAR_17]+numQMFSlots,           5*sizeof(VAR_10[VAR_16][VAR_17][0]));

            ag[VAR_17] = VAR_22[VAR_17] * g_decay_slope;

        }

        for (VAR_18 = VAR_19; VAR_18 < VAR_20; VAR_18++) {

            float in_re = VAR_9[VAR_16][VAR_18+PS_MAX_DELAY-2][0] * phi_fract[VAR_3][VAR_16][0] -

                          VAR_9[VAR_16][VAR_18+PS_MAX_DELAY-2][1] * phi_fract[VAR_3][VAR_16][1];

            float in_im = VAR_9[VAR_16][VAR_18+PS_MAX_DELAY-2][0] * phi_fract[VAR_3][VAR_16][1] +

                          VAR_9[VAR_16][VAR_18+PS_MAX_DELAY-2][1] * phi_fract[VAR_3][VAR_16][0];

            for (VAR_17 = 0; VAR_17 < PS_AP_LINKS; VAR_17++) {

                float a_re                = ag[VAR_17] * in_re;

                float a_im                = ag[VAR_17] * in_im;

                float link_delay_re       = VAR_10[VAR_16][VAR_17][VAR_18+5-VAR_21[VAR_17]][0];

                float link_delay_im       = VAR_10[VAR_16][VAR_17][VAR_18+5-VAR_21[VAR_17]][1];

                float fractional_delay_re = Q_fract_allpass[VAR_3][VAR_16][VAR_17][0];

                float fractional_delay_im = Q_fract_allpass[VAR_3][VAR_16][VAR_17][1];

                VAR_10[VAR_16][VAR_17][VAR_18+5][0] = in_re;

                VAR_10[VAR_16][VAR_17][VAR_18+5][1] = in_im;

                in_re = link_delay_re * fractional_delay_re - link_delay_im * fractional_delay_im - a_re;

                in_im = link_delay_re * fractional_delay_im + link_delay_im * fractional_delay_re - a_im;

                VAR_10[VAR_16][VAR_17][VAR_18+5][0] += ag[VAR_17] * in_re;

                VAR_10[VAR_16][VAR_17][VAR_18+5][1] += ag[VAR_17] * in_im;

            }

            VAR_1[VAR_16][VAR_18][0] = VAR_5[b][VAR_18] * in_re;

            VAR_1[VAR_16][VAR_18][1] = VAR_5[b][VAR_18] * in_im;

        }

    }

    for (; VAR_16 < SHORT_DELAY_BAND[VAR_3]; VAR_16++) {

        memcpy(VAR_9[VAR_16], VAR_9[VAR_16]+VAR_20, PS_MAX_DELAY*sizeof(VAR_9[VAR_16][0]));

        memcpy(VAR_9[VAR_16]+PS_MAX_DELAY, VAR_2[VAR_16], numQMFSlots*sizeof(VAR_9[VAR_16][0]));

        for (VAR_18 = VAR_19; VAR_18 < VAR_20; VAR_18++) {

            

            VAR_1[VAR_16][VAR_18][0] = VAR_5[VAR_11[VAR_16]][VAR_18] * VAR_9[VAR_16][VAR_18+PS_MAX_DELAY-14][0];

            VAR_1[VAR_16][VAR_18][1] = VAR_5[VAR_11[VAR_16]][VAR_18] * VAR_9[VAR_16][VAR_18+PS_MAX_DELAY-14][1];

        }

    }

    for (; VAR_16 < NR_BANDS[VAR_3]; VAR_16++) {

        memcpy(VAR_9[VAR_16], VAR_9[VAR_16]+VAR_20, PS_MAX_DELAY*sizeof(VAR_9[VAR_16][0]));

        memcpy(VAR_9[VAR_16]+PS_MAX_DELAY, VAR_2[VAR_16], numQMFSlots*sizeof(VAR_9[VAR_16][0]));

        for (VAR_18 = VAR_19; VAR_18 < VAR_20; VAR_18++) {

            

            VAR_1[VAR_16][VAR_18][0] = VAR_5[VAR_11[VAR_16]][VAR_18] * VAR_9[VAR_16][VAR_18+PS_MAX_DELAY-1][0];

            VAR_1[VAR_16][VAR_18][1] = VAR_5[VAR_11[VAR_16]][VAR_18] * VAR_9[VAR_16][VAR_18+PS_MAX_DELAY-1][1];

        }

    }

}

static void FUNC_0(PSContext *VAR_0, float (*VAR_1)[32][2], const float (*VAR_2)[32][2], int VAR_3)
{ float VAR_4[34][PS_QMF_TIME_SLOTS] = {{0}}; float VAR_5[34][PS_QMF_TIME_SLOTS]; float *VAR_6 = VAR_0->VAR_6; float *VAR_7 = VAR_0->VAR_7; float *VAR_8 = VAR_0->VAR_8; float (*VAR_9)[PS_QMF_TIME_SLOTS + PS_MAX_DELAY][2] = VAR_0->VAR_9; float (*VAR_10)[PS_AP_LINKS][PS_QMF_TIME_SLOTS + PS_MAX_AP_DELAY][2] = VAR_0->VAR_10; const int8_t *VAR_11 = VAR_3 ? k_to_i_34 : k_to_i_20; const float VAR_12 = 0.76592833836465f; const float VAR_13  = 1.5f; const float VAR_14          = 0.25f; int VAR_15, VAR_16, VAR_17, VAR_18; int VAR_19 = 0, VAR_20 = 32; static const int VAR_21[] = { 3, 4, 5 }; static const float VAR_22[] = { 0.65143905753106f, 0.56471812200776f,
0.48954165955695f }; if (VAR_3 != VAR_0->is34bands_old) { memset(VAR_0->VAR_6,         0, sizeof(VAR_0->VAR_6)); memset(VAR_0->VAR_7,           0, sizeof(VAR_0->VAR_7)); memset(VAR_0->VAR_8, 0, sizeof(VAR_0->VAR_8)); memset(VAR_0->VAR_9,                  0, sizeof(VAR_0->VAR_9)); memset(VAR_0->VAR_10,               0, sizeof(VAR_0->VAR_10)); } for (VAR_18 = VAR_19; VAR_18 < VAR_20; VAR_18++) { for (VAR_16 = 0; VAR_16 < NR_BANDS[VAR_3]; VAR_16++) { int VAR_15 = VAR_11[VAR_16]; VAR_4[VAR_15][VAR_18] += VAR_2[VAR_16][VAR_18][0] * VAR_2[VAR_16][VAR_18][0] + VAR_2[VAR_16][VAR_18][1] * VAR_2[VAR_16][VAR_18][1]; } } for (VAR_15 = 0; VAR_15 < NR_PAR_BANDS[VAR_3]; VAR_15++) { for (VAR_18 = VAR_19; VAR_18 < VAR_20; VAR_18++) { float decayed_peak = VAR_12 * VAR_6[VAR_15]; float denom; VAR_6[VAR_15] = FFMAX(decayed_peak, VAR_4[VAR_15][VAR_18]); VAR_7[VAR_15] += VAR_14 * (VAR_4[VAR_15][VAR_18] - VAR_7[VAR_15]); VAR_8[VAR_15] += VAR_14 * (VAR_6[VAR_15] - VAR_4[VAR_15][VAR_18] - VAR_8[VAR_15]); denom = VAR_13 * VAR_8[VAR_15]; VAR_5[VAR_15][VAR_18]   = (denom > VAR_7[VAR_15]) ?
VAR_7[VAR_15] / denom : 1.0f; } } for (VAR_16 = 0; VAR_16 < NR_ALLPASS_BANDS[VAR_3]; VAR_16++) { int b = VAR_11[VAR_16]; float g_decay_slope = 1.f - DECAY_SLOPE * (VAR_16 - DECAY_CUTOFF[VAR_3]); float ag[PS_AP_LINKS]; g_decay_slope = av_clipf(g_decay_slope, 0.f, 1.f); memcpy(VAR_9[VAR_16], VAR_9[VAR_16]+VAR_20, PS_MAX_DELAY*sizeof(VAR_9[VAR_16][0])); memcpy(VAR_9[VAR_16]+PS_MAX_DELAY, VAR_2[VAR_16], numQMFSlots*sizeof(VAR_9[VAR_16][0])); for (VAR_17 = 0; VAR_17 < PS_AP_LINKS; VAR_17++) { memcpy(VAR_10[VAR_16][VAR_17],   VAR_10[VAR_16][VAR_17]+numQMFSlots,           5*sizeof(VAR_10[VAR_16][VAR_17][0])); ag[VAR_17] = VAR_22[VAR_17] * g_decay_slope; } for (VAR_18 = VAR_19; VAR_18 < VAR_20; VAR_18++) { float in_re = VAR_9[VAR_16][VAR_18+PS_MAX_DELAY-2][0] * phi_fract[VAR_3][VAR_16][0] -
VAR_9[VAR_16][VAR_18+PS_MAX_DELAY-2][1] * phi_fract[VAR_3][VAR_16][1]; float in_im = VAR_9[VAR_16][VAR_18+PS_MAX_DELAY-2][0] * phi_fract[VAR_3][VAR_16][1] +
VAR_9[VAR_16][VAR_18+PS_MAX_DELAY-2][1] * phi_fract[VAR_3][VAR_16][0]; for (VAR_17 = 0; VAR_17 < PS_AP_LINKS; VAR_17++) { float a_re                = ag[VAR_17] * in_re; float a_im                = ag[VAR_17] * in_im; float link_delay_re       = VAR_10[VAR_16][VAR_17][VAR_18+5-VAR_21[VAR_17]][0]; float link_delay_im       = VAR_10[VAR_16][VAR_17][VAR_18+5-VAR_21[VAR_17]][1]; float fractional_delay_re = Q_fract_allpass[VAR_3][VAR_16][VAR_17][0]; float fractional_delay_im = Q_fract_allpass[VAR_3][VAR_16][VAR_17][1]; VAR_10[VAR_16][VAR_17][VAR_18+5][0] = in_re; VAR_10[VAR_16][VAR_17][VAR_18+5][1] = in_im; in_re = link_delay_re * fractional_delay_re - link_delay_im * fractional_delay_im - a_re; in_im = link_delay_re * fractional_delay_im + link_delay_im * fractional_delay_re - a_im; VAR_10[VAR_16][VAR_17][VAR_18+5][0] += ag[VAR_17] * in_re; VAR_10[VAR_16][VAR_17][VAR_18+5][1] += ag[VAR_17] * in_im; } VAR_1[VAR_16][VAR_18][0] = VAR_5[b][VAR_18] * in_re; VAR_1[VAR_16][VAR_18][1] = VAR_5[b][VAR_18] * in_im; } } for (; VAR_16 < SHORT_DELAY_BAND[VAR_3]; VAR_16++) { memcpy(VAR_9[VAR_16], VAR_9[VAR_16]+VAR_20, PS_MAX_DELAY*sizeof(VAR_9[VAR_16][0])); memcpy(VAR_9[VAR_16]+PS_MAX_DELAY, VAR_2[VAR_16], numQMFSlots*sizeof(VAR_9[VAR_16][0])); for (VAR_18 = VAR_19; VAR_18 < VAR_20; VAR_18++) { VAR_1[VAR_16][VAR_18][0] = VAR_5[VAR_11[VAR_16]][VAR_18] * VAR_9[VAR_16][VAR_18+PS_MAX_DELAY-14][0]; VAR_1[VAR_16][VAR_18][1] = VAR_5[VAR_11[VAR_16]][VAR_18] * VAR_9[VAR_16][VAR_18+PS_MAX_DELAY-14][1]; } } for (; VAR_16 < NR_BANDS[VAR_3]; VAR_16++) { memcpy(VAR_9[VAR_16], VAR_9[VAR_16]+VAR_20, PS_MAX_DELAY*sizeof(VAR_9[VAR_16][0])); memcpy(VAR_9[VAR_16]+PS_MAX_DELAY, VAR_2[VAR_16], numQMFSlots*sizeof(VAR_9[VAR_16][0])); for (VAR_18 = VAR_19; VAR_18 < VAR_20; VAR_18++) { VAR_1[VAR_16][VAR_18][0] = VAR_5[VAR_11[VAR_16]][VAR_18] * VAR_9[VAR_16][VAR_18+PS_MAX_DELAY-1][0]; VAR_1[VAR_16][VAR_18][1] = VAR_5[VAR_11[VAR_16]][VAR_18] * VAR_9[VAR_16][VAR_18+PS_MAX_DELAY-1][1]; } } }