decoder/ixheaacd_mps_apply_m2.c - platform/external/libxaac - Git at Google

 /******************************************************************************
  *
  * Copyright (C) 2023 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 <string.h>
 #include "ixheaac_type_def.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_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_mps_polyphase.h"
 #include "ixheaacd_config.h"
 #include "ixheaacd_qmf_dec.h"
 #include "ixheaacd_mps_dec.h"
 #include "ixheaacd_mps_macro_def.h"
 #include "ixheaacd_mps_apply_common.h"
 #include "ixheaacd_mps_basic_op.h"
 #include "ixheaacd_mps_get_index.h"

 VOID ixheaacd_apply_m2(ia_heaac_mps_state_struct *pstr_mps_state) {
   WORD32 ts, qs, row, col;
   ia_heaac_mps_state_struct *curr_state = pstr_mps_state;
   ia_mps_persistent_mem *persistent_mem = &curr_state->mps_persistent_mem;
   ia_mps_dec_reuse_array_struct *p_array_struct = pstr_mps_state->array_struct;
   ia_mps_dec_m2_param_struct *p_m2_param = pstr_mps_state->aux_struct->m2_param;

   WORD32 num_direct_signals = curr_state->num_direct_signals;
   WORD32 temp_1, loop_counter, col_counter = num_direct_signals + curr_state->num_decor_signals;

   WORD32 *rout_ptr, *rout_kernel_ptr;

   WORD32 *hyb_output_real_dry, *hyb_output_imag_dry, *hyb_output_real_wet, *hyb_output_imag_wet;

   WORD32 *p_hyb_out_dry_real, *p_hyb_out_dry_imag, *p_hyb_out_dry_re, *p_hyb_out_dry_im;

   WORD32 *w_wet_real, *w_wet_imag, *w_dry_real, *w_dry_imag;

   WORD32 *m2_decor_real_prev = persistent_mem->m2_decor_real_prev;
   WORD32 *m2_decor_imag_prev = persistent_mem->m2_decor_imag_prev;

   WORD32 *p_buffer_real, *p_buffer_imag, *p_buffer_re, *p_buffer_im;
   WORD32 *p_buf_real, *p_buf_imag, *p_buf_re, *p_buf_im;

   WORD32 *m2_resid_real_prev = persistent_mem->m2_resid_real_prev;
   WORD32 *m2_resid_imag_prev = persistent_mem->m2_resid_imag_prev;

   WORD32 idx = 0;
   WORD32 w_wet_offset = num_direct_signals * TSXHB;

   WORD32 num_output_channels = curr_state->num_output_channels;
   WORD32 time_slots = curr_state->time_slots;
   WORD32 hybrid_bands = curr_state->hybrid_bands;
   WORD32 m2_param_imag_present = curr_state->m2_param_imag_present;
   WORD32 num_parameter_bands = curr_state->num_parameter_bands;
   WORD32 up_mix_type = curr_state->up_mix_type;
   WORD32 residual_coding = curr_state->residual_coding;
   WORD32 *index_ptr = curr_state->index;

   SIZE_T params[4];

   params[0] = (SIZE_T)(&curr_state->kernels[0]);
   params[1] = time_slots;
   params[2] = num_parameter_bands;
   params[3] = hybrid_bands;

   rout_ptr = pstr_mps_state->mps_scratch_mem_v;
   rout_kernel_ptr =
       rout_ptr + IXHEAAC_GET_SIZE_ALIGNED_TYPE(TSXHB, sizeof(*rout_kernel_ptr), BYTE_ALIGN_8);

   p_hyb_out_dry_real = p_array_struct->hyb_output_real_dry;
   p_hyb_out_dry_imag = p_array_struct->hyb_output_imag_dry;

   for (row = 0; row < num_output_channels; row++) {
     hyb_output_real_dry = p_hyb_out_dry_real;
     hyb_output_imag_dry = p_hyb_out_dry_imag;

     for (ts = 0; ts < time_slots; ts++) {
       memset(hyb_output_real_dry, 0, (hybrid_bands) * sizeof(hyb_output_real_dry[0]));
       memset(hyb_output_imag_dry, 0, (hybrid_bands) * sizeof(hyb_output_imag_dry[0]));

       hyb_output_real_dry += MAX_HYBRID_BANDS;
       hyb_output_imag_dry += MAX_HYBRID_BANDS;
     }

     p_hyb_out_dry_real += TSXHB;
     p_hyb_out_dry_imag += TSXHB;
   }

   if (residual_coding)
     loop_counter = col_counter;
   else
     loop_counter = num_direct_signals;

   idx = 0;

   p_hyb_out_dry_real = p_array_struct->hyb_output_real_dry;
   p_hyb_out_dry_imag = p_array_struct->hyb_output_imag_dry;

   for (row = 0; row < num_output_channels; row++) {
     p_buffer_real = p_array_struct->buf_real;
     p_buffer_imag = p_array_struct->buf_imag;

     for (col = 0; col < num_direct_signals; col++) {
       p_buffer_re = p_buffer_real;
       p_buffer_im = p_buffer_imag;

       if (curr_state->m2_param_present[row][col] & 2) {
         ixheaacd_dec_interp_umx(p_m2_param->m2_resid_real[idx++], rout_ptr, m2_resid_real_prev,
                                 pstr_mps_state);
         ixheaacd_apply_abs_kernels(rout_ptr, rout_kernel_ptr, params);

         p_hyb_out_dry_re = p_hyb_out_dry_real;
         p_hyb_out_dry_im = p_hyb_out_dry_imag;

         for (ts = 0; ts < time_slots; ts++) {
           hyb_output_real_dry = p_hyb_out_dry_re;
           hyb_output_imag_dry = p_hyb_out_dry_im;

           w_dry_real = p_buffer_re;
           w_dry_imag = p_buffer_im;

           for (qs = 0; qs < hybrid_bands; qs++) {
             temp_1 = ixheaacd_mps_mult32_shr_15(*w_dry_real, *rout_kernel_ptr);
             w_dry_real++;
             *hyb_output_real_dry = *hyb_output_real_dry + temp_1;
             hyb_output_real_dry++;

             temp_1 = ixheaacd_mps_mult32_shr_15(*w_dry_imag, *rout_kernel_ptr);
             w_dry_imag++;
             rout_kernel_ptr++;
             *hyb_output_imag_dry = *hyb_output_imag_dry + temp_1;
             hyb_output_imag_dry++;
           }
           p_buffer_re += MAX_HYBRID_BANDS;
           p_buffer_im += MAX_HYBRID_BANDS;

           p_hyb_out_dry_re += MAX_HYBRID_BANDS;
           p_hyb_out_dry_im += MAX_HYBRID_BANDS;
         }
         m2_resid_real_prev += num_parameter_bands;
       }
       p_buffer_real += TSXHB;
       p_buffer_imag += TSXHB;
     }

     for (; col < loop_counter; col++) {
       WORD32 index;
       WORD32 res = ixheaacd_get_res_idx(pstr_mps_state, col);
       index = index_ptr[res];

       if (curr_state->m2_param_present[row][col] & 2) {
         WORD32 *p_dry_real = p_array_struct->w_dry_real + res * TSXHB;
         WORD32 *p_dry_imag = p_array_struct->w_dry_imag + res * TSXHB;

         ixheaacd_dec_interp_umx(p_m2_param->m2_resid_real[idx++], rout_ptr, m2_resid_real_prev,
                                 pstr_mps_state);
         ixheaacd_apply_abs_kernels(rout_ptr, rout_kernel_ptr, params);

         p_hyb_out_dry_re = p_hyb_out_dry_real;
         p_hyb_out_dry_im = p_hyb_out_dry_imag;

         for (ts = 0; ts < time_slots; ts++) {
           hyb_output_real_dry = p_hyb_out_dry_re;
           hyb_output_imag_dry = p_hyb_out_dry_im;

           w_dry_real = p_dry_real;
           w_dry_imag = p_dry_imag;

           for (qs = 0; qs < index; qs++) {
             temp_1 = ixheaacd_mps_mult32_shr_15(*w_dry_real, *rout_kernel_ptr);
             w_dry_real++;
             *hyb_output_real_dry = *hyb_output_real_dry + temp_1;
             hyb_output_real_dry++;

             temp_1 = ixheaacd_mps_mult32_shr_15(*w_dry_imag, *rout_kernel_ptr);
             w_dry_imag++;
             rout_kernel_ptr++;
             *hyb_output_imag_dry = *hyb_output_imag_dry + temp_1;
             hyb_output_imag_dry++;
           }
           rout_kernel_ptr += hybrid_bands - index;

           p_hyb_out_dry_re += MAX_HYBRID_BANDS;
           p_hyb_out_dry_im += MAX_HYBRID_BANDS;

           p_dry_real += MAX_HYBRID_BANDS;
           p_dry_imag += MAX_HYBRID_BANDS;
         }
         m2_resid_real_prev += num_parameter_bands;
       }
     }

     p_hyb_out_dry_real += TSXHB;
     p_hyb_out_dry_imag += TSXHB;
   }

   if (up_mix_type == 2) {
     if (m2_param_imag_present) {
       if (residual_coding)
         loop_counter = col_counter;
       else
         loop_counter = num_direct_signals;

       idx = 0;

       p_hyb_out_dry_real = p_array_struct->hyb_output_real_dry;
       p_hyb_out_dry_imag = p_array_struct->hyb_output_imag_dry;

       for (row = 0; row < num_output_channels; row++) {
         p_buffer_real = p_array_struct->buf_real;
         p_buffer_imag = p_array_struct->buf_imag;

         for (col = 0; col < num_direct_signals; col++) {
           p_buffer_re = p_buffer_real;
           p_buffer_im = p_buffer_imag;

           if (curr_state->m2_param_present[row][col] & 2) {
             ixheaacd_dec_interp_umx(p_m2_param->m2_resid_imag[idx++], rout_ptr,
                                     m2_resid_imag_prev, pstr_mps_state);
             ixheaacd_apply_abs_kernels(rout_ptr, rout_kernel_ptr, params);

             p_hyb_out_dry_re = p_hyb_out_dry_real;
             p_hyb_out_dry_im = p_hyb_out_dry_imag;

             for (ts = 0; ts < time_slots; ts++) {
               hyb_output_real_dry = p_hyb_out_dry_re;
               hyb_output_imag_dry = p_hyb_out_dry_im;

               w_dry_real = p_buffer_re;
               w_dry_imag = p_buffer_im;

               for (qs = 0; qs < 2; qs++) {
                 temp_1 = ixheaacd_mps_mult32_shr_15(*w_dry_imag, *rout_kernel_ptr);
                 w_dry_imag++;
                 *hyb_output_real_dry = *hyb_output_real_dry + temp_1;
                 hyb_output_real_dry++;

                 temp_1 = ixheaacd_mps_mult32_shr_15(*w_dry_real, *rout_kernel_ptr);
                 w_dry_real++;
                 rout_kernel_ptr++;
                 *hyb_output_imag_dry = *hyb_output_imag_dry - temp_1;
                 hyb_output_imag_dry++;
               }

               for (; qs < hybrid_bands; qs++) {
                 temp_1 = ixheaacd_mps_mult32_shr_15(*w_dry_imag, *rout_kernel_ptr);
                 w_dry_imag++;
                 *hyb_output_real_dry = *hyb_output_real_dry - temp_1;
                 hyb_output_real_dry++;

                 temp_1 = ixheaacd_mps_mult32_shr_15(*w_dry_real, *rout_kernel_ptr);
                 w_dry_real++;
                 rout_kernel_ptr++;
                 *hyb_output_imag_dry = *hyb_output_imag_dry + temp_1;
                 hyb_output_imag_dry++;
               }
               p_buffer_re += MAX_HYBRID_BANDS;
               p_buffer_im += MAX_HYBRID_BANDS;

               p_hyb_out_dry_re += MAX_HYBRID_BANDS;
               p_hyb_out_dry_im += MAX_HYBRID_BANDS;
             }
             m2_resid_imag_prev += num_parameter_bands;
           }
           p_buffer_real += TSXHB;
           p_buffer_imag += TSXHB;
         }

         for (; col < loop_counter; col++) {
           WORD32 index;
           WORD32 res = ixheaacd_get_res_idx(pstr_mps_state, col);
           index = index_ptr[res];

           if (curr_state->m2_param_present[row][col] & 2) {
             WORD32 *p_dry_real = p_array_struct->w_dry_real + res * TSXHB;
             WORD32 *p_dry_imag = p_array_struct->w_dry_imag + res * TSXHB;
             ixheaacd_dec_interp_umx(p_m2_param->m2_resid_imag[idx++], rout_ptr,
                                     m2_resid_imag_prev, pstr_mps_state);
             ixheaacd_apply_abs_kernels(rout_ptr, rout_kernel_ptr, params);

             p_hyb_out_dry_re = p_hyb_out_dry_real;
             p_hyb_out_dry_im = p_hyb_out_dry_imag;

             for (ts = 0; ts < time_slots; ts++) {
               hyb_output_real_dry = p_hyb_out_dry_re;
               hyb_output_imag_dry = p_hyb_out_dry_im;

               w_dry_real = p_dry_real;
               w_dry_imag = p_dry_imag;

               for (qs = 0; qs < 2; qs++) {
                 temp_1 = ixheaacd_mps_mult32_shr_15(*w_dry_imag, *rout_kernel_ptr);
                 w_dry_imag++;
                 *hyb_output_real_dry = *hyb_output_real_dry + temp_1;
                 hyb_output_real_dry++;

                 temp_1 = ixheaacd_mps_mult32_shr_15(*w_dry_real, *rout_kernel_ptr);
                 w_dry_real++;
                 rout_kernel_ptr++;
                 *hyb_output_imag_dry = *hyb_output_imag_dry - temp_1;
                 hyb_output_imag_dry++;
               }

               for (; qs < index; qs++) {
                 temp_1 = ixheaacd_mps_mult32_shr_15(*w_dry_imag, *rout_kernel_ptr);
                 w_dry_imag++;
                 *hyb_output_real_dry = *hyb_output_real_dry - temp_1;
                 hyb_output_real_dry++;

                 temp_1 = ixheaacd_mps_mult32_shr_15(*w_dry_real, *rout_kernel_ptr);
                 w_dry_real++;
                 rout_kernel_ptr++;
                 *hyb_output_imag_dry = *hyb_output_imag_dry + temp_1;
                 hyb_output_imag_dry++;
               }
               rout_kernel_ptr += hybrid_bands - index;

               p_hyb_out_dry_re += MAX_HYBRID_BANDS;
               p_hyb_out_dry_im += MAX_HYBRID_BANDS;

               p_dry_real += MAX_HYBRID_BANDS;
               p_dry_imag += MAX_HYBRID_BANDS;
             }
             m2_resid_imag_prev += num_parameter_bands;
           }
         }
         p_hyb_out_dry_real += TSXHB;
         p_hyb_out_dry_imag += TSXHB;
       }
     }
   }
   p_buffer_real = p_array_struct->buf_real;
   p_buffer_imag = p_array_struct->buf_imag;

   for (row = 0; row < num_output_channels; row++) {
     hyb_output_real_wet = p_buffer_real;
     hyb_output_imag_wet = p_buffer_imag;

     for (ts = 0; ts < time_slots; ts++) {
       memset(hyb_output_real_wet, 0, (hybrid_bands) * sizeof(*hyb_output_real_wet));
       memset(hyb_output_imag_wet, 0, (hybrid_bands) * sizeof(*hyb_output_imag_wet));

       hyb_output_real_wet += MAX_HYBRID_BANDS;
       hyb_output_imag_wet += MAX_HYBRID_BANDS;
     }
     p_buffer_real += TSXHB;
     p_buffer_imag += TSXHB;
   }
   idx = 0;

   p_buffer_real = p_array_struct->buf_real;
   p_buffer_imag = p_array_struct->buf_imag;

   for (row = 0; row < num_output_channels; row++) {
     p_buf_real = p_array_struct->buffer_real + w_wet_offset;
     p_buf_imag = p_array_struct->buffer_imag + w_wet_offset;
     for (col = num_direct_signals; col < col_counter; col++) {
       if (curr_state->m2_param_present[row][col] & 1) {
         ixheaacd_dec_interp_umx(p_m2_param->m2_decor_real[idx++], rout_ptr, m2_decor_real_prev,
                                 pstr_mps_state);

         ixheaacd_apply_abs_kernels(rout_ptr, rout_kernel_ptr, params);
         p_buffer_re = p_buffer_real;
         p_buffer_im = p_buffer_imag;

         p_buf_re = p_buf_real;
         p_buf_im = p_buf_imag;
         for (ts = 0; ts < time_slots; ts++) {
           hyb_output_real_wet = p_buffer_re;
           hyb_output_imag_wet = p_buffer_im;

           w_wet_real = p_buf_re;
           w_wet_imag = p_buf_im;

           for (qs = 0; qs < hybrid_bands; qs++) {
             temp_1 = ixheaacd_mps_mult32_shr_15(*w_wet_real, *rout_kernel_ptr);
             w_wet_real++;
             *hyb_output_real_wet = *hyb_output_real_wet + temp_1;
             hyb_output_real_wet++;

             temp_1 = ixheaacd_mps_mult32_shr_15(*w_wet_imag, *rout_kernel_ptr);
             w_wet_imag++;
             rout_kernel_ptr++;
             *hyb_output_imag_wet = *hyb_output_imag_wet + temp_1;
             hyb_output_imag_wet++;
           }
           p_buffer_re += MAX_HYBRID_BANDS;
           p_buffer_im += MAX_HYBRID_BANDS;

           p_buf_re += MAX_HYBRID_BANDS;
           p_buf_im += MAX_HYBRID_BANDS;
         }
         m2_decor_real_prev += num_parameter_bands;
       }
       p_buf_real += TSXHB;
       p_buf_imag += TSXHB;
     }
     p_buffer_real += TSXHB;
     p_buffer_imag += TSXHB;
   }

   if (up_mix_type == 2) {
     if (m2_param_imag_present) {
       idx = 0;

       p_buffer_real = p_array_struct->buf_real;
       p_buffer_imag = p_array_struct->buf_imag;

       for (row = 0; row < num_output_channels; row++) {
         m2_decor_imag_prev += num_parameter_bands * num_direct_signals;
         p_buf_real = p_array_struct->buffer_real + w_wet_offset;
         p_buf_imag = p_array_struct->buffer_imag + w_wet_offset;
         for (col = num_direct_signals; col < col_counter; col++) {
           if (curr_state->m2_param_present[row][col] & 1) {
             ixheaacd_dec_interp_umx(p_m2_param->m2_decor_imag[idx++], rout_ptr,
                                     m2_decor_imag_prev, pstr_mps_state);
             ixheaacd_apply_abs_kernels(rout_ptr, rout_kernel_ptr, params);

             p_buffer_re = p_buffer_real;
             p_buffer_im = p_buffer_imag;

             p_buf_re = p_buf_real;
             p_buf_im = p_buf_imag;
             for (ts = 0; ts < time_slots; ts++) {
               hyb_output_real_wet = p_buffer_re;
               hyb_output_imag_wet = p_buffer_im;

               w_wet_real = p_buf_re;
               w_wet_imag = p_buf_im;

               for (qs = 0; qs < 2; qs++) {
                 temp_1 = ixheaacd_mps_mult32_shr_15(*w_wet_imag, *rout_kernel_ptr);
                 w_wet_imag++;
                 *hyb_output_real_wet = *hyb_output_real_wet + temp_1;
                 hyb_output_real_wet++;

                 temp_1 = ixheaacd_mps_mult32_shr_15(*w_wet_real, *rout_kernel_ptr);
                 w_wet_real++;
                 rout_kernel_ptr++;
                 *hyb_output_imag_wet = *hyb_output_imag_wet - temp_1;
                 hyb_output_imag_wet++;
               }

               for (; qs < hybrid_bands; qs++) {
                 temp_1 = ixheaacd_mps_mult32_shr_15(*w_wet_imag, *rout_kernel_ptr);
                 w_wet_imag++;
                 *hyb_output_real_wet = *hyb_output_real_wet - temp_1;
                 hyb_output_real_wet++;

                 temp_1 = ixheaacd_mps_mult32_shr_15(*w_wet_real, *rout_kernel_ptr);
                 w_wet_real++;
                 rout_kernel_ptr++;
                 *hyb_output_imag_wet = *hyb_output_imag_wet + temp_1;
                 hyb_output_imag_wet++;
               }
               p_buffer_re += MAX_HYBRID_BANDS;
               p_buffer_im += MAX_HYBRID_BANDS;

               p_buf_re += MAX_HYBRID_BANDS;
               p_buf_im += MAX_HYBRID_BANDS;
             }
             m2_decor_imag_prev += num_parameter_bands;
           }
           p_buf_real += TSXHB;
           p_buf_imag += TSXHB;
         }
         p_buffer_real += TSXHB;
         p_buffer_imag += TSXHB;
       }
     }
   }
   return;
 }
	/******************************************************************************
	*
	* Copyright (C) 2023 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 <string.h>
	#include "ixheaac_type_def.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_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_mps_polyphase.h"
	#include "ixheaacd_config.h"
	#include "ixheaacd_qmf_dec.h"
	#include "ixheaacd_mps_dec.h"
	#include "ixheaacd_mps_macro_def.h"
	#include "ixheaacd_mps_apply_common.h"
	#include "ixheaacd_mps_basic_op.h"
	#include "ixheaacd_mps_get_index.h"

	VOID ixheaacd_apply_m2(ia_heaac_mps_state_struct *pstr_mps_state) {
	WORD32 ts, qs, row, col;
	ia_heaac_mps_state_struct *curr_state = pstr_mps_state;
	ia_mps_persistent_mem *persistent_mem = &curr_state->mps_persistent_mem;
	ia_mps_dec_reuse_array_struct *p_array_struct = pstr_mps_state->array_struct;
	ia_mps_dec_m2_param_struct *p_m2_param = pstr_mps_state->aux_struct->m2_param;

	WORD32 num_direct_signals = curr_state->num_direct_signals;
	WORD32 temp_1, loop_counter, col_counter = num_direct_signals + curr_state->num_decor_signals;

	WORD32 rout_ptr, rout_kernel_ptr;

	WORD32 hyb_output_real_dry, hyb_output_imag_dry, hyb_output_real_wet, hyb_output_imag_wet;

	WORD32 p_hyb_out_dry_real, p_hyb_out_dry_imag, p_hyb_out_dry_re, p_hyb_out_dry_im;

	WORD32 w_wet_real, w_wet_imag, w_dry_real, w_dry_imag;

	WORD32 *m2_decor_real_prev = persistent_mem->m2_decor_real_prev;
	WORD32 *m2_decor_imag_prev = persistent_mem->m2_decor_imag_prev;

	WORD32 p_buffer_real, p_buffer_imag, p_buffer_re, p_buffer_im;
	WORD32 p_buf_real, p_buf_imag, p_buf_re, p_buf_im;

	WORD32 *m2_resid_real_prev = persistent_mem->m2_resid_real_prev;
	WORD32 *m2_resid_imag_prev = persistent_mem->m2_resid_imag_prev;

	WORD32 idx = 0;
	WORD32 w_wet_offset = num_direct_signals * TSXHB;

	WORD32 num_output_channels = curr_state->num_output_channels;
	WORD32 time_slots = curr_state->time_slots;
	WORD32 hybrid_bands = curr_state->hybrid_bands;
	WORD32 m2_param_imag_present = curr_state->m2_param_imag_present;
	WORD32 num_parameter_bands = curr_state->num_parameter_bands;
	WORD32 up_mix_type = curr_state->up_mix_type;
	WORD32 residual_coding = curr_state->residual_coding;
	WORD32 *index_ptr = curr_state->index;

	SIZE_T params[4];

	params[0] = (SIZE_T)(&curr_state->kernels[0]);
	params[1] = time_slots;
	params[2] = num_parameter_bands;
	params[3] = hybrid_bands;

	rout_ptr = pstr_mps_state->mps_scratch_mem_v;
	rout_kernel_ptr =
	rout_ptr + IXHEAAC_GET_SIZE_ALIGNED_TYPE(TSXHB, sizeof(*rout_kernel_ptr), BYTE_ALIGN_8);

	p_hyb_out_dry_real = p_array_struct->hyb_output_real_dry;
	p_hyb_out_dry_imag = p_array_struct->hyb_output_imag_dry;

	for (row = 0; row < num_output_channels; row++) {
	hyb_output_real_dry = p_hyb_out_dry_real;
	hyb_output_imag_dry = p_hyb_out_dry_imag;

	for (ts = 0; ts < time_slots; ts++) {
	memset(hyb_output_real_dry, 0, (hybrid_bands) * sizeof(hyb_output_real_dry[0]));
	memset(hyb_output_imag_dry, 0, (hybrid_bands) * sizeof(hyb_output_imag_dry[0]));

	hyb_output_real_dry += MAX_HYBRID_BANDS;
	hyb_output_imag_dry += MAX_HYBRID_BANDS;
	}

	p_hyb_out_dry_real += TSXHB;
	p_hyb_out_dry_imag += TSXHB;
	}

	if (residual_coding)
	loop_counter = col_counter;
	else
	loop_counter = num_direct_signals;

	idx = 0;

	p_hyb_out_dry_real = p_array_struct->hyb_output_real_dry;
	p_hyb_out_dry_imag = p_array_struct->hyb_output_imag_dry;

	for (row = 0; row < num_output_channels; row++) {
	p_buffer_real = p_array_struct->buf_real;
	p_buffer_imag = p_array_struct->buf_imag;

	for (col = 0; col < num_direct_signals; col++) {
	p_buffer_re = p_buffer_real;
	p_buffer_im = p_buffer_imag;

	if (curr_state->m2_param_present[row][col] & 2) {
	ixheaacd_dec_interp_umx(p_m2_param->m2_resid_real[idx++], rout_ptr, m2_resid_real_prev,
	pstr_mps_state);
	ixheaacd_apply_abs_kernels(rout_ptr, rout_kernel_ptr, params);

	p_hyb_out_dry_re = p_hyb_out_dry_real;
	p_hyb_out_dry_im = p_hyb_out_dry_imag;

	for (ts = 0; ts < time_slots; ts++) {
	hyb_output_real_dry = p_hyb_out_dry_re;
	hyb_output_imag_dry = p_hyb_out_dry_im;

	w_dry_real = p_buffer_re;
	w_dry_imag = p_buffer_im;

	for (qs = 0; qs < hybrid_bands; qs++) {
	temp_1 = ixheaacd_mps_mult32_shr_15(w_dry_real, rout_kernel_ptr);
	w_dry_real++;
	hyb_output_real_dry = hyb_output_real_dry + temp_1;
	hyb_output_real_dry++;

	temp_1 = ixheaacd_mps_mult32_shr_15(w_dry_imag, rout_kernel_ptr);
	w_dry_imag++;
	rout_kernel_ptr++;
	hyb_output_imag_dry = hyb_output_imag_dry + temp_1;
	hyb_output_imag_dry++;
	}
	p_buffer_re += MAX_HYBRID_BANDS;
	p_buffer_im += MAX_HYBRID_BANDS;

	p_hyb_out_dry_re += MAX_HYBRID_BANDS;
	p_hyb_out_dry_im += MAX_HYBRID_BANDS;
	}
	m2_resid_real_prev += num_parameter_bands;
	}
	p_buffer_real += TSXHB;
	p_buffer_imag += TSXHB;
	}

	for (; col < loop_counter; col++) {
	WORD32 index;
	WORD32 res = ixheaacd_get_res_idx(pstr_mps_state, col);
	index = index_ptr[res];

	if (curr_state->m2_param_present[row][col] & 2) {
	WORD32 p_dry_real = p_array_struct->w_dry_real + res TSXHB;
	WORD32 p_dry_imag = p_array_struct->w_dry_imag + res TSXHB;

	ixheaacd_dec_interp_umx(p_m2_param->m2_resid_real[idx++], rout_ptr, m2_resid_real_prev,
	pstr_mps_state);
	ixheaacd_apply_abs_kernels(rout_ptr, rout_kernel_ptr, params);

	p_hyb_out_dry_re = p_hyb_out_dry_real;
	p_hyb_out_dry_im = p_hyb_out_dry_imag;

	for (ts = 0; ts < time_slots; ts++) {
	hyb_output_real_dry = p_hyb_out_dry_re;
	hyb_output_imag_dry = p_hyb_out_dry_im;

	w_dry_real = p_dry_real;
	w_dry_imag = p_dry_imag;

	for (qs = 0; qs < index; qs++) {
	temp_1 = ixheaacd_mps_mult32_shr_15(w_dry_real, rout_kernel_ptr);
	w_dry_real++;
	hyb_output_real_dry = hyb_output_real_dry + temp_1;
	hyb_output_real_dry++;

	temp_1 = ixheaacd_mps_mult32_shr_15(w_dry_imag, rout_kernel_ptr);
	w_dry_imag++;
	rout_kernel_ptr++;
	hyb_output_imag_dry = hyb_output_imag_dry + temp_1;
	hyb_output_imag_dry++;
	}
	rout_kernel_ptr += hybrid_bands - index;

	p_hyb_out_dry_re += MAX_HYBRID_BANDS;
	p_hyb_out_dry_im += MAX_HYBRID_BANDS;

	p_dry_real += MAX_HYBRID_BANDS;
	p_dry_imag += MAX_HYBRID_BANDS;
	}
	m2_resid_real_prev += num_parameter_bands;
	}
	}

	p_hyb_out_dry_real += TSXHB;
	p_hyb_out_dry_imag += TSXHB;
	}

	if (up_mix_type == 2) {
	if (m2_param_imag_present) {
	if (residual_coding)
	loop_counter = col_counter;
	else
	loop_counter = num_direct_signals;

	idx = 0;

	p_hyb_out_dry_real = p_array_struct->hyb_output_real_dry;
	p_hyb_out_dry_imag = p_array_struct->hyb_output_imag_dry;

	for (row = 0; row < num_output_channels; row++) {
	p_buffer_real = p_array_struct->buf_real;
	p_buffer_imag = p_array_struct->buf_imag;

	for (col = 0; col < num_direct_signals; col++) {
	p_buffer_re = p_buffer_real;
	p_buffer_im = p_buffer_imag;

	if (curr_state->m2_param_present[row][col] & 2) {
	ixheaacd_dec_interp_umx(p_m2_param->m2_resid_imag[idx++], rout_ptr,
	m2_resid_imag_prev, pstr_mps_state);
	ixheaacd_apply_abs_kernels(rout_ptr, rout_kernel_ptr, params);

	p_hyb_out_dry_re = p_hyb_out_dry_real;
	p_hyb_out_dry_im = p_hyb_out_dry_imag;

	for (ts = 0; ts < time_slots; ts++) {
	hyb_output_real_dry = p_hyb_out_dry_re;
	hyb_output_imag_dry = p_hyb_out_dry_im;

	w_dry_real = p_buffer_re;
	w_dry_imag = p_buffer_im;

	for (qs = 0; qs < 2; qs++) {
	temp_1 = ixheaacd_mps_mult32_shr_15(w_dry_imag, rout_kernel_ptr);
	w_dry_imag++;
	hyb_output_real_dry = hyb_output_real_dry + temp_1;
	hyb_output_real_dry++;

	temp_1 = ixheaacd_mps_mult32_shr_15(w_dry_real, rout_kernel_ptr);
	w_dry_real++;
	rout_kernel_ptr++;
	hyb_output_imag_dry = hyb_output_imag_dry - temp_1;
	hyb_output_imag_dry++;
	}

	for (; qs < hybrid_bands; qs++) {
	temp_1 = ixheaacd_mps_mult32_shr_15(w_dry_imag, rout_kernel_ptr);
	w_dry_imag++;
	hyb_output_real_dry = hyb_output_real_dry - temp_1;
	hyb_output_real_dry++;

	temp_1 = ixheaacd_mps_mult32_shr_15(w_dry_real, rout_kernel_ptr);
	w_dry_real++;
	rout_kernel_ptr++;
	hyb_output_imag_dry = hyb_output_imag_dry + temp_1;
	hyb_output_imag_dry++;
	}
	p_buffer_re += MAX_HYBRID_BANDS;
	p_buffer_im += MAX_HYBRID_BANDS;

	p_hyb_out_dry_re += MAX_HYBRID_BANDS;
	p_hyb_out_dry_im += MAX_HYBRID_BANDS;
	}
	m2_resid_imag_prev += num_parameter_bands;
	}
	p_buffer_real += TSXHB;
	p_buffer_imag += TSXHB;
	}

	for (; col < loop_counter; col++) {
	WORD32 index;
	WORD32 res = ixheaacd_get_res_idx(pstr_mps_state, col);
	index = index_ptr[res];

	if (curr_state->m2_param_present[row][col] & 2) {
	WORD32 p_dry_real = p_array_struct->w_dry_real + res TSXHB;
	WORD32 p_dry_imag = p_array_struct->w_dry_imag + res TSXHB;
	ixheaacd_dec_interp_umx(p_m2_param->m2_resid_imag[idx++], rout_ptr,
	m2_resid_imag_prev, pstr_mps_state);
	ixheaacd_apply_abs_kernels(rout_ptr, rout_kernel_ptr, params);

	p_hyb_out_dry_re = p_hyb_out_dry_real;
	p_hyb_out_dry_im = p_hyb_out_dry_imag;

	for (ts = 0; ts < time_slots; ts++) {
	hyb_output_real_dry = p_hyb_out_dry_re;
	hyb_output_imag_dry = p_hyb_out_dry_im;

	w_dry_real = p_dry_real;
	w_dry_imag = p_dry_imag;

	for (qs = 0; qs < 2; qs++) {
	temp_1 = ixheaacd_mps_mult32_shr_15(w_dry_imag, rout_kernel_ptr);
	w_dry_imag++;
	hyb_output_real_dry = hyb_output_real_dry + temp_1;
	hyb_output_real_dry++;

	temp_1 = ixheaacd_mps_mult32_shr_15(w_dry_real, rout_kernel_ptr);
	w_dry_real++;
	rout_kernel_ptr++;
	hyb_output_imag_dry = hyb_output_imag_dry - temp_1;
	hyb_output_imag_dry++;
	}

	for (; qs < index; qs++) {
	temp_1 = ixheaacd_mps_mult32_shr_15(w_dry_imag, rout_kernel_ptr);
	w_dry_imag++;
	hyb_output_real_dry = hyb_output_real_dry - temp_1;
	hyb_output_real_dry++;

	temp_1 = ixheaacd_mps_mult32_shr_15(w_dry_real, rout_kernel_ptr);
	w_dry_real++;
	rout_kernel_ptr++;
	hyb_output_imag_dry = hyb_output_imag_dry + temp_1;
	hyb_output_imag_dry++;
	}
	rout_kernel_ptr += hybrid_bands - index;

	p_hyb_out_dry_re += MAX_HYBRID_BANDS;
	p_hyb_out_dry_im += MAX_HYBRID_BANDS;

	p_dry_real += MAX_HYBRID_BANDS;
	p_dry_imag += MAX_HYBRID_BANDS;
	}
	m2_resid_imag_prev += num_parameter_bands;
	}
	}
	p_hyb_out_dry_real += TSXHB;
	p_hyb_out_dry_imag += TSXHB;
	}
	}
	}
	p_buffer_real = p_array_struct->buf_real;
	p_buffer_imag = p_array_struct->buf_imag;

	for (row = 0; row < num_output_channels; row++) {
	hyb_output_real_wet = p_buffer_real;
	hyb_output_imag_wet = p_buffer_imag;

	for (ts = 0; ts < time_slots; ts++) {
	memset(hyb_output_real_wet, 0, (hybrid_bands) * sizeof(*hyb_output_real_wet));
	memset(hyb_output_imag_wet, 0, (hybrid_bands) * sizeof(*hyb_output_imag_wet));

	hyb_output_real_wet += MAX_HYBRID_BANDS;
	hyb_output_imag_wet += MAX_HYBRID_BANDS;
	}
	p_buffer_real += TSXHB;
	p_buffer_imag += TSXHB;
	}
	idx = 0;

	p_buffer_real = p_array_struct->buf_real;
	p_buffer_imag = p_array_struct->buf_imag;

	for (row = 0; row < num_output_channels; row++) {
	p_buf_real = p_array_struct->buffer_real + w_wet_offset;
	p_buf_imag = p_array_struct->buffer_imag + w_wet_offset;
	for (col = num_direct_signals; col < col_counter; col++) {
	if (curr_state->m2_param_present[row][col] & 1) {
	ixheaacd_dec_interp_umx(p_m2_param->m2_decor_real[idx++], rout_ptr, m2_decor_real_prev,
	pstr_mps_state);

	ixheaacd_apply_abs_kernels(rout_ptr, rout_kernel_ptr, params);
	p_buffer_re = p_buffer_real;
	p_buffer_im = p_buffer_imag;

	p_buf_re = p_buf_real;
	p_buf_im = p_buf_imag;
	for (ts = 0; ts < time_slots; ts++) {
	hyb_output_real_wet = p_buffer_re;
	hyb_output_imag_wet = p_buffer_im;

	w_wet_real = p_buf_re;
	w_wet_imag = p_buf_im;

	for (qs = 0; qs < hybrid_bands; qs++) {
	temp_1 = ixheaacd_mps_mult32_shr_15(w_wet_real, rout_kernel_ptr);
	w_wet_real++;
	hyb_output_real_wet = hyb_output_real_wet + temp_1;
	hyb_output_real_wet++;

	temp_1 = ixheaacd_mps_mult32_shr_15(w_wet_imag, rout_kernel_ptr);
	w_wet_imag++;
	rout_kernel_ptr++;
	hyb_output_imag_wet = hyb_output_imag_wet + temp_1;
	hyb_output_imag_wet++;
	}
	p_buffer_re += MAX_HYBRID_BANDS;
	p_buffer_im += MAX_HYBRID_BANDS;

	p_buf_re += MAX_HYBRID_BANDS;
	p_buf_im += MAX_HYBRID_BANDS;
	}
	m2_decor_real_prev += num_parameter_bands;
	}
	p_buf_real += TSXHB;
	p_buf_imag += TSXHB;
	}
	p_buffer_real += TSXHB;
	p_buffer_imag += TSXHB;
	}

	if (up_mix_type == 2) {
	if (m2_param_imag_present) {
	idx = 0;

	p_buffer_real = p_array_struct->buf_real;
	p_buffer_imag = p_array_struct->buf_imag;

	for (row = 0; row < num_output_channels; row++) {
	m2_decor_imag_prev += num_parameter_bands * num_direct_signals;
	p_buf_real = p_array_struct->buffer_real + w_wet_offset;
	p_buf_imag = p_array_struct->buffer_imag + w_wet_offset;
	for (col = num_direct_signals; col < col_counter; col++) {
	if (curr_state->m2_param_present[row][col] & 1) {
	ixheaacd_dec_interp_umx(p_m2_param->m2_decor_imag[idx++], rout_ptr,
	m2_decor_imag_prev, pstr_mps_state);
	ixheaacd_apply_abs_kernels(rout_ptr, rout_kernel_ptr, params);

	p_buffer_re = p_buffer_real;
	p_buffer_im = p_buffer_imag;

	p_buf_re = p_buf_real;
	p_buf_im = p_buf_imag;
	for (ts = 0; ts < time_slots; ts++) {
	hyb_output_real_wet = p_buffer_re;
	hyb_output_imag_wet = p_buffer_im;

	w_wet_real = p_buf_re;
	w_wet_imag = p_buf_im;

	for (qs = 0; qs < 2; qs++) {
	temp_1 = ixheaacd_mps_mult32_shr_15(w_wet_imag, rout_kernel_ptr);
	w_wet_imag++;
	hyb_output_real_wet = hyb_output_real_wet + temp_1;
	hyb_output_real_wet++;

	temp_1 = ixheaacd_mps_mult32_shr_15(w_wet_real, rout_kernel_ptr);
	w_wet_real++;
	rout_kernel_ptr++;
	hyb_output_imag_wet = hyb_output_imag_wet - temp_1;
	hyb_output_imag_wet++;
	}

	for (; qs < hybrid_bands; qs++) {
	temp_1 = ixheaacd_mps_mult32_shr_15(w_wet_imag, rout_kernel_ptr);
	w_wet_imag++;
	hyb_output_real_wet = hyb_output_real_wet - temp_1;
	hyb_output_real_wet++;

	temp_1 = ixheaacd_mps_mult32_shr_15(w_wet_real, rout_kernel_ptr);
	w_wet_real++;
	rout_kernel_ptr++;
	hyb_output_imag_wet = hyb_output_imag_wet + temp_1;
	hyb_output_imag_wet++;
	}
	p_buffer_re += MAX_HYBRID_BANDS;
	p_buffer_im += MAX_HYBRID_BANDS;

	p_buf_re += MAX_HYBRID_BANDS;
	p_buf_im += MAX_HYBRID_BANDS;
	}
	m2_decor_imag_prev += num_parameter_bands;
	}
	p_buf_real += TSXHB;
	p_buf_imag += TSXHB;
	}
	p_buffer_real += TSXHB;
	p_buffer_imag += TSXHB;
	}
	}
	}
	return;
	}