1/******************************************************************************
2 *                                                                            *
3 * Copyright (C) 2018 The Android Open Source Project
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at:
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 *
17 *****************************************************************************
18 * Originally developed and contributed by Ittiam Systems Pvt. Ltd, Bangalore
19*/
20#include <float.h>
21#include <stdlib.h>
22#include <stdio.h>
23#include <math.h>
24#include <string.h>
25#include <ixheaacd_type_def.h>
26#include "ixheaacd_bitbuffer.h"
27
28#include "ixheaacd_interface.h"
29
30#include "ixheaacd_tns_usac.h"
31#include "ixheaacd_cnst.h"
32
33#include "ixheaacd_acelp_info.h"
34
35#include "ixheaacd_td_mdct.h"
36
37#include "ixheaacd_sbrdecsettings.h"
38#include "ixheaacd_info.h"
39#include "ixheaacd_sbr_common.h"
40#include "ixheaacd_drc_data_struct.h"
41#include "ixheaacd_drc_dec.h"
42#include "ixheaacd_sbrdecoder.h"
43#include "ixheaacd_mps_polyphase.h"
44#include "ixheaacd_sbr_const.h"
45
46#include "ixheaacd_main.h"
47#include "ixheaacd_arith_dec.h"
48#include "ixheaacd_func_def.h"
49#include "ixheaacd_windows.h"
50#include "ixheaacd_acelp_com.h"
51
52#include "ixheaacd_constants.h"
53#include <ixheaacd_type_def.h>
54#include <ixheaacd_basic_ops32.h>
55#include <ixheaacd_basic_ops40.h>
56
57static FLOAT32 ixheaacd_randomsign(UWORD32 *seed);
58#define ABS(A) ((A) < 0 ? (-A) : (A))
59
60VOID ixheaacd_lpc_coeff_wt_apply(FLOAT32 *a, FLOAT32 *ap) {
61  FLOAT32 f;
62  WORD32 i;
63  ap[0] = a[0];
64  f = 0.92f;
65  for (i = 1; i <= 16; i++) {
66    ap[i] = f * a[i];
67    f *= 0.92f;
68  }
69  return;
70}
71
72WORD8 ixheaacd_float2fix(FLOAT32 *x, WORD32 *int_x, WORD32 length) {
73  WORD32 k, itemp;
74  FLOAT32 ftemp = 0.0;
75  WORD8 shiftp;
76  for (k = 0; k < length; k++) {
77    if (ABS(x[k]) > ftemp) ftemp = ABS(x[k]);
78  }
79
80  itemp = (WORD32)(ftemp);
81  shiftp = ixheaacd_norm32(itemp);
82
83  for (k = 0; k < length; k++) {
84    int_x[k] = (WORD32)(x[k] * (FLOAT32)((WORD64)1 << shiftp));
85  }
86
87  return (shiftp);
88}
89
90VOID ixheaacd_fix2float(WORD32 *int_xn1, FLOAT32 *xn1, WORD32 length,
91                        WORD8 *shiftp, WORD32 *preshift) {
92  WORD32 k;
93  FLOAT32 qfac;
94  if ((*shiftp - *preshift) > 0) {
95    qfac = 1.0f / (FLOAT32)((WORD64)1 << (*shiftp - *preshift));
96    for (k = 0; k < length; k++) {
97      xn1[k] = (FLOAT32)((FLOAT32)int_xn1[k] * qfac);
98    }
99  } else {
100    for (k = 0; k < length; k++) {
101      xn1[k] = (FLOAT32)((FLOAT32)int_xn1[k] *
102                         (FLOAT32)((WORD64)1 << (*preshift - *shiftp)));
103    }
104  }
105}
106
107static VOID ixheaacd_low_fq_deemphasis(FLOAT32 x[], WORD32 lg,
108                                       FLOAT32 gains[]) {
109  WORD32 i, j, k, i_max;
110  FLOAT32 max, factor, rm;
111
112  k = 8;
113  i_max = lg / 4;
114
115  max = 0.01f;
116  for (i = 0; i < i_max; i += k) {
117    rm = 0.01f;
118    for (j = i; j < i + k; j++) rm += x[j] * x[j];
119
120    if (rm > max) max = rm;
121  }
122
123  factor = 0.1f;
124  for (i = 0; i < i_max; i += k) {
125    rm = 0.01f;
126    for (j = i; j < i + k; j++) rm += x[j] * x[j];
127
128    rm = (FLOAT32)sqrt(rm / max);
129    if (rm > factor) factor = rm;
130
131    for (j = i; j < i + k; j++) x[j] *= factor;
132
133    gains[i / k] = factor;
134  }
135
136  return;
137}
138
139WORD32 ixheaacd_tcx_mdct(ia_usac_data_struct *usac_data,
140                         ia_td_frame_data_struct *pstr_td_frame_data,
141                         WORD32 frame_index, FLOAT32 lp_flt_coff_a[], WORD32 lg,
142                         ia_usac_lpd_decoder_handle st) {
143  WORD32 i, mode;
144  WORD32 *ptr_tcx_quant;
145  FLOAT32 tmp, gain_tcx, noise_level, energy, temp;
146  FLOAT32 *ptr_a, i_ap[ORDER + 1];
147  const FLOAT32 *sine_window_prev, *sine_window;
148  WORD32 fac_length_prev;
149  FLOAT32 alfd_gains[LEN_SUPERFRAME / (4 * 8)];
150  FLOAT32 x[LEN_SUPERFRAME], buf[ORDER + LEN_SUPERFRAME];
151  WORD32 int_x[LEN_SUPERFRAME + (2 * FAC_LENGTH)];
152  WORD32 int_xn1[LEN_SUPERFRAME + (2 * FAC_LENGTH)];
153  FLOAT32 gain1[LEN_SUPERFRAME], gain2[LEN_SUPERFRAME];
154  FLOAT32 xn_buf[LEN_SUPERFRAME + (2 * FAC_LENGTH)];
155  FLOAT32 *xn;
156  FLOAT32 xn1[2 * FAC_LENGTH], facwindow[2 * FAC_LENGTH];
157  WORD32 TTT;
158  WORD8 shiftp;
159  WORD32 preshift = 0;
160  WORD32 loop_count = 0;
161  FLOAT32 *exc = &usac_data->exc_buf[usac_data->len_subfrm * frame_index +
162                                     MAX_PITCH + INTER_LP_FIL_ORDER + 1];
163  FLOAT32 *synth =
164      &usac_data->synth_buf[usac_data->len_subfrm * frame_index + MAX_PITCH +
165                            (((NUM_FRAMES * usac_data->num_subfrm) / 2) - 1) *
166                                LEN_SUBFR];
167
168  WORD32 *ptr_scratch = &usac_data->scratch_buffer[0];
169
170  WORD32 fac_length = (usac_data->len_subfrm) / 2;
171  WORD32 err = 0;
172
173  mode = lg / (usac_data->len_subfrm);
174  if (mode > 2) mode = 3;
175
176  if (st->mode_prev == -2)
177    fac_length_prev = (usac_data->ccfl) / 16;
178
179  else
180    fac_length_prev = fac_length;
181
182  if (fac_length == 96)
183    sine_window = ixheaacd_sine_window192;
184  else
185    sine_window = ixheaacd__sine_window256;
186
187  if (fac_length_prev == 48)
188    sine_window_prev = ixheaacd_sine_window96;
189
190  else if (fac_length_prev == 64)
191    sine_window_prev = ixheaacd_sine_window128;
192
193  else if (fac_length_prev == 96)
194    sine_window_prev = ixheaacd_sine_window192;
195
196  else
197    sine_window_prev = ixheaacd__sine_window256;
198
199  xn = xn_buf + fac_length;
200
201  if (st->mode_prev != 0) {
202    if (st->mode_prev > 0) {
203      for (i = 0; i < (2 * fac_length_prev); i++) {
204        st->exc_prev[i + fac_length - fac_length_prev + 1] *=
205            sine_window_prev[(2 * fac_length_prev) - 1 - i];
206      }
207    }
208    for (i = 0; i < fac_length - fac_length_prev; i++) {
209      st->exc_prev[i + fac_length + fac_length_prev + 1] = 0.0f;
210    }
211  }
212
213  noise_level =
214      0.0625f *
215      (8.0f - ((FLOAT32)pstr_td_frame_data->noise_factor[frame_index]));
216
217  ptr_tcx_quant = pstr_td_frame_data->x_tcx_invquant;
218  for (i = 0; i < frame_index; i++)
219    ptr_tcx_quant += pstr_td_frame_data->tcx_lg[i];
220
221  for (i = 0; i < lg; i++) x[i] = (FLOAT32)ptr_tcx_quant[i];
222
223  for (i = lg / 6; i < lg; i += 8) {
224    WORD32 k, max_k = min(lg, i + 8);
225    FLOAT32 tmp = 0.0f;
226    for (k = i; k < max_k; k++) tmp += ptr_tcx_quant[k] * ptr_tcx_quant[k];
227
228    if (tmp == 0.0f) {
229      for (k = i; k < max_k; k++)
230        x[k] = noise_level *
231               ixheaacd_randomsign(
232                   &(usac_data->seed_value[usac_data->present_chan]));
233    }
234  }
235
236  ixheaacd_low_fq_deemphasis(x, lg, alfd_gains);
237
238  ixheaacd_lpc_coeff_wt_apply(lp_flt_coff_a + (ORDER + 1), i_ap);
239  ixheaacd_lpc_to_td(i_ap, ORDER, gain1, usac_data->len_subfrm / 4);
240
241  ixheaacd_lpc_coeff_wt_apply(lp_flt_coff_a + (2 * (ORDER + 1)), i_ap);
242  ixheaacd_lpc_to_td(i_ap, ORDER, gain2, usac_data->len_subfrm / 4);
243
244  energy = 0.01f;
245  for (i = 0; i < lg; i++) energy += x[i] * x[i];
246
247  temp = (FLOAT32)sqrt(energy) / lg;
248
249  gain_tcx =
250      (FLOAT32)pow(
251          10.0f,
252          ((FLOAT32)pstr_td_frame_data->global_gain[frame_index]) / 28.0f) /
253      (temp * 2.0f);
254
255  ixheaacd_noise_shaping(x, lg, (usac_data->len_subfrm) / 4, gain1, gain2);
256
257  shiftp = ixheaacd_float2fix(x, int_x, lg);
258
259  err = ixheaacd_acelp_mdct_main(usac_data, int_x, int_xn1, (2 * fac_length),
260                                 lg - (2 * fac_length), &preshift);
261  if (err == -1) return err;
262
263  ixheaacd_fix2float(int_xn1, xn_buf, (lg + (2 * fac_length)), &shiftp,
264                     &preshift);
265
266  ixheaacd_vec_cnst_mul((2.0f / lg), xn_buf, xn_buf, lg + (2 * fac_length));
267
268  st->fac_gain =
269      gain_tcx * 0.5f * (FLOAT32)sqrt(((FLOAT32)fac_length) / (FLOAT32)lg);
270
271  for (i = 0; i < fac_length / 4; i++)
272    st->fac_fd_data[i] = alfd_gains[i * lg / (8 * fac_length)];
273
274  if (st->mode_prev == 0) {
275    for (i = 0; i < fac_length_prev; i++) {
276      facwindow[i] =
277          sine_window_prev[i] * sine_window_prev[(2 * fac_length_prev) - 1 - i];
278      facwindow[fac_length_prev + i] =
279          1.0f - (sine_window_prev[fac_length_prev + i] *
280                  sine_window_prev[fac_length_prev + i]);
281    }
282
283    for (i = 0; i < fac_length / 2; i++) {
284      x[i] = st->fac_gain *
285             (FLOAT32)pstr_td_frame_data->fac[frame_index * FAC_LENGTH + 2 * i];
286      x[fac_length / 2 + i] =
287          st->fac_gain *
288          (FLOAT32)pstr_td_frame_data
289              ->fac[frame_index * FAC_LENGTH + fac_length - 2 * i - 1];
290    }
291
292    for (i = 0; i < fac_length / 8; i++) {
293      x[i] *= st->fac_fd_data[2 * i];
294      x[fac_length - i - 1] *= st->fac_fd_data[2 * i + 1];
295    }
296
297    preshift = 0;
298    shiftp = ixheaacd_float2fix(x, int_x, fac_length);
299
300    err =
301        ixheaacd_acelp_mdct(int_x, int_xn1, &preshift, fac_length, ptr_scratch);
302    if (err == -1) return err;
303
304    ixheaacd_fix2float(int_xn1, xn1, fac_length, &shiftp, &preshift);
305
306    ixheaacd_vec_cnst_mul((2.0f / (FLOAT32)fac_length), xn1, xn1, fac_length);
307
308    memset(xn1 + fac_length, 0, fac_length * sizeof(FLOAT32));
309
310    ixheaacd_lpc_coeff_wt_apply(lp_flt_coff_a + (ORDER + 1), i_ap);
311    ixheaacd_synthesis_tool_float(i_ap, xn1, xn1, 2 * fac_length,
312                                  xn1 + fac_length);
313
314    for (i = 0; i < fac_length; i++) {
315      temp = st->exc_prev[1 + fac_length + i] * facwindow[fac_length + i] +
316             st->exc_prev[fac_length - i] * facwindow[fac_length - 1 - i];
317      xn1[i] += temp;
318    }
319  }
320
321  for (i = 0; i < lg + (2 * fac_length); i++) xn_buf[i] *= gain_tcx;
322
323  for (i = 0; i < (2 * fac_length_prev); i++)
324    xn_buf[i + fac_length - fac_length_prev] *= sine_window_prev[i];
325
326  for (i = 0; i < fac_length - fac_length_prev; i++) xn_buf[i] = 0.0f;
327
328  if (st->mode_prev != 0) {
329    for (i = fac_length - fac_length_prev; i < (fac_length + fac_length_prev);
330         i++)
331      xn_buf[i] += st->exc_prev[1 + i];
332  } else {
333    for (i = fac_length - fac_length_prev; i < (fac_length + fac_length_prev);
334         i++)
335      xn_buf[i + fac_length] += xn1[i];
336  }
337
338  ixheaacd_mem_cpy(xn_buf + lg - 1, st->exc_prev, 1 + (2 * fac_length));
339
340  for (i = 0; i < (2 * fac_length); i++) {
341    xn_buf[i + lg] *= sine_window[(2 * fac_length) - 1 - i];
342  }
343
344  if (st->mode_prev != 0) {
345    ixheaacd_mem_cpy(xn_buf + fac_length - fac_length_prev,
346                     synth - fac_length_prev, fac_length_prev);
347
348    for (i = 0; i < ORDER + fac_length; i++)
349      buf[i] = synth[i - ORDER - fac_length] -
350               (PREEMPH_FILT_FAC * synth[i - ORDER - fac_length - 1]);
351
352    ptr_a = st->lp_flt_coeff_a_prev;
353    TTT = fac_length % LEN_SUBFR;
354    if (TTT != 0)
355      ixheaacd_residual_tool_float(ptr_a, &buf[ORDER], &exc[-fac_length], TTT,
356                                   1);
357
358    loop_count = (fac_length - TTT) / LEN_SUBFR;
359    ixheaacd_residual_tool_float(ptr_a, &buf[ORDER + TTT],
360                                 &exc[TTT - fac_length], LEN_SUBFR, loop_count);
361  }
362
363  ixheaacd_mem_cpy(xn, synth, lg);
364
365  ixheaacd_mem_cpy(synth - ORDER - 1, xn - ORDER - 1, ORDER + 1);
366  tmp = xn[-ORDER - 1];
367  ixheaacd_preemphsis_tool_float(xn - ORDER, PREEMPH_FILT_FAC, ORDER + lg, tmp);
368
369  ptr_a = lp_flt_coff_a + (2 * (ORDER + 1));
370
371  ixheaacd_residual_tool_float(ptr_a, xn, exc, lg, 1);
372
373  ixheaacd_mem_cpy(ptr_a, st->lp_flt_coeff_a_prev, ORDER + 1);
374  ixheaacd_mem_cpy(ptr_a, st->lp_flt_coeff_a_prev + ORDER + 1, ORDER + 1);
375
376  return err;
377}
378
379static FLOAT32 ixheaacd_randomsign(UWORD32 *seed) {
380  FLOAT32 sign = 0.0f;
381  *seed = (UWORD32)(((UWORD64)(*seed) * (UWORD64)69069) + 5);
382
383  if (((*seed) & 0x10000) > 0)
384    sign = -1.f;
385  else
386    sign = +1.f;
387
388  return sign;
389}
390