10725
|
1 /*
|
|
2 ** FAAD2 - Freeware Advanced Audio (AAC) Decoder including SBR decoding
|
12527
|
3 ** Copyright (C) 2003-2004 M. Bakker, Ahead Software AG, http://www.nero.com
|
10725
|
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 ** Commercial non-GPL licensing of this software is possible.
|
|
23 ** For more info contact Ahead Software through Mpeg4AAClicense@nero.com.
|
|
24 **
|
18141
|
25 ** Initially modified for use with MPlayer on 2005/12/05
|
|
26 ** $Id: sbr_dec.c,v 1.39 2004/09/04 14:56:28 menno Exp $
|
18783
|
27 ** detailed changelog at http://svn.mplayerhq.hu/mplayer/trunk/
|
18141
|
28 ** local_changes.diff contains the exact changes to this file.
|
10725
|
29 **/
|
|
30
|
|
31
|
|
32 #include "common.h"
|
|
33 #include "structs.h"
|
|
34
|
|
35 #ifdef SBR_DEC
|
|
36
|
12527
|
37 #include <string.h>
|
10725
|
38 #include <stdlib.h>
|
|
39
|
|
40 #include "syntax.h"
|
|
41 #include "bits.h"
|
|
42 #include "sbr_syntax.h"
|
|
43 #include "sbr_qmf.h"
|
|
44 #include "sbr_hfgen.h"
|
|
45 #include "sbr_hfadj.h"
|
|
46
|
13453
|
47
|
12527
|
48 /* static function declarations */
|
|
49 static uint8_t sbr_save_prev_data(sbr_info *sbr, uint8_t ch);
|
13453
|
50 static void sbr_save_matrix(sbr_info *sbr, uint8_t ch);
|
|
51
|
10725
|
52
|
12527
|
53 sbr_info *sbrDecodeInit(uint16_t framelength, uint8_t id_aac,
|
13453
|
54 uint32_t sample_rate, uint8_t downSampledSBR
|
10989
|
55 #ifdef DRM
|
|
56 , uint8_t IsDRM
|
|
57 #endif
|
|
58 )
|
10725
|
59 {
|
12527
|
60 sbr_info *sbr = faad_malloc(sizeof(sbr_info));
|
10725
|
61 memset(sbr, 0, sizeof(sbr_info));
|
|
62
|
12527
|
63 /* save id of the parent element */
|
|
64 sbr->id_aac = id_aac;
|
|
65 sbr->sample_rate = sample_rate;
|
|
66
|
10725
|
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;
|
|
75 sbr->bs_amp_res = 1;
|
|
76 sbr->bs_samplerate_mode = 1;
|
|
77 sbr->prevEnvIsShort[0] = -1;
|
|
78 sbr->prevEnvIsShort[1] = -1;
|
|
79 sbr->header_count = 0;
|
13453
|
80 sbr->Reset = 1;
|
10725
|
81
|
10989
|
82 #ifdef DRM
|
12527
|
83 sbr->Is_DRM_SBR = IsDRM;
|
10989
|
84 #endif
|
12527
|
85 sbr->tHFGen = T_HFGEN;
|
|
86 sbr->tHFAdj = T_HFADJ;
|
10989
|
87
|
13453
|
88 sbr->bsco = 0;
|
|
89 sbr->bsco_prev = 0;
|
|
90 sbr->M_prev = 0;
|
|
91 sbr->frame_len = framelength;
|
|
92
|
10989
|
93 /* force sbr reset */
|
|
94 sbr->bs_start_freq_prev = -1;
|
|
95
|
|
96 if (framelength == 960)
|
|
97 {
|
|
98 sbr->numTimeSlotsRate = RATE * NO_TIME_SLOTS_960;
|
|
99 sbr->numTimeSlots = NO_TIME_SLOTS_960;
|
|
100 } else {
|
|
101 sbr->numTimeSlotsRate = RATE * NO_TIME_SLOTS;
|
|
102 sbr->numTimeSlots = NO_TIME_SLOTS;
|
|
103 }
|
|
104
|
13453
|
105 sbr->GQ_ringbuf_index[0] = 0;
|
|
106 sbr->GQ_ringbuf_index[1] = 0;
|
|
107
|
|
108 if (id_aac == ID_CPE)
|
|
109 {
|
|
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 {
|
|
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));
|
|
123 }
|
|
124
|
|
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));
|
|
127 } else {
|
|
128 /* mono */
|
|
129 uint8_t j;
|
|
130 sbr->qmfa[0] = qmfa_init(32);
|
|
131 sbr->qmfs[0] = qmfs_init((downSampledSBR)?32:64);
|
|
132 sbr->qmfs[1] = NULL;
|
|
133
|
|
134 for (j = 0; j < 5; j++)
|
|
135 {
|
|
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));
|
|
138 }
|
|
139
|
|
140 memset(sbr->Xsbr[0], 0, (sbr->numTimeSlotsRate+sbr->tHFGen)*64 * sizeof(qmf_t));
|
|
141 }
|
|
142
|
10725
|
143 return sbr;
|
|
144 }
|
|
145
|
|
146 void sbrDecodeEnd(sbr_info *sbr)
|
|
147 {
|
|
148 uint8_t j;
|
|
149
|
|
150 if (sbr)
|
|
151 {
|
|
152 qmfa_end(sbr->qmfa[0]);
|
|
153 qmfs_end(sbr->qmfs[0]);
|
12527
|
154 if (sbr->qmfs[1] != NULL)
|
10725
|
155 {
|
|
156 qmfa_end(sbr->qmfa[1]);
|
|
157 qmfs_end(sbr->qmfs[1]);
|
|
158 }
|
|
159
|
|
160 for (j = 0; j < 5; j++)
|
|
161 {
|
12527
|
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]);
|
10725
|
166 }
|
|
167
|
13453
|
168 #ifdef PS_DEC
|
|
169 if (sbr->ps != NULL)
|
|
170 ps_free(sbr->ps);
|
|
171 #endif
|
|
172
|
|
173 #ifdef DRM_PS
|
|
174 if (sbr->drm_ps != NULL)
|
|
175 drm_ps_free(sbr->drm_ps);
|
|
176 #endif
|
|
177
|
12527
|
178 faad_free(sbr);
|
10725
|
179 }
|
|
180 }
|
|
181
|
12527
|
182 static uint8_t sbr_save_prev_data(sbr_info *sbr, uint8_t ch)
|
10725
|
183 {
|
|
184 uint8_t i;
|
|
185
|
|
186 /* save data for next frame */
|
|
187 sbr->kx_prev = sbr->kx;
|
13453
|
188 sbr->M_prev = sbr->M;
|
|
189 sbr->bsco_prev = sbr->bsco;
|
10725
|
190
|
|
191 sbr->L_E_prev[ch] = sbr->L_E[ch];
|
|
192
|
12527
|
193 /* sbr->L_E[ch] can become 0 on files with bit errors */
|
|
194 if (sbr->L_E[ch] <= 0)
|
|
195 return 19;
|
|
196
|
10725
|
197 sbr->f_prev[ch] = sbr->f[ch][sbr->L_E[ch] - 1];
|
13453
|
198 for (i = 0; i < MAX_M; i++)
|
10725
|
199 {
|
|
200 sbr->E_prev[ch][i] = sbr->E[ch][i][sbr->L_E[ch] - 1];
|
|
201 sbr->Q_prev[ch][i] = sbr->Q[ch][i][sbr->L_Q[ch] - 1];
|
|
202 }
|
|
203
|
13453
|
204 for (i = 0; i < MAX_M; i++)
|
10725
|
205 {
|
|
206 sbr->bs_add_harmonic_prev[ch][i] = sbr->bs_add_harmonic[ch][i];
|
|
207 }
|
|
208 sbr->bs_add_harmonic_flag_prev[ch] = sbr->bs_add_harmonic_flag[ch];
|
|
209
|
|
210 if (sbr->l_A[ch] == sbr->L_E[ch])
|
|
211 sbr->prevEnvIsShort[ch] = 0;
|
|
212 else
|
|
213 sbr->prevEnvIsShort[ch] = -1;
|
12527
|
214
|
|
215 return 0;
|
10725
|
216 }
|
|
217
|
13453
|
218 static void sbr_save_matrix(sbr_info *sbr, uint8_t ch)
|
|
219 {
|
|
220 uint8_t i;
|
|
221
|
|
222 for (i = 0; i < sbr->tHFGen; i++)
|
|
223 {
|
|
224 memmove(sbr->Xsbr[ch][i], sbr->Xsbr[ch][i+sbr->numTimeSlotsRate], 64 * sizeof(qmf_t));
|
|
225 }
|
|
226 for (i = sbr->tHFGen; i < MAX_NTSRHFG; i++)
|
|
227 {
|
|
228 memset(sbr->Xsbr[ch][i], 0, 64 * sizeof(qmf_t));
|
|
229 }
|
|
230 }
|
|
231
|
12527
|
232 static void sbr_process_channel(sbr_info *sbr, real_t *channel_buf, qmf_t X[MAX_NTSR][64],
|
13453
|
233 uint8_t ch, uint8_t dont_process,
|
|
234 const uint8_t downSampledSBR)
|
10725
|
235 {
|
13453
|
236 int16_t k, l;
|
10725
|
237
|
12527
|
238 #ifdef SBR_LOW_POWER
|
|
239 ALIGN real_t deg[64];
|
|
240 #endif
|
|
241
|
13453
|
242 #ifdef DRM
|
|
243 if (sbr->Is_DRM_SBR)
|
12527
|
244 {
|
13453
|
245 sbr->bsco = max((int32_t)sbr->maxAACLine*32/(int32_t)sbr->frame_len - (int32_t)sbr->kx, 0);
|
|
246 } else {
|
|
247 #endif
|
|
248 sbr->bsco = 0;
|
|
249 #ifdef DRM
|
|
250 }
|
|
251 #endif
|
12527
|
252
|
13453
|
253
|
|
254 //#define PRE_QMF_PRINT
|
|
255 #ifdef PRE_QMF_PRINT
|
|
256 {
|
|
257 int i;
|
|
258 for (i = 0; i < 1024; i++)
|
12527
|
259 {
|
13453
|
260 printf("%d\n", channel_buf[i]);
|
12527
|
261 }
|
13453
|
262 }
|
|
263 #endif
|
12527
|
264
|
10725
|
265
|
12527
|
266 /* subband analysis */
|
|
267 if (dont_process)
|
13453
|
268 sbr_qmf_analysis_32(sbr, sbr->qmfa[ch], channel_buf, sbr->Xsbr[ch], sbr->tHFGen, 32);
|
12527
|
269 else
|
13453
|
270 sbr_qmf_analysis_32(sbr, sbr->qmfa[ch], channel_buf, sbr->Xsbr[ch], sbr->tHFGen, sbr->kx);
|
12527
|
271
|
|
272 if (!dont_process)
|
|
273 {
|
|
274 #if 1
|
|
275 /* insert high frequencies here */
|
|
276 /* hf generation using patching */
|
13453
|
277 hf_generation(sbr, sbr->Xsbr[ch], sbr->Xsbr[ch]
|
10725
|
278 #ifdef SBR_LOW_POWER
|
12527
|
279 ,deg
|
|
280 #endif
|
|
281 ,ch);
|
|
282 #endif
|
|
283
|
|
284 #ifdef SBR_LOW_POWER
|
|
285 for (l = sbr->t_E[ch][0]; l < sbr->t_E[ch][sbr->L_E[ch]]; l++)
|
|
286 {
|
|
287 for (k = 0; k < sbr->kx; k++)
|
|
288 {
|
|
289 QMF_RE(sbr->Xsbr[ch][sbr->tHFAdj + l][k]) = 0;
|
|
290 }
|
|
291 }
|
10725
|
292 #endif
|
|
293
|
12527
|
294 #if 1
|
|
295 /* hf adjustment */
|
|
296 hf_adjustment(sbr, sbr->Xsbr[ch]
|
|
297 #ifdef SBR_LOW_POWER
|
|
298 ,deg
|
|
299 #endif
|
|
300 ,ch);
|
|
301 #endif
|
10989
|
302 }
|
|
303
|
12527
|
304 if ((sbr->just_seeked != 0) || dont_process)
|
|
305 {
|
|
306 for (l = 0; l < sbr->numTimeSlotsRate; l++)
|
|
307 {
|
|
308 for (k = 0; k < 32; k++)
|
|
309 {
|
13453
|
310 QMF_RE(X[l][k]) = QMF_RE(sbr->Xsbr[ch][l + sbr->tHFAdj][k]);
|
12527
|
311 #ifndef SBR_LOW_POWER
|
13453
|
312 QMF_IM(X[l][k]) = QMF_IM(sbr->Xsbr[ch][l + sbr->tHFAdj][k]);
|
12527
|
313 #endif
|
|
314 }
|
|
315 for (k = 32; k < 64; k++)
|
|
316 {
|
|
317 QMF_RE(X[l][k]) = 0;
|
|
318 #ifndef SBR_LOW_POWER
|
|
319 QMF_IM(X[l][k]) = 0;
|
|
320 #endif
|
|
321 }
|
|
322 }
|
|
323 } else {
|
|
324 for (l = 0; l < sbr->numTimeSlotsRate; l++)
|
|
325 {
|
13453
|
326 uint8_t kx_band, M_band, bsco_band;
|
12527
|
327
|
|
328 if (l < sbr->t_E[ch][0])
|
|
329 {
|
13453
|
330 kx_band = sbr->kx_prev;
|
|
331 M_band = sbr->M_prev;
|
|
332 bsco_band = sbr->bsco_prev;
|
|
333 } else {
|
|
334 kx_band = sbr->kx;
|
|
335 M_band = sbr->M;
|
|
336 bsco_band = sbr->bsco;
|
|
337 }
|
|
338
|
12527
|
339 #ifndef SBR_LOW_POWER
|
13453
|
340 for (k = 0; k < kx_band + bsco_band; k++)
|
|
341 {
|
|
342 QMF_RE(X[l][k]) = QMF_RE(sbr->Xsbr[ch][l + sbr->tHFAdj][k]);
|
|
343 QMF_IM(X[l][k]) = QMF_IM(sbr->Xsbr[ch][l + sbr->tHFAdj][k]);
|
12527
|
344 }
|
13453
|
345 for (k = kx_band + bsco_band; k < kx_band + M_band; k++)
|
12527
|
346 {
|
|
347 QMF_RE(X[l][k]) = QMF_RE(sbr->Xsbr[ch][l + sbr->tHFAdj][k]);
|
|
348 QMF_IM(X[l][k]) = QMF_IM(sbr->Xsbr[ch][l + sbr->tHFAdj][k]);
|
13453
|
349 }
|
|
350 for (k = max(kx_band + bsco_band, kx_band + M_band); k < 64; k++)
|
|
351 {
|
|
352 QMF_RE(X[l][k]) = 0;
|
|
353 QMF_IM(X[l][k]) = 0;
|
|
354 }
|
|
355 #else
|
|
356 for (k = 0; k < kx_band + bsco_band; k++)
|
|
357 {
|
|
358 QMF_RE(X[l][k]) = QMF_RE(sbr->Xsbr[ch][l + sbr->tHFAdj][k]);
|
12527
|
359 }
|
13453
|
360 for (k = kx_band + bsco_band; k < min(kx_band + M_band, 63); k++)
|
|
361 {
|
|
362 QMF_RE(X[l][k]) = QMF_RE(sbr->Xsbr[ch][l + sbr->tHFAdj][k]);
|
|
363 }
|
|
364 for (k = max(kx_band + bsco_band, kx_band + M_band); k < 64; k++)
|
|
365 {
|
|
366 QMF_RE(X[l][k]) = 0;
|
|
367 }
|
|
368 QMF_RE(X[l][kx_band - 1 + bsco_band]) +=
|
|
369 QMF_RE(sbr->Xsbr[ch][l + sbr->tHFAdj][kx_band - 1 + bsco_band]);
|
12527
|
370 #endif
|
|
371 }
|
|
372 }
|
|
373 }
|
|
374
|
|
375 uint8_t sbrDecodeCoupleFrame(sbr_info *sbr, real_t *left_chan, real_t *right_chan,
|
13453
|
376 const uint8_t just_seeked, const uint8_t downSampledSBR)
|
12527
|
377 {
|
|
378 uint8_t dont_process = 0;
|
|
379 uint8_t ret = 0;
|
|
380 ALIGN qmf_t X[MAX_NTSR][64];
|
|
381
|
|
382 if (sbr == NULL)
|
|
383 return 20;
|
|
384
|
|
385 /* case can occur due to bit errors */
|
|
386 if (sbr->id_aac != ID_CPE)
|
|
387 return 21;
|
|
388
|
|
389 if (sbr->ret || (sbr->header_count == 0))
|
10725
|
390 {
|
|
391 /* don't process just upsample */
|
|
392 dont_process = 1;
|
10989
|
393
|
|
394 /* Re-activate reset for next frame */
|
12527
|
395 if (sbr->ret && sbr->Reset)
|
10989
|
396 sbr->bs_start_freq_prev = -1;
|
10725
|
397 }
|
|
398
|
|
399 if (just_seeked)
|
10989
|
400 {
|
10725
|
401 sbr->just_seeked = 1;
|
10989
|
402 } else {
|
10725
|
403 sbr->just_seeked = 0;
|
10989
|
404 }
|
10725
|
405
|
13453
|
406 sbr_process_channel(sbr, left_chan, X, 0, dont_process, downSampledSBR);
|
12527
|
407 /* subband synthesis */
|
13453
|
408 if (downSampledSBR)
|
|
409 {
|
|
410 sbr_qmf_synthesis_32(sbr, sbr->qmfs[0], X, left_chan);
|
|
411 } else {
|
|
412 sbr_qmf_synthesis_64(sbr, sbr->qmfs[0], X, left_chan);
|
|
413 }
|
10725
|
414
|
13453
|
415 sbr_process_channel(sbr, right_chan, X, 1, dont_process, downSampledSBR);
|
12527
|
416 /* subband synthesis */
|
13453
|
417 if (downSampledSBR)
|
|
418 {
|
|
419 sbr_qmf_synthesis_32(sbr, sbr->qmfs[1], X, right_chan);
|
|
420 } else {
|
|
421 sbr_qmf_synthesis_64(sbr, sbr->qmfs[1], X, right_chan);
|
|
422 }
|
10725
|
423
|
12527
|
424 if (sbr->bs_header_flag)
|
|
425 sbr->just_seeked = 0;
|
|
426
|
|
427 if (sbr->header_count != 0 && sbr->ret == 0)
|
|
428 {
|
|
429 ret = sbr_save_prev_data(sbr, 0);
|
|
430 if (ret) return ret;
|
|
431 ret = sbr_save_prev_data(sbr, 1);
|
|
432 if (ret) return ret;
|
|
433 }
|
|
434
|
13453
|
435 sbr_save_matrix(sbr, 0);
|
|
436 sbr_save_matrix(sbr, 1);
|
|
437
|
12527
|
438 sbr->frame++;
|
|
439
|
13453
|
440 //#define POST_QMF_PRINT
|
|
441 #ifdef POST_QMF_PRINT
|
|
442 {
|
|
443 int i;
|
|
444 for (i = 0; i < 2048; i++)
|
|
445 {
|
|
446 printf("%d\n", left_chan[i]);
|
|
447 }
|
|
448 for (i = 0; i < 2048; i++)
|
|
449 {
|
|
450 printf("%d\n", right_chan[i]);
|
|
451 }
|
|
452 }
|
|
453 #endif
|
|
454
|
12527
|
455 return 0;
|
|
456 }
|
|
457
|
|
458 uint8_t sbrDecodeSingleFrame(sbr_info *sbr, real_t *channel,
|
13453
|
459 const uint8_t just_seeked, const uint8_t downSampledSBR)
|
12527
|
460 {
|
|
461 uint8_t dont_process = 0;
|
|
462 uint8_t ret = 0;
|
|
463 ALIGN qmf_t X[MAX_NTSR][64];
|
|
464
|
|
465 if (sbr == NULL)
|
|
466 return 20;
|
10725
|
467
|
12527
|
468 /* case can occur due to bit errors */
|
|
469 if (sbr->id_aac != ID_SCE && sbr->id_aac != ID_LFE)
|
|
470 return 21;
|
|
471
|
|
472 if (sbr->ret || (sbr->header_count == 0))
|
|
473 {
|
|
474 /* don't process just upsample */
|
|
475 dont_process = 1;
|
|
476
|
|
477 /* Re-activate reset for next frame */
|
|
478 if (sbr->ret && sbr->Reset)
|
|
479 sbr->bs_start_freq_prev = -1;
|
|
480 }
|
10725
|
481
|
12527
|
482 if (just_seeked)
|
|
483 {
|
|
484 sbr->just_seeked = 1;
|
|
485 } else {
|
|
486 sbr->just_seeked = 0;
|
|
487 }
|
10725
|
488
|
13453
|
489 sbr_process_channel(sbr, channel, X, 0, dont_process, downSampledSBR);
|
12527
|
490 /* subband synthesis */
|
13453
|
491 if (downSampledSBR)
|
|
492 {
|
|
493 sbr_qmf_synthesis_32(sbr, sbr->qmfs[0], X, channel);
|
|
494 } else {
|
|
495 sbr_qmf_synthesis_64(sbr, sbr->qmfs[0], X, channel);
|
|
496 }
|
10725
|
497
|
|
498 if (sbr->bs_header_flag)
|
|
499 sbr->just_seeked = 0;
|
|
500
|
12527
|
501 if (sbr->header_count != 0 && sbr->ret == 0)
|
10725
|
502 {
|
12527
|
503 ret = sbr_save_prev_data(sbr, 0);
|
|
504 if (ret) return ret;
|
10725
|
505 }
|
|
506
|
13453
|
507 sbr_save_matrix(sbr, 0);
|
|
508
|
10725
|
509 sbr->frame++;
|
12527
|
510
|
13453
|
511 //#define POST_QMF_PRINT
|
|
512 #ifdef POST_QMF_PRINT
|
|
513 {
|
|
514 int i;
|
|
515 for (i = 0; i < 2048; i++)
|
|
516 {
|
|
517 printf("%d\n", channel[i]);
|
|
518 }
|
|
519 }
|
|
520 #endif
|
|
521
|
12527
|
522 return 0;
|
|
523 }
|
|
524
|
|
525 #if (defined(PS_DEC) || defined(DRM_PS))
|
|
526 uint8_t sbrDecodeSingleFramePS(sbr_info *sbr, real_t *left_channel, real_t *right_channel,
|
13453
|
527 const uint8_t just_seeked, const uint8_t downSampledSBR)
|
12527
|
528 {
|
13453
|
529 uint8_t l, k;
|
12527
|
530 uint8_t dont_process = 0;
|
|
531 uint8_t ret = 0;
|
17098
|
532 ALIGN qmf_t X_left[38][64] = {{{0}}};
|
|
533 ALIGN qmf_t X_right[38][64] = {{{0}}}; /* must set this to 0 */
|
12527
|
534
|
|
535 if (sbr == NULL)
|
|
536 return 20;
|
|
537
|
|
538 /* case can occur due to bit errors */
|
|
539 if (sbr->id_aac != ID_SCE && sbr->id_aac != ID_LFE)
|
|
540 return 21;
|
|
541
|
|
542 if (sbr->ret || (sbr->header_count == 0))
|
|
543 {
|
|
544 /* don't process just upsample */
|
|
545 dont_process = 1;
|
|
546
|
|
547 /* Re-activate reset for next frame */
|
|
548 if (sbr->ret && sbr->Reset)
|
|
549 sbr->bs_start_freq_prev = -1;
|
|
550 }
|
|
551
|
|
552 if (just_seeked)
|
|
553 {
|
|
554 sbr->just_seeked = 1;
|
|
555 } else {
|
|
556 sbr->just_seeked = 0;
|
|
557 }
|
|
558
|
13453
|
559 if (sbr->qmfs[1] == NULL)
|
12527
|
560 {
|
13453
|
561 sbr->qmfs[1] = qmfs_init((downSampledSBR)?32:64);
|
12527
|
562 }
|
|
563
|
13453
|
564 sbr_process_channel(sbr, left_channel, X_left, 0, dont_process, downSampledSBR);
|
|
565
|
|
566 /* copy some extra data for PS */
|
|
567 for (l = 32; l < 38; l++)
|
|
568 {
|
|
569 for (k = 0; k < 5; k++)
|
|
570 {
|
|
571 QMF_RE(X_left[l][k]) = QMF_RE(sbr->Xsbr[0][sbr->tHFAdj+l][k]);
|
|
572 QMF_IM(X_left[l][k]) = QMF_IM(sbr->Xsbr[0][sbr->tHFAdj+l][k]);
|
|
573 }
|
|
574 }
|
12527
|
575
|
|
576 /* perform parametric stereo */
|
13453
|
577 #ifdef DRM_PS
|
|
578 if (sbr->Is_DRM_SBR)
|
|
579 {
|
18141
|
580 drm_ps_decode(sbr->drm_ps, (sbr->ret > 0), sbr->sample_rate, X_left, X_right);
|
13453
|
581 } else {
|
|
582 #endif
|
|
583 #ifdef PS_DEC
|
|
584 ps_decode(sbr->ps, X_left, X_right);
|
|
585 #endif
|
|
586 #ifdef DRM_PS
|
|
587 }
|
|
588 #endif
|
12527
|
589
|
|
590 /* subband synthesis */
|
13453
|
591 if (downSampledSBR)
|
|
592 {
|
|
593 sbr_qmf_synthesis_32(sbr, sbr->qmfs[0], X_left, left_channel);
|
|
594 sbr_qmf_synthesis_32(sbr, sbr->qmfs[1], X_right, right_channel);
|
|
595 } else {
|
|
596 sbr_qmf_synthesis_64(sbr, sbr->qmfs[0], X_left, left_channel);
|
|
597 sbr_qmf_synthesis_64(sbr, sbr->qmfs[1], X_right, right_channel);
|
|
598 }
|
12527
|
599
|
|
600 if (sbr->bs_header_flag)
|
|
601 sbr->just_seeked = 0;
|
|
602
|
|
603 if (sbr->header_count != 0 && sbr->ret == 0)
|
|
604 {
|
|
605 ret = sbr_save_prev_data(sbr, 0);
|
|
606 if (ret) return ret;
|
|
607 }
|
|
608
|
13453
|
609 sbr_save_matrix(sbr, 0);
|
|
610
|
12527
|
611 sbr->frame++;
|
|
612
|
|
613 return 0;
|
|
614 }
|
|
615 #endif
|
|
616
|
|
617 #endif
|