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_syntax.c,v 1.39 2009/01/26 22:32:31 menno Exp $
51 /* static function declarations */
52 /* static function declarations */
53 static void sbr_header(bitfile *ld, sbr_info *sbr);
54 static uint8_t calc_sbr_tables(sbr_info *sbr, uint8_t start_freq, uint8_t stop_freq,
55 uint8_t samplerate_mode, uint8_t freq_scale,
56 uint8_t alter_scale, uint8_t xover_band);
57 static uint8_t sbr_data(bitfile *ld, sbr_info *sbr);
58 static uint16_t sbr_extension(bitfile *ld, sbr_info *sbr,
59 uint8_t bs_extension_id, uint16_t num_bits_left);
60 static uint8_t sbr_single_channel_element(bitfile *ld, sbr_info *sbr);
61 static uint8_t sbr_channel_pair_element(bitfile *ld, sbr_info *sbr);
62 static uint8_t sbr_grid(bitfile *ld, sbr_info *sbr, uint8_t ch);
63 static void sbr_dtdf(bitfile *ld, sbr_info *sbr, uint8_t ch);
64 static void invf_mode(bitfile *ld, sbr_info *sbr, uint8_t ch);
65 static void sinusoidal_coding(bitfile *ld, sbr_info *sbr, uint8_t ch);
68 static void sbr_reset(sbr_info *sbr)
71 printf("%d\n", sbr->bs_start_freq_prev);
72 printf("%d\n", sbr->bs_stop_freq_prev);
73 printf("%d\n", sbr->bs_freq_scale_prev);
74 printf("%d\n", sbr->bs_alter_scale_prev);
75 printf("%d\n", sbr->bs_xover_band_prev);
76 printf("%d\n\n", sbr->bs_noise_bands_prev);
79 /* if these are different from the previous frame: Reset = 1 */
80 if ((sbr->bs_start_freq != sbr->bs_start_freq_prev) ||
81 (sbr->bs_stop_freq != sbr->bs_stop_freq_prev) ||
82 (sbr->bs_freq_scale != sbr->bs_freq_scale_prev) ||
83 (sbr->bs_alter_scale != sbr->bs_alter_scale_prev) ||
84 (sbr->bs_xover_band != sbr->bs_xover_band_prev) ||
85 (sbr->bs_noise_bands != sbr->bs_noise_bands_prev))
92 sbr->bs_start_freq_prev = sbr->bs_start_freq;
93 sbr->bs_stop_freq_prev = sbr->bs_stop_freq;
94 sbr->bs_freq_scale_prev = sbr->bs_freq_scale;
95 sbr->bs_alter_scale_prev = sbr->bs_alter_scale;
96 sbr->bs_xover_band_prev = sbr->bs_xover_band;
97 sbr->bs_noise_bands_prev = sbr->bs_noise_bands;
100 static uint8_t calc_sbr_tables(sbr_info *sbr, uint8_t start_freq, uint8_t stop_freq,
101 uint8_t samplerate_mode, uint8_t freq_scale,
102 uint8_t alter_scale, uint8_t xover_band)
107 /* calculate the Master Frequency Table */
108 sbr->k0 = qmf_start_channel(start_freq, samplerate_mode, sbr->sample_rate);
109 k2 = qmf_stop_channel(stop_freq, sbr->sample_rate, sbr->k0);
111 /* check k0 and k2 */
112 if (sbr->sample_rate >= 48000)
114 if ((k2 - sbr->k0) > 32)
116 } else if (sbr->sample_rate <= 32000) {
117 if ((k2 - sbr->k0) > 48)
119 } else { /* (sbr->sample_rate == 44100) */
120 if ((k2 - sbr->k0) > 45)
126 result += master_frequency_table_fs0(sbr, sbr->k0, k2, alter_scale);
128 result += master_frequency_table(sbr, sbr->k0, k2, freq_scale, alter_scale);
130 result += derived_frequency_table(sbr, xover_band, k2);
132 result = (result > 0) ? 1 : 0;
138 uint8_t sbr_extension_data(bitfile *ld, sbr_info *sbr, uint16_t cnt,
142 uint16_t num_align_bits = 0;
143 uint16_t num_sbr_bits1 = (uint16_t)faad_get_processed_bits(ld);
144 uint16_t num_sbr_bits2;
146 uint8_t saved_start_freq, saved_samplerate_mode;
147 uint8_t saved_stop_freq, saved_freq_scale;
148 uint8_t saved_alter_scale, saved_xover_band;
150 #if (defined(PS_DEC) || defined(DRM_PS))
152 sbr->psResetFlag = psResetFlag;
156 if (!sbr->Is_DRM_SBR)
159 uint8_t bs_extension_type = (uint8_t)faad_getbits(ld, 4
160 DEBUGVAR(1,198,"sbr_bitstream(): bs_extension_type"));
162 if (bs_extension_type == EXT_SBR_DATA_CRC)
164 sbr->bs_sbr_crc_bits = (uint16_t)faad_getbits(ld, 10
165 DEBUGVAR(1,199,"sbr_bitstream(): bs_sbr_crc_bits"));
169 /* save old header values, in case the new ones are corrupted */
170 saved_start_freq = sbr->bs_start_freq;
171 saved_samplerate_mode = sbr->bs_samplerate_mode;
172 saved_stop_freq = sbr->bs_stop_freq;
173 saved_freq_scale = sbr->bs_freq_scale;
174 saved_alter_scale = sbr->bs_alter_scale;
175 saved_xover_band = sbr->bs_xover_band;
177 sbr->bs_header_flag = faad_get1bit(ld
178 DEBUGVAR(1,200,"sbr_bitstream(): bs_header_flag"));
180 if (sbr->bs_header_flag)
186 /* first frame should have a header */
187 //if (!(sbr->frame == 0 && sbr->bs_header_flag == 0))
188 if (sbr->header_count != 0)
190 if (sbr->Reset || (sbr->bs_header_flag && sbr->just_seeked))
192 uint8_t rt = calc_sbr_tables(sbr, sbr->bs_start_freq, sbr->bs_stop_freq,
193 sbr->bs_samplerate_mode, sbr->bs_freq_scale,
194 sbr->bs_alter_scale, sbr->bs_xover_band);
196 /* if an error occured with the new header values revert to the old ones */
199 calc_sbr_tables(sbr, saved_start_freq, saved_stop_freq,
200 saved_samplerate_mode, saved_freq_scale,
201 saved_alter_scale, saved_xover_band);
207 result = sbr_data(ld, sbr);
209 /* sbr_data() returning an error means that there was an error in
210 envelope_time_border_vector().
211 In this case the old time border vector is saved and all the previous
212 data normally read after sbr_grid() is saved.
214 /* to be on the safe side, calculate old sbr tables in case of error */
216 (sbr->Reset || (sbr->bs_header_flag && sbr->just_seeked)))
218 calc_sbr_tables(sbr, saved_start_freq, saved_stop_freq,
219 saved_samplerate_mode, saved_freq_scale,
220 saved_alter_scale, saved_xover_band);
223 /* we should be able to safely set result to 0 now, */
224 /* but practise indicates this doesn't work well */
230 num_sbr_bits2 = (uint16_t)faad_get_processed_bits(ld) - num_sbr_bits1;
232 /* check if we read more bits then were available for sbr */
233 if (8*cnt < num_sbr_bits2)
235 faad_resetbits(ld, num_sbr_bits1 + 8*cnt);
236 num_sbr_bits2 = 8*cnt;
239 /* turn off PS for the unfortunate case that we randomly read some
240 * PS data that looks correct */
244 /* Make sure it doesn't decode SBR in this frame, or we'll get glitches */
249 if (!sbr->Is_DRM_SBR)
252 /* -4 does not apply, bs_extension_type is re-read in this function */
253 num_align_bits = 8*cnt /*- 4*/ - num_sbr_bits2;
255 while (num_align_bits > 7)
258 DEBUGVAR(1,999,"sbr_bitstream(): num_align_bits"));
261 faad_getbits(ld, num_align_bits
262 DEBUGVAR(1,999,"sbr_bitstream(): num_align_bits"));
269 static void sbr_header(bitfile *ld, sbr_info *sbr)
271 uint8_t bs_header_extra_1, bs_header_extra_2;
275 sbr->bs_amp_res = faad_get1bit(ld
276 DEBUGVAR(1,203,"sbr_header(): bs_amp_res"));
278 /* bs_start_freq and bs_stop_freq must define a fequency band that does
279 not exceed 48 channels */
280 sbr->bs_start_freq = (uint8_t)faad_getbits(ld, 4
281 DEBUGVAR(1,204,"sbr_header(): bs_start_freq"));
282 sbr->bs_stop_freq = (uint8_t)faad_getbits(ld, 4
283 DEBUGVAR(1,205,"sbr_header(): bs_stop_freq"));
284 sbr->bs_xover_band = (uint8_t)faad_getbits(ld, 3
285 DEBUGVAR(1,206,"sbr_header(): bs_xover_band"));
287 DEBUGVAR(1,207,"sbr_header(): bs_reserved_bits_hdr"));
288 bs_header_extra_1 = (uint8_t)faad_get1bit(ld
289 DEBUGVAR(1,208,"sbr_header(): bs_header_extra_1"));
290 bs_header_extra_2 = (uint8_t)faad_get1bit(ld
291 DEBUGVAR(1,209,"sbr_header(): bs_header_extra_2"));
293 if (bs_header_extra_1)
295 sbr->bs_freq_scale = (uint8_t)faad_getbits(ld, 2
296 DEBUGVAR(1,211,"sbr_header(): bs_freq_scale"));
297 sbr->bs_alter_scale = (uint8_t)faad_get1bit(ld
298 DEBUGVAR(1,212,"sbr_header(): bs_alter_scale"));
299 sbr->bs_noise_bands = (uint8_t)faad_getbits(ld, 2
300 DEBUGVAR(1,213,"sbr_header(): bs_noise_bands"));
303 sbr->bs_freq_scale = 2;
304 sbr->bs_alter_scale = 1;
305 sbr->bs_noise_bands = 2;
308 if (bs_header_extra_2)
310 sbr->bs_limiter_bands = (uint8_t)faad_getbits(ld, 2
311 DEBUGVAR(1,214,"sbr_header(): bs_limiter_bands"));
312 sbr->bs_limiter_gains = (uint8_t)faad_getbits(ld, 2
313 DEBUGVAR(1,215,"sbr_header(): bs_limiter_gains"));
314 sbr->bs_interpol_freq = (uint8_t)faad_get1bit(ld
315 DEBUGVAR(1,216,"sbr_header(): bs_interpol_freq"));
316 sbr->bs_smoothing_mode = (uint8_t)faad_get1bit(ld
317 DEBUGVAR(1,217,"sbr_header(): bs_smoothing_mode"));
320 sbr->bs_limiter_bands = 2;
321 sbr->bs_limiter_gains = 2;
322 sbr->bs_interpol_freq = 1;
323 sbr->bs_smoothing_mode = 1;
327 /* print the header to screen */
328 printf("bs_amp_res: %d\n", sbr->bs_amp_res);
329 printf("bs_start_freq: %d\n", sbr->bs_start_freq);
330 printf("bs_stop_freq: %d\n", sbr->bs_stop_freq);
331 printf("bs_xover_band: %d\n", sbr->bs_xover_band);
332 if (bs_header_extra_1)
334 printf("bs_freq_scale: %d\n", sbr->bs_freq_scale);
335 printf("bs_alter_scale: %d\n", sbr->bs_alter_scale);
336 printf("bs_noise_bands: %d\n", sbr->bs_noise_bands);
338 if (bs_header_extra_2)
340 printf("bs_limiter_bands: %d\n", sbr->bs_limiter_bands);
341 printf("bs_limiter_gains: %d\n", sbr->bs_limiter_gains);
342 printf("bs_interpol_freq: %d\n", sbr->bs_interpol_freq);
343 printf("bs_smoothing_mode: %d\n", sbr->bs_smoothing_mode);
350 static uint8_t sbr_data(bitfile *ld, sbr_info *sbr)
354 sbr->bs_samplerate_mode = faad_get1bit(ld
355 DEBUGVAR(1,219,"sbr_data(): bs_samplerate_mode"));
358 sbr->rate = (sbr->bs_samplerate_mode) ? 2 : 1;
363 if ((result = sbr_single_channel_element(ld, sbr)) > 0)
367 if ((result = sbr_channel_pair_element(ld, sbr)) > 0)
376 static uint8_t sbr_single_channel_element(bitfile *ld, sbr_info *sbr)
381 DEBUGVAR(1,220,"sbr_single_channel_element(): bs_data_extra")))
384 DEBUGVAR(1,221,"sbr_single_channel_element(): bs_reserved_bits_data"));
388 /* bs_coupling, from sbr_channel_pair_base_element(bs_amp_res) */
395 if ((result = sbr_grid(ld, sbr, 0)) > 0)
398 sbr_dtdf(ld, sbr, 0);
399 invf_mode(ld, sbr, 0);
400 sbr_envelope(ld, sbr, 0);
401 sbr_noise(ld, sbr, 0);
404 envelope_noise_dequantisation(sbr, 0);
407 memset(sbr->bs_add_harmonic[0], 0, 64*sizeof(uint8_t));
409 sbr->bs_add_harmonic_flag[0] = faad_get1bit(ld
410 DEBUGVAR(1,223,"sbr_single_channel_element(): bs_add_harmonic_flag[0]"));
411 if (sbr->bs_add_harmonic_flag[0])
412 sinusoidal_coding(ld, sbr, 0);
414 sbr->bs_extended_data = faad_get1bit(ld
415 DEBUGVAR(1,224,"sbr_single_channel_element(): bs_extended_data[0]"));
417 if (sbr->bs_extended_data)
419 uint16_t nr_bits_left;
420 #if (defined(PS_DEC) || defined(DRM_PS))
421 uint8_t ps_ext_read = 0;
423 uint16_t cnt = (uint16_t)faad_getbits(ld, 4
424 DEBUGVAR(1,225,"sbr_single_channel_element(): bs_extension_size"));
427 cnt += (uint16_t)faad_getbits(ld, 8
428 DEBUGVAR(1,226,"sbr_single_channel_element(): bs_esc_count"));
431 nr_bits_left = 8 * cnt;
432 while (nr_bits_left > 7)
434 uint16_t tmp_nr_bits = 0;
436 sbr->bs_extension_id = (uint8_t)faad_getbits(ld, 2
437 DEBUGVAR(1,227,"sbr_single_channel_element(): bs_extension_id"));
440 /* allow only 1 PS extension element per extension data */
441 #if (defined(PS_DEC) || defined(DRM_PS))
442 #if (defined(PS_DEC) && defined(DRM_PS))
443 if (sbr->bs_extension_id == EXTENSION_ID_PS || sbr->bs_extension_id == DRM_PARAMETRIC_STEREO)
446 if (sbr->bs_extension_id == EXTENSION_ID_PS)
449 if (sbr->bs_extension_id == DRM_PARAMETRIC_STEREO)
454 if (ps_ext_read == 0)
458 /* to be safe make it 3, will switch to "default"
459 * in sbr_extension() */
463 sbr->bs_extension_id = 3;
469 tmp_nr_bits += sbr_extension(ld, sbr, sbr->bs_extension_id, nr_bits_left);
471 /* check if the data read is bigger than the number of available bits */
472 if (tmp_nr_bits > nr_bits_left)
475 nr_bits_left -= tmp_nr_bits;
479 if (nr_bits_left > 0)
481 faad_getbits(ld, nr_bits_left
482 DEBUGVAR(1,280,"sbr_single_channel_element(): nr_bits_left"));
490 static uint8_t sbr_channel_pair_element(bitfile *ld, sbr_info *sbr)
495 DEBUGVAR(1,228,"sbr_single_channel_element(): bs_data_extra")))
498 DEBUGVAR(1,228,"sbr_channel_pair_element(): bs_reserved_bits_data"));
500 DEBUGVAR(1,228,"sbr_channel_pair_element(): bs_reserved_bits_data"));
503 sbr->bs_coupling = faad_get1bit(ld
504 DEBUGVAR(1,228,"sbr_channel_pair_element(): bs_coupling"));
506 if (sbr->bs_coupling)
508 if ((result = sbr_grid(ld, sbr, 0)) > 0)
511 /* need to copy some data from left to right */
512 sbr->bs_frame_class[1] = sbr->bs_frame_class[0];
513 sbr->L_E[1] = sbr->L_E[0];
514 sbr->L_Q[1] = sbr->L_Q[0];
515 sbr->bs_pointer[1] = sbr->bs_pointer[0];
517 for (n = 0; n <= sbr->L_E[0]; n++)
519 sbr->t_E[1][n] = sbr->t_E[0][n];
520 sbr->f[1][n] = sbr->f[0][n];
522 for (n = 0; n <= sbr->L_Q[0]; n++)
523 sbr->t_Q[1][n] = sbr->t_Q[0][n];
525 sbr_dtdf(ld, sbr, 0);
526 sbr_dtdf(ld, sbr, 1);
527 invf_mode(ld, sbr, 0);
530 for (n = 0; n < sbr->N_Q; n++)
531 sbr->bs_invf_mode[1][n] = sbr->bs_invf_mode[0][n];
533 sbr_envelope(ld, sbr, 0);
534 sbr_noise(ld, sbr, 0);
535 sbr_envelope(ld, sbr, 1);
536 sbr_noise(ld, sbr, 1);
538 memset(sbr->bs_add_harmonic[0], 0, 64*sizeof(uint8_t));
539 memset(sbr->bs_add_harmonic[1], 0, 64*sizeof(uint8_t));
541 sbr->bs_add_harmonic_flag[0] = faad_get1bit(ld
542 DEBUGVAR(1,231,"sbr_channel_pair_element(): bs_add_harmonic_flag[0]"));
543 if (sbr->bs_add_harmonic_flag[0])
544 sinusoidal_coding(ld, sbr, 0);
546 sbr->bs_add_harmonic_flag[1] = faad_get1bit(ld
547 DEBUGVAR(1,232,"sbr_channel_pair_element(): bs_add_harmonic_flag[1]"));
548 if (sbr->bs_add_harmonic_flag[1])
549 sinusoidal_coding(ld, sbr, 1);
551 uint8_t saved_t_E[6] = {0}, saved_t_Q[3] = {0};
552 uint8_t saved_L_E = sbr->L_E[0];
553 uint8_t saved_L_Q = sbr->L_Q[0];
554 uint8_t saved_frame_class = sbr->bs_frame_class[0];
556 for (n = 0; n < saved_L_E; n++)
557 saved_t_E[n] = sbr->t_E[0][n];
558 for (n = 0; n < saved_L_Q; n++)
559 saved_t_Q[n] = sbr->t_Q[0][n];
561 if ((result = sbr_grid(ld, sbr, 0)) > 0)
563 if ((result = sbr_grid(ld, sbr, 1)) > 0)
565 /* restore first channel data as well */
566 sbr->bs_frame_class[0] = saved_frame_class;
567 sbr->L_E[0] = saved_L_E;
568 sbr->L_Q[0] = saved_L_Q;
569 for (n = 0; n < 6; n++)
570 sbr->t_E[0][n] = saved_t_E[n];
571 for (n = 0; n < 3; n++)
572 sbr->t_Q[0][n] = saved_t_Q[n];
576 sbr_dtdf(ld, sbr, 0);
577 sbr_dtdf(ld, sbr, 1);
578 invf_mode(ld, sbr, 0);
579 invf_mode(ld, sbr, 1);
580 sbr_envelope(ld, sbr, 0);
581 sbr_envelope(ld, sbr, 1);
582 sbr_noise(ld, sbr, 0);
583 sbr_noise(ld, sbr, 1);
585 memset(sbr->bs_add_harmonic[0], 0, 64*sizeof(uint8_t));
586 memset(sbr->bs_add_harmonic[1], 0, 64*sizeof(uint8_t));
588 sbr->bs_add_harmonic_flag[0] = faad_get1bit(ld
589 DEBUGVAR(1,239,"sbr_channel_pair_element(): bs_add_harmonic_flag[0]"));
590 if (sbr->bs_add_harmonic_flag[0])
591 sinusoidal_coding(ld, sbr, 0);
593 sbr->bs_add_harmonic_flag[1] = faad_get1bit(ld
594 DEBUGVAR(1,240,"sbr_channel_pair_element(): bs_add_harmonic_flag[1]"));
595 if (sbr->bs_add_harmonic_flag[1])
596 sinusoidal_coding(ld, sbr, 1);
599 envelope_noise_dequantisation(sbr, 0);
600 envelope_noise_dequantisation(sbr, 1);
602 if (sbr->bs_coupling)
603 unmap_envelope_noise(sbr);
606 sbr->bs_extended_data = faad_get1bit(ld
607 DEBUGVAR(1,233,"sbr_channel_pair_element(): bs_extended_data[0]"));
608 if (sbr->bs_extended_data)
610 uint16_t nr_bits_left;
611 uint16_t cnt = (uint16_t)faad_getbits(ld, 4
612 DEBUGVAR(1,234,"sbr_channel_pair_element(): bs_extension_size"));
615 cnt += (uint16_t)faad_getbits(ld, 8
616 DEBUGVAR(1,235,"sbr_channel_pair_element(): bs_esc_count"));
619 nr_bits_left = 8 * cnt;
620 while (nr_bits_left > 7)
622 uint16_t tmp_nr_bits = 0;
624 sbr->bs_extension_id = (uint8_t)faad_getbits(ld, 2
625 DEBUGVAR(1,236,"sbr_channel_pair_element(): bs_extension_id"));
627 tmp_nr_bits += sbr_extension(ld, sbr, sbr->bs_extension_id, nr_bits_left);
629 /* check if the data read is bigger than the number of available bits */
630 if (tmp_nr_bits > nr_bits_left)
633 nr_bits_left -= tmp_nr_bits;
637 if (nr_bits_left > 0)
639 faad_getbits(ld, nr_bits_left
640 DEBUGVAR(1,280,"sbr_channel_pair_element(): nr_bits_left"));
647 /* integer log[2](x): input range [0,10) */
648 static int8_t sbr_log2(const int8_t val)
650 int8_t log2tab[] = { 0, 0, 1, 2, 2, 3, 3, 3, 3, 4 };
651 if (val < 10 && val >= 0)
659 static uint8_t sbr_grid(bitfile *ld, sbr_info *sbr, uint8_t ch)
661 uint8_t i, env, rel, result;
662 uint8_t bs_abs_bord, bs_abs_bord_1;
663 uint8_t bs_num_env = 0;
664 uint8_t saved_L_E = sbr->L_E[ch];
665 uint8_t saved_L_Q = sbr->L_Q[ch];
666 uint8_t saved_frame_class = sbr->bs_frame_class[ch];
668 sbr->bs_frame_class[ch] = (uint8_t)faad_getbits(ld, 2
669 DEBUGVAR(1,248,"sbr_grid(): bs_frame_class"));
671 switch (sbr->bs_frame_class[ch])
674 i = (uint8_t)faad_getbits(ld, 2
675 DEBUGVAR(1,249,"sbr_grid(): bs_num_env_raw"));
677 bs_num_env = min(1 << i, 5);
679 i = (uint8_t)faad_get1bit(ld
680 DEBUGVAR(1,250,"sbr_grid(): bs_freq_res_flag"));
681 for (env = 0; env < bs_num_env; env++)
684 sbr->abs_bord_lead[ch] = 0;
685 sbr->abs_bord_trail[ch] = sbr->numTimeSlots;
686 sbr->n_rel_lead[ch] = bs_num_env - 1;
687 sbr->n_rel_trail[ch] = 0;
691 bs_abs_bord = (uint8_t)faad_getbits(ld, 2
692 DEBUGVAR(1,251,"sbr_grid(): bs_abs_bord")) + sbr->numTimeSlots;
693 bs_num_env = (uint8_t)faad_getbits(ld, 2
694 DEBUGVAR(1,252,"sbr_grid(): bs_num_env")) + 1;
696 for (rel = 0; rel < bs_num_env-1; rel++)
698 sbr->bs_rel_bord[ch][rel] = 2 * (uint8_t)faad_getbits(ld, 2
699 DEBUGVAR(1,253,"sbr_grid(): bs_rel_bord")) + 2;
701 i = sbr_log2(bs_num_env + 1);
702 sbr->bs_pointer[ch] = (uint8_t)faad_getbits(ld, i
703 DEBUGVAR(1,254,"sbr_grid(): bs_pointer"));
705 for (env = 0; env < bs_num_env; env++)
707 sbr->f[ch][bs_num_env - env - 1] = (uint8_t)faad_get1bit(ld
708 DEBUGVAR(1,255,"sbr_grid(): bs_freq_res"));
711 sbr->abs_bord_lead[ch] = 0;
712 sbr->abs_bord_trail[ch] = bs_abs_bord;
713 sbr->n_rel_lead[ch] = 0;
714 sbr->n_rel_trail[ch] = bs_num_env - 1;
718 bs_abs_bord = (uint8_t)faad_getbits(ld, 2
719 DEBUGVAR(1,256,"sbr_grid(): bs_abs_bord"));
720 bs_num_env = (uint8_t)faad_getbits(ld, 2
721 DEBUGVAR(1,257,"sbr_grid(): bs_num_env")) + 1;
723 for (rel = 0; rel < bs_num_env-1; rel++)
725 sbr->bs_rel_bord[ch][rel] = 2 * (uint8_t)faad_getbits(ld, 2
726 DEBUGVAR(1,258,"sbr_grid(): bs_rel_bord")) + 2;
728 i = sbr_log2(bs_num_env + 1);
729 sbr->bs_pointer[ch] = (uint8_t)faad_getbits(ld, i
730 DEBUGVAR(1,259,"sbr_grid(): bs_pointer"));
732 for (env = 0; env < bs_num_env; env++)
734 sbr->f[ch][env] = (uint8_t)faad_get1bit(ld
735 DEBUGVAR(1,260,"sbr_grid(): bs_freq_res"));
738 sbr->abs_bord_lead[ch] = bs_abs_bord;
739 sbr->abs_bord_trail[ch] = sbr->numTimeSlots;
740 sbr->n_rel_lead[ch] = bs_num_env - 1;
741 sbr->n_rel_trail[ch] = 0;
745 bs_abs_bord = (uint8_t)faad_getbits(ld, 2
746 DEBUGVAR(1,261,"sbr_grid(): bs_abs_bord_0"));
747 bs_abs_bord_1 = (uint8_t)faad_getbits(ld, 2
748 DEBUGVAR(1,262,"sbr_grid(): bs_abs_bord_1")) + sbr->numTimeSlots;
749 sbr->bs_num_rel_0[ch] = (uint8_t)faad_getbits(ld, 2
750 DEBUGVAR(1,263,"sbr_grid(): bs_num_rel_0"));
751 sbr->bs_num_rel_1[ch] = (uint8_t)faad_getbits(ld, 2
752 DEBUGVAR(1,264,"sbr_grid(): bs_num_rel_1"));
754 bs_num_env = min(5, sbr->bs_num_rel_0[ch] + sbr->bs_num_rel_1[ch] + 1);
756 for (rel = 0; rel < sbr->bs_num_rel_0[ch]; rel++)
758 sbr->bs_rel_bord_0[ch][rel] = 2 * (uint8_t)faad_getbits(ld, 2
759 DEBUGVAR(1,265,"sbr_grid(): bs_rel_bord")) + 2;
761 for(rel = 0; rel < sbr->bs_num_rel_1[ch]; rel++)
763 sbr->bs_rel_bord_1[ch][rel] = 2 * (uint8_t)faad_getbits(ld, 2
764 DEBUGVAR(1,266,"sbr_grid(): bs_rel_bord")) + 2;
766 i = sbr_log2(sbr->bs_num_rel_0[ch] + sbr->bs_num_rel_1[ch] + 2);
767 sbr->bs_pointer[ch] = (uint8_t)faad_getbits(ld, i
768 DEBUGVAR(1,267,"sbr_grid(): bs_pointer"));
770 for (env = 0; env < bs_num_env; env++)
772 sbr->f[ch][env] = (uint8_t)faad_get1bit(ld
773 DEBUGVAR(1,268,"sbr_grid(): bs_freq_res"));
776 sbr->abs_bord_lead[ch] = bs_abs_bord;
777 sbr->abs_bord_trail[ch] = bs_abs_bord_1;
778 sbr->n_rel_lead[ch] = sbr->bs_num_rel_0[ch];
779 sbr->n_rel_trail[ch] = sbr->bs_num_rel_1[ch];
783 if (sbr->bs_frame_class[ch] == VARVAR)
784 sbr->L_E[ch] = min(bs_num_env, 5);
786 sbr->L_E[ch] = min(bs_num_env, 4);
788 if (sbr->L_E[ch] <= 0)
791 if (sbr->L_E[ch] > 1)
796 /* TODO: this code can probably be integrated into the code above! */
797 if ((result = envelope_time_border_vector(sbr, ch)) > 0)
799 sbr->bs_frame_class[ch] = saved_frame_class;
800 sbr->L_E[ch] = saved_L_E;
801 sbr->L_Q[ch] = saved_L_Q;
804 noise_floor_time_border_vector(sbr, ch);
807 for (env = 0; env < bs_num_env; env++)
809 printf("freq_res[ch:%d][env:%d]: %d\n", ch, env, sbr->f[ch][env]);
817 static void sbr_dtdf(bitfile *ld, sbr_info *sbr, uint8_t ch)
821 for (i = 0; i < sbr->L_E[ch]; i++)
823 sbr->bs_df_env[ch][i] = faad_get1bit(ld
824 DEBUGVAR(1,269,"sbr_dtdf(): bs_df_env"));
827 for (i = 0; i < sbr->L_Q[ch]; i++)
829 sbr->bs_df_noise[ch][i] = faad_get1bit(ld
830 DEBUGVAR(1,270,"sbr_dtdf(): bs_df_noise"));
835 static void invf_mode(bitfile *ld, sbr_info *sbr, uint8_t ch)
839 for (n = 0; n < sbr->N_Q; n++)
841 sbr->bs_invf_mode[ch][n] = (uint8_t)faad_getbits(ld, 2
842 DEBUGVAR(1,271,"invf_mode(): bs_invf_mode"));
846 static uint16_t sbr_extension(bitfile *ld, sbr_info *sbr,
847 uint8_t bs_extension_id, uint16_t num_bits_left)
854 switch (bs_extension_id)
857 case EXTENSION_ID_PS:
860 sbr->ps = ps_init(get_sr_index(sbr->sample_rate), sbr->numTimeSlotsRate);
862 if (sbr->psResetFlag)
864 sbr->ps->header_read = 0;
866 ret = ps_data(sbr->ps, ld, &header);
868 /* enable PS if and only if: a header has been decoded */
869 if (sbr->ps_used == 0 && header == 1)
876 sbr->psResetFlag = 0;
882 case DRM_PARAMETRIC_STEREO:
886 sbr->drm_ps = drm_ps_init();
888 return drm_ps_data(sbr->drm_ps, ld);
891 sbr->bs_extension_data = (uint8_t)faad_getbits(ld, 6
892 DEBUGVAR(1,279,"sbr_single_channel_element(): bs_extension_data"));
898 static void sinusoidal_coding(bitfile *ld, sbr_info *sbr, uint8_t ch)
902 for (n = 0; n < sbr->N_high; n++)
904 sbr->bs_add_harmonic[ch][n] = faad_get1bit(ld
905 DEBUGVAR(1,278,"sinusoidal_coding(): bs_add_harmonic"));