libxaac/encoder/ixheaace_mps_qmf.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 <stdlib.h>
#include "ixheaac_type_def.h"
#include "ixheaac_error_standards.h"
#include "ixheaace_error_codes.h"
#include "ixheaace_mps_common_fix.h"
#include "ixheaace_mps_defines.h"
#include "ixheaace_mps_common_define.h"
#include "ixheaace_mps_buf.h"
#include "ixheaace_mps_lib.h"
#include "ixheaace_mps_main_structure.h"
#include "ixheaace_mps_tools_rom.h"
#include "ixheaace_mps_dct.h"
#include "ixheaace_mps_qmf.h"
#include "ixheaac_constants.h"
#include "ixheaac_basic_ops32.h"
#include "ixheaac_basic_ops40.h"
#include "ixheaac_basic_ops.h"

static IA_ERRORCODE ixheaace_mps_212_qmf_forward_modulation_hq(
    ixheaace_mps_pstr_qmf_filter_bank pstr_qmf_filter_bank, const FLOAT32 *time_in,
    FLOAT32 *real_subband, FLOAT32 *imag_subband, WORD8 *ptr_scratch) {
  IA_ERRORCODE error;
  WORD32 idx;
  WORD32 qmf_bands = pstr_qmf_filter_bank->no_channels;
  WORD32 qmf_bands_by_2 = qmf_bands << 1;
  FLOAT32 intermediate_band;
  FLOAT32 x0, x1, y0, y1;
  if (qmf_bands == 64) {
    x0 = time_in[1];
    y0 = time_in[0];
    real_subband[0] = (x0 + y0) / 2;
    imag_subband[0] = (x0 - y0) / 2;
    for (idx = 1; idx < qmf_bands; idx++) {
      x0 = time_in[idx + 1];
      y0 = time_in[qmf_bands_by_2 - idx];
      real_subband[idx] = (x0 - y0) / 2;
      imag_subband[idx] = (x0 + y0) / 2;
    }
  } else {
    for (idx = 0; idx < qmf_bands; idx += 2) {
      x0 = time_in[idx + 0];
      x1 = time_in[idx + 1];
      y0 = time_in[qmf_bands_by_2 - 1 - idx];
      y1 = time_in[qmf_bands_by_2 - 2 - idx];

      real_subband[idx + 0] = (x0 - y0) / 2;
      real_subband[idx + 1] = (x1 - y1) / 2;
      imag_subband[idx + 0] = (x0 + y0) / 2;
      imag_subband[idx + 1] = (x1 + y1) / 2;
    }
  }
  error = ixheaace_mps_212_dct_iv(real_subband, qmf_bands, ptr_scratch);
  if (error != IA_NO_ERROR) {
    return error;
  }
  error = ixheaace_mps_212_dst_iv(imag_subband, qmf_bands, ptr_scratch);
  if (error != IA_NO_ERROR) {
    return error;
  }

  for (idx = 0; idx < MIN(pstr_qmf_filter_bank->lsb, qmf_bands); idx += 2) {
    intermediate_band = real_subband[idx];
    real_subband[idx] = -imag_subband[idx];
    imag_subband[idx] = intermediate_band;

    intermediate_band = -real_subband[idx + 1];
    real_subband[idx + 1] = imag_subband[idx + 1];
    imag_subband[idx + 1] = intermediate_band;
  }
  return IA_NO_ERROR;
}

static VOID ixheaace_mps_212_qmf_ana_prototype_fir_slot(FLOAT32 *ptr_analysis_buffer,
                                                        WORD32 qmf_bands,
                                                        const FLOAT32 *ptr_filter, WORD32 stride,
                                                        FLOAT32 *ptr_filter_states) {
  const FLOAT32 *p_flt = ptr_filter;
  WORD32 poly, band;
  FLOAT32 accumlate;

  for (band = 0; band < 2 * qmf_bands; band++) {
    accumlate = 0;
    p_flt += QMF_NO_POLY * (stride - 1);
    for (poly = 0; poly < QMF_NO_POLY; poly++) {
      accumlate += (((*p_flt++) * ptr_filter_states[2 * qmf_bands * poly]));
    }
    ptr_analysis_buffer[2 * qmf_bands - 1 - band] = accumlate;
    ptr_filter_states++;
  }
}

IA_ERRORCODE ixheaace_mps_212_qmf_analysis_filtering_slot(
    ixheaace_mps_pstr_qmf_filter_bank pstr_qmf_filter_bank, FLOAT32 *real_subband,
    FLOAT32 *imag_subband, const FLOAT32 *time_in, const WORD32 stride, FLOAT32 *p_work_buffer,
    WORD8 *ptr_scratch) {
  IA_ERRORCODE error = IA_NO_ERROR;
  WORD32 idx;
  WORD32 offset = pstr_qmf_filter_bank->no_channels * (QMF_NO_POLY * 2 - 1);
  FLOAT32 *pstr_filter_states_ana_tmp =
      ((FLOAT32 *)pstr_qmf_filter_bank->ptr_filter_states) + offset;
  for (idx = 0; idx < pstr_qmf_filter_bank->no_channels; idx++) {
    *pstr_filter_states_ana_tmp++ = (FLOAT32)*time_in;
    time_in += stride;
  }
  ixheaace_mps_212_qmf_ana_prototype_fir_slot(
      p_work_buffer, pstr_qmf_filter_bank->no_channels, pstr_qmf_filter_bank->pstr_filter,
      pstr_qmf_filter_bank->p_stride, (FLOAT32 *)pstr_qmf_filter_bank->ptr_filter_states);

  error = ixheaace_mps_212_qmf_forward_modulation_hq(pstr_qmf_filter_bank, p_work_buffer,
                                                     real_subband, imag_subband, ptr_scratch);
  if (error != IA_NO_ERROR) {
    return error;
  }

  memmove(pstr_qmf_filter_bank->ptr_filter_states,
          (FLOAT32 *)pstr_qmf_filter_bank->ptr_filter_states + pstr_qmf_filter_bank->no_channels,
          offset * sizeof(FLOAT32));
  return error;
}

IA_ERRORCODE
ixheaace_mps_212_qmf_init_filter_bank(ixheaace_mps_pstr_qmf_filter_bank pstr_qmf_filter_bank,
                                      VOID *ptr_filter_states, WORD32 num_cols, WORD32 lsb,
                                      WORD32 usb, WORD32 no_channels) {
  memset(pstr_qmf_filter_bank, 0, sizeof(ixheaace_mps_qmf_filter_bank));
  pstr_qmf_filter_bank->no_channels = no_channels;
  pstr_qmf_filter_bank->no_col = num_cols;
  pstr_qmf_filter_bank->lsb = MIN(lsb, pstr_qmf_filter_bank->no_channels);
  pstr_qmf_filter_bank->usb = MIN(usb, pstr_qmf_filter_bank->no_channels);
  pstr_qmf_filter_bank->ptr_filter_states = (VOID *)ptr_filter_states;
  memset(pstr_qmf_filter_bank->ptr_filter_states, 0,
         (2 * QMF_NO_POLY - 1) * pstr_qmf_filter_bank->no_channels * sizeof(FLOAT32));
  pstr_qmf_filter_bank->p_stride = 1;
  if (no_channels == 64) {
    pstr_qmf_filter_bank->pstr_filter = qmf_mps_ld_fb_640;
    pstr_qmf_filter_bank->filter_size = 640;
  } else {
    pstr_qmf_filter_bank->pstr_filter = qmf_mps_ld_fb_320;
    pstr_qmf_filter_bank->filter_size = 320;
  }

  return IA_NO_ERROR;
}