encoder/ixheaace_hybrid.c

/******************************************************************************
 *                                                                            *
 * 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 "ixheaac_error_standards.h"
#include "ixheaace_error_codes.h"
#include "ixheaace_common_rom.h"
#include "ixheaace_sbr_def.h"
#include "ixheaace_resampler.h"
#include "ixheaace_sbr_rom.h"
#include "ixheaace_sbr_hybrid.h"

#include "ixheaace_aac_constants.h"

VOID ia_enhaacplus_enc_fft(complex *out, WORD32 N, ixheaace_common_tables *);

static VOID ixheaace_four_chan_filtering(const FLOAT32 *ptr_qmf_real, const FLOAT32 *ptr_qmf_imag,
                                         FLOAT32 **ptr_hyb_real, FLOAT32 **ptr_hyb_imag,
                                         WORD32 ch_offset, const FLOAT32 *ptr_p4_13,
                                         ixheaace_common_tables *pstr_common_tab) {
  WORD32 i, k, n;
  WORD32 mid_tap = IXHEAACE_HYBRID_FILTER_DELAY;

  FLOAT32 cum[8], *ptr_cum;
  FLOAT32 tmp1, tmp2, tmp_p4;
  FLOAT32 real, imag;
  const FLOAT32 *ptr_re, *ptr_im;
  FLOAT32 *ptr_hy_im, *ptr_hy_re;
  ptr_re = &ptr_qmf_real[0];
  ptr_im = &ptr_qmf_imag[0];
  ptr_hy_re = &ptr_hyb_real[0][ch_offset];
  ptr_hy_im = &ptr_hyb_imag[0][ch_offset];

  for (i = IXHEAACE_QMF_TIME_SLOTS - 1; i >= 0; i--) {
    real = imag = 0;
    for (k = 0; k < 16; k += 4) {
      tmp_p4 = ptr_p4_13[k];
      tmp1 = ptr_re[k];
      tmp2 = ptr_im[k];

      tmp1 = tmp_p4 * tmp1;
      real = real - tmp1;

      tmp1 = tmp_p4 * tmp2;
      imag = imag + tmp1;
    }

    cum[3] = imag;
    cum[2] = real;
    real = imag = 0;

    for (k = 3; k < 15; k += 4) {
      tmp_p4 = ptr_p4_13[k];
      tmp1 = ptr_re[k];
      tmp2 = ptr_im[k];
      tmp1 = tmp_p4 * tmp1;
      real = real + tmp1;
      tmp1 = tmp_p4 * tmp2;
      imag = imag + tmp1;
    }

    tmp1 = imag + real;
    cum[7] = tmp1 * IXHEAACE_COS_PI_BY_4;
    tmp1 = imag - real;
    cum[6] = tmp1 * IXHEAACE_COS_PI_BY_4;

    cum[1] = ptr_p4_13[mid_tap] * ptr_re[mid_tap];
    cum[0] = ptr_p4_13[mid_tap] * ptr_im[mid_tap];

    real = imag = 0;

    for (k = 1; k < 13; k += 4) {
      tmp_p4 = ptr_p4_13[k];
      tmp1 = ptr_re[k];
      tmp2 = ptr_im[k];
      tmp1 = tmp_p4 * tmp1;
      real = real + tmp1;
      tmp1 = tmp_p4 * tmp2;
      imag = imag + tmp1;
    }

    tmp1 = real - imag;
    cum[5] = tmp1 * IXHEAACE_COS_PI_BY_4;
    tmp1 = real + imag;
    cum[4] = tmp1 * IXHEAACE_COS_PI_BY_4;

    ia_enhaacplus_enc_fft((complex *)cum, 4, pstr_common_tab);

    ptr_cum = &cum[0];

    for (n = 3; n >= 0; n--) {
      tmp1 = *ptr_cum++;
      tmp2 = *ptr_cum++;
      *ptr_hy_im++ = tmp1;
      *ptr_hy_re++ = tmp2;
    }
    ptr_re++;
    ptr_im++;
    ptr_hy_re += IXHEAACE_QMF_TIME_SLOTS - 4;
    ptr_hy_im += IXHEAACE_QMF_TIME_SLOTS - 4;
  }
}

static VOID ixheaace_eight_chan_filtering(const FLOAT32 *ptr_qmf_real,
                                          const FLOAT32 *ptr_qmf_imag, FLOAT32 **ptr_hyb_real,
                                          FLOAT32 **ptr_hyb_imag, const FLOAT32 *ptr_p8_13,
                                          ixheaace_common_tables *pstr_common_tab)

{
  LOOPINDEX i, n;
  LOOPINDEX mid_tap = IXHEAACE_HYBRID_FILTER_DELAY;
  FLOAT32 real, imag;
  FLOAT32 cum[16], *ptr_cum;
  FLOAT32 tmp1, tmp2, tmp3;
  const FLOAT32 *ptr_re, *ptr_im;
  FLOAT32 *ptr_hy_re, *ptr_hy_im;
  ptr_re = &ptr_qmf_real[0];
  ptr_im = &ptr_qmf_imag[0];
  ptr_hy_re = &ptr_hyb_real[0][0];
  ptr_hy_im = &ptr_hyb_imag[0][0];

  for (i = IXHEAACE_QMF_TIME_SLOTS - 1; i >= 0; i--) {
    tmp1 = ptr_p8_13[4] * ptr_re[4];
    tmp2 = ptr_p8_13[12] * ptr_re[12];

    tmp3 = ptr_im[4];
    real = tmp1 + tmp2;
    tmp2 = ptr_im[12];
    tmp1 = ptr_p8_13[4] * tmp3;
    tmp2 = ptr_p8_13[12] * tmp2;
    imag = tmp1 + tmp2;

    tmp1 = imag - real;
    cum[5] = tmp1 * IXHEAACE_COS_PI_BY_4;

    tmp1 = imag + real;
    tmp3 = ptr_re[3];
    cum[4] = -tmp1 * IXHEAACE_COS_PI_BY_4;
    tmp2 = ptr_re[11];
    tmp1 = ptr_p8_13[3] * tmp3;
    tmp2 = ptr_p8_13[11] * tmp2;
    tmp3 = ptr_im[3];
    real = tmp1 + tmp2;
    tmp2 = ptr_im[11];
    tmp1 = ptr_p8_13[3] * tmp3;
    tmp2 = ptr_p8_13[11] * tmp2;
    imag = tmp1 + tmp2;

    tmp1 = imag * IXHEAACE_COS_PI_BY_8;
    tmp2 = real * IXHEAACE_SIN_PI_BY_8;
    cum[13] = tmp1 - tmp2;

    tmp1 = imag * IXHEAACE_SIN_PI_BY_8;
    tmp2 = real * IXHEAACE_COS_PI_BY_8;
    tmp3 = ptr_re[2];
    cum[12] = -tmp1 - tmp2;
    tmp2 = ptr_re[10];
    tmp1 = ptr_p8_13[2] * tmp3;
    tmp2 = ptr_p8_13[10] * tmp2;
    tmp3 = ptr_im[2];
    cum[2] = -tmp1 - tmp2;
    tmp2 = ptr_im[10];
    tmp1 = ptr_p8_13[2] * tmp3;
    tmp2 = ptr_p8_13[10] * tmp2;
    cum[3] = tmp1 + tmp2;

    tmp1 = ptr_p8_13[1] * ptr_re[1];
    tmp2 = ptr_p8_13[9] * ptr_re[9];
    real = tmp1 + tmp2;

    tmp1 = ptr_p8_13[1] * ptr_im[1];
    tmp2 = ptr_p8_13[9] * ptr_im[9];
    imag = tmp1 + tmp2;

    tmp1 = imag * IXHEAACE_COS_PI_BY_8;
    tmp2 = real * IXHEAACE_SIN_PI_BY_8;
    cum[11] = tmp1 + tmp2;

    tmp1 = imag * IXHEAACE_SIN_PI_BY_8;
    tmp2 = real * IXHEAACE_COS_PI_BY_8;
    cum[10] = tmp1 - tmp2;

    tmp1 = ptr_p8_13[0] * ptr_re[0];
    tmp2 = ptr_p8_13[8] * ptr_re[8];
    real = tmp1 + tmp2;

    tmp1 = ptr_p8_13[0] * ptr_im[0];
    tmp2 = ptr_p8_13[8] * ptr_im[8];
    imag = tmp1 + tmp2;

    tmp1 = imag + real;
    cum[7] = tmp1 * IXHEAACE_COS_PI_BY_4;

    tmp1 = imag - real;
    cum[6] = tmp1 * IXHEAACE_COS_PI_BY_4;

    real = ptr_p8_13[7] * ptr_re[7];
    imag = ptr_p8_13[7] * ptr_im[7];

    tmp1 = imag * IXHEAACE_SIN_PI_BY_8;
    tmp2 = real * IXHEAACE_COS_PI_BY_8;
    cum[15] = tmp1 + tmp2;

    tmp1 = imag * IXHEAACE_COS_PI_BY_8;
    tmp2 = real * IXHEAACE_SIN_PI_BY_8;
    cum[14] = tmp1 - tmp2;

    cum[1] = ptr_p8_13[mid_tap] * ptr_re[mid_tap];
    cum[0] = ptr_p8_13[mid_tap] * ptr_im[mid_tap];

    real = ptr_p8_13[5] * ptr_re[5];
    imag = ptr_p8_13[5] * ptr_im[5];

    tmp1 = real * IXHEAACE_COS_PI_BY_8;
    tmp2 = imag * IXHEAACE_SIN_PI_BY_8;
    cum[9] = tmp1 - tmp2;

    tmp1 = real * IXHEAACE_SIN_PI_BY_8;
    tmp2 = imag * IXHEAACE_COS_PI_BY_8;
    cum[8] = tmp1 + tmp2;

    ia_enhaacplus_enc_fft((complex *)cum, 8, pstr_common_tab);

    ptr_cum = &cum[0];

    for (n = 7; n >= 0; n--) {
      tmp1 = *ptr_cum++;
      tmp2 = *ptr_cum++;
      *ptr_hy_im++ = tmp1;
      *ptr_hy_re++ = tmp2;
    }
    ptr_re++;
    ptr_im++;
    ptr_hy_re += IXHEAACE_QMF_TIME_SLOTS - 8;
    ptr_hy_im += IXHEAACE_QMF_TIME_SLOTS - 8;
  }
}

IA_ERRORCODE ixheaace_hybrid_analysis(const FLOAT32 **ptr_qmf_real_in,
                                      const FLOAT32 **ptr_qmf_imag_in, FLOAT32 **ptr_hyb_real_in,
                                      FLOAT32 **ptr_hyb_imag_in, ixheaace_pstr_hybrid pstr_hybrid,
                                      ixheaace_str_ps_tab *pstr_ps_tab,
                                      ixheaace_common_tables *pstr_common_tab) {
  WORD32 band, i;
  ixheaace_hybrid_res hybrid_res;
  WORD32 ch_offset = 0;

  FLOAT32 *ptr_re, *ptr_im;
  const FLOAT32 *ptr_qmf_real, *ptr_qmf_imag;
  FLOAT32 tmp1, tmp2;

  for (band = 0; band < IXHEAACE_NUM_QMF_BANDS_IN_HYBRID; band++) {
    hybrid_res = (ixheaace_hybrid_res)pstr_ps_tab->a_hyb_res[band];

    memcpy(pstr_hybrid->ptr_work_real, pstr_hybrid->ptr_qmf_buf_real[band],
           IXHEAACE_QMF_BUFFER_MOVE * sizeof(FLOAT32));
    memcpy(pstr_hybrid->ptr_work_imag, pstr_hybrid->ptr_qmf_buf_imag[band],
           IXHEAACE_QMF_BUFFER_MOVE * sizeof(FLOAT32));
    ptr_re = &pstr_hybrid->ptr_work_real[IXHEAACE_QMF_BUFFER_MOVE];
    ptr_im = &pstr_hybrid->ptr_work_imag[IXHEAACE_QMF_BUFFER_MOVE];
    ptr_qmf_real = &ptr_qmf_real_in[0][band];
    ptr_qmf_imag = &ptr_qmf_imag_in[0][band];

    for (i = IXHEAACE_QMF_TIME_SLOTS - 1; i >= 0; i--) {
      tmp1 = *ptr_qmf_real;
      tmp2 = *ptr_qmf_imag;

      ptr_qmf_real += IXHEAACE_QMF_CHANNELS;
      ptr_qmf_imag += IXHEAACE_QMF_CHANNELS;

      *ptr_im++ = tmp2;
      *ptr_re++ = tmp1;
    }

    ptr_re = &pstr_hybrid->ptr_qmf_buf_real[band][0];
    ptr_im = &pstr_hybrid->ptr_qmf_buf_imag[band][0];

    ptr_qmf_real = &ptr_qmf_real_in[IXHEAACE_QMF_TIME_SLOTS - IXHEAACE_QMF_BUFFER_MOVE][band];
    ptr_qmf_imag = &ptr_qmf_imag_in[IXHEAACE_QMF_TIME_SLOTS - IXHEAACE_QMF_BUFFER_MOVE][band];

    for (i = 0; i < IXHEAACE_QMF_BUFFER_MOVE; i++) {
      tmp1 = *ptr_qmf_real;
      ptr_qmf_real += IXHEAACE_QMF_CHANNELS;
      tmp2 = *ptr_qmf_imag;
      ptr_qmf_imag += IXHEAACE_QMF_CHANNELS;
      *ptr_re++ = tmp1;
      *ptr_im++ = tmp2;
    }

    switch (hybrid_res) {
      case IXHEAACE_HYBRID_4_CPLX:
        ixheaace_four_chan_filtering(pstr_hybrid->ptr_work_real, pstr_hybrid->ptr_work_imag,
                                     ptr_hyb_real_in, ptr_hyb_imag_in, ch_offset,
                                     pstr_ps_tab->p4_13, pstr_common_tab);
        break;
      case IXHEAACE_HYBRID_8_CPLX:
        ixheaace_eight_chan_filtering(pstr_hybrid->ptr_work_real, pstr_hybrid->ptr_work_imag,
                                      ptr_hyb_real_in, ptr_hyb_imag_in, pstr_ps_tab->p8_13,
                                      pstr_common_tab);
        break;
      default:
        return IA_EXHEAACE_EXE_FATAL_PS_INVALID_HYBRID_RES_VAL;
        break;
    }
    ch_offset += hybrid_res;
  }
  return IA_NO_ERROR;
}

VOID ixheaace_hybrid_synthesis(const FLOAT32 **ptr_hybrid_real_flt,
                               const FLOAT32 **ptr_hybrid_imag_flt, FLOAT32 **ptr_qmf_real_flt,
                               FLOAT32 **ptr_qmf_imag_flt, const WORD32 *ptr_hyb_res) {
  WORD32 k, n, band;
  ixheaace_hybrid_res hybrid_res;
  WORD32 ch_offset = 0;

  FLOAT32 temp1, temp2;
  FLOAT32 *ptr_qmf_real;
  FLOAT32 *ptr_qmf_imag;

  for (band = 0; band < IXHEAACE_NUM_QMF_BANDS_IN_HYBRID; band++) {
    const FLOAT32 *ptr_hybrid_real = &ptr_hybrid_real_flt[0][ch_offset];
    const FLOAT32 *ptr_hybrid_imag = &ptr_hybrid_imag_flt[0][ch_offset];

    hybrid_res = (ixheaace_hybrid_res)ptr_hyb_res[band];

    ptr_qmf_real = &ptr_qmf_real_flt[0][band];
    ptr_qmf_imag = &ptr_qmf_imag_flt[0][band];

    for (n = 0; n < IXHEAACE_QMF_TIME_SLOTS; n++) {
      FLOAT32 temo_real = 0, temo_imag = 0;

      for (k = hybrid_res - 1; k >= 0; k--) {
        temp1 = *ptr_hybrid_real++;
        temp2 = *ptr_hybrid_imag++;
        temo_real += temp1;
        temo_imag += temp2;
      }

      ptr_hybrid_real += IXHEAACE_QMF_TIME_SLOTS - hybrid_res;
      ptr_hybrid_imag += IXHEAACE_QMF_TIME_SLOTS - hybrid_res;

      *ptr_qmf_real = temo_real;
      ptr_qmf_real += IXHEAACE_QMF_CHANNELS;

      *ptr_qmf_imag = temo_imag;
      ptr_qmf_imag += IXHEAACE_QMF_CHANNELS;
    }
    ch_offset += hybrid_res;
  }
}