android-14.0.0_r21/s

/******************************************************************************
 *                                                                            *
 * Copyright (C) 2018 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at:
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 *****************************************************************************
 * Originally developed and contributed by Ittiam Systems Pvt. Ltd, Bangalore
*/
#include <stdlib.h>
#include "ixheaacd_type_def.h"
#include "ixheaacd_constants.h"
#include "ixheaacd_bitbuffer.h"
#include "ixheaacd_interface.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 "ixheaacd_mps_dec.h"
#include "ixheaacd_function_selector.h"

extern const FLOAT32
    ixheaacd_mps_polyphase_filter_coeff[10 * MAX_NUM_QMF_BANDS_SAC / 2];
extern const FLOAT32 ixheaacd_mps_post_twid[30];
extern const FLOAT32 ixheaacd_mps_pre_twid[64];

extern const FLOAT32 ixheaacd_ldmps_polyphase_filter_coeff[1280];

extern const FLOAT32 ixheaacd_ldmps_pre_twid[32];
extern const FLOAT32 ixheaacd_mps_post_re_32[64];
extern const FLOAT32 ixheaacd_mps_post_im_32[64];


VOID ixheaacd_mps_synt_init(FLOAT32 state[POLY_PHASE_SYNTH_SIZE]) {
  memset(state, 0, sizeof(FLOAT32) * POLY_PHASE_SYNTH_SIZE);
}

VOID ixheaacd_mps_synt_post_fft_twiddle_dec(WORD32 resolution, FLOAT32 *fin_re,
  FLOAT32 *fin_im,
  const FLOAT32 *table_re,
  const FLOAT32 *table_im,
  FLOAT32 *state) {
  WORD32 l;
  for (l = 0; l < 2 * resolution; l++) {
    state[2 * resolution - l - 1] =
      ((fin_re[l] * table_re[l]) + (fin_im[l] * table_im[l]));
  }
}

VOID ixheaacd_mps_synt_out_calc_dec(WORD32 resolution, FLOAT32 *out,
                                    FLOAT32 *state,
                                    const FLOAT32 *filter_coeff) {
  WORD32 l, k;
  FLOAT32 *out1, *out2, *state1, *state2;
  out1 = out;
  out2 = out + resolution;
  state1 = state;
  state2 = state + (3 * resolution);

  for (k = 0; k < 5; k++) {
    for (l = 0; l < resolution; l++) {
      *out1++ = (*state1++) * (*filter_coeff++);
      *out2++ = (*state2++) * (*filter_coeff++);
    }
    out1 += resolution;
    out2 += resolution;
    state1 += (3 * resolution);
    state2 += (3 * resolution);
  }
}

VOID ixheaacd_mps_synt_out_calc_dec_ldmps(WORD32 resolution, FLOAT32 *out,
  FLOAT32 *state, const FLOAT32 *filter_coeff) {
  WORD32 l, k;
  FLOAT32 *out1, *out2, *state1, *state2;
  const FLOAT32 *filter1, *filter2;
  filter1 = filter_coeff;
  filter2 = filter_coeff + resolution;
  out1 = out;
  out2 = out + resolution;
  state1 = state;
  state2 = state + (3 * resolution);

  for (k = 0; k < 5; k++) {
    for (l = 0; l < resolution; l++) {
      *out1++ = (*state1++) * (*filter1++);
      *out2++ = (*state2++) * (*filter2++);
    }
    filter1 += resolution;
    filter2 += resolution;
    out1 += resolution;
    out2 += resolution;
    state1 += (3 * resolution);
    state2 += (3 * resolution);
  }
}

VOID ixheaacd_mps_synt_out_calc_dec_ldmps_32(WORD32 resolution, FLOAT32 *out,
  FLOAT32 *state, const FLOAT32 *filter_coeff) {
  WORD32 l, k;
  FLOAT32 *out1, *out2, *state1, *state2;
  const FLOAT32 *filter1, *filter2;
  filter1 = filter_coeff;
  filter2 = filter_coeff + 2 * resolution;
  out1 = out;
  out2 = out + resolution;
  state1 = state;
  state2 = state + (3 * resolution);

  for (k = 0; k < 5; k++) {
    for (l = 0; l < resolution; l++) {
      *out1++ = ((*state1++) * (filter1[2*l] + filter1[2*l+1])/2);
      *out2++ = ((*state2++) *  (filter2[2 * l] + filter2[2 * l + 1])/2);
    }
    filter1 += 4 * resolution;
    filter2 += 4 * resolution;
    out1 += resolution;
    out2 += resolution;
    state1 += (3 * resolution);
    state2 += (3 * resolution);
  }
}

