/******************************************************************************

 *                                                                            *

 * 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 "ixheaac_type_def.h"

#include "ixheaacd_bitbuffer.h"

#include "ixheaacd_common_rom.h"

#include "ixheaacd_sbrdecsettings.h"

#include "ixheaacd_sbr_scale.h"

#include "ixheaacd_env_extr_part.h"

#include "ixheaacd_sbr_rom.h"

#include "ixheaacd_hybrid.h"

#include "ixheaacd_ps_dec.h"

#include "ixheaacd_config.h"

#include "ixheaacd_qmf_dec.h"

#include "ixheaacd_mps_polyphase.h"

#include "ixheaacd_mps_struct_def.h"

#include "ixheaacd_mps_res_rom.h"

#include "ixheaacd_mps_aac_struct.h"

#include "ixheaac_constants.h"

#include "ixheaac_basic_ops32.h"

#include "ixheaac_basic_ops40.h"

#include "ixheaacd_mps_dec.h"

#include "ixheaac_error_standards.h"

#include "ixheaacd_error_codes.h"

#include "ixheaacd_mps_macro_def.h"

#include "ixheaacd_mps_smoothing.h"

#include "ixheaacd_mps_tonality.h"

#ifndef MULT

#define MULT(a, b) (a * b)

#endif

#define ONE_BY_128_IN_Q30 (8388608)

#define ONE_IN_Q30 (1073741824)

#define PI_IN_Q27 (421657440)

#define FIFTY_X_PI_BY_180_Q27 (117127067)

#define TWENTY_FIVE_X_PI_BY_180_Q27 (58563533)

#define Q28_VALUE (1 << 28)

#define Q28_FLOAT_VAL ((FLOAT32)(1 << 28))

#define ONE_BY_Q28_FLOAT_VAL (1.0f / Q28_FLOAT_VAL)

VOID ixheaacd_mps_pre_matrix_mix_matrix_smoothing(

    ia_mps_dec_state_struct *self) {

  WORD32 smooth_band;

  FLOAT32 delta, one_minus_delta;

  WORD32 ps = 0, pb, row, col;

  WORD32 res_bands = 0;

  WORD32 *p_smoothing_data;

  if (self->residual_coding) res_bands = self->max_res_bands;

  p_smoothing_data = &self->smoothing_data[ps][res_bands];

  delta = self->param_slot_diff[ps] * self->inv_smoothing_time[ps];

  one_minus_delta = 1.0f - delta;

  for (pb = res_bands; pb < self->bs_param_bands; pb++) {

    smooth_band = *p_smoothing_data++;

    if (smooth_band) {

      for (row = 0; row < MAX_M_OUTPUT; row++) {

        for (col = 0; col < MAX_M_INPUT; col++) {

          self->m1_param_re[ps][pb][row][col] =

              (MULT(delta, self->m1_param_re[ps][pb][row][col]) +

               MULT(one_minus_delta, self->m1_param_re_prev[pb][row][col]));

          self->m1_param_im[ps][pb][row][col] =

              (MULT(delta, self->m1_param_im[ps][pb][row][col]) +

               MULT(one_minus_delta, self->m1_param_im_prev[pb][row][col]));

          self->m2_decor_re[ps][pb][row][col] =

              (MULT(delta, self->m2_decor_re[ps][pb][row][col]) +

               MULT(one_minus_delta, self->m2_decor_re_prev[pb][row][col]));

          self->m2_decor_im[ps][pb][row][col] =

              (MULT(delta, self->m2_decor_im[ps][pb][row][col]) +

               MULT(one_minus_delta, self->m2_decor_im_prev[pb][row][col]));

          self->m2_resid_re[ps][pb][row][col] =

              (MULT(delta, self->m2_resid_re[ps][pb][row][col]) +

               MULT(one_minus_delta, self->m2_resid_re_prev[pb][row][col]));

          self->m2_resid_im[ps][pb][row][col] =

              (MULT(delta, self->m2_resid_im[ps][pb][row][col]) +

               MULT(one_minus_delta, self->m2_resid_im_prev[pb][row][col]));

        }

      }

      self->pre_mix_req++;

    }

  }

  for (ps = 1; ps < self->num_parameter_sets; ps++) {

    delta = self->param_slot_diff[ps] * self->inv_smoothing_time[ps];

    one_minus_delta = 1.0f - delta;

    p_smoothing_data = &self->smoothing_data[ps][res_bands];

    for (pb = res_bands; pb < self->bs_param_bands; pb++) {

      smooth_band = *p_smoothing_data++;

      if (smooth_band) {

        for (row = 0; row < MAX_M_OUTPUT; row++) {

          for (col = 0; col < MAX_M_INPUT; col++) {

            self->m1_param_re[ps][pb][row][col] =

                (MULT(delta, self->m1_param_re[ps][pb][row][col]) +

                 MULT(one_minus_delta,

                      self->m1_param_re[ps - 1][pb][row][col]));

            self->m1_param_im[ps][pb][row][col] =

                (MULT(delta, self->m1_param_im[ps][pb][row][col]) +

                 MULT(one_minus_delta,

                      self->m1_param_im[ps - 1][pb][row][col]));

            self->m2_resid_re[ps][pb][row][col] =

                (MULT(delta, self->m2_resid_re[ps][pb][row][col]) +

                 MULT(one_minus_delta,

                      self->m2_resid_re[ps - 1][pb][row][col]));

            self->m2_decor_re[ps][pb][row][col] =

                (MULT(delta, self->m2_decor_re[ps][pb][row][col]) +

                 MULT(one_minus_delta,

                      self->m2_decor_re[ps - 1][pb][row][col]));

            self->m2_decor_im[ps][pb][row][col] =

                (MULT(delta, self->m2_decor_im[ps][pb][row][col]) +

                 MULT(one_minus_delta,

                      self->m2_decor_im[ps - 1][pb][row][col]));

            self->m2_resid_im[ps][pb][row][col] =

                (MULT(delta, self->m2_resid_im[ps][pb][row][col]) +

                 MULT(one_minus_delta,

                      self->m2_resid_im[ps - 1][pb][row][col]));

          }

        }

        self->pre_mix_req++;

      }

    }

  }

}

VOID ixheaacd_mps_smoothing_opd(ia_mps_dec_state_struct *self) {

  WORD32 ps, pb;

  WORD32 delta, one_minus_delta;

  if (self->opd_smoothing_mode == 0) {

    for (pb = 0; pb < self->bs_param_bands; pb++) {

      self->opd_smooth.smooth_l_phase[pb] =

          ((WORD32)(self->phase_l[self->num_parameter_sets - 1][pb] *

                    Q28_VALUE)) >>

          1;

      self->opd_smooth.smooth_r_phase[pb] =

          ((WORD32)(self->phase_r[self->num_parameter_sets - 1][pb] *

                    Q28_VALUE)) >>

          1;

    }

    return;

  }

  for (ps = 0; ps < self->num_parameter_sets; ps++) {

    WORD32 thr = self->bs_frame.ipd_data.bs_quant_coarse_xxx[ps]

                  ? FIFTY_X_PI_BY_180_Q27

                  : TWENTY_FIVE_X_PI_BY_180_Q27;

    delta = self->param_slot_diff[ps] * ONE_BY_128_IN_Q30;

    one_minus_delta = ONE_IN_Q30 - delta;

    for (pb = 0; pb < self->bs_param_bands; pb++) {

      WORD32 ltemp, rtemp, tmp;

      ltemp = ((WORD32)(self->phase_l[ps][pb] * Q28_FLOAT_VAL)) >> 1;

      rtemp = ((WORD32)(self->phase_r[ps][pb] * Q28_FLOAT_VAL)) >> 1;

      while (ltemp > self->opd_smooth.smooth_l_phase[pb] + PI_IN_Q27)

        ltemp -= 2 * PI_IN_Q27;

      while (ltemp < self->opd_smooth.smooth_l_phase[pb] - PI_IN_Q27)

        ltemp += 2 * PI_IN_Q27;

      while (rtemp > self->opd_smooth.smooth_r_phase[pb] + PI_IN_Q27)

        rtemp -= 2 * PI_IN_Q27;

      while (rtemp < self->opd_smooth.smooth_r_phase[pb] - PI_IN_Q27)

        rtemp += 2 * PI_IN_Q27;

      self->opd_smooth.smooth_l_phase[pb] =

          (ixheaac_mult32_shl(delta, ltemp) +

           ixheaac_mult32_shl(one_minus_delta,

                               self->opd_smooth.smooth_l_phase[pb]))

          << 1;

      self->opd_smooth.smooth_r_phase[pb] =

          (ixheaac_mult32_shl(delta, rtemp) +

           ixheaac_mult32_shl(one_minus_delta,

                               self->opd_smooth.smooth_r_phase[pb]))

          << 1;

      tmp = (ltemp - rtemp) - (self->opd_smooth.smooth_l_phase[pb] -

                               self->opd_smooth.smooth_r_phase[pb]);

      while (tmp > PI_IN_Q27) tmp -= 2 * PI_IN_Q27;

      while (tmp < -PI_IN_Q27) tmp += 2 * PI_IN_Q27;

      if (ixheaac_abs32(tmp) > thr) {

        self->opd_smooth.smooth_l_phase[pb] = ltemp;

        self->opd_smooth.smooth_r_phase[pb] = rtemp;

      }

      while (self->opd_smooth.smooth_l_phase[pb] > 2 * PI_IN_Q27)

        self->opd_smooth.smooth_l_phase[pb] -= 2 * PI_IN_Q27;

      while (self->opd_smooth.smooth_l_phase[pb] < 0)

        self->opd_smooth.smooth_l_phase[pb] += 2 * PI_IN_Q27;

      while (self->opd_smooth.smooth_r_phase[pb] > 2 * PI_IN_Q27)

        self->opd_smooth.smooth_r_phase[pb] -= 2 * PI_IN_Q27;

      while (self->opd_smooth.smooth_r_phase[pb] < 0)

        self->opd_smooth.smooth_r_phase[pb] += 2 * PI_IN_Q27;

      self->phase_l[ps][pb] =

          (self->opd_smooth.smooth_l_phase[pb] << 1) * ONE_BY_Q28_FLOAT_VAL;

      self->phase_r[ps][pb] =

          (self->opd_smooth.smooth_r_phase[pb] << 1) * ONE_BY_Q28_FLOAT_VAL;

    }

  }

}

static VOID ixheaacd_calc_filter_coeff(

    ia_heaac_mps_state_struct *pstr_mps_state, WORD32 ps, WORD32 *delta) {

  WORD32 d_slots;

  WORD32 *param_slot = pstr_mps_state->aux_struct->param_slot;

  WORD32 *smg_time = pstr_mps_state->aux_struct->smg_time;

  if (ps == 0)

    d_slots = param_slot[ps] + 1;

  else

    d_slots = param_slot[ps] - param_slot[ps - 1];

  if (pstr_mps_state->smooth_control) {

    switch (smg_time[ps]) {

      case SMG_TIME_64:

        *delta = d_slots << 9;

        break;

      case SMG_TIME_128:

        *delta = d_slots << 8;

        break;

      case SMG_TIME_256:

        *delta = d_slots << 7;

        break;

      case SMG_TIME_512:

        *delta = d_slots << 6;

        break;

      default:

        break;

    }

  } else {

    *delta = d_slots << 7;

  }

  return;

}

VOID ixheaacd_smooth_m1m2(ia_heaac_mps_state_struct *pstr_mps_state) {

  ia_heaac_mps_state_struct *curr_state = pstr_mps_state;

  ia_mps_persistent_mem *persistent_mem = &curr_state->mps_persistent_mem;

  ia_mps_dec_auxilary_struct *p_aux_struct = pstr_mps_state->aux_struct;

  ia_mps_dec_m2_param_struct *m2_param = p_aux_struct->m2_param;

  ia_mps_dec_m1_param_struct *m1_param = pstr_mps_state->array_struct->m1_param;

  WORD32 *m1_param_real_prev = persistent_mem->m1_param_real_prev;

  WORD32 *m2_decor_real_prev = persistent_mem->m2_decor_real_prev;

  WORD32 *m2_resid_real_prev = persistent_mem->m2_resid_real_prev;

  WORD32 num_parameter_bands = curr_state->num_parameter_bands;

  WORD32 num_direct_signals = curr_state->num_direct_signals;

  WORD32 num_decor_signals = curr_state->num_decor_signals;

  WORD32 m1_param_imag_present = curr_state->m1_param_imag_present;

  WORD32 m2_param_imag_present = curr_state->m2_param_imag_present;

  WORD32 col_counter = num_direct_signals + num_decor_signals;

  WORD32 num_parameter_sets = curr_state->num_parameter_sets;

  WORD32 num_output_channels = curr_state->num_output_channels;

  WORD32 num_v_channels = curr_state->num_v_channels;

  WORD32 num_x_channels = curr_state->num_x_channels;

  WORD32 smooth_control = curr_state->smooth_control;

  WORD32 smooth_config = curr_state->smooth_config;

  WORD32 resid_col_counter;

  WORD32 smooth_band_arr[MAX_PARAMETER_SETS][MAX_PARAMETER_BANDS];

  WORD32 *delta, *one_minus_delta, *delta_ptr, *one_minus_delta_ptr;

  WORD32 *param_r, *param_i, *param_prev_r, *param_prev_i;

  WORD32 *ton;

  WORD32 i, ps, pb, row, col;

  WORD32 res_bands = 0;

  WORD32 idx = 0;

  WORD32 *m2_decor_imag_prev = persistent_mem->m2_decor_imag_prev;

  WORD32 *m2_resid_imag_prev = persistent_mem->m2_resid_imag_prev;

  WORD32 *m1_param_imag_prev = persistent_mem->m1_param_imag_prev;

  ton = pstr_mps_state->mps_scratch_mem_v;

  delta = delta_ptr =

      ton + IXHEAAC_GET_SIZE_ALIGNED_TYPE(MAX_PARAMETER_BANDS, sizeof(*delta), BYTE_ALIGN_8);

  one_minus_delta = one_minus_delta_ptr =

      delta +

      IXHEAAC_GET_SIZE_ALIGNED_TYPE(MAX_PARAMETER_SETS, sizeof(*one_minus_delta), BYTE_ALIGN_8);

  param_r = curr_state->res_bands;

  if (curr_state->residual_coding) {

    for (i = 0; i < MAX_RESIDUAL_CHANNELS_MPS; i++) {

      if (param_r[i] > res_bands) {

        res_bands = param_r[i];

      }

    }

  }

  if (curr_state->arbitrary_downmix == 2) {

    if (res_bands < curr_state->arbdmx_residual_bands) {

      res_bands = curr_state->arbdmx_residual_bands;

    }

  }

  if (smooth_config) {

    ixheaacd_measure_tonality(pstr_mps_state, ton);

  }

  for (ps = 0; ps < num_parameter_sets; ps++) {

    ixheaacd_calc_filter_coeff(pstr_mps_state, ps, delta);

    *one_minus_delta++ = (1 << 15) - *delta++;

  }

  if (smooth_control) {

    for (ps = 0; ps < num_parameter_sets; ps++) {

      if (ps < 8) {

        for (pb = 0; pb < num_parameter_bands; pb++) {

          smooth_band_arr[ps][pb] = pstr_mps_state->aux_struct->smg_data[ps][pb];

        }

      }

    }

  } else if (smooth_config) {

    for (ps = 0; ps < num_parameter_sets; ps++) {

      for (pb = 0; pb < num_parameter_bands; pb++) {

        smooth_band_arr[ps][pb] = (ton[pb] > POINT_EIGHT_Q15);

      }

    }

  }

  if (!(smooth_control == 0 && smooth_config == 0)) {

    if (m1_param_imag_present) {

      WORD32 *ptr_r1 = &m1_param->m1_param_real[0][0][0][0];

      WORD32 *ptr_i1 = &m1_param->m1_param_imag[0][0][0][0];

      for (row = 0; row < num_v_channels; row++) {

        WORD32 *ptr_r2 = ptr_r1;

        WORD32 *ptr_i2 = ptr_i1;

        for (col = 0; col < num_x_channels; col++) {

          param_r = ptr_r2;

          param_i = ptr_i2;

          m1_param_real_prev += res_bands;

          m1_param_imag_prev += res_bands;

          for (pb = res_bands; pb < num_parameter_bands; pb++) {

            if (smooth_band_arr[0][pb]) {

              WORD64 acc;

              acc = (WORD64)((WORD64)param_r[pb] * (WORD64)(*delta_ptr) +

                             (WORD64)(*m1_param_real_prev) *

                                 (WORD64)(*one_minus_delta_ptr));

              acc >>= 15;

              param_r[pb] = (WORD32)acc;

              acc = (WORD64)((WORD64)param_i[pb] * (WORD64)(*delta_ptr) +

                             (WORD64)(*m1_param_imag_prev) *

                                 (WORD64)(*one_minus_delta_ptr));

              acc >>= 15;

              param_i[pb] = (WORD32)acc;

            }

            m1_param_real_prev++;

            m1_param_imag_prev++;

          }

          param_r += MAX_PARAMETER_BANDS;

          param_i += MAX_PARAMETER_BANDS;

          for (ps = 1; ps < num_parameter_sets; ps++) {

            WORD32 del = delta_ptr[ps];

            WORD32 one_minus_del = one_minus_delta_ptr[ps];

            param_prev_r = param_r - MAX_PARAMETER_BANDS;

            param_prev_i = param_i - MAX_PARAMETER_BANDS;

            for (pb = res_bands; pb < num_parameter_bands; pb++) {

              if (smooth_band_arr[ps][pb]) {

                WORD64 acc;

                acc = (WORD64)((WORD64)param_r[pb] * (WORD64)(del) +

                               (WORD64)param_prev_r[pb] *

                                   (WORD64)(one_minus_del));

                acc >>= 15;

                param_r[pb] = (WORD32)acc;

                acc = (WORD64)((WORD64)param_i[pb] * (WORD64)(del) +

                               (WORD64)param_prev_i[pb] *

                                   (WORD64)(one_minus_del));

                acc >>= 15;

                param_i[pb] = (WORD32)acc;

              }

            }

            param_r += MAX_PARAMETER_BANDS;

            param_i += MAX_PARAMETER_BANDS;

          }

          ptr_r2 += PBXPS;

          ptr_i2 += PBXPS;

        }

        ptr_r1 += INCHXPBXPS;

        ptr_i1 += INCHXPBXPS;

      }

    } else {

      WORD32 *ptr1 = (WORD32 *)m1_param;

      for (row = 0; row < num_v_channels; row++) {

        WORD32 *ptr2 = ptr1;

        for (col = 0; col < num_x_channels; col++) {

          WORD32 *param_r = ptr2;

          WORD32 del = delta_ptr[0];

          WORD32 one_minus_del = one_minus_delta_ptr[0];

          m1_param_real_prev += res_bands;

          for (pb = res_bands; pb < num_parameter_bands; pb++) {

            if (smooth_band_arr[0][pb]) {

              WORD64 acc;

              acc = (WORD64)((WORD64)(param_r[pb]) * (WORD64)(del)) +

                    (WORD64)((WORD64)(*m1_param_real_prev) *

                             (WORD64)(one_minus_del));

              param_r[pb] = (WORD32)(acc >> 15);

            }

            m1_param_real_prev++;

          }

          param_r += MAX_PARAMETER_BANDS;

          for (ps = 1; ps < num_parameter_sets; ps++) {

            WORD32 del = delta_ptr[ps];

            WORD32 one_minus_del = one_minus_delta_ptr[ps];

            param_prev_r = param_r - MAX_PARAMETER_BANDS;

            for (pb = res_bands; pb < num_parameter_bands; pb++) {

              if (smooth_band_arr[ps][pb]) {

                WORD64 acc;

                acc = (WORD64)((WORD64)(param_r[pb]) * (WORD64)del) +

                      (WORD64)((WORD64)(param_prev_r[pb]) *

                               (WORD64)one_minus_del);

                param_r[pb] = (WORD32)(acc >> 15);

              }

            }

            param_r += MAX_PARAMETER_BANDS;

          }

          ptr2 += PBXPS;

        }

        ptr1 += INCHXPBXPS;

      }

    }

    if (curr_state->residual_coding)

      resid_col_counter = col_counter;

    else

      resid_col_counter = num_direct_signals;

    idx = 0;

    if (m2_param_imag_present) {

      WORD32 *ptr_r1 = &m2_param->m2_resid_real[0][0][0];

      WORD32 *ptr_i1 = &m2_param->m2_resid_imag[0][0][0];

      for (row = 0; row < num_output_channels; row++) {

        for (col = 0; col < resid_col_counter; col++) {

          if (curr_state->m2_param_present[row][col] & 2) {

            WORD32 del = *delta_ptr;

            WORD32 one_minus_del = *one_minus_delta_ptr;

            param_r = ptr_r1;

            param_i = ptr_i1;

            m2_resid_real_prev += res_bands;

            m2_resid_imag_prev += res_bands;

            for (pb = res_bands; pb < num_parameter_bands; pb++) {

              if (smooth_band_arr[0][pb]) {

                WORD64 acc;

                acc = (WORD64)((WORD64)(param_r[pb]) * (WORD64)(del) +

                               (WORD64)(*m2_resid_real_prev) *

                                   (WORD64)(one_minus_del));

                acc >>= 15;

                param_r[pb] = (WORD32)acc;

                acc = (WORD64)((WORD64)(param_i[pb]) * (WORD64)(del) +

                               (WORD64)(*m2_resid_imag_prev) *

                                   (WORD64)(one_minus_del));

                acc >>= 15;

                param_i[pb] = (WORD32)acc;

              }

              m2_resid_real_prev++;

              m2_resid_imag_prev++;

            }

            param_r += MAX_PARAMETER_BANDS;

            param_i += MAX_PARAMETER_BANDS;

            for (ps = 1; ps < num_parameter_sets; ps++) {

              WORD32 del = delta_ptr[ps];

              WORD32 one_minus_del = one_minus_delta_ptr[ps];

              param_prev_r = param_r - MAX_PARAMETER_BANDS;

              param_prev_i = param_i - MAX_PARAMETER_BANDS;

              for (pb = res_bands; pb < num_parameter_bands; pb++) {

                if (smooth_band_arr[ps][pb]) {

                  WORD64 acc;

                  acc = (WORD64)((WORD64)(param_r[pb]) * (WORD64)(del) +

                                 (WORD64)(param_prev_r[pb]) *

                                     (WORD64)(one_minus_del));

                  acc >>= 15;

                  param_r[pb] = (WORD32)acc;

                  acc = (WORD64)((WORD64)(param_i[pb]) * (WORD64)(del) +

                                 (WORD64)(param_prev_i[pb]) *

                                     (WORD64)(one_minus_del));

                  acc >>= 15;

                  param_i[pb] = (WORD32)acc;

                }

              }

              param_r += MAX_PARAMETER_BANDS;

              param_i += MAX_PARAMETER_BANDS;

            }

            idx++;

            ptr_r1 += PBXPS;

            ptr_i1 += PBXPS;

          }

        }

      }

      idx = 0;

      ptr_r1 = &m2_param->m2_resid_real[0][0][0];

      ptr_i1 = &m2_param->m2_resid_imag[0][0][0];

      for (row = 0; row < num_output_channels; row++) {

        for (col = num_direct_signals; col < col_counter; col++) {

          if (curr_state->m2_param_present[row][col] & 1) {

            WORD32 del = *delta_ptr;

            WORD32 one_minus_del = *one_minus_delta_ptr;

            m2_decor_real_prev += res_bands;

            m2_decor_imag_prev += res_bands;

            param_r = ptr_r1;

            param_i = ptr_i1;

            for (pb = res_bands; pb < num_parameter_bands; pb++) {

              if (smooth_band_arr[0][pb]) {

                WORD64 acc;

                acc = (WORD64)((WORD64)(param_r[pb]) * (WORD64)del +

                               (WORD64)(*m2_decor_real_prev) *

                                   (WORD64)one_minus_del);

                acc >>= 15;

                param_r[pb] = (WORD32)acc;

                acc = (WORD64)((WORD64)(param_i[pb]) * (WORD64)del +

                               (WORD64)(*m2_decor_imag_prev) *

                                   (WORD64)one_minus_del);

                acc >>= 15;

                param_i[pb] = (WORD32)acc;

              }

              m2_decor_real_prev++;

              m2_decor_imag_prev++;

            }

            param_r += MAX_PARAMETER_BANDS;

            param_i += MAX_PARAMETER_BANDS;

            for (ps = 1; ps < num_parameter_sets; ps++) {

              WORD32 del = delta_ptr[ps];

              WORD32 one_minus_del = one_minus_delta_ptr[ps];

              param_prev_r = param_r - MAX_PARAMETER_BANDS;

              param_prev_i = param_i - MAX_PARAMETER_BANDS;

              for (pb = res_bands; pb < num_parameter_bands; pb++) {

                if (smooth_band_arr[ps][pb]) {

                  WORD64 acc;

                  acc = (WORD64)((WORD64)(param_r[pb]) * (WORD64)del +

                                 (WORD64)(param_prev_r[pb]) *

                                     (WORD64)one_minus_del);

                  acc >>= 15;

                  param_r[pb] = (WORD32)acc;

                  acc = (WORD64)((WORD64)(param_i[pb]) * (WORD64)del +

                                 (WORD64)(param_prev_i[pb]) *

                                     (WORD64)one_minus_del);

                  acc >>= 15;

                  param_i[pb] = (WORD32)acc;

                }

              }

              param_r += MAX_PARAMETER_BANDS;

              param_i += MAX_PARAMETER_BANDS;

            }

            idx++;

            ptr_r1 += PBXPS;

            ptr_i1 += PBXPS;

          }

        }

      }

    } else {

      WORD32 *ptr1 = &m2_param->m2_resid_real[0][0][0];

      for (row = 0; row < num_output_channels; row++) {

        for (col = 0; col < resid_col_counter; col++) {

          if (curr_state->m2_param_present[row][col] & 2) {

            WORD32 *ptr2 = ptr1;

            WORD32 del = *delta_ptr;

            WORD32 one_minus_del = *one_minus_delta_ptr;

            m2_resid_real_prev += res_bands;

            for (pb = res_bands; pb < num_parameter_bands; pb++) {

              if (smooth_band_arr[0][pb]) {

                WORD64 acc;

                acc = (WORD64)((WORD64)(ptr2[pb]) * (WORD64)(del) +

                               (WORD64)(*m2_resid_real_prev) *

                                   (WORD64)(one_minus_del));

                acc >>= 15;

                ptr2[pb] = (WORD32)acc;

              }

              m2_resid_real_prev++;

            }

            ptr2 += MAX_PARAMETER_BANDS;

            for (ps = 1; ps < num_parameter_sets; ps++) {

              WORD32 del = delta_ptr[ps];

              WORD32 one_minus_del = one_minus_delta_ptr[ps];

              param_prev_r = ptr2 - MAX_PARAMETER_BANDS;

              for (pb = res_bands; pb < num_parameter_bands; pb++) {

                if (smooth_band_arr[ps][pb]) {

                  WORD64 acc;

                  acc = (WORD64)((WORD64)(ptr2[pb]) * (WORD64)(del) +

                                 (WORD64)(*param_prev_r) *

                                     (WORD64)(one_minus_del));

                  acc >>= 15;

                  ptr2[pb] = (WORD32)acc;

                }

                param_prev_r++;

              }

              ptr2 += MAX_PARAMETER_BANDS;

            }

            idx++;

            ptr1 += PBXPS;

          }

        }

      }

      idx = 0;

      ptr1 = &m2_param->m2_decor_real[0][0][0];

      for (row = 0; row < num_output_channels; row++) {

        for (col = num_direct_signals; col < col_counter; col++) {

          if (curr_state->m2_param_present[row][col] & 1) {

            WORD32 *ptr2 = ptr1;

            m2_decor_real_prev += res_bands;

            param_r = &m2_param->m2_decor_real[idx][0][res_bands];

            for (pb = res_bands; pb < num_parameter_bands; pb++) {

              if (smooth_band_arr[0][pb]) {

                WORD64 acc;

                acc = (WORD64)((WORD64)(ptr2[pb]) * (WORD64)*delta_ptr +

                               (WORD64)(*m2_decor_real_prev) *

                                   (WORD64)*one_minus_delta_ptr);

                acc >>= 15;

                ptr2[pb] = (WORD32)acc;

              }

              m2_decor_real_prev++;

            }

            ptr2 += MAX_PARAMETER_BANDS;

            for (ps = 1; ps < num_parameter_sets; ps++) {

              WORD32 del = delta_ptr[ps];

              WORD32 one_minus_del = one_minus_delta_ptr[ps];

              param_prev_r = ptr2 - MAX_PARAMETER_BANDS;

              for (pb = res_bands; pb < num_parameter_bands; pb++) {

                if (smooth_band_arr[ps][pb]) {

                  WORD64 acc;

                  acc =

                      (WORD64)((WORD64)(ptr2[pb]) * (WORD64)del +

                               (WORD64)(*param_prev_r) * (WORD64)one_minus_del);

                  acc >>= 15;

                  ptr2[pb] = (WORD32)acc;

                }

                param_prev_r++;

              }

              ptr2 += MAX_PARAMETER_BANDS;

            }

            idx++;

            ptr1 += PBXPS;

          }

        }

      }

    }

  }

  return;

}