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