2 ** FAAD2 - Freeware Advanced Audio (AAC) Decoder including SBR decoding
3 ** Copyright (C) 2003-2005 M. Bakker, Nero AG, http://www.nero.com
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.
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.
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.
19 ** Any non-GPL usage of this software or parts of this software is strictly
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"
25 ** Commercial non-GPL licensing of this software is possible.
26 ** For more info contact Nero AG through Mpeg4AAClicense@nero.com.
28 ** $Id: sbr_dec.c,v 1.44 2009/01/26 22:32:31 menno Exp $
48 /* static function declarations */
49 static uint8_t sbr_save_prev_data(sbr_info *sbr, uint8_t ch);
50 static void sbr_save_matrix(sbr_info *sbr, uint8_t ch);
53 sbr_info *sbrDecodeInit(uint16_t framelength, uint8_t id_aac,
54 uint32_t sample_rate, uint8_t downSampledSBR
60 sbr_info *sbr = faad_malloc(sizeof(sbr_info));
61 memset(sbr, 0, sizeof(sbr_info));
63 /* save id of the parent element */
65 sbr->sample_rate = sample_rate;
67 sbr->bs_freq_scale = 2;
68 sbr->bs_alter_scale = 1;
69 sbr->bs_noise_bands = 2;
70 sbr->bs_limiter_bands = 2;
71 sbr->bs_limiter_gains = 2;
72 sbr->bs_interpol_freq = 1;
73 sbr->bs_smoothing_mode = 1;
74 sbr->bs_start_freq = 5;
76 sbr->bs_samplerate_mode = 1;
77 sbr->prevEnvIsShort[0] = -1;
78 sbr->prevEnvIsShort[1] = -1;
79 sbr->header_count = 0;
83 sbr->Is_DRM_SBR = IsDRM;
85 sbr->tHFGen = T_HFGEN;
86 sbr->tHFAdj = T_HFADJ;
91 sbr->frame_len = framelength;
94 sbr->bs_start_freq_prev = -1;
96 if (framelength == 960)
98 sbr->numTimeSlotsRate = RATE * NO_TIME_SLOTS_960;
99 sbr->numTimeSlots = NO_TIME_SLOTS_960;
101 sbr->numTimeSlotsRate = RATE * NO_TIME_SLOTS;
102 sbr->numTimeSlots = NO_TIME_SLOTS;
105 sbr->GQ_ringbuf_index[0] = 0;
106 sbr->GQ_ringbuf_index[1] = 0;
108 if (id_aac == ID_CPE)
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);
117 for (j = 0; j < 5; j++)
119 sbr->G_temp_prev[0][j] = faad_malloc(64*sizeof(real_t));
120 sbr->G_temp_prev[1][j] = faad_malloc(64*sizeof(real_t));
121 sbr->Q_temp_prev[0][j] = faad_malloc(64*sizeof(real_t));
122 sbr->Q_temp_prev[1][j] = faad_malloc(64*sizeof(real_t));
125 memset(sbr->Xsbr[0], 0, (sbr->numTimeSlotsRate+sbr->tHFGen)*64 * sizeof(qmf_t));
126 memset(sbr->Xsbr[1], 0, (sbr->numTimeSlotsRate+sbr->tHFGen)*64 * sizeof(qmf_t));
130 sbr->qmfa[0] = qmfa_init(32);
131 sbr->qmfs[0] = qmfs_init((downSampledSBR)?32:64);
134 for (j = 0; j < 5; j++)
136 sbr->G_temp_prev[0][j] = faad_malloc(64*sizeof(real_t));
137 sbr->Q_temp_prev[0][j] = faad_malloc(64*sizeof(real_t));
140 memset(sbr->Xsbr[0], 0, (sbr->numTimeSlotsRate+sbr->tHFGen)*64 * sizeof(qmf_t));
146 void sbrDecodeEnd(sbr_info *sbr)
152 qmfa_end(sbr->qmfa[0]);
153 qmfs_end(sbr->qmfs[0]);
154 if (sbr->qmfs[1] != NULL)
156 qmfa_end(sbr->qmfa[1]);
157 qmfs_end(sbr->qmfs[1]);
160 for (j = 0; j < 5; j++)
162 if (sbr->G_temp_prev[0][j]) faad_free(sbr->G_temp_prev[0][j]);
163 if (sbr->Q_temp_prev[0][j]) faad_free(sbr->Q_temp_prev[0][j]);
164 if (sbr->G_temp_prev[1][j]) faad_free(sbr->G_temp_prev[1][j]);
165 if (sbr->Q_temp_prev[1][j]) faad_free(sbr->Q_temp_prev[1][j]);
174 if (sbr->drm_ps != NULL)
175 drm_ps_free(sbr->drm_ps);
182 void sbrReset(sbr_info *sbr)
185 if (sbr->qmfa[0] != NULL)
186 memset(sbr->qmfa[0]->x, 0, 2 * sbr->qmfa[0]->channels * 10 * sizeof(real_t));
187 if (sbr->qmfa[1] != NULL)
188 memset(sbr->qmfa[1]->x, 0, 2 * sbr->qmfa[1]->channels * 10 * sizeof(real_t));
189 if (sbr->qmfs[0] != NULL)
190 memset(sbr->qmfs[0]->v, 0, 2 * sbr->qmfs[0]->channels * 20 * sizeof(real_t));
191 if (sbr->qmfs[1] != NULL)
192 memset(sbr->qmfs[1]->v, 0, 2 * sbr->qmfs[1]->channels * 20 * sizeof(real_t));
194 for (j = 0; j < 5; j++)
196 if (sbr->G_temp_prev[0][j] != NULL)
197 memset(sbr->G_temp_prev[0][j], 0, 64*sizeof(real_t));
198 if (sbr->G_temp_prev[1][j] != NULL)
199 memset(sbr->G_temp_prev[1][j], 0, 64*sizeof(real_t));
200 if (sbr->Q_temp_prev[0][j] != NULL)
201 memset(sbr->Q_temp_prev[0][j], 0, 64*sizeof(real_t));
202 if (sbr->Q_temp_prev[1][j] != NULL)
203 memset(sbr->Q_temp_prev[1][j], 0, 64*sizeof(real_t));
206 memset(sbr->Xsbr[0], 0, (sbr->numTimeSlotsRate+sbr->tHFGen)*64 * sizeof(qmf_t));
207 memset(sbr->Xsbr[1], 0, (sbr->numTimeSlotsRate+sbr->tHFGen)*64 * sizeof(qmf_t));
209 sbr->GQ_ringbuf_index[0] = 0;
210 sbr->GQ_ringbuf_index[1] = 0;
211 sbr->header_count = 0;
214 sbr->L_E_prev[0] = 0;
215 sbr->L_E_prev[1] = 0;
216 sbr->bs_freq_scale = 2;
217 sbr->bs_alter_scale = 1;
218 sbr->bs_noise_bands = 2;
219 sbr->bs_limiter_bands = 2;
220 sbr->bs_limiter_gains = 2;
221 sbr->bs_interpol_freq = 1;
222 sbr->bs_smoothing_mode = 1;
223 sbr->bs_start_freq = 5;
225 sbr->bs_samplerate_mode = 1;
226 sbr->prevEnvIsShort[0] = -1;
227 sbr->prevEnvIsShort[1] = -1;
231 sbr->bs_start_freq_prev = -1;
235 for (j = 0; j < MAX_M; j++)
237 sbr->E_prev[0][j] = 0;
238 sbr->Q_prev[0][j] = 0;
239 sbr->E_prev[1][j] = 0;
240 sbr->Q_prev[1][j] = 0;
241 sbr->bs_add_harmonic_prev[0][j] = 0;
242 sbr->bs_add_harmonic_prev[1][j] = 0;
244 sbr->bs_add_harmonic_flag_prev[0] = 0;
245 sbr->bs_add_harmonic_flag_prev[1] = 0;
248 static uint8_t sbr_save_prev_data(sbr_info *sbr, uint8_t ch)
252 /* save data for next frame */
253 sbr->kx_prev = sbr->kx;
254 sbr->M_prev = sbr->M;
255 sbr->bsco_prev = sbr->bsco;
257 sbr->L_E_prev[ch] = sbr->L_E[ch];
259 /* sbr->L_E[ch] can become 0 on files with bit errors */
260 if (sbr->L_E[ch] <= 0)
263 sbr->f_prev[ch] = sbr->f[ch][sbr->L_E[ch] - 1];
264 for (i = 0; i < MAX_M; i++)
266 sbr->E_prev[ch][i] = sbr->E[ch][i][sbr->L_E[ch] - 1];
267 sbr->Q_prev[ch][i] = sbr->Q[ch][i][sbr->L_Q[ch] - 1];
270 for (i = 0; i < MAX_M; i++)
272 sbr->bs_add_harmonic_prev[ch][i] = sbr->bs_add_harmonic[ch][i];
274 sbr->bs_add_harmonic_flag_prev[ch] = sbr->bs_add_harmonic_flag[ch];
276 if (sbr->l_A[ch] == sbr->L_E[ch])
277 sbr->prevEnvIsShort[ch] = 0;
279 sbr->prevEnvIsShort[ch] = -1;
284 static void sbr_save_matrix(sbr_info *sbr, uint8_t ch)
288 for (i = 0; i < sbr->tHFGen; i++)
290 memmove(sbr->Xsbr[ch][i], sbr->Xsbr[ch][i+sbr->numTimeSlotsRate], 64 * sizeof(qmf_t));
292 for (i = sbr->tHFGen; i < MAX_NTSRHFG; i++)
294 memset(sbr->Xsbr[ch][i], 0, 64 * sizeof(qmf_t));
298 static uint8_t sbr_process_channel(sbr_info *sbr, real_t *channel_buf, qmf_t X[MAX_NTSR][64],
299 uint8_t ch, uint8_t dont_process,
300 const uint8_t downSampledSBR)
306 ALIGN real_t deg[64];
312 sbr->bsco = max((int32_t)sbr->maxAACLine*32/(int32_t)sbr->frame_len - (int32_t)sbr->kx, 0);
321 //#define PRE_QMF_PRINT
325 for (i = 0; i < 1024; i++)
327 printf("%d\n", channel_buf[i]);
333 /* subband analysis */
335 sbr_qmf_analysis_32(sbr, sbr->qmfa[ch], channel_buf, sbr->Xsbr[ch], sbr->tHFGen, 32);
337 sbr_qmf_analysis_32(sbr, sbr->qmfa[ch], channel_buf, sbr->Xsbr[ch], sbr->tHFGen, sbr->kx);
342 /* insert high frequencies here */
343 /* hf generation using patching */
344 hf_generation(sbr, sbr->Xsbr[ch], sbr->Xsbr[ch]
351 #if 0 //def SBR_LOW_POWER
352 for (l = sbr->t_E[ch][0]; l < sbr->t_E[ch][sbr->L_E[ch]]; l++)
354 for (k = 0; k < sbr->kx; k++)
356 QMF_RE(sbr->Xsbr[ch][sbr->tHFAdj + l][k]) = 0;
363 ret = hf_adjustment(sbr, sbr->Xsbr[ch]
375 if ((sbr->just_seeked != 0) || dont_process)
377 for (l = 0; l < sbr->numTimeSlotsRate; l++)
379 for (k = 0; k < 32; k++)
381 QMF_RE(X[l][k]) = QMF_RE(sbr->Xsbr[ch][l + sbr->tHFAdj][k]);
382 #ifndef SBR_LOW_POWER
383 QMF_IM(X[l][k]) = QMF_IM(sbr->Xsbr[ch][l + sbr->tHFAdj][k]);
386 for (k = 32; k < 64; k++)
389 #ifndef SBR_LOW_POWER
395 for (l = 0; l < sbr->numTimeSlotsRate; l++)
397 uint8_t kx_band, M_band, bsco_band;
399 if (l < sbr->t_E[ch][0])
401 kx_band = sbr->kx_prev;
402 M_band = sbr->M_prev;
403 bsco_band = sbr->bsco_prev;
407 bsco_band = sbr->bsco;
410 #ifndef SBR_LOW_POWER
411 for (k = 0; k < kx_band + bsco_band; k++)
413 QMF_RE(X[l][k]) = QMF_RE(sbr->Xsbr[ch][l + sbr->tHFAdj][k]);
414 QMF_IM(X[l][k]) = QMF_IM(sbr->Xsbr[ch][l + sbr->tHFAdj][k]);
416 for (k = kx_band + bsco_band; k < kx_band + M_band; k++)
418 QMF_RE(X[l][k]) = QMF_RE(sbr->Xsbr[ch][l + sbr->tHFAdj][k]);
419 QMF_IM(X[l][k]) = QMF_IM(sbr->Xsbr[ch][l + sbr->tHFAdj][k]);
421 for (k = max(kx_band + bsco_band, kx_band + M_band); k < 64; k++)
427 for (k = 0; k < kx_band + bsco_band; k++)
429 QMF_RE(X[l][k]) = QMF_RE(sbr->Xsbr[ch][l + sbr->tHFAdj][k]);
431 for (k = kx_band + bsco_band; k < min(kx_band + M_band, 63); k++)
433 QMF_RE(X[l][k]) = QMF_RE(sbr->Xsbr[ch][l + sbr->tHFAdj][k]);
435 for (k = max(kx_band + bsco_band, kx_band + M_band); k < 64; k++)
439 QMF_RE(X[l][kx_band - 1 + bsco_band]) +=
440 QMF_RE(sbr->Xsbr[ch][l + sbr->tHFAdj][kx_band - 1 + bsco_band]);
448 uint8_t sbrDecodeCoupleFrame(sbr_info *sbr, real_t *left_chan, real_t *right_chan,
449 const uint8_t just_seeked, const uint8_t downSampledSBR)
451 uint8_t dont_process = 0;
453 ALIGN qmf_t X[MAX_NTSR][64];
458 /* case can occur due to bit errors */
459 if (sbr->id_aac != ID_CPE)
462 if (sbr->ret || (sbr->header_count == 0))
464 /* don't process just upsample */
467 /* Re-activate reset for next frame */
468 if (sbr->ret && sbr->Reset)
469 sbr->bs_start_freq_prev = -1;
474 sbr->just_seeked = 1;
476 sbr->just_seeked = 0;
479 sbr->ret += sbr_process_channel(sbr, left_chan, X, 0, dont_process, downSampledSBR);
480 /* subband synthesis */
483 sbr_qmf_synthesis_32(sbr, sbr->qmfs[0], X, left_chan);
485 sbr_qmf_synthesis_64(sbr, sbr->qmfs[0], X, left_chan);
488 sbr->ret += sbr_process_channel(sbr, right_chan, X, 1, dont_process, downSampledSBR);
489 /* subband synthesis */
492 sbr_qmf_synthesis_32(sbr, sbr->qmfs[1], X, right_chan);
494 sbr_qmf_synthesis_64(sbr, sbr->qmfs[1], X, right_chan);
497 if (sbr->bs_header_flag)
498 sbr->just_seeked = 0;
500 if (sbr->header_count != 0 && sbr->ret == 0)
502 ret = sbr_save_prev_data(sbr, 0);
504 ret = sbr_save_prev_data(sbr, 1);
508 sbr_save_matrix(sbr, 0);
509 sbr_save_matrix(sbr, 1);
513 //#define POST_QMF_PRINT
514 #ifdef POST_QMF_PRINT
517 for (i = 0; i < 2048; i++)
519 printf("%d\n", left_chan[i]);
521 for (i = 0; i < 2048; i++)
523 printf("%d\n", right_chan[i]);
531 uint8_t sbrDecodeSingleFrame(sbr_info *sbr, real_t *channel,
532 const uint8_t just_seeked, const uint8_t downSampledSBR)
534 uint8_t dont_process = 0;
536 ALIGN qmf_t X[MAX_NTSR][64];
541 /* case can occur due to bit errors */
542 if (sbr->id_aac != ID_SCE && sbr->id_aac != ID_LFE)
545 if (sbr->ret || (sbr->header_count == 0))
547 /* don't process just upsample */
550 /* Re-activate reset for next frame */
551 if (sbr->ret && sbr->Reset)
552 sbr->bs_start_freq_prev = -1;
557 sbr->just_seeked = 1;
559 sbr->just_seeked = 0;
562 sbr->ret += sbr_process_channel(sbr, channel, X, 0, dont_process, downSampledSBR);
563 /* subband synthesis */
566 sbr_qmf_synthesis_32(sbr, sbr->qmfs[0], X, channel);
568 sbr_qmf_synthesis_64(sbr, sbr->qmfs[0], X, channel);
571 if (sbr->bs_header_flag)
572 sbr->just_seeked = 0;
574 if (sbr->header_count != 0 && sbr->ret == 0)
576 ret = sbr_save_prev_data(sbr, 0);
580 sbr_save_matrix(sbr, 0);
584 //#define POST_QMF_PRINT
585 #ifdef POST_QMF_PRINT
588 for (i = 0; i < 2048; i++)
590 printf("%d\n", channel[i]);
598 #if (defined(PS_DEC) || defined(DRM_PS))
599 uint8_t sbrDecodeSingleFramePS(sbr_info *sbr, real_t *left_channel, real_t *right_channel,
600 const uint8_t just_seeked, const uint8_t downSampledSBR)
603 uint8_t dont_process = 0;
605 ALIGN qmf_t X_left[38][64] = {{0}};
606 ALIGN qmf_t X_right[38][64] = {{0}}; /* must set this to 0 */
611 /* case can occur due to bit errors */
612 if (sbr->id_aac != ID_SCE && sbr->id_aac != ID_LFE)
615 if (sbr->ret || (sbr->header_count == 0))
617 /* don't process just upsample */
620 /* Re-activate reset for next frame */
621 if (sbr->ret && sbr->Reset)
622 sbr->bs_start_freq_prev = -1;
627 sbr->just_seeked = 1;
629 sbr->just_seeked = 0;
632 if (sbr->qmfs[1] == NULL)
634 sbr->qmfs[1] = qmfs_init((downSampledSBR)?32:64);
637 sbr->ret += sbr_process_channel(sbr, left_channel, X_left, 0, dont_process, downSampledSBR);
639 /* copy some extra data for PS */
640 for (l = sbr->numTimeSlotsRate; l < sbr->numTimeSlotsRate + 6; l++)
642 for (k = 0; k < 5; k++)
644 QMF_RE(X_left[l][k]) = QMF_RE(sbr->Xsbr[0][sbr->tHFAdj+l][k]);
645 QMF_IM(X_left[l][k]) = QMF_IM(sbr->Xsbr[0][sbr->tHFAdj+l][k]);
649 /* perform parametric stereo */
653 drm_ps_decode(sbr->drm_ps, (sbr->ret > 0), X_left, X_right);
657 ps_decode(sbr->ps, X_left, X_right);
663 /* subband synthesis */
666 sbr_qmf_synthesis_32(sbr, sbr->qmfs[0], X_left, left_channel);
667 sbr_qmf_synthesis_32(sbr, sbr->qmfs[1], X_right, right_channel);
669 sbr_qmf_synthesis_64(sbr, sbr->qmfs[0], X_left, left_channel);
670 sbr_qmf_synthesis_64(sbr, sbr->qmfs[1], X_right, right_channel);
673 if (sbr->bs_header_flag)
674 sbr->just_seeked = 0;
676 if (sbr->header_count != 0 && sbr->ret == 0)
678 ret = sbr_save_prev_data(sbr, 0);
682 sbr_save_matrix(sbr, 0);