2 ** FAAD2 - Freeware Advanced Audio (AAC) Decoder including SBR decoding
3 ** Copyright (C) 2003-2004 M. Bakker, Ahead Software 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 ** Commercial non-GPL licensing of this software is possible.
23 ** For more info contact Ahead Software through Mpeg4AAClicense@nero.com.
25 ** $Id: sbr_dec.c,v 1.37 2004/06/30 12:45:56 menno Exp $
39 #include "sbr_syntax.h"
41 #include "sbr_hfgen.h"
42 #include "sbr_hfadj.h"
45 /* static function declarations */
46 static uint8_t sbr_save_prev_data(sbr_info
*sbr
, uint8_t ch
);
47 static void sbr_save_matrix(sbr_info
*sbr
, uint8_t ch
);
50 sbr_info
*sbrDecodeInit(uint16_t framelength
, uint8_t id_aac
,
51 uint32_t sample_rate
, uint8_t downSampledSBR
57 sbr_info
*sbr
= faad_malloc(sizeof(sbr_info
));
58 memset(sbr
, 0, sizeof(sbr_info
));
60 /* save id of the parent element */
62 sbr
->sample_rate
= sample_rate
;
64 sbr
->bs_freq_scale
= 2;
65 sbr
->bs_alter_scale
= 1;
66 sbr
->bs_noise_bands
= 2;
67 sbr
->bs_limiter_bands
= 2;
68 sbr
->bs_limiter_gains
= 2;
69 sbr
->bs_interpol_freq
= 1;
70 sbr
->bs_smoothing_mode
= 1;
71 sbr
->bs_start_freq
= 5;
73 sbr
->bs_samplerate_mode
= 1;
74 sbr
->prevEnvIsShort
[0] = -1;
75 sbr
->prevEnvIsShort
[1] = -1;
76 sbr
->header_count
= 0;
80 sbr
->Is_DRM_SBR
= IsDRM
;
82 sbr
->bs_samplerate_mode
= 1;
83 sbr
->tHFGen
= T_HFGEN
;
84 sbr
->tHFAdj
= T_HFADJ
;
89 sbr
->frame_len
= framelength
;
92 sbr
->bs_start_freq_prev
= -1;
94 if (framelength
== 960)
96 sbr
->numTimeSlotsRate
= RATE
* NO_TIME_SLOTS_960
;
97 sbr
->numTimeSlots
= NO_TIME_SLOTS_960
;
99 sbr
->numTimeSlotsRate
= RATE
* NO_TIME_SLOTS
;
100 sbr
->numTimeSlots
= NO_TIME_SLOTS
;
103 sbr
->GQ_ringbuf_index
[0] = 0;
104 sbr
->GQ_ringbuf_index
[1] = 0;
106 if (id_aac
== ID_CPE
)
110 sbr
->qmfa
[0] = qmfa_init(32);
111 sbr
->qmfa
[1] = qmfa_init(32);
112 sbr
->qmfs
[0] = qmfs_init((downSampledSBR
)?32:64);
113 sbr
->qmfs
[1] = qmfs_init((downSampledSBR
)?32:64);
115 for (j
= 0; j
< 5; j
++)
117 sbr
->G_temp_prev
[0][j
] = faad_malloc(64*sizeof(real_t
));
118 sbr
->G_temp_prev
[1][j
] = faad_malloc(64*sizeof(real_t
));
119 sbr
->Q_temp_prev
[0][j
] = faad_malloc(64*sizeof(real_t
));
120 sbr
->Q_temp_prev
[1][j
] = faad_malloc(64*sizeof(real_t
));
123 memset(sbr
->Xsbr
[0], 0, (sbr
->numTimeSlotsRate
+sbr
->tHFGen
)*64 * sizeof(qmf_t
));
124 memset(sbr
->Xsbr
[1], 0, (sbr
->numTimeSlotsRate
+sbr
->tHFGen
)*64 * sizeof(qmf_t
));
128 sbr
->qmfa
[0] = qmfa_init(32);
129 sbr
->qmfs
[0] = qmfs_init((downSampledSBR
)?32:64);
132 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
));
138 memset(sbr
->Xsbr
[0], 0, (sbr
->numTimeSlotsRate
+sbr
->tHFGen
)*64 * sizeof(qmf_t
));
144 void sbrDecodeEnd(sbr_info
*sbr
)
150 qmfa_end(sbr
->qmfa
[0]);
151 qmfs_end(sbr
->qmfs
[0]);
152 if (sbr
->qmfs
[1] != NULL
)
154 qmfa_end(sbr
->qmfa
[1]);
155 qmfs_end(sbr
->qmfs
[1]);
158 for (j
= 0; j
< 5; j
++)
160 if (sbr
->G_temp_prev
[0][j
]) faad_free(sbr
->G_temp_prev
[0][j
]);
161 if (sbr
->Q_temp_prev
[0][j
]) faad_free(sbr
->Q_temp_prev
[0][j
]);
162 if (sbr
->G_temp_prev
[1][j
]) faad_free(sbr
->G_temp_prev
[1][j
]);
163 if (sbr
->Q_temp_prev
[1][j
]) faad_free(sbr
->Q_temp_prev
[1][j
]);
172 if (sbr
->drm_ps
!= NULL
)
173 drm_ps_free(sbr
->drm_ps
);
180 static uint8_t sbr_save_prev_data(sbr_info
*sbr
, uint8_t ch
)
184 /* save data for next frame */
185 sbr
->kx_prev
= sbr
->kx
;
186 sbr
->M_prev
= sbr
->M
;
187 sbr
->bsco_prev
= sbr
->bsco
;
189 sbr
->L_E_prev
[ch
] = sbr
->L_E
[ch
];
191 /* sbr->L_E[ch] can become 0 on files with bit errors */
192 if (sbr
->L_E
[ch
] <= 0)
195 sbr
->f_prev
[ch
] = sbr
->f
[ch
][sbr
->L_E
[ch
] - 1];
196 for (i
= 0; i
< MAX_M
; i
++)
198 sbr
->E_prev
[ch
][i
] = sbr
->E
[ch
][i
][sbr
->L_E
[ch
] - 1];
199 sbr
->Q_prev
[ch
][i
] = sbr
->Q
[ch
][i
][sbr
->L_Q
[ch
] - 1];
202 for (i
= 0; i
< MAX_M
; i
++)
204 sbr
->bs_add_harmonic_prev
[ch
][i
] = sbr
->bs_add_harmonic
[ch
][i
];
206 sbr
->bs_add_harmonic_flag_prev
[ch
] = sbr
->bs_add_harmonic_flag
[ch
];
208 if (sbr
->l_A
[ch
] == sbr
->L_E
[ch
])
209 sbr
->prevEnvIsShort
[ch
] = 0;
211 sbr
->prevEnvIsShort
[ch
] = -1;
216 static void sbr_save_matrix(sbr_info
*sbr
, uint8_t ch
)
220 for (i
= 0; i
< sbr
->tHFGen
; i
++)
222 memmove(sbr
->Xsbr
[ch
][i
], sbr
->Xsbr
[ch
][i
+sbr
->numTimeSlotsRate
], 64 * sizeof(qmf_t
));
224 for (i
= sbr
->tHFGen
; i
< MAX_NTSRHFG
; i
++)
226 memset(sbr
->Xsbr
[ch
][i
], 0, 64 * sizeof(qmf_t
));
230 static void sbr_process_channel(sbr_info
*sbr
, real_t
*channel_buf
, qmf_t X
[MAX_NTSR
][64],
231 uint8_t ch
, uint8_t dont_process
,
232 const uint8_t downSampledSBR
)
237 ALIGN real_t deg
[64];
243 sbr
->bsco
= max((int32_t)sbr
->maxAACLine
*32/(int32_t)sbr
->frame_len
- (int32_t)sbr
->kx
, 0);
252 //#define PRE_QMF_PRINT
256 for (i
= 0; i
< 1024; i
++)
258 printf("%d\n", channel_buf
[i
]);
264 /* subband analysis */
266 sbr_qmf_analysis_32(sbr
, sbr
->qmfa
[ch
], channel_buf
, sbr
->Xsbr
[ch
], sbr
->tHFGen
, 32);
268 sbr_qmf_analysis_32(sbr
, sbr
->qmfa
[ch
], channel_buf
, sbr
->Xsbr
[ch
], sbr
->tHFGen
, sbr
->kx
);
273 /* insert high frequencies here */
274 /* hf generation using patching */
275 hf_generation(sbr
, sbr
->Xsbr
[ch
], sbr
->Xsbr
[ch
]
283 for (l
= sbr
->t_E
[ch
][0]; l
< sbr
->t_E
[ch
][sbr
->L_E
[ch
]]; l
++)
285 for (k
= 0; k
< sbr
->kx
; k
++)
287 QMF_RE(sbr
->Xsbr
[ch
][sbr
->tHFAdj
+ l
][k
]) = 0;
294 hf_adjustment(sbr
, sbr
->Xsbr
[ch
]
302 if ((sbr
->just_seeked
!= 0) || dont_process
)
304 for (l
= 0; l
< sbr
->numTimeSlotsRate
; l
++)
306 for (k
= 0; k
< 32; k
++)
308 QMF_RE(X
[l
][k
]) = QMF_RE(sbr
->Xsbr
[ch
][l
+ sbr
->tHFAdj
][k
]);
309 #ifndef SBR_LOW_POWER
310 QMF_IM(X
[l
][k
]) = QMF_IM(sbr
->Xsbr
[ch
][l
+ sbr
->tHFAdj
][k
]);
313 for (k
= 32; k
< 64; k
++)
316 #ifndef SBR_LOW_POWER
322 for (l
= 0; l
< sbr
->numTimeSlotsRate
; l
++)
324 uint8_t kx_band
, M_band
, bsco_band
;
326 if (l
< sbr
->t_E
[ch
][0])
328 kx_band
= sbr
->kx_prev
;
329 M_band
= sbr
->M_prev
;
330 bsco_band
= sbr
->bsco_prev
;
334 bsco_band
= sbr
->bsco
;
337 #ifndef SBR_LOW_POWER
338 for (k
= 0; k
< kx_band
+ bsco_band
; k
++)
340 QMF_RE(X
[l
][k
]) = QMF_RE(sbr
->Xsbr
[ch
][l
+ sbr
->tHFAdj
][k
]);
341 QMF_IM(X
[l
][k
]) = QMF_IM(sbr
->Xsbr
[ch
][l
+ sbr
->tHFAdj
][k
]);
343 for (k
= kx_band
+ bsco_band
; k
< kx_band
+ M_band
; k
++)
345 QMF_RE(X
[l
][k
]) = QMF_RE(sbr
->Xsbr
[ch
][l
+ sbr
->tHFAdj
][k
]);
346 QMF_IM(X
[l
][k
]) = QMF_IM(sbr
->Xsbr
[ch
][l
+ sbr
->tHFAdj
][k
]);
348 for (k
= max(kx_band
+ bsco_band
, kx_band
+ M_band
); k
< 64; k
++)
354 for (k
= 0; k
< kx_band
+ bsco_band
; k
++)
356 QMF_RE(X
[l
][k
]) = QMF_RE(sbr
->Xsbr
[ch
][l
+ sbr
->tHFAdj
][k
]);
358 for (k
= kx_band
+ bsco_band
; k
< min(kx_band
+ M_band
, 63); k
++)
360 QMF_RE(X
[l
][k
]) = QMF_RE(sbr
->Xsbr
[ch
][l
+ sbr
->tHFAdj
][k
]);
362 for (k
= max(kx_band
+ bsco_band
, kx_band
+ M_band
); k
< 64; k
++)
366 QMF_RE(X
[l
][kx_band
- 1 + bsco_band
]) +=
367 QMF_RE(sbr
->Xsbr
[ch
][l
+ sbr
->tHFAdj
][kx_band
- 1 + bsco_band
]);
373 uint8_t sbrDecodeCoupleFrame(sbr_info
*sbr
, real_t
*left_chan
, real_t
*right_chan
,
374 const uint8_t just_seeked
, const uint8_t downSampledSBR
)
376 uint8_t dont_process
= 0;
378 ALIGN qmf_t X
[MAX_NTSR
][64];
383 /* case can occur due to bit errors */
384 if (sbr
->id_aac
!= ID_CPE
)
387 if (sbr
->ret
|| (sbr
->header_count
== 0))
389 /* don't process just upsample */
392 /* Re-activate reset for next frame */
393 if (sbr
->ret
&& sbr
->Reset
)
394 sbr
->bs_start_freq_prev
= -1;
399 sbr
->just_seeked
= 1;
401 sbr
->just_seeked
= 0;
404 sbr_process_channel(sbr
, left_chan
, X
, 0, dont_process
, downSampledSBR
);
405 /* subband synthesis */
408 sbr_qmf_synthesis_32(sbr
, sbr
->qmfs
[0], X
, left_chan
);
410 sbr_qmf_synthesis_64(sbr
, sbr
->qmfs
[0], X
, left_chan
);
413 sbr_process_channel(sbr
, right_chan
, X
, 1, dont_process
, downSampledSBR
);
414 /* subband synthesis */
417 sbr_qmf_synthesis_32(sbr
, sbr
->qmfs
[1], X
, right_chan
);
419 sbr_qmf_synthesis_64(sbr
, sbr
->qmfs
[1], X
, right_chan
);
422 if (sbr
->bs_header_flag
)
423 sbr
->just_seeked
= 0;
425 if (sbr
->header_count
!= 0 && sbr
->ret
== 0)
427 ret
= sbr_save_prev_data(sbr
, 0);
429 ret
= sbr_save_prev_data(sbr
, 1);
433 sbr_save_matrix(sbr
, 0);
434 sbr_save_matrix(sbr
, 1);
438 //#define POST_QMF_PRINT
439 #ifdef POST_QMF_PRINT
442 for (i
= 0; i
< 2048; i
++)
444 printf("%d\n", left_chan
[i
]);
446 for (i
= 0; i
< 2048; i
++)
448 printf("%d\n", right_chan
[i
]);
456 uint8_t sbrDecodeSingleFrame(sbr_info
*sbr
, real_t
*channel
,
457 const uint8_t just_seeked
, const uint8_t downSampledSBR
)
459 uint8_t dont_process
= 0;
461 ALIGN qmf_t X
[MAX_NTSR
][64];
466 /* case can occur due to bit errors */
467 if (sbr
->id_aac
!= ID_SCE
&& sbr
->id_aac
!= ID_LFE
)
470 if (sbr
->ret
|| (sbr
->header_count
== 0))
472 /* don't process just upsample */
475 /* Re-activate reset for next frame */
476 if (sbr
->ret
&& sbr
->Reset
)
477 sbr
->bs_start_freq_prev
= -1;
482 sbr
->just_seeked
= 1;
484 sbr
->just_seeked
= 0;
487 sbr_process_channel(sbr
, channel
, X
, 0, dont_process
, downSampledSBR
);
488 /* subband synthesis */
491 sbr_qmf_synthesis_32(sbr
, sbr
->qmfs
[0], X
, channel
);
493 sbr_qmf_synthesis_64(sbr
, sbr
->qmfs
[0], X
, channel
);
496 if (sbr
->bs_header_flag
)
497 sbr
->just_seeked
= 0;
499 if (sbr
->header_count
!= 0 && sbr
->ret
== 0)
501 ret
= sbr_save_prev_data(sbr
, 0);
505 sbr_save_matrix(sbr
, 0);
509 //#define POST_QMF_PRINT
510 #ifdef POST_QMF_PRINT
513 for (i
= 0; i
< 2048; i
++)
515 printf("%d\n", channel
[i
]);
523 #if (defined(PS_DEC) || defined(DRM_PS))
524 uint8_t sbrDecodeSingleFramePS(sbr_info
*sbr
, real_t
*left_channel
, real_t
*right_channel
,
525 const uint8_t just_seeked
, const uint8_t downSampledSBR
)
528 uint8_t dont_process
= 0;
530 ALIGN qmf_t X_left
[38][64] = {{0}};
531 ALIGN qmf_t X_right
[38][64] = {{0}}; /* must set this to 0 */
536 /* case can occur due to bit errors */
537 if (sbr
->id_aac
!= ID_SCE
&& sbr
->id_aac
!= ID_LFE
)
540 if (sbr
->ret
|| (sbr
->header_count
== 0))
542 /* don't process just upsample */
545 /* Re-activate reset for next frame */
546 if (sbr
->ret
&& sbr
->Reset
)
547 sbr
->bs_start_freq_prev
= -1;
552 sbr
->just_seeked
= 1;
554 sbr
->just_seeked
= 0;
557 if (sbr
->qmfs
[1] == NULL
)
559 sbr
->qmfs
[1] = qmfs_init((downSampledSBR
)?32:64);
562 sbr_process_channel(sbr
, left_channel
, X_left
, 0, dont_process
, downSampledSBR
);
564 /* copy some extra data for PS */
565 for (l
= 32; l
< 38; l
++)
567 for (k
= 0; k
< 5; k
++)
569 QMF_RE(X_left
[l
][k
]) = QMF_RE(sbr
->Xsbr
[0][sbr
->tHFAdj
+l
][k
]);
570 QMF_IM(X_left
[l
][k
]) = QMF_IM(sbr
->Xsbr
[0][sbr
->tHFAdj
+l
][k
]);
574 /* perform parametric stereo */
578 drm_ps_decode(sbr
->drm_ps
, sbr
->sample_rate
, X_left
, X_right
);
582 ps_decode(sbr
->ps
, X_left
, X_right
);
588 /* subband synthesis */
591 sbr_qmf_synthesis_32(sbr
, sbr
->qmfs
[0], X_left
, left_channel
);
592 sbr_qmf_synthesis_32(sbr
, sbr
->qmfs
[1], X_right
, right_channel
);
594 sbr_qmf_synthesis_64(sbr
, sbr
->qmfs
[0], X_left
, left_channel
);
595 sbr_qmf_synthesis_64(sbr
, sbr
->qmfs
[1], X_right
, right_channel
);
598 if (sbr
->bs_header_flag
)
599 sbr
->just_seeked
= 0;
601 if (sbr
->header_count
!= 0 && sbr
->ret
== 0)
603 ret
= sbr_save_prev_data(sbr
, 0);
607 sbr_save_matrix(sbr
, 0);