Mercurial > audlegacy
comparison Plugins/Input/aac/libfaad2/sbr_syntax.c @ 1010:29feaace84d0 trunk
[svn] - synchronize audacious-faad with FAAD2 CVS.
author | nenolod |
---|---|
date | Mon, 08 May 2006 06:56:47 -0700 |
parents | 0a2ad94e8607 |
children | 1e6c0a3f2d15 |
comparison
equal
deleted
inserted
replaced
1009:1008da26c12d | 1010:29feaace84d0 |
---|---|
20 ** forbidden. | 20 ** forbidden. |
21 ** | 21 ** |
22 ** Commercial non-GPL licensing of this software is possible. | 22 ** Commercial non-GPL licensing of this software is possible. |
23 ** For more info contact Ahead Software through Mpeg4AAClicense@nero.com. | 23 ** For more info contact Ahead Software through Mpeg4AAClicense@nero.com. |
24 ** | 24 ** |
25 ** $Id: sbr_syntax.c,v 1.34 2004/09/04 14:56:28 menno Exp $ | 25 ** $Id: sbr_syntax.c,v 1.25 2004/01/29 11:31:11 menno Exp $ |
26 **/ | 26 **/ |
27 | 27 |
28 #include "common.h" | 28 #include "common.h" |
29 #include "structs.h" | 29 #include "structs.h" |
30 | 30 |
45 #endif | 45 #endif |
46 #include "analysis.h" | 46 #include "analysis.h" |
47 | 47 |
48 /* static function declarations */ | 48 /* static function declarations */ |
49 static void sbr_header(bitfile *ld, sbr_info *sbr); | 49 static void sbr_header(bitfile *ld, sbr_info *sbr); |
50 static uint8_t calc_sbr_tables(sbr_info *sbr, uint8_t start_freq, uint8_t stop_freq, | |
51 uint8_t samplerate_mode, uint8_t freq_scale, | |
52 uint8_t alter_scale, uint8_t xover_band); | |
53 static uint8_t sbr_data(bitfile *ld, sbr_info *sbr); | 50 static uint8_t sbr_data(bitfile *ld, sbr_info *sbr); |
54 static uint16_t sbr_extension(bitfile *ld, sbr_info *sbr, | 51 static uint16_t sbr_extension(bitfile *ld, sbr_info *sbr, |
55 uint8_t bs_extension_id, uint16_t num_bits_left); | 52 uint8_t bs_extension_id, uint16_t num_bits_left); |
56 static uint8_t sbr_single_channel_element(bitfile *ld, sbr_info *sbr); | 53 static uint8_t sbr_single_channel_element(bitfile *ld, sbr_info *sbr); |
57 static uint8_t sbr_channel_pair_element(bitfile *ld, sbr_info *sbr); | 54 static uint8_t sbr_channel_pair_element(bitfile *ld, sbr_info *sbr); |
74 | 71 |
75 /* if these are different from the previous frame: Reset = 1 */ | 72 /* if these are different from the previous frame: Reset = 1 */ |
76 if ((sbr->bs_start_freq != sbr->bs_start_freq_prev) || | 73 if ((sbr->bs_start_freq != sbr->bs_start_freq_prev) || |
77 (sbr->bs_stop_freq != sbr->bs_stop_freq_prev) || | 74 (sbr->bs_stop_freq != sbr->bs_stop_freq_prev) || |
78 (sbr->bs_freq_scale != sbr->bs_freq_scale_prev) || | 75 (sbr->bs_freq_scale != sbr->bs_freq_scale_prev) || |
76 (sbr->bs_alter_scale != sbr->bs_alter_scale_prev)) | |
77 { | |
78 sbr->Reset = 1; | |
79 } else { | |
80 sbr->Reset = 0; | |
81 } | |
82 | |
83 if ((sbr->bs_start_freq != sbr->bs_start_freq_prev) || | |
84 (sbr->bs_stop_freq != sbr->bs_stop_freq_prev) || | |
85 (sbr->bs_freq_scale != sbr->bs_freq_scale_prev) || | |
79 (sbr->bs_alter_scale != sbr->bs_alter_scale_prev) || | 86 (sbr->bs_alter_scale != sbr->bs_alter_scale_prev) || |
80 (sbr->bs_xover_band != sbr->bs_xover_band_prev) || | 87 (sbr->bs_xover_band != sbr->bs_xover_band_prev) || |
81 (sbr->bs_noise_bands != sbr->bs_noise_bands_prev)) | 88 (sbr->bs_noise_bands != sbr->bs_noise_bands_prev)) |
82 { | 89 { |
83 sbr->Reset = 1; | 90 sbr->Reset = 1; |
89 sbr->bs_stop_freq_prev = sbr->bs_stop_freq; | 96 sbr->bs_stop_freq_prev = sbr->bs_stop_freq; |
90 sbr->bs_freq_scale_prev = sbr->bs_freq_scale; | 97 sbr->bs_freq_scale_prev = sbr->bs_freq_scale; |
91 sbr->bs_alter_scale_prev = sbr->bs_alter_scale; | 98 sbr->bs_alter_scale_prev = sbr->bs_alter_scale; |
92 sbr->bs_xover_band_prev = sbr->bs_xover_band; | 99 sbr->bs_xover_band_prev = sbr->bs_xover_band; |
93 sbr->bs_noise_bands_prev = sbr->bs_noise_bands; | 100 sbr->bs_noise_bands_prev = sbr->bs_noise_bands; |
94 } | 101 |
95 | 102 if (sbr->frame == 0) |
96 static uint8_t calc_sbr_tables(sbr_info *sbr, uint8_t start_freq, uint8_t stop_freq, | 103 { |
97 uint8_t samplerate_mode, uint8_t freq_scale, | 104 sbr->Reset = 1; |
98 uint8_t alter_scale, uint8_t xover_band) | 105 } |
99 { | |
100 uint8_t result = 0; | |
101 uint8_t k2; | |
102 | |
103 /* calculate the Master Frequency Table */ | |
104 sbr->k0 = qmf_start_channel(start_freq, samplerate_mode, sbr->sample_rate); | |
105 k2 = qmf_stop_channel(stop_freq, sbr->sample_rate, sbr->k0); | |
106 | |
107 /* check k0 and k2 */ | |
108 if (sbr->sample_rate >= 48000) | |
109 { | |
110 if ((k2 - sbr->k0) > 32) | |
111 result += 1; | |
112 } else if (sbr->sample_rate <= 32000) { | |
113 if ((k2 - sbr->k0) > 48) | |
114 result += 1; | |
115 } else { /* (sbr->sample_rate == 44100) */ | |
116 if ((k2 - sbr->k0) > 45) | |
117 result += 1; | |
118 } | |
119 | |
120 if (freq_scale == 0) | |
121 { | |
122 result += master_frequency_table_fs0(sbr, sbr->k0, k2, alter_scale); | |
123 } else { | |
124 result += master_frequency_table(sbr, sbr->k0, k2, freq_scale, alter_scale); | |
125 } | |
126 result += derived_frequency_table(sbr, xover_band, k2); | |
127 | |
128 result = (result > 0) ? 1 : 0; | |
129 | |
130 return result; | |
131 } | 106 } |
132 | 107 |
133 /* table 2 */ | 108 /* table 2 */ |
134 uint8_t sbr_extension_data(bitfile *ld, sbr_info *sbr, uint16_t cnt) | 109 uint8_t sbr_extension_data(bitfile *ld, sbr_info *sbr, uint16_t cnt) |
135 { | 110 { |
136 uint8_t result = 0; | 111 uint8_t result = 0; |
137 uint16_t num_align_bits = 0; | 112 uint16_t num_align_bits = 0; |
138 uint16_t num_sbr_bits = (uint16_t)faad_get_processed_bits(ld); | 113 uint16_t num_sbr_bits = (uint16_t)faad_get_processed_bits(ld); |
139 | 114 |
140 uint8_t saved_start_freq, saved_samplerate_mode; | |
141 uint8_t saved_stop_freq, saved_freq_scale; | |
142 uint8_t saved_alter_scale, saved_xover_band; | |
143 | |
144 #ifdef DRM | 115 #ifdef DRM |
145 if (!sbr->Is_DRM_SBR) | 116 if (!sbr->Is_DRM_SBR) |
146 #endif | 117 #endif |
147 { | 118 { |
148 uint8_t bs_extension_type = (uint8_t)faad_getbits(ld, 4 | 119 uint8_t bs_extension_type = (uint8_t)faad_getbits(ld, 4 |
152 { | 123 { |
153 sbr->bs_sbr_crc_bits = (uint16_t)faad_getbits(ld, 10 | 124 sbr->bs_sbr_crc_bits = (uint16_t)faad_getbits(ld, 10 |
154 DEBUGVAR(1,199,"sbr_bitstream(): bs_sbr_crc_bits")); | 125 DEBUGVAR(1,199,"sbr_bitstream(): bs_sbr_crc_bits")); |
155 } | 126 } |
156 } | 127 } |
157 | |
158 /* save old header values, in case the new ones are corrupted */ | |
159 saved_start_freq = sbr->bs_start_freq; | |
160 saved_samplerate_mode = sbr->bs_samplerate_mode; | |
161 saved_stop_freq = sbr->bs_stop_freq; | |
162 saved_freq_scale = sbr->bs_freq_scale; | |
163 saved_alter_scale = sbr->bs_alter_scale; | |
164 saved_xover_band = sbr->bs_xover_band; | |
165 | 128 |
166 sbr->bs_header_flag = faad_get1bit(ld | 129 sbr->bs_header_flag = faad_get1bit(ld |
167 DEBUGVAR(1,200,"sbr_bitstream(): bs_header_flag")); | 130 DEBUGVAR(1,200,"sbr_bitstream(): bs_header_flag")); |
168 | 131 |
169 if (sbr->bs_header_flag) | 132 if (sbr->bs_header_flag) |
176 //if (!(sbr->frame == 0 && sbr->bs_header_flag == 0)) | 139 //if (!(sbr->frame == 0 && sbr->bs_header_flag == 0)) |
177 if (sbr->header_count != 0) | 140 if (sbr->header_count != 0) |
178 { | 141 { |
179 if (sbr->Reset || (sbr->bs_header_flag && sbr->just_seeked)) | 142 if (sbr->Reset || (sbr->bs_header_flag && sbr->just_seeked)) |
180 { | 143 { |
181 uint8_t rt = calc_sbr_tables(sbr, sbr->bs_start_freq, sbr->bs_stop_freq, | 144 uint8_t k2; |
182 sbr->bs_samplerate_mode, sbr->bs_freq_scale, | 145 |
183 sbr->bs_alter_scale, sbr->bs_xover_band); | 146 /* calculate the Master Frequency Table */ |
184 | 147 sbr->k0 = qmf_start_channel(sbr->bs_start_freq, sbr->bs_samplerate_mode, |
185 /* if an error occured with the new header values revert to the old ones */ | 148 sbr->sample_rate); |
186 if (rt > 0) | 149 k2 = qmf_stop_channel(sbr->bs_stop_freq, sbr->sample_rate, sbr->k0); |
150 | |
151 /* check k0 and k2 */ | |
152 if (sbr->sample_rate >= 48000) | |
187 { | 153 { |
188 calc_sbr_tables(sbr, saved_start_freq, saved_stop_freq, | 154 if ((k2 - sbr->k0) > 32) |
189 saved_samplerate_mode, saved_freq_scale, | 155 result += 1; |
190 saved_alter_scale, saved_xover_band); | 156 } else if (sbr->sample_rate <= 32000) { |
157 if ((k2 - sbr->k0) > 48) | |
158 result += 1; | |
159 } else { /* (sbr->sample_rate == 44100) */ | |
160 if ((k2 - sbr->k0) > 45) | |
161 result += 1; | |
191 } | 162 } |
163 | |
164 if (sbr->bs_freq_scale == 0) | |
165 { | |
166 result += master_frequency_table_fs0(sbr, sbr->k0, k2, | |
167 sbr->bs_alter_scale); | |
168 } else { | |
169 result += master_frequency_table(sbr, sbr->k0, k2, sbr->bs_freq_scale, | |
170 sbr->bs_alter_scale); | |
171 } | |
172 result += derived_frequency_table(sbr, sbr->bs_xover_band, k2); | |
173 | |
174 result = (result > 0) ? 1 : 0; | |
192 } | 175 } |
193 | 176 |
194 if (result == 0) | 177 if (result == 0) |
195 { | |
196 result = sbr_data(ld, sbr); | 178 result = sbr_data(ld, sbr); |
197 | |
198 /* sbr_data() returning an error means that there was an error in | |
199 envelope_time_border_vector(). | |
200 In this case the old time border vector is saved and all the previous | |
201 data normally read after sbr_grid() is saved. | |
202 */ | |
203 /* to be on the safe side, calculate old sbr tables in case of error */ | |
204 if ((result > 0) && | |
205 (sbr->Reset || (sbr->bs_header_flag && sbr->just_seeked))) | |
206 { | |
207 calc_sbr_tables(sbr, saved_start_freq, saved_stop_freq, | |
208 saved_samplerate_mode, saved_freq_scale, | |
209 saved_alter_scale, saved_xover_band); | |
210 } | |
211 | |
212 /* we should be able to safely set result to 0 now */ | |
213 result = 0; | |
214 } | |
215 } else { | 179 } else { |
216 result = 1; | 180 result = 1; |
217 } | 181 } |
218 | 182 |
219 #ifdef DRM | 183 #ifdef DRM |
220 if (!sbr->Is_DRM_SBR) | 184 if (!sbr->Is_DRM_SBR) |
221 #endif | 185 #endif |
222 { | 186 { |
223 num_sbr_bits = (uint16_t)faad_get_processed_bits(ld) - num_sbr_bits; | 187 num_sbr_bits = (uint16_t)faad_get_processed_bits(ld) - num_sbr_bits; |
224 | |
225 /* check if we read more bits then were available for sbr */ | |
226 if (8*cnt < num_sbr_bits) | |
227 return 1; | |
228 | |
229 /* -4 does not apply, bs_extension_type is re-read in this function */ | 188 /* -4 does not apply, bs_extension_type is re-read in this function */ |
230 num_align_bits = 8*cnt /*- 4*/ - num_sbr_bits; | 189 num_align_bits = 8*cnt /*- 4*/ - num_sbr_bits; |
231 | 190 |
232 while (num_align_bits > 7) | 191 while (num_align_bits > 7) |
233 { | 192 { |
372 sbr_dtdf(ld, sbr, 0); | 331 sbr_dtdf(ld, sbr, 0); |
373 invf_mode(ld, sbr, 0); | 332 invf_mode(ld, sbr, 0); |
374 sbr_envelope(ld, sbr, 0); | 333 sbr_envelope(ld, sbr, 0); |
375 sbr_noise(ld, sbr, 0); | 334 sbr_noise(ld, sbr, 0); |
376 | 335 |
377 #ifndef FIXED_POINT | |
378 envelope_noise_dequantisation(sbr, 0); | 336 envelope_noise_dequantisation(sbr, 0); |
379 #endif | |
380 | 337 |
381 memset(sbr->bs_add_harmonic[0], 0, 64*sizeof(uint8_t)); | 338 memset(sbr->bs_add_harmonic[0], 0, 64*sizeof(uint8_t)); |
382 | 339 |
383 sbr->bs_add_harmonic_flag[0] = faad_get1bit(ld | 340 sbr->bs_add_harmonic_flag[0] = faad_get1bit(ld |
384 DEBUGVAR(1,223,"sbr_single_channel_element(): bs_add_harmonic_flag[0]")); | 341 DEBUGVAR(1,223,"sbr_single_channel_element(): bs_add_harmonic_flag[0]")); |
385 if (sbr->bs_add_harmonic_flag[0]) | 342 if (sbr->bs_add_harmonic_flag[0]) |
386 sinusoidal_coding(ld, sbr, 0); | 343 sinusoidal_coding(ld, sbr, 0); |
387 | 344 |
388 sbr->bs_extended_data = faad_get1bit(ld | 345 sbr->bs_extended_data = faad_get1bit(ld |
389 DEBUGVAR(1,224,"sbr_single_channel_element(): bs_extended_data[0]")); | 346 DEBUGVAR(1,224,"sbr_single_channel_element(): bs_extended_data[0]")); |
390 | |
391 if (sbr->bs_extended_data) | 347 if (sbr->bs_extended_data) |
392 { | 348 { |
393 uint16_t nr_bits_left; | 349 uint16_t nr_bits_left; |
394 #if (defined(PS_DEC) || defined(DRM_PS)) | |
395 uint8_t ps_ext_read = 0; | |
396 #endif | |
397 uint16_t cnt = (uint16_t)faad_getbits(ld, 4 | 350 uint16_t cnt = (uint16_t)faad_getbits(ld, 4 |
398 DEBUGVAR(1,225,"sbr_single_channel_element(): bs_extension_size")); | 351 DEBUGVAR(1,225,"sbr_single_channel_element(): bs_extension_size")); |
399 if (cnt == 15) | 352 if (cnt == 15) |
400 { | 353 { |
401 cnt += (uint16_t)faad_getbits(ld, 8 | 354 cnt += (uint16_t)faad_getbits(ld, 8 |
403 } | 356 } |
404 | 357 |
405 nr_bits_left = 8 * cnt; | 358 nr_bits_left = 8 * cnt; |
406 while (nr_bits_left > 7) | 359 while (nr_bits_left > 7) |
407 { | 360 { |
408 uint16_t tmp_nr_bits = 0; | |
409 | |
410 sbr->bs_extension_id = (uint8_t)faad_getbits(ld, 2 | 361 sbr->bs_extension_id = (uint8_t)faad_getbits(ld, 2 |
411 DEBUGVAR(1,227,"sbr_single_channel_element(): bs_extension_id")); | 362 DEBUGVAR(1,227,"sbr_single_channel_element(): bs_extension_id")); |
412 tmp_nr_bits += 2; | 363 nr_bits_left -= 2; |
413 | 364 nr_bits_left -= sbr_extension(ld, sbr, sbr->bs_extension_id, nr_bits_left); |
414 /* allow only 1 PS extension element per extension data */ | |
415 #if (defined(PS_DEC) || defined(DRM_PS)) | |
416 #if (defined(PS_DEC) && defined(DRM_PS)) | |
417 if (sbr->bs_extension_id == EXTENSION_ID_PS || sbr->bs_extension_id == DRM_PARAMETRIC_STEREO) | |
418 #else | |
419 #ifdef PS_DEC | |
420 if (sbr->bs_extension_id == EXTENSION_ID_PS) | |
421 #else | |
422 #ifdef DRM_PS | |
423 if (sbr->bs_extension_id == DRM_PARAMETRIC_STEREO) | |
424 #endif | |
425 #endif | |
426 #endif | |
427 { | |
428 if (ps_ext_read == 0) | |
429 { | |
430 ps_ext_read = 1; | |
431 } else { | |
432 /* to be safe make it 3, will switch to "default" | |
433 * in sbr_extension() */ | |
434 sbr->bs_extension_id = 3; | |
435 } | |
436 } | |
437 #endif | |
438 | |
439 tmp_nr_bits += sbr_extension(ld, sbr, sbr->bs_extension_id, nr_bits_left); | |
440 | |
441 /* check if the data read is bigger than the number of available bits */ | |
442 if (tmp_nr_bits > nr_bits_left) | |
443 return 1; | |
444 | |
445 nr_bits_left -= tmp_nr_bits; | |
446 } | 365 } |
447 | 366 |
448 /* Corrigendum */ | 367 /* Corrigendum */ |
449 if (nr_bits_left > 0) | 368 if (nr_bits_left > 0) |
450 { | 369 { |
516 sbr->bs_add_harmonic_flag[1] = faad_get1bit(ld | 435 sbr->bs_add_harmonic_flag[1] = faad_get1bit(ld |
517 DEBUGVAR(1,232,"sbr_channel_pair_element(): bs_add_harmonic_flag[1]")); | 436 DEBUGVAR(1,232,"sbr_channel_pair_element(): bs_add_harmonic_flag[1]")); |
518 if (sbr->bs_add_harmonic_flag[1]) | 437 if (sbr->bs_add_harmonic_flag[1]) |
519 sinusoidal_coding(ld, sbr, 1); | 438 sinusoidal_coding(ld, sbr, 1); |
520 } else { | 439 } else { |
521 uint8_t saved_t_E[6] = {0}, saved_t_Q[3] = {0}; | |
522 uint8_t saved_L_E = sbr->L_E[0]; | |
523 uint8_t saved_L_Q = sbr->L_Q[0]; | |
524 uint8_t saved_frame_class = sbr->bs_frame_class[0]; | |
525 | |
526 for (n = 0; n < saved_L_E; n++) | |
527 saved_t_E[n] = sbr->t_E[0][n]; | |
528 for (n = 0; n < saved_L_Q; n++) | |
529 saved_t_Q[n] = sbr->t_Q[0][n]; | |
530 | |
531 if ((result = sbr_grid(ld, sbr, 0)) > 0) | 440 if ((result = sbr_grid(ld, sbr, 0)) > 0) |
532 return result; | 441 return result; |
533 if ((result = sbr_grid(ld, sbr, 1)) > 0) | 442 if ((result = sbr_grid(ld, sbr, 1)) > 0) |
534 { | |
535 /* restore first channel data as well */ | |
536 sbr->bs_frame_class[0] = saved_frame_class; | |
537 sbr->L_E[0] = saved_L_E; | |
538 sbr->L_Q[0] = saved_L_Q; | |
539 for (n = 0; n < 6; n++) | |
540 sbr->t_E[0][n] = saved_t_E[n]; | |
541 for (n = 0; n < 3; n++) | |
542 sbr->t_Q[0][n] = saved_t_Q[n]; | |
543 | |
544 return result; | 443 return result; |
545 } | |
546 sbr_dtdf(ld, sbr, 0); | 444 sbr_dtdf(ld, sbr, 0); |
547 sbr_dtdf(ld, sbr, 1); | 445 sbr_dtdf(ld, sbr, 1); |
548 invf_mode(ld, sbr, 0); | 446 invf_mode(ld, sbr, 0); |
549 invf_mode(ld, sbr, 1); | 447 invf_mode(ld, sbr, 1); |
550 sbr_envelope(ld, sbr, 0); | 448 sbr_envelope(ld, sbr, 0); |
563 sbr->bs_add_harmonic_flag[1] = faad_get1bit(ld | 461 sbr->bs_add_harmonic_flag[1] = faad_get1bit(ld |
564 DEBUGVAR(1,240,"sbr_channel_pair_element(): bs_add_harmonic_flag[1]")); | 462 DEBUGVAR(1,240,"sbr_channel_pair_element(): bs_add_harmonic_flag[1]")); |
565 if (sbr->bs_add_harmonic_flag[1]) | 463 if (sbr->bs_add_harmonic_flag[1]) |
566 sinusoidal_coding(ld, sbr, 1); | 464 sinusoidal_coding(ld, sbr, 1); |
567 } | 465 } |
568 #ifndef FIXED_POINT | |
569 envelope_noise_dequantisation(sbr, 0); | 466 envelope_noise_dequantisation(sbr, 0); |
570 envelope_noise_dequantisation(sbr, 1); | 467 envelope_noise_dequantisation(sbr, 1); |
571 | 468 |
572 if (sbr->bs_coupling) | 469 if (sbr->bs_coupling) |
573 unmap_envelope_noise(sbr); | 470 unmap_envelope_noise(sbr); |
574 #endif | |
575 | 471 |
576 sbr->bs_extended_data = faad_get1bit(ld | 472 sbr->bs_extended_data = faad_get1bit(ld |
577 DEBUGVAR(1,233,"sbr_channel_pair_element(): bs_extended_data[0]")); | 473 DEBUGVAR(1,233,"sbr_channel_pair_element(): bs_extended_data[0]")); |
578 if (sbr->bs_extended_data) | 474 if (sbr->bs_extended_data) |
579 { | 475 { |
587 } | 483 } |
588 | 484 |
589 nr_bits_left = 8 * cnt; | 485 nr_bits_left = 8 * cnt; |
590 while (nr_bits_left > 7) | 486 while (nr_bits_left > 7) |
591 { | 487 { |
592 uint16_t tmp_nr_bits = 0; | |
593 | |
594 sbr->bs_extension_id = (uint8_t)faad_getbits(ld, 2 | 488 sbr->bs_extension_id = (uint8_t)faad_getbits(ld, 2 |
595 DEBUGVAR(1,236,"sbr_channel_pair_element(): bs_extension_id")); | 489 DEBUGVAR(1,236,"sbr_channel_pair_element(): bs_extension_id")); |
596 tmp_nr_bits += 2; | 490 nr_bits_left -= 2; |
597 tmp_nr_bits += sbr_extension(ld, sbr, sbr->bs_extension_id, nr_bits_left); | 491 sbr_extension(ld, sbr, sbr->bs_extension_id, nr_bits_left); |
598 | |
599 /* check if the data read is bigger than the number of available bits */ | |
600 if (tmp_nr_bits > nr_bits_left) | |
601 return 1; | |
602 | |
603 nr_bits_left -= tmp_nr_bits; | |
604 } | 492 } |
605 | 493 |
606 /* Corrigendum */ | 494 /* Corrigendum */ |
607 if (nr_bits_left > 0) | 495 if (nr_bits_left > 0) |
608 { | 496 { |
629 static uint8_t sbr_grid(bitfile *ld, sbr_info *sbr, uint8_t ch) | 517 static uint8_t sbr_grid(bitfile *ld, sbr_info *sbr, uint8_t ch) |
630 { | 518 { |
631 uint8_t i, env, rel, result; | 519 uint8_t i, env, rel, result; |
632 uint8_t bs_abs_bord, bs_abs_bord_1; | 520 uint8_t bs_abs_bord, bs_abs_bord_1; |
633 uint8_t bs_num_env = 0; | 521 uint8_t bs_num_env = 0; |
634 uint8_t saved_L_E = sbr->L_E[ch]; | |
635 uint8_t saved_L_Q = sbr->L_Q[ch]; | |
636 uint8_t saved_frame_class = sbr->bs_frame_class[ch]; | |
637 | 522 |
638 sbr->bs_frame_class[ch] = (uint8_t)faad_getbits(ld, 2 | 523 sbr->bs_frame_class[ch] = (uint8_t)faad_getbits(ld, 2 |
639 DEBUGVAR(1,248,"sbr_grid(): bs_frame_class")); | 524 DEBUGVAR(1,248,"sbr_grid(): bs_frame_class")); |
640 | 525 |
641 switch (sbr->bs_frame_class[ch]) | 526 switch (sbr->bs_frame_class[ch]) |
763 else | 648 else |
764 sbr->L_Q[ch] = 1; | 649 sbr->L_Q[ch] = 1; |
765 | 650 |
766 /* TODO: this code can probably be integrated into the code above! */ | 651 /* TODO: this code can probably be integrated into the code above! */ |
767 if ((result = envelope_time_border_vector(sbr, ch)) > 0) | 652 if ((result = envelope_time_border_vector(sbr, ch)) > 0) |
768 { | |
769 sbr->bs_frame_class[ch] = saved_frame_class; | |
770 sbr->L_E[ch] = saved_L_E; | |
771 sbr->L_Q[ch] = saved_L_Q; | |
772 return result; | 653 return result; |
773 } | |
774 noise_floor_time_border_vector(sbr, ch); | 654 noise_floor_time_border_vector(sbr, ch); |
775 | |
776 #if 0 | |
777 for (env = 0; env < bs_num_env; env++) | |
778 { | |
779 printf("freq_res[ch:%d][env:%d]: %d\n", ch, env, sbr->f[ch][env]); | |
780 } | |
781 #endif | |
782 | 655 |
783 return 0; | 656 return 0; |
784 } | 657 } |
785 | 658 |
786 /* table 8 */ | 659 /* table 8 */ |
814 } | 687 } |
815 | 688 |
816 static uint16_t sbr_extension(bitfile *ld, sbr_info *sbr, | 689 static uint16_t sbr_extension(bitfile *ld, sbr_info *sbr, |
817 uint8_t bs_extension_id, uint16_t num_bits_left) | 690 uint8_t bs_extension_id, uint16_t num_bits_left) |
818 { | 691 { |
819 #ifdef PS_DEC | |
820 uint8_t header; | |
821 uint16_t ret; | |
822 #endif | |
823 | |
824 switch (bs_extension_id) | 692 switch (bs_extension_id) |
825 { | 693 { |
826 #ifdef PS_DEC | 694 #ifdef PS_DEC |
827 case EXTENSION_ID_PS: | 695 case EXTENSION_ID_PS: |
828 if (!sbr->ps) | 696 sbr->ps_used = 1; |
829 { | 697 return ps_data(&(sbr->ps), ld); |
830 sbr->ps = ps_init(get_sr_index(sbr->sample_rate)); | |
831 } | |
832 ret = ps_data(sbr->ps, ld, &header); | |
833 | |
834 /* enable PS if and only if: a header has been decoded */ | |
835 if (sbr->ps_used == 0 && header == 1) | |
836 { | |
837 sbr->ps_used = 1; | |
838 } | |
839 | |
840 return ret; | |
841 #endif | 698 #endif |
842 #ifdef DRM_PS | 699 #ifdef DRM_PS |
843 case DRM_PARAMETRIC_STEREO: | 700 case DRM_PARAMETRIC_STEREO: |
844 sbr->ps_used = 1; | 701 sbr->ps_used = 1; |
845 if (!sbr->drm_ps) | 702 return drm_ps_data(&(sbr->drm_ps), ld); |
846 { | |
847 sbr->drm_ps = drm_ps_init(); | |
848 } | |
849 return drm_ps_data(sbr->drm_ps, ld); | |
850 #endif | 703 #endif |
851 default: | 704 default: |
852 sbr->bs_extension_data = (uint8_t)faad_getbits(ld, 6 | 705 sbr->bs_extension_data = (uint8_t)faad_getbits(ld, 6 |
853 DEBUGVAR(1,279,"sbr_single_channel_element(): bs_extension_data")); | 706 DEBUGVAR(1,279,"sbr_single_channel_element(): bs_extension_data")); |
854 return 6; | 707 return 6; |