Mercurial > audlegacy
comparison Plugins/Input/aac/libfaad2/sbr_syntax.c @ 61:fa848bd484d8 trunk
[svn] Move plugins to Plugins/
author | nenolod |
---|---|
date | Fri, 28 Oct 2005 22:58:11 -0700 |
parents | |
children | 0a2ad94e8607 |
comparison
equal
deleted
inserted
replaced
60:1771f253e1b2 | 61:fa848bd484d8 |
---|---|
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 */ |