1 /******************************************************************************
2 * *
3 * Copyright (C) 2023 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
21 #include <string.h>
22 #include <stdlib.h>
23
24 #include "ixheaac_type_def.h"
25 #include "ixheaac_constants.h"
26 #include "ixheaace_sbr_def.h"
27 #include "ixheaace_resampler.h"
28 #include "ixheaace_sbr_rom.h"
29 #include "ixheaace_common_rom.h"
30 #include "ixheaace_sbr_hbe.h"
31 #include "ixheaace_sbr_qmf_enc.h"
32 #include "ixheaace_sbr_hybrid.h"
33
34 #include "ixheaace_aac_constants.h"
35 #include "ixheaac_basic_ops32.h"
36 #include "ixheaac_basic_ops16.h"
37 #include "ixheaac_basic_ops40.h"
38 #include "ixheaac_basic_ops.h"
39
40 #include "ixheaace_psy_const.h"
41 #include "ixheaace_tns.h"
42 #include "ixheaace_tns_params.h"
43 #include "ixheaace_rom.h"
44 #include "ixheaace_fft.h"
45
ia_enhaacplus_enc_fct3_4(FLOAT32 * ptr_x)46 static VOID ia_enhaacplus_enc_fct3_4(FLOAT32 *ptr_x) {
47 FLOAT32 tmp00, tmp01, tmp10, tmp11, xp, xp2;
48
49 xp2 = ptr_x[1];
50 xp = ptr_x[0];
51
52 xp2 = xp2 * IXHEAACE_COS_PI_BY_4;
53
54 tmp00 = xp + xp2;
55 tmp01 = xp - xp2;
56
57 xp = ptr_x[2];
58 xp2 = ptr_x[3];
59
60 tmp10 = (xp * IXHEAACE_COS_PI_BY_8) + (xp2 * IXHEAACE_SIN_PI_BY_8);
61
62 ptr_x[0] = tmp00 + tmp10;
63 ptr_x[3] = tmp00 - tmp10;
64
65 tmp11 = (xp * IXHEAACE_SIN_PI_BY_8) - (xp2 * IXHEAACE_COS_PI_BY_8);
66
67 ptr_x[1] = tmp01 + tmp11;
68 ptr_x[2] = tmp01 - tmp11;
69 }
70
ia_enhaacplus_enc_fst3_4r(FLOAT32 * ptr_x)71 static VOID ia_enhaacplus_enc_fst3_4r(FLOAT32 *ptr_x) {
72 FLOAT32 tmp00, tmp01, tmp10, tmp11, xp, xp2;
73
74 xp2 = ptr_x[2];
75 xp = ptr_x[3];
76
77 xp2 = xp2 * IXHEAACE_COS_PI_BY_4;
78
79 tmp00 = xp + xp2;
80 tmp01 = xp - xp2;
81
82 xp = ptr_x[1];
83 xp2 = ptr_x[0];
84
85 tmp10 = (xp * IXHEAACE_COS_PI_BY_8) + (xp2 * IXHEAACE_SIN_PI_BY_8);
86
87 ptr_x[3] = tmp00 + tmp10;
88 ptr_x[0] = tmp10 - tmp00;
89
90 tmp11 = (xp2 * IXHEAACE_COS_PI_BY_8) - (xp * IXHEAACE_SIN_PI_BY_8);
91
92 ptr_x[2] = tmp11 - tmp01;
93 ptr_x[1] = tmp11 + tmp01;
94 }
95
ia_enhaacplus_enc_fct4_4r(FLOAT32 * ptr_x)96 static VOID ia_enhaacplus_enc_fct4_4r(FLOAT32 *ptr_x) {
97 FLOAT32 tmp00, tmp01, tmp10, tmp11, xp, xp2;
98
99 xp = ptr_x[1];
100 xp2 = ptr_x[0];
101
102 xp = xp * IXHEAACE_COS_PI_BY_4;
103 tmp00 = xp2 + xp;
104 tmp01 = xp2 - xp;
105
106 xp = ptr_x[2];
107 xp2 = ptr_x[3];
108
109 xp = xp * IXHEAACE_COS_PI_BY_4;
110 tmp11 = xp2 - xp;
111 tmp10 = xp2 + xp;
112
113 ptr_x[3] = tmp00 * IXHEAACE_COS_PI_BY_16 + tmp10 * IXHEAACE_SIN_PI_BY_16;
114 ptr_x[0] = tmp00 * IXHEAACE_SIN_PI_BY_16 - tmp10 * IXHEAACE_COS_PI_BY_16;
115
116 ptr_x[2] = tmp01 * IXHEAACE_COS_3_PI_BY_16 - tmp11 * IXHEAACE_SIN_3_PI_BY_16;
117 ptr_x[1] = tmp01 * IXHEAACE_SIN_3_PI_BY_16 + tmp11 * IXHEAACE_COS_3_PI_BY_16;
118 }
119
ia_enhaacplus_enc_fst4_4(FLOAT32 * ptr_x)120 static VOID ia_enhaacplus_enc_fst4_4(FLOAT32 *ptr_x) {
121 FLOAT32 tmp00, tmp01, tmp10, tmp11, xp, xp2;
122
123 xp = ptr_x[1];
124 xp2 = ptr_x[0];
125
126 xp = xp * IXHEAACE_COS_PI_BY_4;
127 tmp10 = xp2 + xp;
128 tmp11 = xp2 - xp;
129
130 xp = ptr_x[2];
131 xp2 = ptr_x[3];
132
133 xp = xp * IXHEAACE_COS_PI_BY_4;
134 tmp01 = xp2 - xp;
135 tmp00 = xp2 + xp;
136
137 ptr_x[0] = tmp00 * IXHEAACE_COS_PI_BY_16 + tmp10 * IXHEAACE_SIN_PI_BY_16;
138 ptr_x[3] = tmp10 * IXHEAACE_COS_PI_BY_16 - tmp00 * IXHEAACE_SIN_PI_BY_16;
139 ptr_x[1] = tmp11 * IXHEAACE_SIN_3_PI_BY_16 - tmp01 * IXHEAACE_COS_3_PI_BY_16;
140 ptr_x[2] = tmp01 * IXHEAACE_SIN_3_PI_BY_16 + tmp11 * IXHEAACE_COS_3_PI_BY_16;
141 }
142
ia_enhaacplus_enc_fct3_64(FLOAT32 * ptr_a,ixheaace_str_qmf_tabs * pstr_qmf_tab)143 static VOID ia_enhaacplus_enc_fct3_64(FLOAT32 *ptr_a, ixheaace_str_qmf_tabs *pstr_qmf_tab) {
144 WORD32 k;
145
146 const FLOAT32 *ptr_t1;
147 FLOAT32 xp, xp2, xp3, xp4, wc, ws;
148
149 FLOAT32 *ptr1, *ptr2;
150 FLOAT32 *ptr_ap, *ptr_an;
151
152 /* bit reversal */
153 xp = ptr_a[1];
154 ptr_a[1] = ptr_a[32];
155 ptr_a[32] = xp;
156 xp = ptr_a[2];
157 ptr_a[2] = ptr_a[16];
158 ptr_a[16] = xp;
159 xp = ptr_a[3];
160 ptr_a[3] = ptr_a[48];
161 ptr_a[48] = xp;
162 xp = ptr_a[4];
163 ptr_a[4] = ptr_a[8];
164 ptr_a[8] = xp;
165 xp = ptr_a[5];
166 ptr_a[5] = ptr_a[40];
167 ptr_a[40] = xp;
168 xp = ptr_a[6];
169 ptr_a[6] = ptr_a[24];
170 ptr_a[24] = xp;
171 xp = ptr_a[7];
172 ptr_a[7] = ptr_a[56];
173 ptr_a[56] = xp;
174 xp = ptr_a[9];
175 ptr_a[9] = ptr_a[36];
176 ptr_a[36] = xp;
177 xp = ptr_a[10];
178 ptr_a[10] = ptr_a[20];
179 ptr_a[20] = xp;
180 xp = ptr_a[11];
181 ptr_a[11] = ptr_a[52];
182 ptr_a[52] = xp;
183 xp = ptr_a[13];
184 ptr_a[13] = ptr_a[44];
185 ptr_a[44] = xp;
186 xp = ptr_a[14];
187 ptr_a[14] = ptr_a[28];
188 ptr_a[28] = xp;
189 xp = ptr_a[15];
190 ptr_a[15] = ptr_a[60];
191 ptr_a[60] = xp;
192 xp = ptr_a[17];
193 ptr_a[17] = ptr_a[34];
194 ptr_a[34] = xp;
195 xp = ptr_a[19];
196 ptr_a[19] = ptr_a[50];
197 ptr_a[50] = xp;
198 xp = ptr_a[21];
199 ptr_a[21] = ptr_a[42];
200 ptr_a[42] = xp;
201 xp = ptr_a[22];
202 ptr_a[22] = ptr_a[26];
203 ptr_a[26] = xp;
204 xp = ptr_a[23];
205 ptr_a[23] = ptr_a[58];
206 ptr_a[58] = xp;
207 xp = ptr_a[25];
208 ptr_a[25] = ptr_a[38];
209 ptr_a[38] = xp;
210 xp = ptr_a[27];
211 ptr_a[27] = ptr_a[54];
212 ptr_a[54] = xp;
213 xp = ptr_a[29];
214 ptr_a[29] = ptr_a[46];
215 ptr_a[46] = xp;
216 xp = ptr_a[31];
217 ptr_a[31] = ptr_a[62];
218 ptr_a[62] = xp;
219 xp = ptr_a[35];
220 ptr_a[35] = ptr_a[49];
221 ptr_a[49] = xp;
222 xp = ptr_a[37];
223 ptr_a[37] = ptr_a[41];
224 ptr_a[41] = xp;
225 xp = ptr_a[39];
226 ptr_a[39] = ptr_a[57];
227 ptr_a[57] = xp;
228 xp = ptr_a[43];
229 ptr_a[43] = ptr_a[53];
230 ptr_a[53] = xp;
231 xp = ptr_a[47];
232 ptr_a[47] = ptr_a[61];
233 ptr_a[61] = xp;
234 xp = ptr_a[55];
235 ptr_a[55] = ptr_a[59];
236 ptr_a[59] = xp;
237
238 xp = ptr_a[33];
239 xp2 = ptr_a[62];
240 ptr_a[62] = xp2 - xp;
241 ptr_a[33] = xp2 + xp;
242 xp = ptr_a[34];
243 xp2 = ptr_a[60];
244 ptr_a[60] = xp2 - xp;
245 ptr_a[34] = xp2 + xp;
246 xp = ptr_a[35];
247 xp2 = ptr_a[61];
248 ptr_a[61] = xp2 - xp;
249 ptr_a[35] = xp2 + xp;
250 xp = ptr_a[36];
251 xp2 = ptr_a[56];
252 ptr_a[56] = xp2 - xp;
253 ptr_a[36] = xp2 + xp;
254 xp = ptr_a[37];
255 xp2 = ptr_a[57];
256 ptr_a[57] = xp2 - xp;
257 ptr_a[37] = xp2 + xp;
258 xp = ptr_a[38];
259 xp2 = ptr_a[58];
260 ptr_a[58] = xp2 - xp;
261 ptr_a[38] = xp2 + xp;
262 xp = ptr_a[39];
263 xp2 = ptr_a[59];
264 ptr_a[59] = xp2 - xp;
265 ptr_a[39] = xp2 + xp;
266 xp = ptr_a[40];
267 xp2 = ptr_a[48];
268 ptr_a[48] = xp2 - xp;
269 ptr_a[40] = xp2 + xp;
270 xp = ptr_a[41];
271 xp2 = ptr_a[49];
272 ptr_a[49] = xp2 - xp;
273 ptr_a[41] = xp2 + xp;
274 xp = ptr_a[42];
275 xp2 = ptr_a[50];
276 ptr_a[50] = xp2 - xp;
277 ptr_a[42] = xp2 + xp;
278 xp = ptr_a[43];
279 xp2 = ptr_a[51];
280 ptr_a[51] = xp2 - xp;
281 ptr_a[43] = xp2 + xp;
282 xp = ptr_a[44];
283 xp2 = ptr_a[52];
284 ptr_a[52] = xp2 - xp;
285 ptr_a[44] = xp2 + xp;
286 xp = ptr_a[45];
287 xp2 = ptr_a[53];
288 ptr_a[53] = xp2 - xp;
289 ptr_a[45] = xp2 + xp;
290 xp = ptr_a[46];
291 xp2 = ptr_a[54];
292 ptr_a[54] = xp2 - xp;
293 ptr_a[46] = xp2 + xp;
294 xp = ptr_a[47];
295 xp2 = ptr_a[55];
296 ptr_a[55] = xp2 - xp;
297 ptr_a[47] = xp2 + xp;
298 xp = ptr_a[17];
299 xp2 = ptr_a[30];
300 ptr_a[30] = xp2 - xp;
301 ptr_a[17] = xp2 + xp;
302 xp = ptr_a[18];
303 xp2 = ptr_a[28];
304 ptr_a[28] = xp2 - xp;
305 ptr_a[18] = xp2 + xp;
306 xp = ptr_a[19];
307 xp2 = ptr_a[29];
308 ptr_a[29] = xp2 - xp;
309 ptr_a[19] = xp2 + xp;
310 xp = ptr_a[20];
311 xp2 = ptr_a[24];
312 ptr_a[24] = xp2 - xp;
313 ptr_a[20] = xp2 + xp;
314 xp = ptr_a[21];
315 xp2 = ptr_a[25];
316 ptr_a[25] = xp2 - xp;
317 ptr_a[21] = xp2 + xp;
318 xp = ptr_a[22];
319 xp2 = ptr_a[26];
320 ptr_a[26] = xp2 - xp;
321 ptr_a[22] = xp2 + xp;
322 xp = ptr_a[23];
323 xp2 = ptr_a[27];
324 ptr_a[27] = xp2 - xp;
325 ptr_a[23] = xp2 + xp;
326 xp = ptr_a[9];
327 xp2 = ptr_a[14];
328 ptr_a[14] = xp2 - xp;
329 ptr_a[9] = xp2 + xp;
330 xp = ptr_a[10];
331 xp2 = ptr_a[12];
332 ptr_a[12] = xp2 - xp;
333 ptr_a[10] = xp2 + xp;
334 xp = ptr_a[11];
335 xp2 = ptr_a[13];
336 ptr_a[13] = xp2 - xp;
337 ptr_a[11] = xp2 + xp;
338 xp = ptr_a[41];
339 xp2 = ptr_a[46];
340 ptr_a[46] = xp2 - xp;
341 ptr_a[41] = xp2 + xp;
342 xp = ptr_a[42];
343 xp2 = ptr_a[44];
344 ptr_a[44] = xp2 - xp;
345 ptr_a[42] = xp2 + xp;
346 xp = ptr_a[43];
347 xp2 = ptr_a[45];
348 ptr_a[45] = xp2 - xp;
349 ptr_a[43] = xp2 + xp;
350 xp = ptr_a[49];
351 xp2 = ptr_a[54];
352 ptr_a[49] = xp - xp2;
353 ptr_a[54] = xp2 + xp;
354 xp = ptr_a[50];
355 xp2 = ptr_a[52];
356 ptr_a[50] = xp - xp2;
357 ptr_a[52] = xp2 + xp;
358 xp = ptr_a[51];
359 xp2 = ptr_a[53];
360 ptr_a[51] = xp - xp2;
361 ptr_a[53] = xp2 + xp;
362 xp = ptr_a[5];
363 xp2 = ptr_a[6];
364 ptr_a[6] = xp2 - xp;
365 ptr_a[5] = xp2 + xp;
366 xp = ptr_a[21];
367 xp2 = ptr_a[22];
368 ptr_a[22] = xp2 - xp;
369 ptr_a[21] = xp2 + xp;
370 xp = ptr_a[25];
371 xp2 = ptr_a[26];
372 ptr_a[25] = xp - xp2;
373 ptr_a[26] = xp2 + xp;
374 xp = ptr_a[37];
375 xp2 = ptr_a[38];
376 ptr_a[38] = xp2 - xp;
377 ptr_a[37] = xp2 + xp;
378 xp = ptr_a[57];
379 xp2 = ptr_a[58];
380 ptr_a[57] = xp - xp2;
381 ptr_a[58] = xp2 + xp;
382
383 ia_enhaacplus_enc_fct3_4(ptr_a);
384 ia_enhaacplus_enc_fct4_4r(ptr_a + 4);
385 ia_enhaacplus_enc_fct3_4(ptr_a + 8);
386 ia_enhaacplus_enc_fst3_4r(ptr_a + 12);
387
388 ia_enhaacplus_enc_fct3_4(ptr_a + 16);
389 ia_enhaacplus_enc_fct4_4r(ptr_a + 20);
390 ia_enhaacplus_enc_fst4_4(ptr_a + 24);
391 ia_enhaacplus_enc_fst3_4r(ptr_a + 28);
392
393 ia_enhaacplus_enc_fct3_4(ptr_a + 32);
394 ia_enhaacplus_enc_fct4_4r(ptr_a + 36);
395 ia_enhaacplus_enc_fct3_4(ptr_a + 40);
396 ia_enhaacplus_enc_fst3_4r(ptr_a + 44);
397
398 ia_enhaacplus_enc_fct3_4(ptr_a + 48);
399 ia_enhaacplus_enc_fst3_4r(ptr_a + 52);
400 ia_enhaacplus_enc_fst4_4(ptr_a + 56);
401 ia_enhaacplus_enc_fst3_4r(ptr_a + 60);
402
403 ptr_ap = ptr_a;
404 ptr_an = ptr_a + 7;
405 for (k = 4; k != 0; k--) {
406 xp = *ptr_ap++;
407 xp2 = *ptr_an--;
408 xp3 = *(ptr_ap + 15);
409 xp4 = *(ptr_an + 17);
410 *(ptr_an + 1) = xp - xp2;
411 *(ptr_ap - 1) = xp + xp2;
412
413 xp = *(ptr_ap + 23);
414 xp2 = *(ptr_an + 25);
415 *(ptr_an + 17) = xp3 - xp4;
416 *(ptr_ap + 15) = xp3 + xp4;
417
418 xp3 = *(ptr_ap + 31);
419 xp4 = *(ptr_an + 33);
420 *(ptr_ap + 23) = xp - xp2;
421 *(ptr_an + 25) = xp + xp2;
422
423 xp = *(ptr_ap + 55);
424 xp2 = *(ptr_an + 57);
425 *(ptr_an + 33) = xp3 - xp4;
426 *(ptr_ap + 31) = xp3 + xp4;
427
428 *(ptr_ap + 55) = xp - xp2;
429 *(ptr_an + 57) = xp + xp2;
430 }
431
432 ptr_t1 = pstr_qmf_tab->cos_sin_fct4_8;
433
434 ptr_ap = ptr_a + 8;
435 ptr_an = ptr_a + 15;
436 for (k = 4; k != 0; k--) {
437 wc = *ptr_t1++;
438 ws = *ptr_t1++;
439
440 xp = *ptr_ap * wc + *ptr_an * ws;
441 *ptr_ap = *ptr_ap * ws - *ptr_an * wc;
442 ptr_ap++;
443 *ptr_an-- = xp;
444
445 xp = *(ptr_ap + 31) * wc + *(ptr_an + 33) * ws;
446 *(ptr_ap + 31) = *(ptr_ap + 31) * ws - *(ptr_an + 33) * wc;
447 *(ptr_an + 33) = xp;
448
449 xp = *(ptr_ap + 39) * ws + *(ptr_an + 41) * wc;
450 *(ptr_an + 41) = *(ptr_ap + 39) * wc - *(ptr_an + 41) * ws;
451 *(ptr_ap + 39) = xp;
452 }
453
454 ptr_ap = ptr_a;
455 ptr_an = ptr_a + 15;
456 for (k = 8; k != 0; k--) {
457 xp = *ptr_ap++;
458 xp2 = *ptr_an--;
459 xp3 = *(ptr_ap + 31);
460 xp4 = *(ptr_an + 33);
461
462 *(ptr_an + 1) = xp - xp2;
463 *(ptr_ap - 1) = xp + xp2;
464
465 xp = *(ptr_ap + 47);
466 xp2 = *(ptr_an + 49);
467 *(ptr_an + 33) = xp3 - xp4;
468 *(ptr_ap + 31) = xp3 + xp4;
469 *(ptr_ap + 47) = xp - xp2;
470 *(ptr_an + 49) = xp + xp2;
471 }
472
473 ptr_t1 = pstr_qmf_tab->cos_sin_fct4_16;
474
475 ptr1 = &ptr_a[16];
476 ptr2 = &ptr_a[31];
477 for (k = 7; k >= 0; k--) {
478 wc = *ptr_t1++;
479 ws = *ptr_t1++;
480
481 xp = *ptr1;
482 xp2 = *ptr2;
483
484 *ptr2-- = xp * wc + xp2 * ws;
485 *ptr1++ = xp * ws - xp2 * wc;
486 }
487
488 ptr1 = &ptr_a[0];
489 ptr2 = &ptr_a[31];
490 for (k = 15; k >= 0; k--) {
491 xp = *ptr1;
492 xp2 = *ptr2;
493
494 *ptr1++ = xp + xp2;
495 *ptr2-- = xp - xp2;
496 }
497
498 ptr_t1 = pstr_qmf_tab->cos_sin_fct4_32;
499 ptr1 = &ptr_a[32];
500 ptr2 = &ptr_a[63];
501
502 for (k = 15; k >= 0; k--) {
503 wc = *ptr_t1++;
504 ws = *ptr_t1++;
505
506 xp = *ptr1;
507 xp2 = *ptr2;
508
509 *ptr2-- = xp * wc + xp2 * ws;
510 *ptr1++ = xp * ws - xp2 * wc;
511 }
512
513 ptr1 = &ptr_a[0];
514 ptr2 = &ptr_a[63];
515 for (k = 31; k >= 0; k--) {
516 xp = *ptr1;
517 xp2 = *ptr2;
518
519 *ptr1++ = xp + xp2;
520 *ptr2-- = xp - xp2;
521 }
522 }
523
ia_enhaacplus_enc_fst3_64(FLOAT32 * ptr_a,ixheaace_str_qmf_tabs * pstr_qmf_tab)524 static VOID ia_enhaacplus_enc_fst3_64(FLOAT32 *ptr_a, ixheaace_str_qmf_tabs *pstr_qmf_tab) {
525 WORD32 k;
526 FLOAT32 xp, xp2;
527 FLOAT32 *ptr1, *ptr2;
528
529 ptr1 = &ptr_a[0];
530 ptr2 = &ptr_a[63];
531
532 for (k = 31; k >= 0; k--) {
533 xp = *ptr1;
534 xp2 = *ptr2;
535 *ptr2-- = xp;
536 *ptr1++ = xp2;
537 }
538
539 ia_enhaacplus_enc_fct3_64(ptr_a, pstr_qmf_tab);
540
541 ptr1 = &ptr_a[1];
542
543 for (k = 15; k >= 0; k--) {
544 xp = *ptr1;
545 xp2 = *(ptr1 + 2);
546 *ptr1++ = -xp;
547 ptr1++;
548 *ptr1++ = -xp2;
549 ptr1++;
550 }
551 }
552
ixheaace_sbr_pre_mdct(FLOAT32 * ptr_x,WORD32 len,const FLOAT32 * ptr_sine_window)553 static VOID ixheaace_sbr_pre_mdct(FLOAT32 *ptr_x, WORD32 len, const FLOAT32 *ptr_sine_window) {
554 WORD32 i;
555 FLOAT32 wre, wim, re1, re2, im1, im2;
556
557 for (i = 0; i < len / 4; i++) {
558 re1 = ptr_x[2 * i];
559 re2 = ptr_x[2 * i + 1];
560 im2 = ptr_x[len - 2 - 2 * i];
561 im1 = ptr_x[len - 1 - 2 * i];
562
563 wim = ptr_sine_window[2 * i];
564 wre = ptr_sine_window[len - 1 - 2 * i];
565
566 ptr_x[2 * i] = im1 * wim + re1 * wre;
567
568 ptr_x[2 * i + 1] = im1 * wre - re1 * wim;
569
570 wre = ptr_sine_window[len - 2 - 2 * i];
571 wim = ptr_sine_window[2 * i + 1];
572
573 ptr_x[len - 2 - 2 * i] = im2 * wim + re2 * wre;
574
575 ptr_x[len - 1 - 2 * i] = -(im2 * wre - re2 * wim);
576 }
577 }
ixheaace_sbr_pre_mdst(FLOAT32 * ptr_x,WORD32 len,const FLOAT32 * ptr_sine_window)578 static VOID ixheaace_sbr_pre_mdst(FLOAT32 *ptr_x, WORD32 len, const FLOAT32 *ptr_sine_window) {
579 WORD32 i;
580 FLOAT32 wre, wim, re1, re2, im1, im2;
581
582 for (i = 0; i < len / 4; i++) {
583 re1 = -ptr_x[2 * i];
584 re2 = ptr_x[2 * i + 1];
585 im2 = -ptr_x[len - 2 - 2 * i];
586 im1 = ptr_x[len - 1 - 2 * i];
587
588 wim = ptr_sine_window[2 * i];
589 wre = ptr_sine_window[len - 1 - 2 * i];
590
591 ptr_x[2 * i] = im1 * wim + re1 * wre;
592
593 ptr_x[2 * i + 1] = im1 * wre - re1 * wim;
594
595 wim = ptr_sine_window[2 * i + 1];
596 wre = ptr_sine_window[len - 2 - 2 * i];
597
598 ptr_x[len - 2 - 2 * i] = im2 * wim + re2 * wre;
599
600 ptr_x[len - 1 - 2 * i] = -(im2 * wre - re2 * wim);
601 }
602 }
ixheaace_sbr_post_mdct(FLOAT32 * ptr_x,WORD32 len,const FLOAT32 * ptr_trig_data)603 static VOID ixheaace_sbr_post_mdct(FLOAT32 *ptr_x, WORD32 len, const FLOAT32 *ptr_trig_data) {
604 WORD32 i;
605 FLOAT32 wre, wim, re1, re2, im1, im2;
606
607 FLOAT32 temp1 = -ptr_x[1];
608 FLOAT32 temp2 = ptr_x[len / 2];
609 FLOAT32 temp3 = ptr_x[len / 2 + 1];
610 FLOAT32 val = 0.70709228515625f;
611
612 re2 = ptr_x[len - 2];
613 im2 = ptr_x[len - 1];
614 for (i = 1; i < len / 4; i++) {
615 wim = ptr_trig_data[i];
616 wre = ptr_trig_data[len / 2 - 1 - i];
617
618 ptr_x[2 * i - 1] = (re2 * wre - im2 * wim);
619 ptr_x[len - 2 * i] = (re2 * wim + im2 * wre);
620
621 re1 = ptr_x[2 * i];
622 im1 = ptr_x[2 * i + 1];
623 re2 = ptr_x[len - 2 - 2 * i];
624 im2 = ptr_x[len - 1 - 2 * i];
625
626 ptr_x[2 * i] = (re1 * wre + im1 * wim);
627 ptr_x[len - 1 - 2 * i] = (re1 * wim - im1 * wre);
628 }
629
630 ptr_x[len / 2 - 1] = (temp2 - temp3) * val;
631 ptr_x[len / 2] = (temp2 + temp3) * val;
632 ptr_x[len - 1] = temp1;
633 }
ixheaace_sbr_post_mdst(FLOAT32 * ptr_x,WORD32 len,const FLOAT32 * ptr_trig_data)634 static VOID ixheaace_sbr_post_mdst(FLOAT32 *ptr_x, WORD32 len, const FLOAT32 *ptr_trig_data) {
635 WORD32 i;
636 FLOAT32 wre, wim, re1, re2, im1, im2;
637 FLOAT32 temp0 = -ptr_x[0];
638 FLOAT32 temp1 = ptr_x[1];
639 FLOAT32 temp2 = ptr_x[len / 2];
640 FLOAT32 temp3 = ptr_x[len / 2 + 1];
641 FLOAT32 val = 0.70709228515625f;
642
643 re2 = ptr_x[len - 2];
644 im2 = ptr_x[len - 1];
645
646 for (i = 1; i < len / 4; i++) {
647 wim = ptr_trig_data[i];
648 wre = ptr_trig_data[len / 2 - 1 - i];
649
650 ptr_x[2 * i - 1] = -(re2 * wim + im2 * wre);
651 ptr_x[len - 2 * i] = -(re2 * wre - im2 * wim);
652
653 re1 = ptr_x[2 * i];
654 im1 = ptr_x[2 * i + 1];
655 re2 = ptr_x[len - 2 - 2 * i];
656 im2 = ptr_x[len - 1 - 2 * i];
657
658 ptr_x[len - 1 - 2 * i] = -(re1 * wre + im1 * wim);
659 ptr_x[2 * i] = -(re1 * wim - im1 * wre);
660 }
661
662 ptr_x[len / 2] = (temp3 - temp2) * val;
663 ptr_x[len / 2 - 1] = -(temp3 + temp2) * val;
664
665 ptr_x[0] = temp1;
666 ptr_x[len - 1] = temp0;
667 }
ixheaace_sbr_mdct(FLOAT32 * ptr_dct_data,WORD32 n,FLOAT32 * ptr_sbr_scratch)668 static VOID ixheaace_sbr_mdct(FLOAT32 *ptr_dct_data, WORD32 n, FLOAT32 *ptr_sbr_scratch) {
669 ixheaace_sbr_pre_mdct(ptr_dct_data, n, &long_window_sine_ld_64[0]);
670
671 ia_enhaacplus_enc_complex_fft_p2(ptr_dct_data, n / 2, ptr_sbr_scratch);
672
673 ixheaace_sbr_post_mdct(ptr_dct_data, n, &fft_twiddle_tab_32[0]);
674 }
675
ixheaace_sbr_mdst(FLOAT32 * ptr_dct_data,WORD32 n,FLOAT32 * ptr_sbr_scratch)676 static VOID ixheaace_sbr_mdst(FLOAT32 *ptr_dct_data, WORD32 n, FLOAT32 *ptr_sbr_scratch) {
677 ixheaace_sbr_pre_mdst(ptr_dct_data, n, &long_window_sine_ld_64[0]);
678
679 ia_enhaacplus_enc_complex_fft_p2(ptr_dct_data, n / 2, ptr_sbr_scratch);
680
681 ixheaace_sbr_post_mdst(ptr_dct_data, n, &fft_twiddle_tab_32[0]);
682 }
ia_enhaacplus_enc_forward_modulation(const FLOAT32 * ptr_time_in,FLOAT32 * ptr_r_subband,FLOAT32 * ptr_i_subband,ixheaace_str_qmf_tabs * pstr_qmf_tab,WORD32 is_ld_sbr,FLOAT32 * ptr_sbr_scratch)683 static VOID ia_enhaacplus_enc_forward_modulation(const FLOAT32 *ptr_time_in,
684 FLOAT32 *ptr_r_subband, FLOAT32 *ptr_i_subband,
685 ixheaace_str_qmf_tabs *pstr_qmf_tab,
686 WORD32 is_ld_sbr, FLOAT32 *ptr_sbr_scratch) {
687 WORD32 i;
688 FLOAT32 tmp1, tmp2, tmp3, tmp4;
689 const FLOAT32 *ptr_inp1, *ptr_inp2;
690 FLOAT32 *ptr_re, *ptr_im;
691 FLOAT32 real, imag;
692 const FLOAT32 *ptr_window = &sbr_sin_cos_window[0];
693 if (is_ld_sbr) {
694 ptr_re = &ptr_r_subband[0];
695 ptr_im = &ptr_i_subband[0];
696 ptr_inp1 = &ptr_time_in[0];
697 } else {
698 ptr_r_subband[0] = ptr_time_in[0];
699 ptr_re = &ptr_r_subband[1];
700 ptr_im = &ptr_i_subband[0];
701 ptr_inp1 = &ptr_time_in[1];
702 }
703 ptr_inp2 = &ptr_time_in[127];
704 if (is_ld_sbr) {
705 i = IXHEAACE_QMF_CHANNELS / 2 - 1;
706 while (i >= 0) {
707 tmp1 = *ptr_inp1++;
708 tmp2 = *ptr_inp2--;
709 tmp3 = *ptr_inp1++;
710 tmp4 = *ptr_inp2--;
711 *ptr_re++ = (tmp1 - tmp2);
712 *ptr_im++ = (tmp1 + tmp2);
713 *ptr_re++ = (tmp3 - tmp4);
714 *ptr_im++ = (tmp3 + tmp4);
715 i--;
716 }
717
718 ixheaace_sbr_mdct(ptr_r_subband, 64, ptr_sbr_scratch);
719 ixheaace_sbr_mdst(ptr_i_subband, 64, ptr_sbr_scratch);
720
721 i = 0;
722 while (i < IXHEAACE_QMF_CHANNELS) {
723 real = ptr_r_subband[i];
724 imag = ptr_i_subband[i];
725 ptr_r_subband[i] =
726 imag * ptr_window[i] + real * ptr_window[2 * IXHEAACE_QMF_CHANNELS - 1 - i];
727 ptr_i_subband[i] =
728 imag * ptr_window[2 * IXHEAACE_QMF_CHANNELS - 1 - i] - real * ptr_window[i];
729 i++;
730 }
731 } else {
732 for (i = 30; i >= 0; i--) {
733 tmp1 = *ptr_inp1++;
734 tmp2 = *ptr_inp2--;
735 tmp3 = *ptr_inp1++;
736
737 *ptr_re++ = tmp1 - tmp2;
738 tmp4 = *ptr_inp2--;
739 *ptr_im++ = tmp1 + tmp2;
740 *ptr_re++ = tmp3 - tmp4;
741 *ptr_im++ = tmp3 + tmp4;
742 }
743 tmp1 = *ptr_inp1;
744 tmp2 = *ptr_inp2;
745 *ptr_re = tmp1 - tmp2;
746 *ptr_im = tmp1 + tmp2;
747
748 ptr_i_subband[63] = ptr_time_in[64];
749
750 ia_enhaacplus_enc_fct3_64(ptr_r_subband, pstr_qmf_tab);
751
752 ia_enhaacplus_enc_fst3_64(ptr_i_subband, pstr_qmf_tab);
753 }
754 }
755
ia_enhaacplus_enc_sbr_qmf_analysis_win_add(const FLOAT32 * ptr_pf_l,const FLOAT32 * ptr_pf_r,FLOAT32 * ptr_fp1,FLOAT32 * ptr_fp2,FLOAT32 * ptr_syn_buffer)756 static VOID ia_enhaacplus_enc_sbr_qmf_analysis_win_add(const FLOAT32 *ptr_pf_l,
757 const FLOAT32 *ptr_pf_r, FLOAT32 *ptr_fp1,
758 FLOAT32 *ptr_fp2,
759 FLOAT32 *ptr_syn_buffer) {
760 FLOAT32 accu_l = 0, accu_r = 0;
761 WORD k;
762 for (k = 0; k < 64; k++) {
763 accu_l = 0;
764 accu_r = 0;
765
766 {
767 accu_l += *ptr_pf_l++ * ptr_fp1[k];
768 accu_l += *ptr_pf_l++ * ptr_fp1[128 + k];
769 accu_l += *ptr_pf_l++ * ptr_fp1[256 + k];
770 accu_l += *ptr_pf_l++ * ptr_fp1[384 + k];
771 accu_l += *ptr_pf_l++ * ptr_fp1[512 + k];
772
773 accu_r += *--ptr_pf_r * ptr_fp2[k];
774 accu_r += *--ptr_pf_r * ptr_fp2[128 + k];
775 accu_r += *--ptr_pf_r * ptr_fp2[256 + k];
776 accu_r += *--ptr_pf_r * ptr_fp2[384 + k];
777 accu_r += *--ptr_pf_r * ptr_fp2[512 + k];
778 }
779 ptr_syn_buffer[127 - k] = accu_l;
780 ptr_syn_buffer[63 - k] = accu_r;
781 ptr_pf_l += 5;
782 ptr_pf_r -= 5;
783 }
784 }
785
ia_enhaacplus_enc_sbr_cld_analysis_win_add(FLOAT32 * ptr_filter_states,const FLOAT32 * ptr_coeffs,FLOAT32 * ptr_sync_buffer,WORD32 num_qmf_ch,WORD32 time_sn_stride)786 static VOID ia_enhaacplus_enc_sbr_cld_analysis_win_add(FLOAT32 *ptr_filter_states,
787 const FLOAT32 *ptr_coeffs,
788 FLOAT32 *ptr_sync_buffer,
789 WORD32 num_qmf_ch, WORD32 time_sn_stride) {
790 WORD32 i;
791 WORD32 len = num_qmf_ch * time_sn_stride;
792 FLOAT32 *ptr_fil_states = &ptr_filter_states[CLD_FILTER_LENGTH - 1];
793
794 memset(ptr_sync_buffer, 0, len * sizeof(*ptr_sync_buffer));
795
796 for (i = 0; i < CLD_FILTER_LENGTH; i++) {
797 ptr_sync_buffer[i % len] += (*ptr_fil_states-- * ptr_coeffs[i]);
798 }
799 }
ixheaace_sbr_analysis_filtering(const FLOAT32 * ptr_time_in,WORD32 time_sn_stride,FLOAT32 ** ptr_ana_r,FLOAT32 ** ptr_ana_i,ixheaace_pstr_sbr_qmf_filter_bank pstr_qmf_bank,ixheaace_str_qmf_tabs * pstr_qmf_tab,WORD32 num_qmf_subsamp,WORD32 is_ld_sbr,FLOAT32 * ptr_sbr_scratch,WORD32 is_ps_960)800 VOID ixheaace_sbr_analysis_filtering(const FLOAT32 *ptr_time_in, WORD32 time_sn_stride,
801 FLOAT32 **ptr_ana_r, FLOAT32 **ptr_ana_i,
802 ixheaace_pstr_sbr_qmf_filter_bank pstr_qmf_bank,
803 ixheaace_str_qmf_tabs *pstr_qmf_tab, WORD32 num_qmf_subsamp,
804 WORD32 is_ld_sbr, FLOAT32 *ptr_sbr_scratch,
805 WORD32 is_ps_960) {
806 WORD32 i, k;
807 const FLOAT32 *ptr_pf_l, *ptr_pf_r;
808 FLOAT32 *ptr_fp1, *ptr_fp2, *ptr_tmp;
809 FLOAT32 syn_buffer[2 * IXHEAACE_QMF_CHANNELS] = {0};
810 const FLOAT32 *ptr_start_coeff_l;
811 const FLOAT32 *ptr_start_coeff_r;
812 FLOAT32 *ptr_qmf_states_curr_pos;
813 WORD32 start_coeff_cnt = 0;
814 WORD16 flag = 0;
815 WORD32 offset;
816 if (is_ld_sbr) {
817 offset = 576;
818 i = 0;
819 while (i < num_qmf_subsamp) {
820 ptr_qmf_states_curr_pos = pstr_qmf_bank->ptr_qmf_states_curr_pos;
821
822 if (ptr_time_in) {
823 FLOAT32 *ptr_qmf_states = pstr_qmf_bank->ptr_qmf_states_curr_pos + offset;
824
825 const FLOAT32 *ptr_inp = &ptr_time_in[(i * 64 * time_sn_stride)];
826 FLOAT32 tmp1, tmp2, tmp3, tmp4;
827 for (k = 15; k >= 0; k--) {
828 tmp1 = *ptr_inp;
829 ptr_inp += time_sn_stride;
830
831 tmp2 = *ptr_inp;
832 ptr_inp += time_sn_stride;
833
834 tmp3 = *ptr_inp;
835 ptr_inp += time_sn_stride;
836
837 *ptr_qmf_states++ = tmp1;
838 tmp4 = *ptr_inp;
839 ptr_inp += time_sn_stride;
840
841 *ptr_qmf_states++ = tmp2;
842 *ptr_qmf_states++ = tmp3;
843 *ptr_qmf_states++ = tmp4;
844 }
845 } else {
846 memset(&ptr_qmf_states_curr_pos[0], 0,
847 sizeof(ptr_qmf_states_curr_pos[0]) * IXHEAACE_QMF_CHANNELS);
848 }
849
850 ia_enhaacplus_enc_sbr_cld_analysis_win_add(&ptr_qmf_states_curr_pos[0],
851 pstr_qmf_bank->ptr_filter, syn_buffer,
852 IXHEAACE_QMF_CHANNELS, time_sn_stride);
853
854 ia_enhaacplus_enc_forward_modulation(syn_buffer, &(ptr_ana_r[i][0]), &(ptr_ana_i[i][0]),
855 pstr_qmf_tab, is_ld_sbr, ptr_sbr_scratch);
856
857 for (k = 0; k < offset; k++) {
858 pstr_qmf_bank->ptr_qmf_states_curr_pos[k] =
859 pstr_qmf_bank->ptr_qmf_states_curr_pos[64 + k];
860 }
861
862 i++;
863 }
864 } else {
865 flag = pstr_qmf_bank->flag;
866 ptr_fp1 = pstr_qmf_bank->ptr_qmf_states_buf;
867 ptr_fp2 = pstr_qmf_bank->ptr_qmf_states_buf + 64;
868 pstr_qmf_bank->ptr_qmf_states_curr_pos =
869 ((FLOAT32 *)(pstr_qmf_bank->ptr_qmf_states_buf) + (pstr_qmf_bank->offset * 64));
870
871 if (pstr_qmf_bank->offset == 8) {
872 pstr_qmf_bank->offset = 0;
873 } else {
874 pstr_qmf_bank->offset += 2;
875 }
876
877 ptr_start_coeff_l = pstr_qmf_bank->ptr_ref_coeff_l + pstr_qmf_bank->offset_l;
878 ptr_start_coeff_r = pstr_qmf_bank->ptr_ref_coeff_r - pstr_qmf_bank->offset_r;
879
880 for (i = 0; i < num_qmf_subsamp; i++) {
881 ptr_qmf_states_curr_pos = pstr_qmf_bank->ptr_qmf_states_curr_pos;
882 ptr_tmp = ptr_fp1;
883 ptr_fp1 = ptr_fp2;
884 ptr_fp2 = ptr_tmp;
885 if (((1 == is_ld_sbr) && start_coeff_cnt) || ((0 == is_ld_sbr) && (i % 2))) {
886 ptr_start_coeff_l--;
887 if (ptr_start_coeff_l == pstr_qmf_bank->ptr_ref_coeff_l) {
888 ptr_start_coeff_l += 5;
889 }
890 } else {
891 ptr_start_coeff_r++;
892 if (ptr_start_coeff_r == pstr_qmf_bank->ptr_ref_coeff_r) {
893 ptr_start_coeff_r -= 5;
894 }
895 }
896
897 if (ptr_time_in) {
898 FLOAT32 *ptr_qmf_states = &ptr_qmf_states_curr_pos[0];
899 const FLOAT32 *ptr_inp = &ptr_time_in[(i * 64 * time_sn_stride)];
900 FLOAT32 tmp1, tmp2, tmp3, tmp4;
901 for (k = 15; k >= 0; k--) {
902 tmp1 = *ptr_inp;
903 ptr_inp += time_sn_stride;
904
905 tmp2 = *ptr_inp;
906 ptr_inp += time_sn_stride;
907
908 tmp3 = *ptr_inp;
909 ptr_inp += time_sn_stride;
910
911 *ptr_qmf_states++ = tmp1;
912 tmp4 = *ptr_inp;
913 ptr_inp += time_sn_stride;
914
915 *ptr_qmf_states++ = tmp2;
916 *ptr_qmf_states++ = tmp3;
917 *ptr_qmf_states++ = tmp4;
918 }
919 } else {
920 memset(&ptr_qmf_states_curr_pos[0], 0,
921 sizeof(ptr_qmf_states_curr_pos[0]) * IXHEAACE_QMF_CHANNELS);
922 }
923
924 ptr_pf_l = ptr_start_coeff_l;
925 ptr_pf_r = ptr_start_coeff_r;
926
927 ia_enhaacplus_enc_sbr_qmf_analysis_win_add(ptr_pf_l, ptr_pf_r, ptr_fp1, ptr_fp2,
928 syn_buffer);
929
930 ia_enhaacplus_enc_forward_modulation(syn_buffer, &(ptr_ana_r[i][0]), &(ptr_ana_i[i][0]),
931 pstr_qmf_tab, is_ld_sbr, ptr_sbr_scratch);
932
933 pstr_qmf_bank->ptr_qmf_states_curr_pos = pstr_qmf_bank->ptr_qmf_states_curr_pos + 64;
934 if (pstr_qmf_bank->ptr_qmf_states_curr_pos == pstr_qmf_bank->ptr_qmf_states_buf + 640) {
935 pstr_qmf_bank->ptr_qmf_states_curr_pos = pstr_qmf_bank->ptr_qmf_states_buf;
936 }
937 }
938
939 pstr_qmf_bank->offset_l = ptr_start_coeff_l - pstr_qmf_bank->ptr_ref_coeff_l;
940 pstr_qmf_bank->offset_r = pstr_qmf_bank->ptr_ref_coeff_r - ptr_start_coeff_r;
941 pstr_qmf_bank->flag = flag;
942 }
943 if (is_ps_960 == 1) {
944 memset(&ptr_ana_r[num_qmf_subsamp][0], 0, sizeof(ptr_ana_r[num_qmf_subsamp][0]) *
945 IXHEAACE_QMF_CHANNELS * (IXHEAACE_QMF_TIME_SLOTS - num_qmf_subsamp));
946 memset(&ptr_ana_i[num_qmf_subsamp][0], 0, sizeof(ptr_ana_i[num_qmf_subsamp][0]) *
947 IXHEAACE_QMF_CHANNELS * (IXHEAACE_QMF_TIME_SLOTS - num_qmf_subsamp));
948 }
949 }
950
ixheaace_get_energy_from_cplx_qmf(FLOAT32 ** ptr_energy_vals,FLOAT32 ** ptr_real_values,FLOAT32 ** ptr_imag_values,WORD32 is_ld_sbr,WORD32 num_time_slots,WORD32 samp_ratio_fac,ixheaace_str_hbe_enc * pstr_hbe_enc,WORD32 op_delay,WORD32 harmonic_sbr)951 VOID ixheaace_get_energy_from_cplx_qmf(
952 FLOAT32 **ptr_energy_vals, FLOAT32 **ptr_real_values, FLOAT32 **ptr_imag_values,
953 WORD32 is_ld_sbr, WORD32 num_time_slots, WORD32 samp_ratio_fac,
954 ixheaace_str_hbe_enc *pstr_hbe_enc, WORD32 op_delay, WORD32 harmonic_sbr)
955
956 {
957 WORD32 j, k;
958 FLOAT32 avg_fac = 0.5f;
959 if (samp_ratio_fac == 4) {
960 avg_fac = 0.25f;
961 }
962 if (0 == is_ld_sbr) {
963 FLOAT32 *ptr_energy_val = &ptr_energy_vals[0][0];
964 FLOAT32 *ptr_real = &ptr_real_values[0][0];
965 FLOAT32 *ptr_imag = &ptr_imag_values[0][0];
966 FLOAT32 *ptr_hbe_real = NULL;
967 FLOAT32 *ptr_hbe_imag = NULL;
968 if (harmonic_sbr == 1) {
969 ptr_hbe_real = &pstr_hbe_enc->qmf_buf_real[op_delay][0];
970 ptr_hbe_imag = &pstr_hbe_enc->qmf_buf_imag[op_delay][0];
971 }
972 k = (num_time_slots - 1);
973 while (k >= 0) {
974 for (j = 63; j >= 0; j--) {
975 FLOAT32 tmp = 0.0f;
976 if (harmonic_sbr == 1) {
977 FLOAT32 real_hbe, imag_hbe;
978 real_hbe = *(ptr_hbe_real);
979 imag_hbe = *(ptr_hbe_imag);
980 tmp += (real_hbe * real_hbe) + (imag_hbe * imag_hbe);
981 *ptr_energy_val = tmp;
982 ptr_hbe_real++;
983 ptr_hbe_imag++;
984 } else {
985 FLOAT32 real, imag;
986 WORD32 i;
987 for (i = 0; i < samp_ratio_fac; i++) {
988 real = *(ptr_real + i * IXHEAACE_QMF_CHANNELS);
989 imag = *(ptr_imag + i * IXHEAACE_QMF_CHANNELS);
990 tmp += (real * real) + (imag * imag);
991 }
992 *ptr_energy_val = tmp * avg_fac;
993 ptr_real++;
994 ptr_imag++;
995 }
996 ptr_energy_val++;
997 }
998 if (harmonic_sbr == 1) {
999 ptr_hbe_real += 64;
1000 ptr_hbe_imag += 64;
1001 } else {
1002 ptr_real += 64;
1003 ptr_imag += 64;
1004 }
1005 k--;
1006 }
1007 } else {
1008 FLOAT32 *ptr_real = &ptr_real_values[0][0];
1009 FLOAT32 *ptr_imag = &ptr_imag_values[0][0];
1010 for (k = 0; k < num_time_slots; k++) {
1011 FLOAT32 *ptr_energy_val = &ptr_energy_vals[k][0];
1012 for (j = 0; j < 64; j++) {
1013 FLOAT32 real, imag, tmp;
1014 real = *ptr_real;
1015 ptr_real++;
1016 imag = *ptr_imag;
1017 ptr_imag++;
1018
1019 tmp = (real * real) + (imag * imag);
1020 *ptr_energy_val = tmp;
1021 ptr_energy_val++;
1022 }
1023 }
1024 }
1025 }
1026
ixheaace_fft16(FLOAT32 * vector)1027 VOID ixheaace_fft16(FLOAT32 *vector) {
1028 FLOAT32 var10, var11, var12, var13, var14, var15, var16, var17, var18, var19, var110, var111,
1029 var112, var113, var114, var115;
1030 FLOAT32 var20, var21, var22, var23, var24, var25, var26, var27, var28, var29, var210, var211,
1031 var212, var213, var214, var215;
1032 FLOAT32 arr0, arr1, arr2, arr3, arr4, arr5, arr6, arr7, arr8, arr9, arr10, arr11, arr12, arr13,
1033 arr14, arr15;
1034
1035 arr0 = vector[0] + vector[16];
1036 arr8 = vector[8] + vector[24];
1037 var10 = arr0 + arr8;
1038 var12 = arr0 - arr8;
1039 arr1 = vector[1] + vector[17];
1040 arr9 = vector[9] + vector[25];
1041 var11 = arr1 + arr9;
1042 var13 = arr1 - arr9;
1043 arr2 = vector[2] + vector[18];
1044 arr10 = vector[10] + vector[26];
1045 var14 = arr2 + arr10;
1046 var16 = arr2 - arr10;
1047 arr3 = vector[3] + vector[19];
1048 arr11 = vector[11] + vector[27];
1049 var15 = arr3 + arr11;
1050 var17 = arr3 - arr11;
1051 arr4 = vector[4] + vector[20];
1052 arr12 = vector[12] + vector[28];
1053 var18 = arr4 + arr12;
1054 var110 = arr4 - arr12;
1055 arr5 = vector[5] + vector[21];
1056 arr13 = vector[13] + vector[29];
1057 var19 = arr5 + arr13;
1058 var111 = arr5 - arr13;
1059 arr6 = vector[6] + vector[22];
1060 arr14 = vector[14] + vector[30];
1061 var112 = arr6 + arr14;
1062 var114 = arr6 - arr14;
1063 arr7 = vector[7] + vector[23];
1064 arr15 = vector[15] + vector[31];
1065 var113 = arr7 + arr15;
1066 var115 = arr7 - arr15;
1067
1068 var20 = var10 + var18;
1069 var24 = var10 - var18;
1070 var21 = var11 + var19;
1071 var25 = var11 - var19;
1072 var28 = var12 - var111;
1073 var210 = var12 + var111;
1074 var29 = var13 + var110;
1075 var211 = var13 - var110;
1076 var22 = var14 + var112;
1077 var27 = var14 - var112;
1078 var23 = var15 + var113;
1079 var26 = var113 - var15;
1080
1081 var11 = var16 + var114;
1082 var12 = var16 - var114;
1083 var10 = var17 + var115;
1084 var13 = var17 - var115;
1085
1086 var212 = (var10 + var12) * IXHEAACE_INV_SQRT2;
1087 var214 = (var10 - var12) * IXHEAACE_INV_SQRT2;
1088 var213 = (var13 - var11) * IXHEAACE_INV_SQRT2;
1089 var215 = (var11 + var13) * -IXHEAACE_INV_SQRT2;
1090
1091 arr0 = vector[0] - vector[16];
1092 arr1 = vector[1] - vector[17];
1093 arr2 = vector[2] - vector[18];
1094 arr3 = vector[3] - vector[19];
1095 arr4 = vector[4] - vector[20];
1096 arr5 = vector[5] - vector[21];
1097 arr6 = vector[6] - vector[22];
1098 arr7 = vector[7] - vector[23];
1099 arr8 = vector[8] - vector[24];
1100 arr9 = vector[9] - vector[25];
1101 arr10 = vector[10] - vector[26];
1102 arr11 = vector[11] - vector[27];
1103 arr12 = vector[12] - vector[28];
1104 arr13 = vector[13] - vector[29];
1105 arr14 = vector[14] - vector[30];
1106 arr15 = vector[15] - vector[31];
1107
1108 var19 = ((arr2 + arr14) * -IXHEAACE_COS_3PI_DIV8);
1109 var110 = ((arr2 - arr14) * IXHEAACE_COS_PI_DIV8);
1110 var18 = ((arr3 + arr15) * IXHEAACE_COS_3PI_DIV8);
1111 var111 = ((arr3 - arr15) * IXHEAACE_COS_PI_DIV8);
1112 var15 = ((arr4 + arr12) * -IXHEAACE_INV_SQRT2);
1113 var16 = ((arr4 - arr12) * IXHEAACE_INV_SQRT2);
1114 var14 = ((arr5 + arr13) * IXHEAACE_INV_SQRT2);
1115 var17 = ((arr5 - arr13) * IXHEAACE_INV_SQRT2);
1116 var113 = ((arr6 + arr10) * -IXHEAACE_COS_PI_DIV8);
1117 var114 = ((arr6 - arr10) * IXHEAACE_COS_3PI_DIV8);
1118 var112 = ((arr7 + arr11) * IXHEAACE_COS_PI_DIV8);
1119 var115 = ((arr7 - arr11) * IXHEAACE_COS_3PI_DIV8);
1120
1121 arr2 = (var18 * IXHEAACE_SQRT2PLUS1) - (var112 * IXHEAACE_SQRT2MINUS1);
1122 arr3 = (var19 * IXHEAACE_SQRT2PLUS1) - (var113 * IXHEAACE_SQRT2MINUS1);
1123 arr4 = (var110 * IXHEAACE_SQRT2MINUS1) - (var114 * IXHEAACE_SQRT2PLUS1);
1124 arr5 = (var111 * IXHEAACE_SQRT2MINUS1) - (var115 * IXHEAACE_SQRT2PLUS1);
1125
1126 var18 = var18 + var112;
1127 var19 = var19 + var113;
1128 var110 = var110 + var114;
1129 var111 = var111 + var115;
1130
1131 arr6 = arr0 + var14;
1132 arr10 = arr0 - var14;
1133 arr7 = arr1 + var15;
1134 arr11 = arr1 - var15;
1135
1136 arr12 = var16 - arr9;
1137 arr14 = var16 + arr9;
1138 arr13 = arr8 + var17;
1139 arr15 = arr8 - var17;
1140
1141 var10 = arr6 - arr14;
1142 var12 = arr6 + arr14;
1143 var11 = arr7 + arr15;
1144 var13 = arr7 - arr15;
1145 var14 = arr10 + arr12;
1146 var16 = arr10 - arr12;
1147 var15 = arr11 + arr13;
1148 var17 = arr11 - arr13;
1149
1150 arr10 = var18 + var110;
1151 var110 = var18 - var110;
1152 arr11 = var19 + var111;
1153 var111 = var19 - var111;
1154
1155 var112 = (arr2 + arr4);
1156 var114 = (arr2 - arr4);
1157 var113 = (arr3 + arr5);
1158 var115 = (arr3 - arr5);
1159
1160 vector[0] = var20 + var22;
1161 vector[1] = var21 + var23;
1162 vector[2] = var12 + arr10;
1163 vector[3] = var13 + arr11;
1164 vector[4] = var210 + var212;
1165 vector[5] = var211 + var213;
1166 vector[6] = var10 + var112;
1167 vector[7] = var11 + var113;
1168 vector[8] = var24 - var26;
1169 vector[9] = var25 - var27;
1170 vector[10] = var16 + var114;
1171 vector[11] = var17 + var115;
1172 vector[12] = var28 + var214;
1173 vector[13] = var29 + var215;
1174 vector[14] = var14 + var110;
1175 vector[15] = var15 + var111;
1176 vector[16] = var20 - var22;
1177 vector[17] = var21 - var23;
1178 vector[18] = var12 - arr10;
1179 vector[19] = var13 - arr11;
1180 vector[20] = var210 - var212;
1181 vector[21] = var211 - var213;
1182 vector[22] = var10 - var112;
1183 vector[23] = var11 - var113;
1184 vector[24] = var24 + var26;
1185 vector[25] = var25 + var27;
1186 vector[26] = var16 - var114;
1187 vector[27] = var17 - var115;
1188 vector[28] = var28 - var214;
1189 vector[29] = var29 - var215;
1190 vector[30] = var14 - var110;
1191 vector[31] = var15 - var111;
1192 }
1193
ixheaace_cos_sim_mod(FLOAT32 * ptr_subband,ixheaace_pstr_sbr_qmf_filter_bank pstr_qmf_bank)1194 static VOID ixheaace_cos_sim_mod(FLOAT32 *ptr_subband,
1195 ixheaace_pstr_sbr_qmf_filter_bank pstr_qmf_bank) {
1196 WORD32 i;
1197 FLOAT32 re1, im1, re2, im2, re3, im3;
1198 const FLOAT32 *ptr_cos_sin_tab = pstr_qmf_bank->ptr_flt_cos_twiddle;
1199 const FLOAT32 *ptr_cos_sin_tab2 = &pstr_qmf_bank->ptr_flt_cos_twiddle[31];
1200 const FLOAT32 *ptr_alt_sin_tab;
1201 FLOAT32 wim, wre;
1202 FLOAT32 *ptr_subband2 = ptr_subband + 32;
1203
1204 for (i = 0; i < 8; i++) {
1205 wre = *ptr_cos_sin_tab++;
1206 wim = *ptr_cos_sin_tab++;
1207 re1 = ptr_subband[2 * i];
1208 im1 = ptr_subband[31 - 2 * i];
1209 re3 = ptr_subband[30 - 2 * i];
1210 im3 = ptr_subband[2 * i + 1];
1211 ptr_subband[2 * i] = (im1 * wim) + (re1 * wre);
1212 ptr_subband[2 * i + 1] = (im1 * wre) - (re1 * wim);
1213 re1 = ptr_subband2[2 * i];
1214 im1 = ptr_subband2[31 - 2 * i];
1215 re2 = ptr_subband2[30 - 2 * i];
1216 im2 = ptr_subband2[2 * i + 1];
1217 ptr_subband2[2 * i + 1] = (im1 * wre) + (re1 * wim);
1218 ptr_subband2[2 * i] = (im1 * wim) - (re1 * wre);
1219 wim = *ptr_cos_sin_tab2--;
1220 wre = *ptr_cos_sin_tab2--;
1221 ptr_subband[30 - 2 * i] = (im3 * wim) + (re3 * wre);
1222 ptr_subband[31 - 2 * i] = (im3 * wre) - (re3 * wim);
1223 ptr_subband2[31 - 2 * i] = (im2 * wre) + (re2 * wim);
1224 ptr_subband2[30 - 2 * i] = (im2 * wim) - (re2 * wre);
1225 }
1226
1227 ixheaace_fft16(ptr_subband);
1228 ixheaace_fft16(ptr_subband2);
1229
1230 ptr_alt_sin_tab = &pstr_qmf_bank->ptr_flt_alt_sin_twiddle[0];
1231 wim = *ptr_alt_sin_tab++;
1232 wre = *ptr_alt_sin_tab++;
1233 for (i = 0; i < 8; i++) {
1234 re1 = ptr_subband[2 * i];
1235 im1 = ptr_subband[2 * i + 1];
1236 re3 = ptr_subband[30 - 2 * i];
1237 im3 = ptr_subband[31 - 2 * i];
1238 ptr_subband[2 * i] = (re1 * wre) + (im1 * wim);
1239 ptr_subband[31 - 2 * i] = (re1 * wim) - (im1 * wre);
1240 re1 = ptr_subband2[2 * i];
1241 im1 = ptr_subband2[2 * i + 1];
1242 re2 = ptr_subband2[30 - 2 * i];
1243 im2 = ptr_subband2[31 - 2 * i];
1244 ptr_subband2[31 - 2 * i] = -((re1 * wre) + (im1 * wim));
1245 ptr_subband2[2 * i] = -((re1 * wim) - (im1 * wre));
1246 wim = *ptr_alt_sin_tab++;
1247 wre = *ptr_alt_sin_tab++;
1248 ptr_subband[30 - 2 * i] = (re3 * wim) + (im3 * wre);
1249 ptr_subband[2 * i + 1] = (re3 * wre) - (im3 * wim);
1250 ptr_subband2[2 * i + 1] = -((re2 * wim) + (im2 * wre));
1251 ptr_subband2[30 - 2 * i] = -(re2 * wre) + (im2 * wim);
1252 }
1253 }
1254
ixheaace_inverse_modulation(const FLOAT32 * ptr_sbr_real,const FLOAT32 * ptr_sbr_imag,FLOAT32 * ptr_time_out,ixheaace_pstr_sbr_qmf_filter_bank pstr_qmf_bank)1255 static VOID ixheaace_inverse_modulation(const FLOAT32 *ptr_sbr_real, const FLOAT32 *ptr_sbr_imag,
1256 FLOAT32 *ptr_time_out,
1257 ixheaace_pstr_sbr_qmf_filter_bank pstr_qmf_bank) {
1258 WORD32 i;
1259 FLOAT32 gain = 0.015625f;
1260 FLOAT32 r1, i1, r2, i2;
1261 FLOAT32 *ptr_time1, *ptr_time2;
1262 FLOAT32 *ptr_time3, *ptr_time4;
1263 const FLOAT32 *ptr_re;
1264 const FLOAT32 *ptr_im;
1265
1266 ptr_time1 = &ptr_time_out[0];
1267 ptr_time2 = &ptr_time_out[32];
1268 ptr_re = &ptr_sbr_real[0];
1269 ptr_im = &ptr_sbr_imag[0];
1270
1271 for (i = 31; i >= 0; i--) {
1272 r1 = *ptr_re++;
1273 i1 = *ptr_im++;
1274
1275 *ptr_time1++ = r1 * gain;
1276 *ptr_time2++ = i1 * gain;
1277 }
1278
1279 ixheaace_cos_sim_mod(ptr_time_out, pstr_qmf_bank);
1280
1281 ptr_time1 = &ptr_time_out[63];
1282 ptr_time2 = &ptr_time_out[31];
1283 ptr_time3 = &ptr_time_out[0];
1284 ptr_time4 = &ptr_time_out[32];
1285 for (i = 15; i >= 0; i--) {
1286 r1 = *ptr_time3;
1287 i2 = *ptr_time1;
1288 r2 = *ptr_time2;
1289 i1 = *ptr_time4;
1290
1291 *ptr_time3++ = r1 - i1;
1292
1293 *ptr_time1-- = -(r1 + i1);
1294
1295 *ptr_time2-- = r2 - i2;
1296
1297 *ptr_time4++ = -(r2 + i2);
1298 }
1299 }
1300
ixheaace_win_add(FLOAT32 * ptr_time_buf,FLOAT32 * ptr_work_buffer,const FLOAT32 * ptr_filter)1301 static VOID ixheaace_win_add(FLOAT32 *ptr_time_buf, FLOAT32 *ptr_work_buffer,
1302 const FLOAT32 *ptr_filter) {
1303 WORD32 j, k;
1304 FLOAT32 *ptr_work_buf = &ptr_work_buffer[63];
1305 for (j = 0, k = 0; j < 64; j += 2, k++) {
1306 FLOAT32 tmp_var = *ptr_work_buf--;
1307 FLOAT32 temp_a = ptr_filter[2 * k];
1308 FLOAT32 temp_b = ptr_filter[2 * k + 1];
1309 FLOAT32 temp1 = *ptr_work_buf--;
1310 ptr_time_buf[j] += tmp_var * temp_a;
1311 ptr_time_buf[j + 1] += temp1 * temp_b;
1312
1313 temp_a = ptr_filter[64 + 2 * k];
1314 temp_b = ptr_filter[64 + 2 * k + 1];
1315 ptr_time_buf[64 + j] += tmp_var * temp_a;
1316 ptr_time_buf[64 + j + 1] += temp1 * temp_b;
1317
1318 temp_a = ptr_filter[128 + 2 * k];
1319 temp_b = ptr_filter[128 + 2 * k + 1];
1320 ptr_time_buf[128 + j] += tmp_var * temp_a;
1321 ptr_time_buf[128 + j + 1] += temp1 * temp_b;
1322
1323 temp_a = ptr_filter[192 + 2 * k];
1324 temp_b = ptr_filter[192 + 2 * k + 1];
1325 ptr_time_buf[192 + j] += tmp_var * temp_a;
1326 ptr_time_buf[192 + j + 1] += temp1 * temp_b;
1327
1328 temp_a = ptr_filter[256 + 2 * k];
1329 temp_b = ptr_filter[256 + 2 * k + 1];
1330 ptr_time_buf[256 + j] += tmp_var * temp_a;
1331 ptr_time_buf[256 + j + 1] += temp1 * temp_b;
1332 }
1333 }
1334
ixheaace_enc_synthesis_qmf_filtering(FLOAT32 ** ptr_sbr_re,FLOAT32 ** ptr_sbr_im,FLOAT32 * time_float,ixheaace_pstr_sbr_qmf_filter_bank pstr_qmf_bank)1335 VOID ixheaace_enc_synthesis_qmf_filtering(FLOAT32 **ptr_sbr_re, FLOAT32 **ptr_sbr_im,
1336 FLOAT32 *time_float,
1337 ixheaace_pstr_sbr_qmf_filter_bank pstr_qmf_bank) {
1338 WORD32 k, j;
1339 FLOAT32 *timeBuf_flt;
1340 const FLOAT32 *ptr_filter = pstr_qmf_bank->ptr_flt_filter;
1341 for (k = 0; k < 32; k++) {
1342 ixheaace_inverse_modulation(*(ptr_sbr_re + k), *(ptr_sbr_im + k),
1343 pstr_qmf_bank->ptr_flt_work_buf, pstr_qmf_bank);
1344 ixheaace_win_add(pstr_qmf_bank->ptr_flt_time_buf, pstr_qmf_bank->ptr_flt_work_buf,
1345 ptr_filter);
1346 timeBuf_flt = &pstr_qmf_bank->ptr_flt_time_buf[288];
1347 {
1348 FLOAT32 temp1_flt, temp2_flt;
1349 FLOAT32 *ptr_time_out_flt = &time_float[31], temp_out_flt;
1350 for (j = 15; j >= 0; j--) {
1351 temp1_flt = *timeBuf_flt++;
1352 temp2_flt = *timeBuf_flt++;
1353 temp_out_flt = temp1_flt;
1354 *ptr_time_out_flt-- = temp_out_flt * -1;
1355 temp_out_flt = temp2_flt;
1356 *ptr_time_out_flt-- = temp_out_flt * -1;
1357 }
1358 }
1359 time_float += 32;
1360 memmove(pstr_qmf_bank->ptr_flt_time_buf + 32, pstr_qmf_bank->ptr_flt_time_buf,
1361 288 * sizeof(pstr_qmf_bank->ptr_flt_time_buf[0]));
1362 memset(pstr_qmf_bank->ptr_flt_time_buf, 0, 32 * sizeof(pstr_qmf_bank->ptr_flt_time_buf[0]));
1363 }
1364 }
1365