VOID ixheaacd_mps_synth_pre_twidle(FLOAT32 *out_re, FLOAT32 *out_im,
                                   FLOAT32 *c_in, WORD32 len) {
  WORD32 i;
  FLOAT32 *c_s = c_in;
  FLOAT32 *p_re_s = out_re;
  FLOAT32 *p_im_s = out_im;
  FLOAT32 *c_e = c_in + (len << 1) - 1;
  FLOAT32 *p_im_e = out_im + len - 1;
  FLOAT32 *p_re_e = out_re + len - 1;
  const FLOAT32 *prtw = ixheaacd_mps_pre_twid;

  for (i = 0; i < len; i += 4) {
    *p_re_s = ((*c_s++) * (*prtw));
    p_re_s++;
    *p_im_s = -((*c_s--) * (*prtw));
    p_im_s++;
    *p_im_s = ((*c_e--) * (*prtw));
    p_im_s--;
    *p_re_s = ((*c_e++) * (*prtw++));
    p_re_s--;
    *p_im_s += ((*c_e--) * (*prtw));
    p_im_s++;
    *p_re_s += ((*c_e--) * (*prtw));
    p_re_s++;
    *p_re_s -= ((*c_s++) * (*prtw));
    p_re_s++;
    *p_im_s += ((*c_s++) * (*prtw++));
    p_im_s++;
    *p_im_e = ((*c_e--) * (*prtw));
    p_im_e--;
    *p_re_e = -((*c_e++) * (*prtw));
    p_re_e--;
    *p_re_e = ((*c_s++) * (*prtw));
    p_re_e++;
    *p_im_e = ((*c_s--) * (*prtw++));
    p_im_e++;
    *p_re_e += ((*c_s++) * (*prtw));
    p_re_e--;
    *p_im_e += ((*c_s++) * (*prtw));
    p_im_e--;
    *p_im_e -= ((*c_e--) * (*prtw));
    p_im_e--;
    *p_re_e += ((*c_e--) * (*prtw++));
    p_re_e--;
  }
}

VOID ixheaacd_mps_synth_post_twidle(FLOAT32 *state, FLOAT32 *out_re,
                                    FLOAT32 *out_im, WORD32 len) {
  WORD32 i;
  {
    FLOAT32 x_0, x_1, x_2, x_3;
    FLOAT32 *p_re_e, *p_im_e;
    const FLOAT32 *potw = ixheaacd_mps_post_twid;
    FLOAT32 *p_re_s = out_re;
    FLOAT32 *p_im_s = out_im;

    p_re_e = p_re_s + (len - 2);
    p_im_e = p_im_s + (len - 2);
    x_0 = *p_re_e;
    x_1 = *(p_re_e + 1);
    x_2 = *p_im_e;
    x_3 = *(p_im_e + 1);

    *(p_re_e + 1) = -*(p_re_s + 1);
    *(p_im_e + 1) = -*p_im_s;
    *p_im_s = *(p_im_s + 1);

    for (i = 5; i < len; i += 4) {
      FLOAT32 twdr = *potw++;
      FLOAT32 twdi = *potw++;
      FLOAT32 tmp;

      *p_re_e = (x_0 * twdi);
      *p_re_e += (x_1 * twdr);
      p_re_e--;
      p_re_s++;
      *p_re_s = (x_0 * twdr);
      *p_re_s -= (x_1 * twdi);
      p_re_s++;
      x_1 = *p_re_e--;
      x_0 = *p_re_e++;
      *p_re_e = (*p_re_s++ * twdi);
      *p_re_e += -(*p_re_s * twdr);
      p_re_e--;
      tmp = (*p_re_s-- * twdi);
      *p_re_s = tmp + (*p_re_s * twdr);

      *p_im_e = -(x_2 * twdr);
      *p_im_e += (x_3 * twdi);
      p_im_e--;
      p_im_s++;
      *p_im_s = -(x_2 * twdi);
      *p_im_s -= (x_3 * twdr);
      p_im_s++;
      x_3 = *p_im_e--;
      x_2 = *p_im_e++;
      *p_im_e = -(*p_im_s++ * twdr);
      *p_im_e -= (*p_im_s * twdi);
      p_im_e--;
      tmp = (*p_im_s-- * twdr);
      *p_im_s = tmp - (*p_im_s * twdi);
    }

    *p_re_e = 0.7071067f * (x_1 + x_0);
    *p_im_e = 0.7071067f * (x_3 - x_2);
    *(p_re_s + 1) = -0.7071067f * (x_1 - x_0);
    *(p_im_s + 1) = -0.7071067f * (x_3 + x_2);
  }

  for (i = 0; i < len; i++) {
    state[i] = out_im[i] - out_re[i];
    state[len + i] = out_im[len - i - 1] + out_re[len - i - 1];
    state[len - i - 1] = out_im[len - i - 1] - out_re[len - i - 1];
    state[2 * len - i - 1] = out_im[i] + out_re[i];
  }
}

