61
|
1 /*
|
|
2 ** FAAD2 - Freeware Advanced Audio (AAC) Decoder including SBR decoding
|
|
3 ** Copyright (C) 2003 M. Bakker, Ahead Software 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 ** Commercial non-GPL licensing of this software is possible.
|
|
23 ** For more info contact Ahead Software through Mpeg4AAClicense@nero.com.
|
|
24 **
|
|
25 ** $Id: sbr_syntax.c,v 1.15 2003/11/12 20:47:58 menno Exp $
|
|
26 **/
|
|
27
|
|
28 #include "common.h"
|
|
29 #include "structs.h"
|
|
30
|
|
31 #ifdef SBR_DEC
|
|
32
|
|
33 #include "sbr_syntax.h"
|
|
34 #include "syntax.h"
|
|
35 #include "sbr_huff.h"
|
|
36 #include "sbr_fbt.h"
|
|
37 #include "sbr_tf_grid.h"
|
|
38 #include "sbr_e_nf.h"
|
|
39 #include "bits.h"
|
|
40 #include "analysis.h"
|
|
41
|
|
42 static void sbr_reset(sbr_info *sbr)
|
|
43 {
|
|
44 #if 0
|
|
45 printf("%d\n", sbr->bs_start_freq_prev);
|
|
46 printf("%d\n", sbr->bs_stop_freq_prev);
|
|
47 printf("%d\n", sbr->bs_freq_scale_prev);
|
|
48 printf("%d\n", sbr->bs_alter_scale_prev);
|
|
49 printf("%d\n", sbr->bs_xover_band_prev);
|
|
50 printf("%d\n\n", sbr->bs_noise_bands_prev);
|
|
51 #endif
|
|
52
|
|
53 /* if these are different from the previous frame: Reset = 1 */
|
|
54 if ((sbr->bs_start_freq != sbr->bs_start_freq_prev) ||
|
|
55 (sbr->bs_stop_freq != sbr->bs_stop_freq_prev) ||
|
|
56 (sbr->bs_freq_scale != sbr->bs_freq_scale_prev) ||
|
|
57 (sbr->bs_alter_scale != sbr->bs_alter_scale_prev))
|
|
58 {
|
|
59 sbr->Reset = 1;
|
|
60 } else {
|
|
61 sbr->Reset = 0;
|
|
62 }
|
|
63
|
|
64 if ((sbr->bs_start_freq != sbr->bs_start_freq_prev) ||
|
|
65 (sbr->bs_stop_freq != sbr->bs_stop_freq_prev) ||
|
|
66 (sbr->bs_freq_scale != sbr->bs_freq_scale_prev) ||
|
|
67 (sbr->bs_alter_scale != sbr->bs_alter_scale_prev) ||
|
|
68 (sbr->bs_xover_band != sbr->bs_xover_band_prev) ||
|
|
69 (sbr->bs_noise_bands != sbr->bs_noise_bands_prev))
|
|
70 {
|
|
71 sbr->Reset = 1;
|
|
72 } else {
|
|
73 sbr->Reset = 0;
|
|
74 }
|
|
75
|
|
76 sbr->bs_start_freq_prev = sbr->bs_start_freq;
|
|
77 sbr->bs_stop_freq_prev = sbr->bs_stop_freq;
|
|
78 sbr->bs_freq_scale_prev = sbr->bs_freq_scale;
|
|
79 sbr->bs_alter_scale_prev = sbr->bs_alter_scale;
|
|
80 sbr->bs_xover_band_prev = sbr->bs_xover_band;
|
|
81 sbr->bs_noise_bands_prev = sbr->bs_noise_bands;
|
|
82
|
|
83 if (sbr->frame == 0)
|
|
84 {
|
|
85 sbr->Reset = 1;
|
|
86 }
|
|
87 }
|
|
88
|
|
89 /* table 2 */
|
|
90 uint8_t sbr_extension_data(bitfile *ld, sbr_info *sbr)
|
|
91 {
|
|
92 uint8_t result;
|
|
93 #ifdef DRM
|
|
94 uint8_t crc_len;
|
|
95
|
|
96 if (sbr->Is_DRM_SBR)
|
|
97 faad_getbits(ld, 8); /* 8-bit CRC */
|
|
98 else
|
|
99 #endif
|
|
100 {
|
|
101 uint8_t bs_extension_type = (uint8_t)faad_getbits(ld, 4
|
|
102 DEBUGVAR(1,198,"sbr_bitstream(): bs_extension_type"));
|
|
103
|
|
104 if (bs_extension_type == EXT_SBR_DATA_CRC)
|
|
105 {
|
|
106 sbr->bs_sbr_crc_bits = (uint16_t)faad_getbits(ld, 10
|
|
107 DEBUGVAR(1,199,"sbr_bitstream(): bs_sbr_crc_bits"));
|
|
108 }
|
|
109 }
|
|
110
|
|
111 sbr->bs_header_flag = faad_get1bit(ld
|
|
112 DEBUGVAR(1,200,"sbr_bitstream(): bs_header_flag"));
|
|
113
|
|
114 #ifdef DRM
|
|
115 if (sbr->Is_DRM_SBR)
|
|
116 {
|
|
117 /* Check CRC, get number of bits for check */
|
|
118 if (sbr->id_aac == ID_SCE)
|
|
119 {
|
|
120 if (sbr->lcstereo_flag)
|
|
121 {
|
|
122 if (sbr->bs_header_flag)
|
|
123 crc_len = min(76, sbr->data_size_bits);
|
|
124 else
|
|
125 crc_len = min(47, sbr->data_size_bits);
|
|
126 } else {
|
|
127 if (sbr->bs_header_flag)
|
|
128 crc_len = min(74, sbr->data_size_bits);
|
|
129 else
|
|
130 crc_len = min(47, sbr->data_size_bits);
|
|
131 }
|
|
132 } else {
|
|
133 if (sbr->bs_header_flag)
|
|
134 crc_len = min(120, sbr->data_size_bits);
|
|
135 else
|
|
136 crc_len = min(93, sbr->data_size_bits);
|
|
137 }
|
|
138
|
|
139 if ((result = faad_check_CRC(ld, crc_len)) > 0)
|
|
140 return result;
|
|
141
|
|
142 /* Rewind and read bits again to set correct position in bit-stream */
|
|
143 faad_rewindbits(ld);
|
|
144 faad_getbits(ld, 8);
|
|
145 faad_get1bit(ld);
|
|
146 }
|
|
147 #endif
|
|
148
|
|
149 if (sbr->bs_header_flag)
|
|
150 sbr_header(ld, sbr);
|
|
151
|
|
152 /* TODO: Reset? */
|
|
153 sbr_reset(sbr);
|
|
154
|
|
155 /* first frame should have a header */
|
|
156 if (sbr->frame == 0 && sbr->bs_header_flag == 0)
|
|
157 return 1;
|
|
158
|
|
159
|
|
160 if (sbr->Reset || (sbr->bs_header_flag && sbr->just_seeked))
|
|
161 {
|
|
162 uint8_t k2;
|
|
163
|
|
164 /* calculate the Master Frequency Table */
|
|
165 sbr->k0 = qmf_start_channel(sbr->bs_start_freq, sbr->bs_samplerate_mode,
|
|
166 sbr->sample_rate);
|
|
167 k2 = qmf_stop_channel(sbr->bs_stop_freq, sbr->sample_rate, sbr->k0);
|
|
168
|
|
169 /* check k0 and k2 */
|
|
170 if (sbr->sample_rate >= 48000)
|
|
171 {
|
|
172 if ((k2 - sbr->k0) > 32)
|
|
173 return 1;
|
|
174 } else if (sbr->sample_rate <= 32000) {
|
|
175 if ((k2 - sbr->k0) > 48)
|
|
176 return 1;
|
|
177 } else { /* (sbr->sample_rate == 44100) */
|
|
178 if ((k2 - sbr->k0) > 45)
|
|
179 return 1;
|
|
180 }
|
|
181
|
|
182 if (sbr->bs_freq_scale == 0)
|
|
183 {
|
|
184 master_frequency_table_fs0(sbr, sbr->k0, k2, sbr->bs_alter_scale);
|
|
185 } else {
|
|
186 master_frequency_table(sbr, sbr->k0, k2, sbr->bs_freq_scale,
|
|
187 sbr->bs_alter_scale);
|
|
188 }
|
|
189 if ((result = derived_frequency_table(sbr, sbr->bs_xover_band, k2)) > 0)
|
|
190 return result;
|
|
191 }
|
|
192
|
|
193 if ((result = sbr_data(ld, sbr)) > 0)
|
|
194 return result;
|
|
195
|
|
196 /* no error */
|
|
197 return 0;
|
|
198 }
|
|
199
|
|
200 /* table 3 */
|
|
201 static void sbr_header(bitfile *ld, sbr_info *sbr)
|
|
202 {
|
|
203 uint8_t bs_header_extra_1, bs_header_extra_2;
|
|
204
|
|
205 sbr->header_count++;
|
|
206
|
|
207 #ifdef DRM
|
|
208 /* protocol_version (should be 0) */
|
|
209 if (sbr->Is_DRM_SBR)
|
|
210 faad_getbits(ld, 2);
|
|
211 #endif
|
|
212
|
|
213 sbr->bs_amp_res = faad_get1bit(ld
|
|
214 DEBUGVAR(1,203,"sbr_header(): bs_amp_res"));
|
|
215
|
|
216 /* bs_start_freq and bs_stop_freq must define a fequency band that does
|
|
217 not exceed 48 channels */
|
|
218 sbr->bs_start_freq = faad_getbits(ld, 4
|
|
219 DEBUGVAR(1,204,"sbr_header(): bs_start_freq"));
|
|
220 sbr->bs_stop_freq = faad_getbits(ld, 4
|
|
221 DEBUGVAR(1,205,"sbr_header(): bs_stop_freq"));
|
|
222 sbr->bs_xover_band = faad_getbits(ld, 3
|
|
223 DEBUGVAR(1,206,"sbr_header(): bs_xover_band"));
|
|
224 faad_getbits(ld, 2
|
|
225 DEBUGVAR(1,207,"sbr_header(): bs_reserved_bits_hdr"));
|
|
226 #ifdef DRM
|
|
227 if (sbr->Is_DRM_SBR)
|
|
228 sbr->bs_dataextra = faad_getbits(ld, 1);
|
|
229 #endif
|
|
230 bs_header_extra_1 = faad_get1bit(ld
|
|
231 DEBUGVAR(1,208,"sbr_header(): bs_header_extra_1"));
|
|
232 bs_header_extra_2 = faad_get1bit(ld
|
|
233 DEBUGVAR(1,209,"sbr_header(): bs_header_extra_2"));
|
|
234 #ifdef DRM
|
|
235 /* No low complexity stereo support so far */
|
|
236 if ((sbr->lcstereo_flag) && (sbr->Is_DRM_SBR))
|
|
237 faad_getbits(ld, 2);
|
|
238 #endif
|
|
239
|
|
240 if (bs_header_extra_1)
|
|
241 {
|
|
242 sbr->bs_freq_scale = faad_getbits(ld, 2
|
|
243 DEBUGVAR(1,211,"sbr_header(): bs_freq_scale"));
|
|
244 sbr->bs_alter_scale = faad_get1bit(ld
|
|
245 DEBUGVAR(1,212,"sbr_header(): bs_alter_scale"));
|
|
246 sbr->bs_noise_bands = faad_getbits(ld, 2
|
|
247 DEBUGVAR(1,213,"sbr_header(): bs_noise_bands"));
|
|
248 } else {
|
|
249 /* Default values */
|
|
250 sbr->bs_freq_scale = 2;
|
|
251 sbr->bs_alter_scale = 1;
|
|
252 sbr->bs_noise_bands = 2;
|
|
253 }
|
|
254
|
|
255 if (bs_header_extra_2)
|
|
256 {
|
|
257 sbr->bs_limiter_bands = faad_getbits(ld, 2
|
|
258 DEBUGVAR(1,214,"sbr_header(): bs_limiter_bands"));
|
|
259 sbr->bs_limiter_gains = faad_getbits(ld, 2
|
|
260 DEBUGVAR(1,215,"sbr_header(): bs_limiter_gains"));
|
|
261 sbr->bs_interpol_freq = faad_get1bit(ld
|
|
262 DEBUGVAR(1,216,"sbr_header(): bs_interpol_freq"));
|
|
263 sbr->bs_smoothing_mode = faad_get1bit(ld
|
|
264 DEBUGVAR(1,217,"sbr_header(): bs_smoothing_mode"));
|
|
265 #ifdef DRM
|
|
266 /* reserved */
|
|
267 if (sbr->Is_DRM_SBR)
|
|
268 faad_get1bit(ld);
|
|
269 #endif
|
|
270 } else {
|
|
271 /* Default values */
|
|
272 sbr->bs_limiter_bands = 2;
|
|
273 sbr->bs_limiter_gains = 2;
|
|
274 sbr->bs_interpol_freq = 1;
|
|
275 sbr->bs_smoothing_mode = 1;
|
|
276 }
|
|
277
|
|
278 #if 0
|
|
279 /* print the header to screen */
|
|
280 printf("bs_amp_res: %d\n", sbr->bs_amp_res);
|
|
281 printf("bs_start_freq: %d\n", sbr->bs_start_freq);
|
|
282 printf("bs_stop_freq: %d\n", sbr->bs_stop_freq);
|
|
283 printf("bs_xover_band: %d\n", sbr->bs_xover_band);
|
|
284 if (bs_header_extra_1)
|
|
285 {
|
|
286 printf("bs_freq_scale: %d\n", sbr->bs_freq_scale);
|
|
287 printf("bs_alter_scale: %d\n", sbr->bs_alter_scale);
|
|
288 printf("bs_noise_bands: %d\n", sbr->bs_noise_bands);
|
|
289 }
|
|
290 if (bs_header_extra_2)
|
|
291 {
|
|
292 printf("bs_limiter_bands: %d\n", sbr->bs_limiter_bands);
|
|
293 printf("bs_limiter_gains: %d\n", sbr->bs_limiter_gains);
|
|
294 printf("bs_interpol_freq: %d\n", sbr->bs_interpol_freq);
|
|
295 printf("bs_smoothing_mode: %d\n", sbr->bs_smoothing_mode);
|
|
296 }
|
|
297 printf("\n");
|
|
298 #endif
|
|
299 }
|
|
300
|
|
301 /* table 4 */
|
|
302 static uint8_t sbr_data(bitfile *ld, sbr_info *sbr)
|
|
303 {
|
|
304 uint8_t result;
|
|
305 #if 0
|
|
306 sbr->bs_samplerate_mode = faad_get1bit(ld
|
|
307 DEBUGVAR(1,219,"sbr_data(): bs_samplerate_mode"));
|
|
308 #endif
|
|
309
|
|
310 sbr->rate = (sbr->bs_samplerate_mode) ? 2 : 1;
|
|
311
|
|
312 #ifdef DRM
|
|
313 if (sbr->Is_DRM_SBR)
|
|
314 sbr->rate = 2;
|
|
315 #endif
|
|
316
|
|
317 switch (sbr->id_aac)
|
|
318 {
|
|
319 case ID_SCE:
|
|
320 if ((result = sbr_single_channel_element(ld, sbr)) > 0)
|
|
321 return result;
|
|
322 break;
|
|
323 case ID_CPE:
|
|
324 if ((result = sbr_channel_pair_element(ld, sbr)) > 0)
|
|
325 return result;
|
|
326 break;
|
|
327 }
|
|
328
|
|
329 return 0;
|
|
330 }
|
|
331
|
|
332 /* table 5 */
|
|
333 static uint8_t sbr_single_channel_element(bitfile *ld, sbr_info *sbr)
|
|
334 {
|
|
335 uint8_t result;
|
|
336
|
|
337 #ifdef DRM
|
|
338 if (!sbr->Is_DRM_SBR)
|
|
339 #endif
|
|
340 {
|
|
341 if (faad_get1bit(ld
|
|
342 DEBUGVAR(1,220,"sbr_single_channel_element(): bs_data_extra")))
|
|
343 {
|
|
344 faad_getbits(ld, 4
|
|
345 DEBUGVAR(1,221,"sbr_single_channel_element(): bs_reserved_bits_data"));
|
|
346 }
|
|
347 }
|
|
348
|
|
349 if ((result = sbr_grid(ld, sbr, 0)) > 0)
|
|
350 return result;
|
|
351 sbr_dtdf(ld, sbr, 0);
|
|
352 invf_mode(ld, sbr, 0);
|
|
353 #ifdef DRM
|
|
354 if (sbr->Is_DRM_SBR)
|
|
355 {
|
|
356 /* sbr mode not needed in V1.0. Should be set to 2 by a V1.0 encoder */
|
|
357 faad_getbits(ld, 2);
|
|
358
|
|
359 if (sbr->bs_dataextra)
|
|
360 faad_getbits(ld, 3); /* reserved */
|
|
361 }
|
|
362 #endif
|
|
363 sbr_envelope(ld, sbr, 0);
|
|
364 sbr_noise(ld, sbr, 0);
|
|
365
|
|
366 envelope_noise_dequantisation(sbr, 0);
|
|
367
|
|
368 memset(sbr->bs_add_harmonic[0], 0, 64*sizeof(uint8_t));
|
|
369
|
|
370 #ifdef DRM
|
|
371 if (sbr->Is_DRM_SBR)
|
|
372 sbr->bs_add_harmonic_flag[0] = 0;
|
|
373 else
|
|
374 #endif
|
|
375 {
|
|
376 sbr->bs_add_harmonic_flag[0] = faad_get1bit(ld
|
|
377 DEBUGVAR(1,223,"sbr_single_channel_element(): bs_add_harmonic_flag[0]"));
|
|
378 }
|
|
379 if (sbr->bs_add_harmonic_flag[0])
|
|
380 sinusoidal_coding(ld, sbr, 0);
|
|
381
|
|
382 sbr->bs_extended_data = faad_get1bit(ld
|
|
383 DEBUGVAR(1,224,"sbr_single_channel_element(): bs_extended_data[0]"));
|
|
384 if (sbr->bs_extended_data)
|
|
385 {
|
|
386 uint16_t nr_bits_left;
|
|
387 uint16_t cnt = faad_getbits(ld, 4
|
|
388 DEBUGVAR(1,225,"sbr_single_channel_element(): bs_extension_size"));
|
|
389 if (cnt == 15)
|
|
390 {
|
|
391 cnt += faad_getbits(ld, 8
|
|
392 DEBUGVAR(1,226,"sbr_single_channel_element(): bs_esc_count"));
|
|
393 }
|
|
394
|
|
395 nr_bits_left = 8 * cnt;
|
|
396 while (nr_bits_left > 7)
|
|
397 {
|
|
398 sbr->bs_extension_id = faad_getbits(ld, 2
|
|
399 DEBUGVAR(1,227,"sbr_single_channel_element(): bs_extension_id"));
|
|
400 nr_bits_left -= 2;
|
|
401 /* sbr_extension(ld, sbr, 0, nr_bits_left); */
|
|
402 #ifdef DRM
|
|
403 if (!sbr->Is_DRM_SBR)
|
|
404 #endif
|
|
405 {
|
|
406 sbr->bs_extension_data = faad_getbits(ld, 6
|
|
407 DEBUGVAR(1,279,"sbr_single_channel_element(): bs_extension_data"));
|
|
408 }
|
|
409 }
|
|
410
|
|
411 /* Corrigendum */
|
|
412 faad_getbits(ld, nr_bits_left
|
|
413 DEBUGVAR(1,280,"sbr_single_channel_element(): nr_bits_left"));
|
|
414 }
|
|
415
|
|
416 return 0;
|
|
417 }
|
|
418
|
|
419 /* table 6 */
|
|
420 static uint8_t sbr_channel_pair_element(bitfile *ld, sbr_info *sbr)
|
|
421 {
|
|
422 uint8_t n, result;
|
|
423
|
|
424 #ifdef DRM
|
|
425 if (!sbr->Is_DRM_SBR)
|
|
426 #endif
|
|
427 {
|
|
428 if (faad_get1bit(ld
|
|
429 DEBUGVAR(1,228,"sbr_single_channel_element(): bs_data_extra")))
|
|
430 {
|
|
431 faad_getbits(ld, 4
|
|
432 DEBUGVAR(1,228,"sbr_channel_pair_element(): bs_reserved_bits_data"));
|
|
433 faad_getbits(ld, 4
|
|
434 DEBUGVAR(1,228,"sbr_channel_pair_element(): bs_reserved_bits_data"));
|
|
435 }
|
|
436 }
|
|
437
|
|
438 sbr->bs_coupling = faad_get1bit(ld
|
|
439 DEBUGVAR(1,228,"sbr_channel_pair_element(): bs_coupling"));
|
|
440
|
|
441 if (sbr->bs_coupling)
|
|
442 {
|
|
443 if ((result = sbr_grid(ld, sbr, 0)) > 0)
|
|
444 return result;
|
|
445
|
|
446 /* need to copy some data from left to right */
|
|
447 sbr->bs_frame_class[1] = sbr->bs_frame_class[0];
|
|
448 sbr->L_E[1] = sbr->L_E[0];
|
|
449 sbr->L_Q[1] = sbr->L_Q[0];
|
|
450 sbr->bs_pointer[1] = sbr->bs_pointer[0];
|
|
451
|
|
452 for (n = 0; n <= sbr->L_E[0]; n++)
|
|
453 {
|
|
454 sbr->t_E[1][n] = sbr->t_E[0][n];
|
|
455 sbr->f[1][n] = sbr->f[0][n];
|
|
456 }
|
|
457 for (n = 0; n <= sbr->L_Q[0]; n++)
|
|
458 sbr->t_Q[1][n] = sbr->t_Q[0][n];
|
|
459
|
|
460 sbr_dtdf(ld, sbr, 0);
|
|
461 sbr_dtdf(ld, sbr, 1);
|
|
462 invf_mode(ld, sbr, 0);
|
|
463 #ifdef DRM
|
|
464 if (sbr->Is_DRM_SBR)
|
|
465 {
|
|
466 /* sbr mode not needed in V1.0. Should be set to 2 by a V1.0 encoder */
|
|
467 faad_getbits(ld, 2);
|
|
468
|
|
469 if (sbr->bs_dataextra)
|
|
470 faad_getbits(ld, 3); /* reserved */
|
|
471 }
|
|
472 #endif
|
|
473
|
|
474 /* more copying */
|
|
475 for (n = 0; n < sbr->N_Q; n++)
|
|
476 sbr->bs_invf_mode[1][n] = sbr->bs_invf_mode[0][n];
|
|
477
|
|
478 sbr_envelope(ld, sbr, 0);
|
|
479 sbr_noise(ld, sbr, 0);
|
|
480 sbr_envelope(ld, sbr, 1);
|
|
481 sbr_noise(ld, sbr, 1);
|
|
482
|
|
483 memset(sbr->bs_add_harmonic[0], 0, 64*sizeof(uint8_t));
|
|
484 memset(sbr->bs_add_harmonic[1], 0, 64*sizeof(uint8_t));
|
|
485
|
|
486 #ifdef DRM
|
|
487 if (sbr->Is_DRM_SBR)
|
|
488 sbr->bs_add_harmonic_flag[0] = 0;
|
|
489 else
|
|
490 #endif
|
|
491 {
|
|
492 sbr->bs_add_harmonic_flag[0] = faad_get1bit(ld
|
|
493 DEBUGVAR(1,231,"sbr_channel_pair_element(): bs_add_harmonic_flag[0]"));
|
|
494 }
|
|
495 if (sbr->bs_add_harmonic_flag[0])
|
|
496 sinusoidal_coding(ld, sbr, 0);
|
|
497
|
|
498 #ifdef DRM
|
|
499 if (sbr->Is_DRM_SBR)
|
|
500 sbr->bs_add_harmonic_flag[1] = 0;
|
|
501 else
|
|
502 #endif
|
|
503 {
|
|
504 sbr->bs_add_harmonic_flag[1] = faad_get1bit(ld
|
|
505 DEBUGVAR(1,232,"sbr_channel_pair_element(): bs_add_harmonic_flag[1]"));
|
|
506 }
|
|
507 if (sbr->bs_add_harmonic_flag[1])
|
|
508 sinusoidal_coding(ld, sbr, 1);
|
|
509 } else {
|
|
510 if ((result = sbr_grid(ld, sbr, 0)) > 0)
|
|
511 return result;
|
|
512 if ((result = sbr_grid(ld, sbr, 1)) > 0)
|
|
513 return result;
|
|
514 sbr_dtdf(ld, sbr, 0);
|
|
515 sbr_dtdf(ld, sbr, 1);
|
|
516 invf_mode(ld, sbr, 0);
|
|
517 invf_mode(ld, sbr, 1);
|
|
518 #ifdef DRM
|
|
519 if (sbr->Is_DRM_SBR)
|
|
520 {
|
|
521 /* sbr mode not needed in V1.0. Should be set to 2 by a V1.0 encoder */
|
|
522 faad_getbits(ld, 2);
|
|
523 faad_getbits(ld, 2);
|
|
524
|
|
525 if (sbr->bs_dataextra)
|
|
526 faad_getbits(ld, 6); /* reserved */
|
|
527 }
|
|
528 #endif
|
|
529 sbr_envelope(ld, sbr, 0);
|
|
530 sbr_envelope(ld, sbr, 1);
|
|
531 sbr_noise(ld, sbr, 0);
|
|
532 sbr_noise(ld, sbr, 1);
|
|
533
|
|
534 memset(sbr->bs_add_harmonic[0], 0, 64*sizeof(uint8_t));
|
|
535 memset(sbr->bs_add_harmonic[1], 0, 64*sizeof(uint8_t));
|
|
536
|
|
537 #ifdef DRM
|
|
538 if (sbr->Is_DRM_SBR)
|
|
539 sbr->bs_add_harmonic_flag[0] = 0;
|
|
540 else
|
|
541 #endif
|
|
542 {
|
|
543 sbr->bs_add_harmonic_flag[0] = faad_get1bit(ld
|
|
544 DEBUGVAR(1,239,"sbr_channel_pair_element(): bs_add_harmonic_flag[0]"));
|
|
545 }
|
|
546 if (sbr->bs_add_harmonic_flag[0])
|
|
547 sinusoidal_coding(ld, sbr, 0);
|
|
548
|
|
549 #ifdef DRM
|
|
550 if (sbr->Is_DRM_SBR)
|
|
551 sbr->bs_add_harmonic_flag[1] = 0;
|
|
552 else
|
|
553 #endif
|
|
554 {
|
|
555 sbr->bs_add_harmonic_flag[1] = faad_get1bit(ld
|
|
556 DEBUGVAR(1,240,"sbr_channel_pair_element(): bs_add_harmonic_flag[1]"));
|
|
557 }
|
|
558 if (sbr->bs_add_harmonic_flag[1])
|
|
559 sinusoidal_coding(ld, sbr, 1);
|
|
560 }
|
|
561 envelope_noise_dequantisation(sbr, 0);
|
|
562 envelope_noise_dequantisation(sbr, 1);
|
|
563
|
|
564 if (sbr->bs_coupling)
|
|
565 unmap_envelope_noise(sbr);
|
|
566
|
|
567 sbr->bs_extended_data = faad_get1bit(ld
|
|
568 DEBUGVAR(1,233,"sbr_channel_pair_element(): bs_extended_data[0]"));
|
|
569 if (sbr->bs_extended_data)
|
|
570 {
|
|
571 uint16_t nr_bits_left;
|
|
572 uint16_t cnt = faad_getbits(ld, 4
|
|
573 DEBUGVAR(1,234,"sbr_channel_pair_element(): bs_extension_size"));
|
|
574 if (cnt == 15)
|
|
575 {
|
|
576 cnt += faad_getbits(ld, 8
|
|
577 DEBUGVAR(1,235,"sbr_channel_pair_element(): bs_esc_count"));
|
|
578 }
|
|
579
|
|
580 nr_bits_left = 8 * cnt;
|
|
581 while (nr_bits_left > 7)
|
|
582 {
|
|
583 sbr->bs_extension_id = faad_getbits(ld, 2
|
|
584 DEBUGVAR(1,236,"sbr_channel_pair_element(): bs_extension_id"));
|
|
585 nr_bits_left -= 2;
|
|
586 /* sbr_extension(ld, sbr, 0, nr_bits_left); */
|
|
587 #ifdef DRM
|
|
588 if (!sbr->Is_DRM_SBR)
|
|
589 #endif
|
|
590 {
|
|
591 sbr->bs_extension_data = faad_getbits(ld, 6
|
|
592 DEBUGVAR(1,280,"sbr_channel_pair_element(): bs_extension_data"));
|
|
593 }
|
|
594 }
|
|
595
|
|
596 /* Corrigendum */
|
|
597 faad_getbits(ld, nr_bits_left
|
|
598 DEBUGVAR(1,280,"sbr_channel_pair_element(): nr_bits_left"));
|
|
599 }
|
|
600
|
|
601 return 0;
|
|
602 }
|
|
603
|
|
604 /* table 7 */
|
|
605 static uint8_t sbr_grid(bitfile *ld, sbr_info *sbr, uint8_t ch)
|
|
606 {
|
|
607 uint8_t i, env, rel, result;
|
|
608 uint8_t bs_abs_bord, bs_abs_bord_1;
|
|
609 uint16_t bs_num_env;
|
|
610
|
|
611 sbr->bs_frame_class[ch] = faad_getbits(ld, 2
|
|
612 DEBUGVAR(1,248,"sbr_grid(): bs_frame_class"));
|
|
613
|
|
614 switch (sbr->bs_frame_class[ch])
|
|
615 {
|
|
616 case FIXFIX:
|
|
617 i = faad_getbits(ld, 2
|
|
618 DEBUGVAR(1,249,"sbr_grid(): bs_num_env_raw"));
|
|
619
|
|
620 bs_num_env = min(1 << i, 5);
|
|
621
|
|
622 i = faad_get1bit(ld
|
|
623 DEBUGVAR(1,250,"sbr_grid(): bs_freq_res_flag"));
|
|
624 for (env = 0; env < bs_num_env; env++)
|
|
625 sbr->f[ch][env] = i;
|
|
626
|
|
627 sbr->abs_bord_lead[ch] = 0;
|
|
628 sbr->abs_bord_trail[ch] = sbr->numTimeSlots;
|
|
629 sbr->n_rel_lead[ch] = bs_num_env - 1;
|
|
630 sbr->n_rel_trail[ch] = 0;
|
|
631 break;
|
|
632
|
|
633 case FIXVAR:
|
|
634 #ifdef DRM
|
|
635 if (sbr->Is_DRM_SBR)
|
|
636 {
|
|
637 bs_abs_bord = faad_getbits(ld, 3
|
|
638 DEBUGVAR(1,251,"sbr_grid(): bs_abs_bord")) + sbr->numTimeSlots;
|
|
639 } else
|
|
640 #endif
|
|
641 {
|
|
642 bs_abs_bord = faad_getbits(ld, 2
|
|
643 DEBUGVAR(1,251,"sbr_grid(): bs_abs_bord")) + sbr->numTimeSlots;
|
|
644 }
|
|
645 bs_num_env = faad_getbits(ld, 2
|
|
646 DEBUGVAR(1,252,"sbr_grid(): bs_num_env")) + 1;
|
|
647
|
|
648 for (rel = 0; rel < bs_num_env-1; rel++)
|
|
649 {
|
|
650 sbr->bs_rel_bord[ch][rel] = 2 * faad_getbits(ld, 2
|
|
651 DEBUGVAR(1,253,"sbr_grid(): bs_rel_bord")) + 2;
|
|
652 }
|
|
653 i = int_log2((int32_t)(bs_num_env + 1));
|
|
654 sbr->bs_pointer[ch] = faad_getbits(ld, i
|
|
655 DEBUGVAR(1,254,"sbr_grid(): bs_pointer"));
|
|
656
|
|
657 for (env = 0; env < bs_num_env; env++)
|
|
658 {
|
|
659 sbr->f[ch][bs_num_env - env - 1] = faad_get1bit(ld
|
|
660 DEBUGVAR(1,255,"sbr_grid(): bs_freq_res"));
|
|
661 }
|
|
662
|
|
663 sbr->abs_bord_lead[ch] = 0;
|
|
664 sbr->abs_bord_trail[ch] = bs_abs_bord;
|
|
665 sbr->n_rel_lead[ch] = 0;
|
|
666 sbr->n_rel_trail[ch] = bs_num_env - 1;
|
|
667 break;
|
|
668
|
|
669 case VARFIX:
|
|
670 #ifdef DRM
|
|
671 if (sbr->Is_DRM_SBR)
|
|
672 {
|
|
673 bs_abs_bord = faad_getbits(ld, 3
|
|
674 DEBUGVAR(1,256,"sbr_grid(): bs_abs_bord"));
|
|
675 } else
|
|
676 #endif
|
|
677 {
|
|
678 bs_abs_bord = faad_getbits(ld, 2
|
|
679 DEBUGVAR(1,256,"sbr_grid(): bs_abs_bord"));
|
|
680 }
|
|
681 bs_num_env = faad_getbits(ld, 2
|
|
682 DEBUGVAR(1,257,"sbr_grid(): bs_num_env")) + 1;
|
|
683
|
|
684 for (rel = 0; rel < bs_num_env-1; rel++)
|
|
685 {
|
|
686 sbr->bs_rel_bord[ch][rel] = 2 * faad_getbits(ld, 2
|
|
687 DEBUGVAR(1,258,"sbr_grid(): bs_rel_bord")) + 2;
|
|
688 }
|
|
689 i = int_log2((int32_t)(bs_num_env + 1));
|
|
690 sbr->bs_pointer[ch] = faad_getbits(ld, i
|
|
691 DEBUGVAR(1,259,"sbr_grid(): bs_pointer"));
|
|
692
|
|
693 for (env = 0; env < bs_num_env; env++)
|
|
694 {
|
|
695 sbr->f[ch][env] = faad_get1bit(ld
|
|
696 DEBUGVAR(1,260,"sbr_grid(): bs_freq_res"));
|
|
697 }
|
|
698
|
|
699 sbr->abs_bord_lead[ch] = bs_abs_bord;
|
|
700 sbr->abs_bord_trail[ch] = sbr->numTimeSlots;
|
|
701 sbr->n_rel_lead[ch] = bs_num_env - 1;
|
|
702 sbr->n_rel_trail[ch] = 0;
|
|
703 break;
|
|
704
|
|
705 case VARVAR:
|
|
706 #ifdef DRM
|
|
707 if (sbr->Is_DRM_SBR)
|
|
708 {
|
|
709 bs_abs_bord = faad_getbits(ld, 3
|
|
710 DEBUGVAR(1,261,"sbr_grid(): bs_abs_bord_0"));
|
|
711 bs_abs_bord_1 = faad_getbits(ld, 3
|
|
712 DEBUGVAR(1,262,"sbr_grid(): bs_abs_bord_1")) + sbr->numTimeSlots;
|
|
713 }
|
|
714 else
|
|
715 #endif
|
|
716 {
|
|
717 bs_abs_bord = faad_getbits(ld, 2
|
|
718 DEBUGVAR(1,261,"sbr_grid(): bs_abs_bord_0"));
|
|
719 bs_abs_bord_1 = faad_getbits(ld, 2
|
|
720 DEBUGVAR(1,262,"sbr_grid(): bs_abs_bord_1")) + sbr->numTimeSlots;
|
|
721 }
|
|
722 sbr->bs_num_rel_0[ch] = faad_getbits(ld, 2
|
|
723 DEBUGVAR(1,263,"sbr_grid(): bs_num_rel_0"));
|
|
724 sbr->bs_num_rel_1[ch] = faad_getbits(ld, 2
|
|
725 DEBUGVAR(1,264,"sbr_grid(): bs_num_rel_1"));
|
|
726
|
|
727 bs_num_env = min(5, sbr->bs_num_rel_0[ch] + sbr->bs_num_rel_1[ch] + 1);
|
|
728
|
|
729 for (rel = 0; rel < sbr->bs_num_rel_0[ch]; rel++)
|
|
730 {
|
|
731 sbr->bs_rel_bord_0[ch][rel] = 2 * faad_getbits(ld, 2
|
|
732 DEBUGVAR(1,265,"sbr_grid(): bs_rel_bord")) + 2;
|
|
733 }
|
|
734 for(rel = 0; rel < sbr->bs_num_rel_1[ch]; rel++)
|
|
735 {
|
|
736 sbr->bs_rel_bord_1[ch][rel] = 2 * faad_getbits(ld, 2
|
|
737 DEBUGVAR(1,266,"sbr_grid(): bs_rel_bord")) + 2;
|
|
738 }
|
|
739 i = int_log2((int32_t)(sbr->bs_num_rel_0[ch] + sbr->bs_num_rel_1[ch] + 2));
|
|
740 sbr->bs_pointer[ch] = faad_getbits(ld, i
|
|
741 DEBUGVAR(1,267,"sbr_grid(): bs_pointer"));
|
|
742
|
|
743 for (env = 0; env < bs_num_env; env++)
|
|
744 {
|
|
745 sbr->f[ch][env] = faad_get1bit(ld
|
|
746 DEBUGVAR(1,268,"sbr_grid(): bs_freq_res"));
|
|
747 }
|
|
748
|
|
749 sbr->abs_bord_lead[ch] = bs_abs_bord;
|
|
750 sbr->abs_bord_trail[ch] = bs_abs_bord_1;
|
|
751 sbr->n_rel_lead[ch] = sbr->bs_num_rel_0[ch];
|
|
752 sbr->n_rel_trail[ch] = sbr->bs_num_rel_1[ch];
|
|
753 break;
|
|
754 }
|
|
755
|
|
756 if (sbr->bs_frame_class[ch] == VARVAR)
|
|
757 sbr->L_E[ch] = min(bs_num_env, 5);
|
|
758 else
|
|
759 sbr->L_E[ch] = min(bs_num_env, 4);
|
|
760
|
|
761 if (sbr->L_E[ch] > 1)
|
|
762 sbr->L_Q[ch] = 2;
|
|
763 else
|
|
764 sbr->L_Q[ch] = 1;
|
|
765
|
|
766 /* TODO: this code can probably be integrated into the code above! */
|
|
767 if ((result = envelope_time_border_vector(sbr, ch)) > 0)
|
|
768 return result;
|
|
769 noise_floor_time_border_vector(sbr, ch);
|
|
770
|
|
771 return 0;
|
|
772 }
|
|
773
|
|
774 /* table 8 */
|
|
775 static void sbr_dtdf(bitfile *ld, sbr_info *sbr, uint8_t ch)
|
|
776 {
|
|
777 uint8_t i;
|
|
778
|
|
779 for (i = 0; i < sbr->L_E[ch]; i++)
|
|
780 {
|
|
781 sbr->bs_df_env[ch][i] = faad_get1bit(ld
|
|
782 DEBUGVAR(1,269,"sbr_dtdf(): bs_df_env"));
|
|
783 }
|
|
784
|
|
785 for (i = 0; i < sbr->L_Q[ch]; i++)
|
|
786 {
|
|
787 sbr->bs_df_noise[ch][i] = faad_get1bit(ld
|
|
788 DEBUGVAR(1,270,"sbr_dtdf(): bs_df_noise"));
|
|
789 }
|
|
790 }
|
|
791
|
|
792 /* table 9 */
|
|
793 static void invf_mode(bitfile *ld, sbr_info *sbr, uint8_t ch)
|
|
794 {
|
|
795 uint8_t n;
|
|
796
|
|
797 #ifdef DRM
|
|
798 if (sbr->Is_DRM_SBR)
|
|
799 {
|
|
800 /* Only one inv_mode in DRM */
|
|
801 uint8_t invf_mode;
|
|
802 invf_mode = faad_getbits(ld, 2
|
|
803 DEBUGVAR(1,271,"invf_mode(): bs_invf_mode"));
|
|
804 for (n = 0; n < sbr->N_Q; n++)
|
|
805 sbr->bs_invf_mode[ch][n] = invf_mode;
|
|
806 } else
|
|
807 #endif
|
|
808 {
|
|
809 for (n = 0; n < sbr->N_Q; n++)
|
|
810 {
|
|
811 sbr->bs_invf_mode[ch][n] = faad_getbits(ld, 2
|
|
812 DEBUGVAR(1,271,"invf_mode(): bs_invf_mode"));
|
|
813 }
|
|
814 }
|
|
815 }
|
|
816
|
|
817 /* table 12 */
|
|
818 static void sinusoidal_coding(bitfile *ld, sbr_info *sbr, uint8_t ch)
|
|
819 {
|
|
820 uint8_t n;
|
|
821
|
|
822 for (n = 0; n < sbr->N_high; n++)
|
|
823 {
|
|
824 sbr->bs_add_harmonic[ch][n] = faad_get1bit(ld
|
|
825 DEBUGVAR(1,278,"sinusoidal_coding(): bs_add_harmonic"));
|
|
826 }
|
|
827 }
|
|
828
|
|
829
|
|
830 #endif /* SBR_DEC */
|