blob: edecdd7b2e458cd4cdc4ac530883c653b897dda1 [file] [log] [blame]
xingri.gaoc18d4472023-02-28 02:51:02 +00001/*
2** FAAD2 - Freeware Advanced Audio (AAC) Decoder including SBR decoding
3** Copyright (C) 2003-2005 M. Bakker, Nero AG, http://www.nero.com
4**
5** This program is free software; you can redistribute it and/or modify
6** it under the terms of the GNU General Public License as published by
7** the Free Software Foundation; either version 2 of the License, or
8** (at your option) any later version.
9**
10** This program is distributed in the hope that it will be useful,
11** but WITHOUT ANY WARRANTY; without even the implied warranty of
12** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13** GNU General Public License for more details.
14**
15** You should have received a copy of the GNU General Public License
16** along with this program; if not, write to the Free Software
17** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
18**
19** Any non-GPL usage of this software or parts of this software is strictly
20** forbidden.
21**
22** The "appropriate copyright message" mentioned in section 2c of the GPLv2
23** must read: "Code from FAAD2 is copyright (c) Nero AG, www.nero.com"
24**
25** Commercial non-GPL licensing of this software is possible.
26** For more info contact Nero AG through Mpeg4AAClicense@nero.com.
27**
28** $Id: sbr_dec.c,v 1.44 2009/01/26 22:32:31 menno Exp $
29**/
30
31#include <stdlib.h>
32#include "common.h"
33#include "structs.h"
34
35#ifdef SBR_DEC
36
37#include <string.h>
38
39#include "syntax.h"
40#include "bits.h"
41#include "sbr_syntax.h"
42#include "sbr_qmf.h"
43#include "sbr_hfgen.h"
44#include "sbr_hfadj.h"
45
46#ifndef __unused
47#define __unused __attribute__((unused))
48#endif
49
50/* static function declarations */
51static uint8_t sbr_save_prev_data(sbr_info *sbr, uint8_t ch);
52static void sbr_save_matrix(sbr_info *sbr, uint8_t ch);
53
54
55sbr_info *sbrDecodeInit(uint16_t framelength, uint8_t id_aac,
56 uint32_t sample_rate, uint8_t downSampledSBR
57#ifdef DRM
58 , uint8_t IsDRM
59#endif
60 )
61{
62 sbr_info *sbr = faad_malloc(sizeof(sbr_info));
63 memset(sbr, 0, sizeof(sbr_info));
64
65 /* save id of the parent element */
66 sbr->id_aac = id_aac;
67 sbr->sample_rate = sample_rate;
68
69 sbr->bs_freq_scale = 2;
70 sbr->bs_alter_scale = 1;
71 sbr->bs_noise_bands = 2;
72 sbr->bs_limiter_bands = 2;
73 sbr->bs_limiter_gains = 2;
74 sbr->bs_interpol_freq = 1;
75 sbr->bs_smoothing_mode = 1;
76 sbr->bs_start_freq = 5;
77 sbr->bs_amp_res = 1;
78 sbr->bs_samplerate_mode = 1;
79 sbr->prevEnvIsShort[0] = -1;
80 sbr->prevEnvIsShort[1] = -1;
81 sbr->header_count = 0;
82 sbr->Reset = 1;
83
84#ifdef DRM
85 sbr->Is_DRM_SBR = IsDRM;
86#endif
87 sbr->tHFGen = T_HFGEN;
88 sbr->tHFAdj = T_HFADJ;
89
90 sbr->bsco = 0;
91 sbr->bsco_prev = 0;
92 sbr->M_prev = 0;
93 sbr->frame_len = framelength;
94
95 /* force sbr reset */
96 sbr->bs_start_freq_prev = -1;
97
98 if (framelength == 960) {
99 sbr->numTimeSlotsRate = RATE * NO_TIME_SLOTS_960;
100 sbr->numTimeSlots = NO_TIME_SLOTS_960;
101 } else {
102 sbr->numTimeSlotsRate = RATE * NO_TIME_SLOTS;
103 sbr->numTimeSlots = NO_TIME_SLOTS;
104 }
105
106 sbr->GQ_ringbuf_index[0] = 0;
107 sbr->GQ_ringbuf_index[1] = 0;
108
109 if (id_aac == ID_CPE) {
110 /* stereo */
111 uint8_t j;
112 sbr->qmfa[0] = qmfa_init(32);
113 sbr->qmfa[1] = qmfa_init(32);
114 sbr->qmfs[0] = qmfs_init((downSampledSBR) ? 32 : 64);
115 sbr->qmfs[1] = qmfs_init((downSampledSBR) ? 32 : 64);
116
117 for (j = 0; j < 5; j++) {
118 sbr->G_temp_prev[0][j] = faad_malloc(64 * sizeof(real_t));
119 sbr->G_temp_prev[1][j] = faad_malloc(64 * sizeof(real_t));
120 sbr->Q_temp_prev[0][j] = faad_malloc(64 * sizeof(real_t));
121 sbr->Q_temp_prev[1][j] = faad_malloc(64 * sizeof(real_t));
122 }
123
124 memset(sbr->Xsbr[0], 0, (sbr->numTimeSlotsRate + sbr->tHFGen) * 64 * sizeof(qmf_t));
125 memset(sbr->Xsbr[1], 0, (sbr->numTimeSlotsRate + sbr->tHFGen) * 64 * sizeof(qmf_t));
126 } else {
127 /* mono */
128 uint8_t j;
129 sbr->qmfa[0] = qmfa_init(32);
130 sbr->qmfs[0] = qmfs_init((downSampledSBR) ? 32 : 64);
131 sbr->qmfs[1] = NULL;
132
133 for (j = 0; j < 5; j++) {
134 sbr->G_temp_prev[0][j] = faad_malloc(64 * sizeof(real_t));
135 sbr->Q_temp_prev[0][j] = faad_malloc(64 * sizeof(real_t));
136 }
137
138 memset(sbr->Xsbr[0], 0, (sbr->numTimeSlotsRate + sbr->tHFGen) * 64 * sizeof(qmf_t));
139 }
140
141 return sbr;
142}
143
144void sbrDecodeEnd(sbr_info *sbr)
145{
146 uint8_t j;
147
148 if (sbr) {
149 qmfa_end(sbr->qmfa[0]);
150 qmfs_end(sbr->qmfs[0]);
151 if (sbr->qmfs[1] != NULL) {
152 qmfa_end(sbr->qmfa[1]);
153 qmfs_end(sbr->qmfs[1]);
154 }
155
156 for (j = 0; j < 5; j++) {
157 if (sbr->G_temp_prev[0][j]) {
158 faad_free(sbr->G_temp_prev[0][j]);
159 }
160 if (sbr->Q_temp_prev[0][j]) {
161 faad_free(sbr->Q_temp_prev[0][j]);
162 }
163 if (sbr->G_temp_prev[1][j]) {
164 faad_free(sbr->G_temp_prev[1][j]);
165 }
166 if (sbr->Q_temp_prev[1][j]) {
167 faad_free(sbr->Q_temp_prev[1][j]);
168 }
169 }
170
171#ifdef PS_DEC
172 if (sbr->ps != NULL) {
173 ps_free(sbr->ps);
174 }
175#endif
176
177#ifdef DRM_PS
178 if (sbr->drm_ps != NULL) {
179 drm_ps_free(sbr->drm_ps);
180 }
181#endif
182
183 faad_free(sbr);
184 }
185}
186
187void sbrReset(sbr_info *sbr)
188{
189 uint8_t j;
190 if (sbr->qmfa[0] != NULL) {
191 memset(sbr->qmfa[0]->x, 0, 2 * sbr->qmfa[0]->channels * 10 * sizeof(real_t));
192 }
193 if (sbr->qmfa[1] != NULL) {
194 memset(sbr->qmfa[1]->x, 0, 2 * sbr->qmfa[1]->channels * 10 * sizeof(real_t));
195 }
196 if (sbr->qmfs[0] != NULL) {
197 memset(sbr->qmfs[0]->v, 0, 2 * sbr->qmfs[0]->channels * 20 * sizeof(real_t));
198 }
199 if (sbr->qmfs[1] != NULL) {
200 memset(sbr->qmfs[1]->v, 0, 2 * sbr->qmfs[1]->channels * 20 * sizeof(real_t));
201 }
202
203 for (j = 0; j < 5; j++) {
204 if (sbr->G_temp_prev[0][j] != NULL) {
205 memset(sbr->G_temp_prev[0][j], 0, 64 * sizeof(real_t));
206 }
207 if (sbr->G_temp_prev[1][j] != NULL) {
208 memset(sbr->G_temp_prev[1][j], 0, 64 * sizeof(real_t));
209 }
210 if (sbr->Q_temp_prev[0][j] != NULL) {
211 memset(sbr->Q_temp_prev[0][j], 0, 64 * sizeof(real_t));
212 }
213 if (sbr->Q_temp_prev[1][j] != NULL) {
214 memset(sbr->Q_temp_prev[1][j], 0, 64 * sizeof(real_t));
215 }
216 }
217
218 memset(sbr->Xsbr[0], 0, (sbr->numTimeSlotsRate + sbr->tHFGen) * 64 * sizeof(qmf_t));
219 memset(sbr->Xsbr[1], 0, (sbr->numTimeSlotsRate + sbr->tHFGen) * 64 * sizeof(qmf_t));
220
221 sbr->GQ_ringbuf_index[0] = 0;
222 sbr->GQ_ringbuf_index[1] = 0;
223 sbr->header_count = 0;
224 sbr->Reset = 1;
225
226 sbr->L_E_prev[0] = 0;
227 sbr->L_E_prev[1] = 0;
228 sbr->bs_freq_scale = 2;
229 sbr->bs_alter_scale = 1;
230 sbr->bs_noise_bands = 2;
231 sbr->bs_limiter_bands = 2;
232 sbr->bs_limiter_gains = 2;
233 sbr->bs_interpol_freq = 1;
234 sbr->bs_smoothing_mode = 1;
235 sbr->bs_start_freq = 5;
236 sbr->bs_amp_res = 1;
237 sbr->bs_samplerate_mode = 1;
238 sbr->prevEnvIsShort[0] = -1;
239 sbr->prevEnvIsShort[1] = -1;
240 sbr->bsco = 0;
241 sbr->bsco_prev = 0;
242 sbr->M_prev = 0;
243 sbr->bs_start_freq_prev = -1;
244
245 sbr->f_prev[0] = 0;
246 sbr->f_prev[1] = 0;
247 for (j = 0; j < MAX_M; j++) {
248 sbr->E_prev[0][j] = 0;
249 sbr->Q_prev[0][j] = 0;
250 sbr->E_prev[1][j] = 0;
251 sbr->Q_prev[1][j] = 0;
252 sbr->bs_add_harmonic_prev[0][j] = 0;
253 sbr->bs_add_harmonic_prev[1][j] = 0;
254 }
255 sbr->bs_add_harmonic_flag_prev[0] = 0;
256 sbr->bs_add_harmonic_flag_prev[1] = 0;
257}
258
259static uint8_t sbr_save_prev_data(sbr_info *sbr, uint8_t ch)
260{
261 uint8_t i;
262
263 /* save data for next frame */
264 sbr->kx_prev = sbr->kx;
265 sbr->M_prev = sbr->M;
266 sbr->bsco_prev = sbr->bsco;
267
268 sbr->L_E_prev[ch] = sbr->L_E[ch];
269
270 /* sbr->L_E[ch] can become 0 on files with bit errors */
271 if (sbr->L_E[ch] <= 0) {
272 return 19;
273 }
274
275 sbr->f_prev[ch] = sbr->f[ch][sbr->L_E[ch] - 1];
276 for (i = 0; i < MAX_M; i++) {
277 sbr->E_prev[ch][i] = sbr->E[ch][i][sbr->L_E[ch] - 1];
278 sbr->Q_prev[ch][i] = sbr->Q[ch][i][sbr->L_Q[ch] - 1];
279 }
280
281 for (i = 0; i < MAX_M; i++) {
282 sbr->bs_add_harmonic_prev[ch][i] = sbr->bs_add_harmonic[ch][i];
283 }
284 sbr->bs_add_harmonic_flag_prev[ch] = sbr->bs_add_harmonic_flag[ch];
285
286 if (sbr->l_A[ch] == sbr->L_E[ch]) {
287 sbr->prevEnvIsShort[ch] = 0;
288 } else {
289 sbr->prevEnvIsShort[ch] = -1;
290 }
291
292 return 0;
293}
294
295static void sbr_save_matrix(sbr_info *sbr, uint8_t ch)
296{
297 uint8_t i;
298
299 for (i = 0; i < sbr->tHFGen; i++) {
300 memmove(sbr->Xsbr[ch][i], sbr->Xsbr[ch][i + sbr->numTimeSlotsRate], 64 * sizeof(qmf_t));
301 }
302 for (i = sbr->tHFGen; i < MAX_NTSRHFG; i++) {
303 memset(sbr->Xsbr[ch][i], 0, 64 * sizeof(qmf_t));
304 }
305}
306
307static uint8_t sbr_process_channel(sbr_info *sbr, real_t *channel_buf, qmf_t X[MAX_NTSR][64],
308 uint8_t ch, uint8_t dont_process,
309 const uint8_t downSampledSBR __unused)
310{
311 int16_t k, l;
312 uint8_t ret = 0;
313
314#ifdef SBR_LOW_POWER
315 ALIGN real_t deg[64];
316#endif
317
318#ifdef DRM
319 if (sbr->Is_DRM_SBR) {
320 sbr->bsco = max((int32_t)sbr->maxAACLine * 32 / (int32_t)sbr->frame_len - (int32_t)sbr->kx, 0);
321 } else {
322#endif
323 sbr->bsco = 0;
324#ifdef DRM
325 }
326#endif
327
328
329 //#define PRE_QMF_PRINT
330#ifdef PRE_QMF_PRINT
331 {
332 int i;
333 for (i = 0; i < 1024; i++) {
334 printf("%d\n", channel_buf[i]);
335 }
336 }
337#endif
338
339
340 /* subband analysis */
341 if (dont_process) {
342 sbr_qmf_analysis_32(sbr, sbr->qmfa[ch], channel_buf, sbr->Xsbr[ch], sbr->tHFGen, 32);
343 } else {
344 sbr_qmf_analysis_32(sbr, sbr->qmfa[ch], channel_buf, sbr->Xsbr[ch], sbr->tHFGen, sbr->kx);
345 }
346
347 if (!dont_process) {
348#if 1
349 /* insert high frequencies here */
350 /* hf generation using patching */
351 hf_generation(sbr, sbr->Xsbr[ch], sbr->Xsbr[ch]
352#ifdef SBR_LOW_POWER
353 , deg
354#endif
355 , ch);
356#endif
357
358#if 0 //def SBR_LOW_POWER
359 for (l = sbr->t_E[ch][0]; l < sbr->t_E[ch][sbr->L_E[ch]]; l++) {
360 for (k = 0; k < sbr->kx; k++) {
361 QMF_RE(sbr->Xsbr[ch][sbr->tHFAdj + l][k]) = 0;
362 }
363 }
364#endif
365
366#if 1
367 /* hf adjustment */
368 ret = hf_adjustment(sbr, sbr->Xsbr[ch]
369#ifdef SBR_LOW_POWER
370 , deg
371#endif
372 , ch);
373#endif
374 if (ret > 0) {
375 dont_process = 1;
376 }
377 }
378
379 if ((sbr->just_seeked != 0) || dont_process) {
380 for (l = 0; l < sbr->numTimeSlotsRate; l++) {
381 for (k = 0; k < 32; k++) {
382 QMF_RE(X[l][k]) = QMF_RE(sbr->Xsbr[ch][l + sbr->tHFAdj][k]);
383#ifndef SBR_LOW_POWER
384 QMF_IM(X[l][k]) = QMF_IM(sbr->Xsbr[ch][l + sbr->tHFAdj][k]);
385#endif
386 }
387 for (k = 32; k < 64; k++) {
388 QMF_RE(X[l][k]) = 0;
389#ifndef SBR_LOW_POWER
390 QMF_IM(X[l][k]) = 0;
391#endif
392 }
393 }
394 } else {
395 for (l = 0; l < sbr->numTimeSlotsRate; l++) {
396 uint8_t kx_band, M_band, bsco_band;
397
398 if (l < sbr->t_E[ch][0]) {
399 kx_band = sbr->kx_prev;
400 M_band = sbr->M_prev;
401 bsco_band = sbr->bsco_prev;
402 } else {
403 kx_band = sbr->kx;
404 M_band = sbr->M;
405 bsco_band = sbr->bsco;
406 }
407
408#ifndef SBR_LOW_POWER
409 for (k = 0; k < kx_band + bsco_band; k++) {
410 QMF_RE(X[l][k]) = QMF_RE(sbr->Xsbr[ch][l + sbr->tHFAdj][k]);
411 QMF_IM(X[l][k]) = QMF_IM(sbr->Xsbr[ch][l + sbr->tHFAdj][k]);
412 }
413 for (k = kx_band + bsco_band; k < kx_band + M_band; k++) {
414 QMF_RE(X[l][k]) = QMF_RE(sbr->Xsbr[ch][l + sbr->tHFAdj][k]);
415 QMF_IM(X[l][k]) = QMF_IM(sbr->Xsbr[ch][l + sbr->tHFAdj][k]);
416 }
417 for (k = max(kx_band + bsco_band, kx_band + M_band); k < 64; k++) {
418 QMF_RE(X[l][k]) = 0;
419 QMF_IM(X[l][k]) = 0;
420 }
421#else
422 for (k = 0; k < kx_band + bsco_band; k++) {
423 QMF_RE(X[l][k]) = QMF_RE(sbr->Xsbr[ch][l + sbr->tHFAdj][k]);
424 }
425 for (k = kx_band + bsco_band; k < min(kx_band + M_band, 63); k++) {
426 QMF_RE(X[l][k]) = QMF_RE(sbr->Xsbr[ch][l + sbr->tHFAdj][k]);
427 }
428 for (k = max(kx_band + bsco_band, kx_band + M_band); k < 64; k++) {
429 QMF_RE(X[l][k]) = 0;
430 }
431 QMF_RE(X[l][kx_band - 1 + bsco_band]) +=
432 QMF_RE(sbr->Xsbr[ch][l + sbr->tHFAdj][kx_band - 1 + bsco_band]);
433#endif
434 }
435 }
436
437 return ret;
438}
439
440uint8_t sbrDecodeCoupleFrame(sbr_info *sbr, real_t *left_chan, real_t *right_chan,
441 const uint8_t just_seeked, const uint8_t downSampledSBR)
442{
443 uint8_t dont_process = 0;
444 uint8_t ret = 0;
yuliang.hu77fab5b2024-07-19 18:32:11 +0800445 ALIGN static qmf_t X[MAX_NTSR][64];
446 memset(X, 0, sizeof(X));
xingri.gaoc18d4472023-02-28 02:51:02 +0000447
448 if (sbr == NULL) {
449 return 20;
450 }
451
452 /* case can occur due to bit errors */
453 if (sbr->id_aac != ID_CPE) {
454 return 21;
455 }
456
457 if (sbr->ret || (sbr->header_count == 0)) {
458 /* don't process just upsample */
459 dont_process = 1;
460
461 /* Re-activate reset for next frame */
462 if (sbr->ret && sbr->Reset) {
463 sbr->bs_start_freq_prev = -1;
464 }
465 }
466
467 if (just_seeked) {
468 sbr->just_seeked = 1;
469 } else {
470 sbr->just_seeked = 0;
471 }
472
473 sbr->ret += sbr_process_channel(sbr, left_chan, X, 0, dont_process, downSampledSBR);
474 /* subband synthesis */
475 if (downSampledSBR) {
Jiacai.Liuba4fdc02023-11-21 19:58:04 +0800476 sbr_qmf_synthesis_32(sbr, sbr->qmfs[0], &X[0][0], left_chan);
xingri.gaoc18d4472023-02-28 02:51:02 +0000477 } else {
Jiacai.Liuba4fdc02023-11-21 19:58:04 +0800478 sbr_qmf_synthesis_64(sbr, sbr->qmfs[0], &X[0][0], left_chan);
xingri.gaoc18d4472023-02-28 02:51:02 +0000479 }
480
481 sbr->ret += sbr_process_channel(sbr, right_chan, X, 1, dont_process, downSampledSBR);
482 /* subband synthesis */
483 if (downSampledSBR) {
Jiacai.Liuba4fdc02023-11-21 19:58:04 +0800484 sbr_qmf_synthesis_32(sbr, sbr->qmfs[1], &X[0][0], right_chan);
xingri.gaoc18d4472023-02-28 02:51:02 +0000485 } else {
Jiacai.Liuba4fdc02023-11-21 19:58:04 +0800486 sbr_qmf_synthesis_64(sbr, sbr->qmfs[1], &X[0][0], right_chan);
xingri.gaoc18d4472023-02-28 02:51:02 +0000487 }
488
489 if (sbr->bs_header_flag) {
490 sbr->just_seeked = 0;
491 }
492
493 if (sbr->header_count != 0 && sbr->ret == 0) {
494 ret = sbr_save_prev_data(sbr, 0);
495 if (ret) {
496 return ret;
497 }
498 ret = sbr_save_prev_data(sbr, 1);
499 if (ret) {
500 return ret;
501 }
502 }
503
504 sbr_save_matrix(sbr, 0);
505 sbr_save_matrix(sbr, 1);
506
507 sbr->frame++;
508
509 //#define POST_QMF_PRINT
510#ifdef POST_QMF_PRINT
511 {
512 int i;
513 for (i = 0; i < 2048; i++) {
514 printf("%d\n", left_chan[i]);
515 }
516 for (i = 0; i < 2048; i++) {
517 printf("%d\n", right_chan[i]);
518 }
519 }
520#endif
521
522 return 0;
523}
524
525uint8_t sbrDecodeSingleFrame(sbr_info *sbr, real_t *channel,
526 const uint8_t just_seeked, const uint8_t downSampledSBR)
527{
528 uint8_t dont_process = 0;
529 uint8_t ret = 0;
yuliang.hu77fab5b2024-07-19 18:32:11 +0800530 ALIGN static qmf_t X[MAX_NTSR][64];
531 memset(X, 0, sizeof(X));
xingri.gaoc18d4472023-02-28 02:51:02 +0000532
533 if (sbr == NULL) {
534 return 20;
535 }
536
537 /* case can occur due to bit errors */
538 if (sbr->id_aac != ID_SCE && sbr->id_aac != ID_LFE) {
539 return 21;
540 }
541
542 if (sbr->ret || (sbr->header_count == 0)) {
543 /* don't process just upsample */
544 dont_process = 1;
545
546 /* Re-activate reset for next frame */
547 if (sbr->ret && sbr->Reset) {
548 sbr->bs_start_freq_prev = -1;
549 }
550 }
551
552 if (just_seeked) {
553 sbr->just_seeked = 1;
554 } else {
555 sbr->just_seeked = 0;
556 }
557
558 sbr->ret += sbr_process_channel(sbr, channel, X, 0, dont_process, downSampledSBR);
559 /* subband synthesis */
560 if (downSampledSBR) {
Jiacai.Liuba4fdc02023-11-21 19:58:04 +0800561 sbr_qmf_synthesis_32(sbr, sbr->qmfs[0], &X[0][0], channel);
xingri.gaoc18d4472023-02-28 02:51:02 +0000562 } else {
Jiacai.Liuba4fdc02023-11-21 19:58:04 +0800563 sbr_qmf_synthesis_64(sbr, sbr->qmfs[0], &X[0][0], channel);
xingri.gaoc18d4472023-02-28 02:51:02 +0000564 }
565
566 if (sbr->bs_header_flag) {
567 sbr->just_seeked = 0;
568 }
569
570 if (sbr->header_count != 0 && sbr->ret == 0) {
571 ret = sbr_save_prev_data(sbr, 0);
572 if (ret) {
573 return ret;
574 }
575 }
576
577 sbr_save_matrix(sbr, 0);
578
579 sbr->frame++;
580
581 //#define POST_QMF_PRINT
582#ifdef POST_QMF_PRINT
583 {
584 int i;
585 for (i = 0; i < 2048; i++) {
586 printf("%d\n", channel[i]);
587 }
588 }
589#endif
590
591 return 0;
592}
593
594#if (defined(PS_DEC) || defined(DRM_PS))
595uint8_t sbrDecodeSingleFramePS(sbr_info *sbr, real_t *left_channel, real_t *right_channel,
596 const uint8_t just_seeked, const uint8_t downSampledSBR)
597{
598 uint8_t l, k;
599 uint8_t dont_process = 0;
600 uint8_t ret = 0;
yuliang.hu77fab5b2024-07-19 18:32:11 +0800601 ALIGN static qmf_t X_left[38][64] = {{0}};
602 ALIGN static qmf_t X_right[38][64] = {{0}}; /* must set this to 0 */
603 memset(X_left, 0, sizeof(X_left));
604 memset(X_right, 0, sizeof(X_right));
xingri.gaoc18d4472023-02-28 02:51:02 +0000605
606 if (sbr == NULL) {
607 return 20;
608 }
609
610 /* case can occur due to bit errors */
611 if (sbr->id_aac != ID_SCE && sbr->id_aac != ID_LFE) {
612 return 21;
613 }
614
615 if (sbr->ret || (sbr->header_count == 0)) {
616 /* don't process just upsample */
617 dont_process = 1;
618
619 /* Re-activate reset for next frame */
620 if (sbr->ret && sbr->Reset) {
621 sbr->bs_start_freq_prev = -1;
622 }
623 }
624
625 if (just_seeked) {
626 sbr->just_seeked = 1;
627 } else {
628 sbr->just_seeked = 0;
629 }
630
631 if (sbr->qmfs[1] == NULL) {
632 sbr->qmfs[1] = qmfs_init((downSampledSBR) ? 32 : 64);
633 }
634
635 sbr->ret += sbr_process_channel(sbr, left_channel, X_left, 0, dont_process, downSampledSBR);
636
637 /* copy some extra data for PS */
638 for (l = sbr->numTimeSlotsRate; l < sbr->numTimeSlotsRate + 6; l++) {
639 for (k = 0; k < 5; k++) {
640 QMF_RE(X_left[l][k]) = QMF_RE(sbr->Xsbr[0][sbr->tHFAdj + l][k]);
641 QMF_IM(X_left[l][k]) = QMF_IM(sbr->Xsbr[0][sbr->tHFAdj + l][k]);
642 }
643 }
644
645 /* perform parametric stereo */
646#ifdef DRM_PS
647 if (sbr->Is_DRM_SBR) {
648 drm_ps_decode(sbr->drm_ps, (sbr->ret > 0), X_left, X_right);
649 } else {
650#endif
651#ifdef PS_DEC
652 ps_decode(sbr->ps, X_left, X_right);
653#endif
654#ifdef DRM_PS
655 }
656#endif
657
658 /* subband synthesis */
659 if (downSampledSBR) {
Jiacai.Liuba4fdc02023-11-21 19:58:04 +0800660 sbr_qmf_synthesis_32(sbr, sbr->qmfs[0], &X_left[0][0], left_channel);
661 sbr_qmf_synthesis_32(sbr, sbr->qmfs[1], &X_right[0][0], right_channel);
xingri.gaoc18d4472023-02-28 02:51:02 +0000662 } else {
Jiacai.Liuba4fdc02023-11-21 19:58:04 +0800663 sbr_qmf_synthesis_64(sbr, sbr->qmfs[0], &X_left[0][0], left_channel);
664 sbr_qmf_synthesis_64(sbr, sbr->qmfs[1], &X_right[0][0], right_channel);
xingri.gaoc18d4472023-02-28 02:51:02 +0000665 }
666
667 if (sbr->bs_header_flag) {
668 sbr->just_seeked = 0;
669 }
670
671 if (sbr->header_count != 0 && sbr->ret == 0) {
672 ret = sbr_save_prev_data(sbr, 0);
673 if (ret) {
674 return ret;
675 }
676 }
677
678 sbr_save_matrix(sbr, 0);
679
680 sbr->frame++;
681
682 return 0;
683}
684#endif
685
686#endif