summaryrefslogtreecommitdiff
path: root/audio_codec/libfaad/sbr_dec.c (plain)
blob: 7ae5659826fea1d8e18bd2a889a126997058a592
1/*
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
47/* static function declarations */
48static uint8_t sbr_save_prev_data(sbr_info *sbr, uint8_t ch);
49static void sbr_save_matrix(sbr_info *sbr, uint8_t ch);
50
51
52sbr_info *sbrDecodeInit(uint16_t framelength, uint8_t id_aac,
53 uint32_t sample_rate, uint8_t downSampledSBR
54#ifdef DRM
55 , uint8_t IsDRM
56#endif
57 )
58{
59 sbr_info *sbr = faad_malloc(sizeof(sbr_info));
60 memset(sbr, 0, sizeof(sbr_info));
61
62 /* save id of the parent element */
63 sbr->id_aac = id_aac;
64 sbr->sample_rate = sample_rate;
65
66 sbr->bs_freq_scale = 2;
67 sbr->bs_alter_scale = 1;
68 sbr->bs_noise_bands = 2;
69 sbr->bs_limiter_bands = 2;
70 sbr->bs_limiter_gains = 2;
71 sbr->bs_interpol_freq = 1;
72 sbr->bs_smoothing_mode = 1;
73 sbr->bs_start_freq = 5;
74 sbr->bs_amp_res = 1;
75 sbr->bs_samplerate_mode = 1;
76 sbr->prevEnvIsShort[0] = -1;
77 sbr->prevEnvIsShort[1] = -1;
78 sbr->header_count = 0;
79 sbr->Reset = 1;
80
81#ifdef DRM
82 sbr->Is_DRM_SBR = IsDRM;
83#endif
84 sbr->tHFGen = T_HFGEN;
85 sbr->tHFAdj = T_HFADJ;
86
87 sbr->bsco = 0;
88 sbr->bsco_prev = 0;
89 sbr->M_prev = 0;
90 sbr->frame_len = framelength;
91
92 /* force sbr reset */
93 sbr->bs_start_freq_prev = -1;
94
95 if (framelength == 960) {
96 sbr->numTimeSlotsRate = RATE * NO_TIME_SLOTS_960;
97 sbr->numTimeSlots = NO_TIME_SLOTS_960;
98 } else {
99 sbr->numTimeSlotsRate = RATE * NO_TIME_SLOTS;
100 sbr->numTimeSlots = NO_TIME_SLOTS;
101 }
102
103 sbr->GQ_ringbuf_index[0] = 0;
104 sbr->GQ_ringbuf_index[1] = 0;
105
106 if (id_aac == ID_CPE) {
107 /* stereo */
108 uint8_t j;
109 sbr->qmfa[0] = qmfa_init(32);
110 sbr->qmfa[1] = qmfa_init(32);
111 sbr->qmfs[0] = qmfs_init((downSampledSBR) ? 32 : 64);
112 sbr->qmfs[1] = qmfs_init((downSampledSBR) ? 32 : 64);
113
114 for (j = 0; j < 5; j++) {
115 sbr->G_temp_prev[0][j] = faad_malloc(64 * sizeof(real_t));
116 sbr->G_temp_prev[1][j] = faad_malloc(64 * sizeof(real_t));
117 sbr->Q_temp_prev[0][j] = faad_malloc(64 * sizeof(real_t));
118 sbr->Q_temp_prev[1][j] = faad_malloc(64 * sizeof(real_t));
119 }
120
121 memset(sbr->Xsbr[0], 0, (sbr->numTimeSlotsRate + sbr->tHFGen) * 64 * sizeof(qmf_t));
122 memset(sbr->Xsbr[1], 0, (sbr->numTimeSlotsRate + sbr->tHFGen) * 64 * sizeof(qmf_t));
123 } else {
124 /* mono */
125 uint8_t j;
126 sbr->qmfa[0] = qmfa_init(32);
127 sbr->qmfs[0] = qmfs_init((downSampledSBR) ? 32 : 64);
128 sbr->qmfs[1] = NULL;
129
130 for (j = 0; j < 5; j++) {
131 sbr->G_temp_prev[0][j] = faad_malloc(64 * sizeof(real_t));
132 sbr->Q_temp_prev[0][j] = faad_malloc(64 * sizeof(real_t));
133 }
134
135 memset(sbr->Xsbr[0], 0, (sbr->numTimeSlotsRate + sbr->tHFGen) * 64 * sizeof(qmf_t));
136 }
137
138 return sbr;
139}
140
141void sbrDecodeEnd(sbr_info *sbr)
142{
143 uint8_t j;
144
145 if (sbr) {
146 qmfa_end(sbr->qmfa[0]);
147 qmfs_end(sbr->qmfs[0]);
148 if (sbr->qmfs[1] != NULL) {
149 qmfa_end(sbr->qmfa[1]);
150 qmfs_end(sbr->qmfs[1]);
151 }
152
153 for (j = 0; j < 5; j++) {
154 if (sbr->G_temp_prev[0][j]) {
155 faad_free(sbr->G_temp_prev[0][j]);
156 }
157 if (sbr->Q_temp_prev[0][j]) {
158 faad_free(sbr->Q_temp_prev[0][j]);
159 }
160 if (sbr->G_temp_prev[1][j]) {
161 faad_free(sbr->G_temp_prev[1][j]);
162 }
163 if (sbr->Q_temp_prev[1][j]) {
164 faad_free(sbr->Q_temp_prev[1][j]);
165 }
166 }
167
168#ifdef PS_DEC
169 if (sbr->ps != NULL) {
170 ps_free(sbr->ps);
171 }
172#endif
173
174#ifdef DRM_PS
175 if (sbr->drm_ps != NULL) {
176 drm_ps_free(sbr->drm_ps);
177 }
178#endif
179
180 faad_free(sbr);
181 }
182}
183
184void sbrReset(sbr_info *sbr)
185{
186 uint8_t j;
187 if (sbr->qmfa[0] != NULL) {
188 memset(sbr->qmfa[0]->x, 0, 2 * sbr->qmfa[0]->channels * 10 * sizeof(real_t));
189 }
190 if (sbr->qmfa[1] != NULL) {
191 memset(sbr->qmfa[1]->x, 0, 2 * sbr->qmfa[1]->channels * 10 * sizeof(real_t));
192 }
193 if (sbr->qmfs[0] != NULL) {
194 memset(sbr->qmfs[0]->v, 0, 2 * sbr->qmfs[0]->channels * 20 * sizeof(real_t));
195 }
196 if (sbr->qmfs[1] != NULL) {
197 memset(sbr->qmfs[1]->v, 0, 2 * sbr->qmfs[1]->channels * 20 * sizeof(real_t));
198 }
199
200 for (j = 0; j < 5; j++) {
201 if (sbr->G_temp_prev[0][j] != NULL) {
202 memset(sbr->G_temp_prev[0][j], 0, 64 * sizeof(real_t));
203 }
204 if (sbr->G_temp_prev[1][j] != NULL) {
205 memset(sbr->G_temp_prev[1][j], 0, 64 * sizeof(real_t));
206 }
207 if (sbr->Q_temp_prev[0][j] != NULL) {
208 memset(sbr->Q_temp_prev[0][j], 0, 64 * sizeof(real_t));
209 }
210 if (sbr->Q_temp_prev[1][j] != NULL) {
211 memset(sbr->Q_temp_prev[1][j], 0, 64 * sizeof(real_t));
212 }
213 }
214
215 memset(sbr->Xsbr[0], 0, (sbr->numTimeSlotsRate + sbr->tHFGen) * 64 * sizeof(qmf_t));
216 memset(sbr->Xsbr[1], 0, (sbr->numTimeSlotsRate + sbr->tHFGen) * 64 * sizeof(qmf_t));
217
218 sbr->GQ_ringbuf_index[0] = 0;
219 sbr->GQ_ringbuf_index[1] = 0;
220 sbr->header_count = 0;
221 sbr->Reset = 1;
222
223 sbr->L_E_prev[0] = 0;
224 sbr->L_E_prev[1] = 0;
225 sbr->bs_freq_scale = 2;
226 sbr->bs_alter_scale = 1;
227 sbr->bs_noise_bands = 2;
228 sbr->bs_limiter_bands = 2;
229 sbr->bs_limiter_gains = 2;
230 sbr->bs_interpol_freq = 1;
231 sbr->bs_smoothing_mode = 1;
232 sbr->bs_start_freq = 5;
233 sbr->bs_amp_res = 1;
234 sbr->bs_samplerate_mode = 1;
235 sbr->prevEnvIsShort[0] = -1;
236 sbr->prevEnvIsShort[1] = -1;
237 sbr->bsco = 0;
238 sbr->bsco_prev = 0;
239 sbr->M_prev = 0;
240 sbr->bs_start_freq_prev = -1;
241
242 sbr->f_prev[0] = 0;
243 sbr->f_prev[1] = 0;
244 for (j = 0; j < MAX_M; j++) {
245 sbr->E_prev[0][j] = 0;
246 sbr->Q_prev[0][j] = 0;
247 sbr->E_prev[1][j] = 0;
248 sbr->Q_prev[1][j] = 0;
249 sbr->bs_add_harmonic_prev[0][j] = 0;
250 sbr->bs_add_harmonic_prev[1][j] = 0;
251 }
252 sbr->bs_add_harmonic_flag_prev[0] = 0;
253 sbr->bs_add_harmonic_flag_prev[1] = 0;
254}
255
256static uint8_t sbr_save_prev_data(sbr_info *sbr, uint8_t ch)
257{
258 uint8_t i;
259
260 /* save data for next frame */
261 sbr->kx_prev = sbr->kx;
262 sbr->M_prev = sbr->M;
263 sbr->bsco_prev = sbr->bsco;
264
265 sbr->L_E_prev[ch] = sbr->L_E[ch];
266
267 /* sbr->L_E[ch] can become 0 on files with bit errors */
268 if (sbr->L_E[ch] <= 0) {
269 return 19;
270 }
271
272 sbr->f_prev[ch] = sbr->f[ch][sbr->L_E[ch] - 1];
273 for (i = 0; i < MAX_M; i++) {
274 sbr->E_prev[ch][i] = sbr->E[ch][i][sbr->L_E[ch] - 1];
275 sbr->Q_prev[ch][i] = sbr->Q[ch][i][sbr->L_Q[ch] - 1];
276 }
277
278 for (i = 0; i < MAX_M; i++) {
279 sbr->bs_add_harmonic_prev[ch][i] = sbr->bs_add_harmonic[ch][i];
280 }
281 sbr->bs_add_harmonic_flag_prev[ch] = sbr->bs_add_harmonic_flag[ch];
282
283 if (sbr->l_A[ch] == sbr->L_E[ch]) {
284 sbr->prevEnvIsShort[ch] = 0;
285 } else {
286 sbr->prevEnvIsShort[ch] = -1;
287 }
288
289 return 0;
290}
291
292static void sbr_save_matrix(sbr_info *sbr, uint8_t ch)
293{
294 uint8_t i;
295
296 for (i = 0; i < sbr->tHFGen; i++) {
297 memmove(sbr->Xsbr[ch][i], sbr->Xsbr[ch][i + sbr->numTimeSlotsRate], 64 * sizeof(qmf_t));
298 }
299 for (i = sbr->tHFGen; i < MAX_NTSRHFG; i++) {
300 memset(sbr->Xsbr[ch][i], 0, 64 * sizeof(qmf_t));
301 }
302}
303
304static uint8_t sbr_process_channel(sbr_info *sbr, real_t *channel_buf, qmf_t X[MAX_NTSR][64],
305 uint8_t ch, uint8_t dont_process,
306 const uint8_t downSampledSBR)
307{
308 int16_t k, l;
309 uint8_t ret = 0;
310
311#ifdef SBR_LOW_POWER
312 ALIGN real_t deg[64];
313#endif
314
315#ifdef DRM
316 if (sbr->Is_DRM_SBR) {
317 sbr->bsco = max((int32_t)sbr->maxAACLine * 32 / (int32_t)sbr->frame_len - (int32_t)sbr->kx, 0);
318 } else {
319#endif
320 sbr->bsco = 0;
321#ifdef DRM
322 }
323#endif
324
325
326 //#define PRE_QMF_PRINT
327#ifdef PRE_QMF_PRINT
328 {
329 int i;
330 for (i = 0; i < 1024; i++) {
331 printf("%d\n", channel_buf[i]);
332 }
333 }
334#endif
335
336
337 /* subband analysis */
338 if (dont_process) {
339 sbr_qmf_analysis_32(sbr, sbr->qmfa[ch], channel_buf, sbr->Xsbr[ch], sbr->tHFGen, 32);
340 } else {
341 sbr_qmf_analysis_32(sbr, sbr->qmfa[ch], channel_buf, sbr->Xsbr[ch], sbr->tHFGen, sbr->kx);
342 }
343
344 if (!dont_process) {
345#if 1
346 /* insert high frequencies here */
347 /* hf generation using patching */
348 hf_generation(sbr, sbr->Xsbr[ch], sbr->Xsbr[ch]
349#ifdef SBR_LOW_POWER
350 , deg
351#endif
352 , ch);
353#endif
354
355#if 0 //def SBR_LOW_POWER
356 for (l = sbr->t_E[ch][0]; l < sbr->t_E[ch][sbr->L_E[ch]]; l++) {
357 for (k = 0; k < sbr->kx; k++) {
358 QMF_RE(sbr->Xsbr[ch][sbr->tHFAdj + l][k]) = 0;
359 }
360 }
361#endif
362
363#if 1
364 /* hf adjustment */
365 ret = hf_adjustment(sbr, sbr->Xsbr[ch]
366#ifdef SBR_LOW_POWER
367 , deg
368#endif
369 , ch);
370#endif
371 if (ret > 0) {
372 dont_process = 1;
373 }
374 }
375
376 if ((sbr->just_seeked != 0) || dont_process) {
377 for (l = 0; l < sbr->numTimeSlotsRate; l++) {
378 for (k = 0; k < 32; k++) {
379 QMF_RE(X[l][k]) = QMF_RE(sbr->Xsbr[ch][l + sbr->tHFAdj][k]);
380#ifndef SBR_LOW_POWER
381 QMF_IM(X[l][k]) = QMF_IM(sbr->Xsbr[ch][l + sbr->tHFAdj][k]);
382#endif
383 }
384 for (k = 32; k < 64; k++) {
385 QMF_RE(X[l][k]) = 0;
386#ifndef SBR_LOW_POWER
387 QMF_IM(X[l][k]) = 0;
388#endif
389 }
390 }
391 } else {
392 for (l = 0; l < sbr->numTimeSlotsRate; l++) {
393 uint8_t kx_band, M_band, bsco_band;
394
395 if (l < sbr->t_E[ch][0]) {
396 kx_band = sbr->kx_prev;
397 M_band = sbr->M_prev;
398 bsco_band = sbr->bsco_prev;
399 } else {
400 kx_band = sbr->kx;
401 M_band = sbr->M;
402 bsco_band = sbr->bsco;
403 }
404
405#ifndef SBR_LOW_POWER
406 for (k = 0; k < kx_band + bsco_band; k++) {
407 QMF_RE(X[l][k]) = QMF_RE(sbr->Xsbr[ch][l + sbr->tHFAdj][k]);
408 QMF_IM(X[l][k]) = QMF_IM(sbr->Xsbr[ch][l + sbr->tHFAdj][k]);
409 }
410 for (k = kx_band + bsco_band; k < kx_band + M_band; k++) {
411 QMF_RE(X[l][k]) = QMF_RE(sbr->Xsbr[ch][l + sbr->tHFAdj][k]);
412 QMF_IM(X[l][k]) = QMF_IM(sbr->Xsbr[ch][l + sbr->tHFAdj][k]);
413 }
414 for (k = max(kx_band + bsco_band, kx_band + M_band); k < 64; k++) {
415 QMF_RE(X[l][k]) = 0;
416 QMF_IM(X[l][k]) = 0;
417 }
418#else
419 for (k = 0; k < kx_band + bsco_band; k++) {
420 QMF_RE(X[l][k]) = QMF_RE(sbr->Xsbr[ch][l + sbr->tHFAdj][k]);
421 }
422 for (k = kx_band + bsco_band; k < min(kx_band + M_band, 63); k++) {
423 QMF_RE(X[l][k]) = QMF_RE(sbr->Xsbr[ch][l + sbr->tHFAdj][k]);
424 }
425 for (k = max(kx_band + bsco_band, kx_band + M_band); k < 64; k++) {
426 QMF_RE(X[l][k]) = 0;
427 }
428 QMF_RE(X[l][kx_band - 1 + bsco_band]) +=
429 QMF_RE(sbr->Xsbr[ch][l + sbr->tHFAdj][kx_band - 1 + bsco_band]);
430#endif
431 }
432 }
433
434 return ret;
435}
436
437uint8_t sbrDecodeCoupleFrame(sbr_info *sbr, real_t *left_chan, real_t *right_chan,
438 const uint8_t just_seeked, const uint8_t downSampledSBR)
439{
440 uint8_t dont_process = 0;
441 uint8_t ret = 0;
442 ALIGN qmf_t X[MAX_NTSR][64];
443
444 if (sbr == NULL) {
445 return 20;
446 }
447
448 /* case can occur due to bit errors */
449 if (sbr->id_aac != ID_CPE) {
450 return 21;
451 }
452
453 if (sbr->ret || (sbr->header_count == 0)) {
454 /* don't process just upsample */
455 dont_process = 1;
456
457 /* Re-activate reset for next frame */
458 if (sbr->ret && sbr->Reset) {
459 sbr->bs_start_freq_prev = -1;
460 }
461 }
462
463 if (just_seeked) {
464 sbr->just_seeked = 1;
465 } else {
466 sbr->just_seeked = 0;
467 }
468
469 sbr->ret += sbr_process_channel(sbr, left_chan, X, 0, dont_process, downSampledSBR);
470 /* subband synthesis */
471 if (downSampledSBR) {
472 sbr_qmf_synthesis_32(sbr, sbr->qmfs[0], X, left_chan);
473 } else {
474 sbr_qmf_synthesis_64(sbr, sbr->qmfs[0], X, left_chan);
475 }
476
477 sbr->ret += sbr_process_channel(sbr, right_chan, X, 1, dont_process, downSampledSBR);
478 /* subband synthesis */
479 if (downSampledSBR) {
480 sbr_qmf_synthesis_32(sbr, sbr->qmfs[1], X, right_chan);
481 } else {
482 sbr_qmf_synthesis_64(sbr, sbr->qmfs[1], X, right_chan);
483 }
484
485 if (sbr->bs_header_flag) {
486 sbr->just_seeked = 0;
487 }
488
489 if (sbr->header_count != 0 && sbr->ret == 0) {
490 ret = sbr_save_prev_data(sbr, 0);
491 if (ret) {
492 return ret;
493 }
494 ret = sbr_save_prev_data(sbr, 1);
495 if (ret) {
496 return ret;
497 }
498 }
499
500 sbr_save_matrix(sbr, 0);
501 sbr_save_matrix(sbr, 1);
502
503 sbr->frame++;
504
505 //#define POST_QMF_PRINT
506#ifdef POST_QMF_PRINT
507 {
508 int i;
509 for (i = 0; i < 2048; i++) {
510 printf("%d\n", left_chan[i]);
511 }
512 for (i = 0; i < 2048; i++) {
513 printf("%d\n", right_chan[i]);
514 }
515 }
516#endif
517
518 return 0;
519}
520
521uint8_t sbrDecodeSingleFrame(sbr_info *sbr, real_t *channel,
522 const uint8_t just_seeked, const uint8_t downSampledSBR)
523{
524 uint8_t dont_process = 0;
525 uint8_t ret = 0;
526 ALIGN qmf_t X[MAX_NTSR][64];
527
528 if (sbr == NULL) {
529 return 20;
530 }
531
532 /* case can occur due to bit errors */
533 if (sbr->id_aac != ID_SCE && sbr->id_aac != ID_LFE) {
534 return 21;
535 }
536
537 if (sbr->ret || (sbr->header_count == 0)) {
538 /* don't process just upsample */
539 dont_process = 1;
540
541 /* Re-activate reset for next frame */
542 if (sbr->ret && sbr->Reset) {
543 sbr->bs_start_freq_prev = -1;
544 }
545 }
546
547 if (just_seeked) {
548 sbr->just_seeked = 1;
549 } else {
550 sbr->just_seeked = 0;
551 }
552
553 sbr->ret += sbr_process_channel(sbr, channel, X, 0, dont_process, downSampledSBR);
554 /* subband synthesis */
555 if (downSampledSBR) {
556 sbr_qmf_synthesis_32(sbr, sbr->qmfs[0], X, channel);
557 } else {
558 sbr_qmf_synthesis_64(sbr, sbr->qmfs[0], X, channel);
559 }
560
561 if (sbr->bs_header_flag) {
562 sbr->just_seeked = 0;
563 }
564
565 if (sbr->header_count != 0 && sbr->ret == 0) {
566 ret = sbr_save_prev_data(sbr, 0);
567 if (ret) {
568 return ret;
569 }
570 }
571
572 sbr_save_matrix(sbr, 0);
573
574 sbr->frame++;
575
576 //#define POST_QMF_PRINT
577#ifdef POST_QMF_PRINT
578 {
579 int i;
580 for (i = 0; i < 2048; i++) {
581 printf("%d\n", channel[i]);
582 }
583 }
584#endif
585
586 return 0;
587}
588
589#if (defined(PS_DEC) || defined(DRM_PS))
590uint8_t sbrDecodeSingleFramePS(sbr_info *sbr, real_t *left_channel, real_t *right_channel,
591 const uint8_t just_seeked, const uint8_t downSampledSBR)
592{
593 uint8_t l, k;
594 uint8_t dont_process = 0;
595 uint8_t ret = 0;
596 ALIGN qmf_t X_left[38][64] = {{0}};
597 ALIGN qmf_t X_right[38][64] = {{0}}; /* must set this to 0 */
598
599 if (sbr == NULL) {
600 return 20;
601 }
602
603 /* case can occur due to bit errors */
604 if (sbr->id_aac != ID_SCE && sbr->id_aac != ID_LFE) {
605 return 21;
606 }
607
608 if (sbr->ret || (sbr->header_count == 0)) {
609 /* don't process just upsample */
610 dont_process = 1;
611
612 /* Re-activate reset for next frame */
613 if (sbr->ret && sbr->Reset) {
614 sbr->bs_start_freq_prev = -1;
615 }
616 }
617
618 if (just_seeked) {
619 sbr->just_seeked = 1;
620 } else {
621 sbr->just_seeked = 0;
622 }
623
624 if (sbr->qmfs[1] == NULL) {
625 sbr->qmfs[1] = qmfs_init((downSampledSBR) ? 32 : 64);
626 }
627
628 sbr->ret += sbr_process_channel(sbr, left_channel, X_left, 0, dont_process, downSampledSBR);
629
630 /* copy some extra data for PS */
631 for (l = sbr->numTimeSlotsRate; l < sbr->numTimeSlotsRate + 6; l++) {
632 for (k = 0; k < 5; k++) {
633 QMF_RE(X_left[l][k]) = QMF_RE(sbr->Xsbr[0][sbr->tHFAdj + l][k]);
634 QMF_IM(X_left[l][k]) = QMF_IM(sbr->Xsbr[0][sbr->tHFAdj + l][k]);
635 }
636 }
637
638 /* perform parametric stereo */
639#ifdef DRM_PS
640 if (sbr->Is_DRM_SBR) {
641 drm_ps_decode(sbr->drm_ps, (sbr->ret > 0), X_left, X_right);
642 } else {
643#endif
644#ifdef PS_DEC
645 ps_decode(sbr->ps, X_left, X_right);
646#endif
647#ifdef DRM_PS
648 }
649#endif
650
651 /* subband synthesis */
652 if (downSampledSBR) {
653 sbr_qmf_synthesis_32(sbr, sbr->qmfs[0], X_left, left_channel);
654 sbr_qmf_synthesis_32(sbr, sbr->qmfs[1], X_right, right_channel);
655 } else {
656 sbr_qmf_synthesis_64(sbr, sbr->qmfs[0], X_left, left_channel);
657 sbr_qmf_synthesis_64(sbr, sbr->qmfs[1], X_right, right_channel);
658 }
659
660 if (sbr->bs_header_flag) {
661 sbr->just_seeked = 0;
662 }
663
664 if (sbr->header_count != 0 && sbr->ret == 0) {
665 ret = sbr_save_prev_data(sbr, 0);
666 if (ret) {
667 return ret;
668 }
669 }
670
671 sbr_save_matrix(sbr, 0);
672
673 sbr->frame++;
674
675 return 0;
676}
677#endif
678
679#endif
680
generated by cgit at 2024-05-18 20:27:20 (GMT)