VOID ixheaacd_mps_synt_pre_twiddle_dec(FLOAT32 *ptr_in, const FLOAT32 *table,
  FLOAT32 *fin_re, FLOAT32 *fin_im,
  WORD32 resolution) {
  WORD32 k;
  FLOAT32 *c_s = ptr_in;
  FLOAT32 *p_re_s = fin_re;
  FLOAT32 *p_im_s = fin_im;
  FLOAT32 *c_e = ptr_in + (resolution << 1) - 1;
  FLOAT32 *p_im_e = fin_im + resolution - 1;
  FLOAT32 *p_re_e = fin_re + resolution - 1;

  for (k = 0; k < resolution; k += 2) {
    *p_re_s = (*c_s++) * (*table);
    *p_im_s = (*c_s) * (*table);

    *p_re_e = (*c_e--) * (*table);
    *p_im_e = -(*c_e) * (*table++);

    *p_re_s += (*c_s--) * (*table);
    *p_im_s += -(*c_s++) * (*table);
    p_re_s++;
    p_im_s++;
    c_s++;

    *p_re_e += (*c_e++) * (*table);
    *p_im_e += (*c_e--) * (*table++);
    p_re_e--;
    p_im_e--;
    c_e--;
  }
}

VOID ixheaacd_mps_synt_calc(ia_mps_dec_state_struct *self) {
  WORD32 k, l, ts, ch;
  FLOAT32 *state, *tmp_state, *out;
  const FLOAT32 *filt_coeff;
  FLOAT32 *tmp_buf = self->tmp_buf;
  FLOAT32 fin_re[64] = {0};
  FLOAT32 fin_im[64] = {0};

  WORD32 resolution = self->resolution;
  WORD32 m_resolution = resolution >> 1;
  const FLOAT32 *ixheaacd_mps_post_re, *ixheaacd_mps_post_im;
  VOID(*ixheaacd_mps_synt_out_calc_pointer)
  (WORD32 resolution, FLOAT32 *out, FLOAT32 *state, const FLOAT32 *filter_coeff);

  if (self->ldmps_config.ldmps_present_flag)
  {
    ixheaacd_mps_synt_out_calc_pointer = &ixheaacd_mps_synt_out_calc_dec_ldmps;
    filt_coeff = ixheaacd_ldmps_polyphase_filter_coeff;
  }
  else
  {
    ixheaacd_mps_synt_out_calc_pointer = ixheaacd_mps_synt_out_calc;
    filt_coeff = ixheaacd_mps_polyphase_filter_coeff;
  }
  if (self->qmf_band_count == 32)
  {
    for (ch = 0; ch < self->out_ch_count; ch++) {
      tmp_state = self->qmf_filt_state[ch];
      state = &tmp_buf[self->time_slots * 2 * resolution];
      memcpy(state, tmp_state, sizeof(FLOAT32) * 18 * resolution);
      out = &tmp_buf[74 * MAX_NUM_QMF_BANDS_SAC];

      ixheaacd_mps_post_re = ixheaacd_mps_post_re_32;
      ixheaacd_mps_post_im = ixheaacd_mps_post_im_32;

      for (ts = 0; ts < self->time_slots; ts++) {

        state -= (2 * resolution);

        ixheaacd_mps_synt_pre_twiddle_dec(&self->qmf_out_dir[ch][ts][0].re,
            ixheaacd_ldmps_pre_twid, fin_re, fin_im, resolution);

        for (k = resolution; k < 2 * resolution; k++)
        {
          fin_re[k] = 0;
          fin_im[k] = 0;
        }

        ixheaacd_mps_complex_fft(fin_re, fin_im, 2 * resolution);

        ixheaacd_mps_synt_post_fft_twiddle_dec(resolution, fin_re, fin_im,
                                              ixheaacd_mps_post_re,
                                              ixheaacd_mps_post_im, state);

        ixheaacd_mps_synt_out_calc_dec_ldmps_32(resolution, out, state, filt_coeff);

        for (k = 0; k < resolution; k++) {
          FLOAT32 acc = out[k];
          for (l = 1; l < 10; l++) {
            acc += out[resolution * l + k];
          }
          self->output_buffer[ch][self->qmf_band_count * ts + k] = acc;
        }
      }
      memcpy(tmp_state, state, sizeof(FLOAT32) * 18 * resolution);
    }
  }
  else
  {
    for (ch = 0; ch < self->out_ch_count; ch++) {
      tmp_state = self->qmf_filt_state[ch];
      state = &tmp_buf[self->time_slots * 2 * resolution];
      memcpy(state, tmp_state, sizeof(FLOAT32) * 18 * resolution);
      out = &tmp_buf[74 * MAX_NUM_QMF_BANDS_SAC];

      for (ts = 0; ts < self->time_slots; ts++) {

        state -= (2 * resolution);

        ixheaacd_mps_synth_pre_twidle(
          fin_re, fin_im, &self->qmf_out_dir[ch][ts][0].re, resolution);

        ixheaacd_mps_synth_calc_fft(fin_re, fin_im, m_resolution);

        ixheaacd_mps_synth_post_twidle(state, fin_re, fin_im, resolution);
        (*ixheaacd_mps_synt_out_calc_pointer)(resolution, out, state, filt_coeff);

        for (k = 0; k < resolution; k++) {
          FLOAT32 acc = out[k];
          for (l = 1; l < 10; l++) {
            acc += out[resolution * l + k];
          }
          self->output_buffer[ch][self->qmf_band_count * ts + k] = acc;
        }
      }
      memcpy(tmp_state, state, sizeof(FLOAT32) * 18 * resolution);
    }
  }
}