Mercurial > audlegacy

comparison Plugins/Input/aac/libfaad2/sbr_syntax.c @ 1021:1e6c0a3f2d15 trunk

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
[svn] - 2.1 beta
author nenolod
date Wed, 10 May 2006 14:44:20 -0700
parents 29feaace84d0
children f12d7e208b43
comparison
equal deleted inserted replaced
1020:d70514b3b436 1021:1e6c0a3f2d15
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.25 2004/01/29 11:31:11 menno Exp $ 25 ** $Id: sbr_syntax.c,v 1.34 2004/09/04 14:56:28 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);
50 static uint8_t sbr_data(bitfile *ld, sbr_info *sbr); 53 static uint8_t sbr_data(bitfile *ld, sbr_info *sbr);
51 static uint16_t sbr_extension(bitfile *ld, sbr_info *sbr, 54 static uint16_t sbr_extension(bitfile *ld, sbr_info *sbr,
52 uint8_t bs_extension_id, uint16_t num_bits_left); 55 uint8_t bs_extension_id, uint16_t num_bits_left);
53 static uint8_t sbr_single_channel_element(bitfile *ld, sbr_info *sbr); 56 static uint8_t sbr_single_channel_element(bitfile *ld, sbr_info *sbr);
54 static uint8_t sbr_channel_pair_element(bitfile *ld, sbr_info *sbr); 57 static uint8_t sbr_channel_pair_element(bitfile *ld, sbr_info *sbr);
71 74
72 /* if these are different from the previous frame: Reset = 1 */ 75 /* if these are different from the previous frame: Reset = 1 */
73 if ((sbr->bs_start_freq != sbr->bs_start_freq_prev) || 76 if ((sbr->bs_start_freq != sbr->bs_start_freq_prev) ||
74 (sbr->bs_stop_freq != sbr->bs_stop_freq_prev) || 77 (sbr->bs_stop_freq != sbr->bs_stop_freq_prev) ||
75 (sbr->bs_freq_scale != sbr->bs_freq_scale_prev) || 78 (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) ||
86 (sbr->bs_alter_scale != sbr->bs_alter_scale_prev) || 79 (sbr->bs_alter_scale != sbr->bs_alter_scale_prev) ||
87 (sbr->bs_xover_band != sbr->bs_xover_band_prev) || 80 (sbr->bs_xover_band != sbr->bs_xover_band_prev) ||
88 (sbr->bs_noise_bands != sbr->bs_noise_bands_prev)) 81 (sbr->bs_noise_bands != sbr->bs_noise_bands_prev))
89 { 82 {
90 sbr->Reset = 1; 83 sbr->Reset = 1;
96 sbr->bs_stop_freq_prev = sbr->bs_stop_freq; 89 sbr->bs_stop_freq_prev = sbr->bs_stop_freq;
97 sbr->bs_freq_scale_prev = sbr->bs_freq_scale; 90 sbr->bs_freq_scale_prev = sbr->bs_freq_scale;
98 sbr->bs_alter_scale_prev = sbr->bs_alter_scale; 91 sbr->bs_alter_scale_prev = sbr->bs_alter_scale;
99 sbr->bs_xover_band_prev = sbr->bs_xover_band; 92 sbr->bs_xover_band_prev = sbr->bs_xover_band;
100 sbr->bs_noise_bands_prev = sbr->bs_noise_bands; 93 sbr->bs_noise_bands_prev = sbr->bs_noise_bands;
101 94 }
102 if (sbr->frame == 0) 95
103 { 96 static uint8_t calc_sbr_tables(sbr_info *sbr, uint8_t start_freq, uint8_t stop_freq,
104 sbr->Reset = 1; 97 uint8_t samplerate_mode, uint8_t freq_scale,
105 } 98 uint8_t alter_scale, uint8_t xover_band)
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;
106 } 131 }
107 132
108 /* table 2 */ 133 /* table 2 */
109 uint8_t sbr_extension_data(bitfile *ld, sbr_info *sbr, uint16_t cnt) 134 uint8_t sbr_extension_data(bitfile *ld, sbr_info *sbr, uint16_t cnt)
110 { 135 {
111 uint8_t result = 0; 136 uint8_t result = 0;
112 uint16_t num_align_bits = 0; 137 uint16_t num_align_bits = 0;
113 uint16_t num_sbr_bits = (uint16_t)faad_get_processed_bits(ld); 138 uint16_t num_sbr_bits = (uint16_t)faad_get_processed_bits(ld);
114 139
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
115 #ifdef DRM 144 #ifdef DRM
116 if (!sbr->Is_DRM_SBR) 145 if (!sbr->Is_DRM_SBR)
117 #endif 146 #endif
118 { 147 {
119 uint8_t bs_extension_type = (uint8_t)faad_getbits(ld, 4 148 uint8_t bs_extension_type = (uint8_t)faad_getbits(ld, 4
123 { 152 {
124 sbr->bs_sbr_crc_bits = (uint16_t)faad_getbits(ld, 10 153 sbr->bs_sbr_crc_bits = (uint16_t)faad_getbits(ld, 10
125 DEBUGVAR(1,199,"sbr_bitstream(): bs_sbr_crc_bits")); 154 DEBUGVAR(1,199,"sbr_bitstream(): bs_sbr_crc_bits"));
126 } 155 }
127 } 156 }
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;
128 165
129 sbr->bs_header_flag = faad_get1bit(ld 166 sbr->bs_header_flag = faad_get1bit(ld
130 DEBUGVAR(1,200,"sbr_bitstream(): bs_header_flag")); 167 DEBUGVAR(1,200,"sbr_bitstream(): bs_header_flag"));
131 168
132 if (sbr->bs_header_flag) 169 if (sbr->bs_header_flag)
139 //if (!(sbr->frame == 0 && sbr->bs_header_flag == 0)) 176 //if (!(sbr->frame == 0 && sbr->bs_header_flag == 0))
140 if (sbr->header_count != 0) 177 if (sbr->header_count != 0)
141 { 178 {
142 if (sbr->Reset || (sbr->bs_header_flag && sbr->just_seeked)) 179 if (sbr->Reset || (sbr->bs_header_flag && sbr->just_seeked))
143 { 180 {
144 uint8_t k2; 181 uint8_t rt = calc_sbr_tables(sbr, sbr->bs_start_freq, sbr->bs_stop_freq,
145 182 sbr->bs_samplerate_mode, sbr->bs_freq_scale,
146 /* calculate the Master Frequency Table */ 183 sbr->bs_alter_scale, sbr->bs_xover_band);
147 sbr->k0 = qmf_start_channel(sbr->bs_start_freq, sbr->bs_samplerate_mode, 184
148 sbr->sample_rate); 185 /* if an error occured with the new header values revert to the old ones */
149 k2 = qmf_stop_channel(sbr->bs_stop_freq, sbr->sample_rate, sbr->k0); 186 if (rt > 0)
150
151 /* check k0 and k2 */
152 if (sbr->sample_rate >= 48000)
153 { 187 {
154 if ((k2 - sbr->k0) > 32) 188 calc_sbr_tables(sbr, saved_start_freq, saved_stop_freq,
155 result += 1; 189 saved_samplerate_mode, saved_freq_scale,
156 } else if (sbr->sample_rate <= 32000) { 190 saved_alter_scale, saved_xover_band);
157 if ((k2 - sbr->k0) > 48)
158 result += 1;
159 } else { /* (sbr->sample_rate == 44100) */
160 if ((k2 - sbr->k0) > 45)
161 result += 1;
162 } 191 }
163 192 }
164 if (sbr->bs_freq_scale == 0) 193
194 if (result == 0)
195 {
196 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)))
165 { 206 {
166 result += master_frequency_table_fs0(sbr, sbr->k0, k2, 207 calc_sbr_tables(sbr, saved_start_freq, saved_stop_freq,
167 sbr->bs_alter_scale); 208 saved_samplerate_mode, saved_freq_scale,
168 } else { 209 saved_alter_scale, saved_xover_band);
169 result += master_frequency_table(sbr, sbr->k0, k2, sbr->bs_freq_scale,
170 sbr->bs_alter_scale);
171 } 210 }
172 result += derived_frequency_table(sbr, sbr->bs_xover_band, k2); 211
173 212 /* we should be able to safely set result to 0 now */
174 result = (result > 0) ? 1 : 0; 213 result = 0;
175 } 214 }
176
177 if (result == 0)
178 result = sbr_data(ld, sbr);
179 } else { 215 } else {
180 result = 1; 216 result = 1;
181 } 217 }
182 218
183 #ifdef DRM 219 #ifdef DRM
184 if (!sbr->Is_DRM_SBR) 220 if (!sbr->Is_DRM_SBR)
185 #endif 221 #endif
186 { 222 {
187 num_sbr_bits = (uint16_t)faad_get_processed_bits(ld) - num_sbr_bits; 223 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
188 /* -4 does not apply, bs_extension_type is re-read in this function */ 229 /* -4 does not apply, bs_extension_type is re-read in this function */
189 num_align_bits = 8*cnt /*- 4*/ - num_sbr_bits; 230 num_align_bits = 8*cnt /*- 4*/ - num_sbr_bits;
190 231
191 while (num_align_bits > 7) 232 while (num_align_bits > 7)
192 { 233 {
331 sbr_dtdf(ld, sbr, 0); 372 sbr_dtdf(ld, sbr, 0);
332 invf_mode(ld, sbr, 0); 373 invf_mode(ld, sbr, 0);
333 sbr_envelope(ld, sbr, 0); 374 sbr_envelope(ld, sbr, 0);
334 sbr_noise(ld, sbr, 0); 375 sbr_noise(ld, sbr, 0);
335 376
377 #ifndef FIXED_POINT
336 envelope_noise_dequantisation(sbr, 0); 378 envelope_noise_dequantisation(sbr, 0);
379 #endif
337 380
338 memset(sbr->bs_add_harmonic[0], 0, 64*sizeof(uint8_t)); 381 memset(sbr->bs_add_harmonic[0], 0, 64*sizeof(uint8_t));
339 382
340 sbr->bs_add_harmonic_flag[0] = faad_get1bit(ld 383 sbr->bs_add_harmonic_flag[0] = faad_get1bit(ld
341 DEBUGVAR(1,223,"sbr_single_channel_element(): bs_add_harmonic_flag[0]")); 384 DEBUGVAR(1,223,"sbr_single_channel_element(): bs_add_harmonic_flag[0]"));
342 if (sbr->bs_add_harmonic_flag[0]) 385 if (sbr->bs_add_harmonic_flag[0])
343 sinusoidal_coding(ld, sbr, 0); 386 sinusoidal_coding(ld, sbr, 0);
344 387
345 sbr->bs_extended_data = faad_get1bit(ld 388 sbr->bs_extended_data = faad_get1bit(ld
346 DEBUGVAR(1,224,"sbr_single_channel_element(): bs_extended_data[0]")); 389 DEBUGVAR(1,224,"sbr_single_channel_element(): bs_extended_data[0]"));
390
347 if (sbr->bs_extended_data) 391 if (sbr->bs_extended_data)
348 { 392 {
349 uint16_t nr_bits_left; 393 uint16_t nr_bits_left;
394 #if (defined(PS_DEC) || defined(DRM_PS))
395 uint8_t ps_ext_read = 0;
396 #endif
350 uint16_t cnt = (uint16_t)faad_getbits(ld, 4 397 uint16_t cnt = (uint16_t)faad_getbits(ld, 4
351 DEBUGVAR(1,225,"sbr_single_channel_element(): bs_extension_size")); 398 DEBUGVAR(1,225,"sbr_single_channel_element(): bs_extension_size"));
352 if (cnt == 15) 399 if (cnt == 15)
353 { 400 {
354 cnt += (uint16_t)faad_getbits(ld, 8 401 cnt += (uint16_t)faad_getbits(ld, 8
356 } 403 }
357 404
358 nr_bits_left = 8 * cnt; 405 nr_bits_left = 8 * cnt;
359 while (nr_bits_left > 7) 406 while (nr_bits_left > 7)
360 { 407 {
408 uint16_t tmp_nr_bits = 0;
409
361 sbr->bs_extension_id = (uint8_t)faad_getbits(ld, 2 410 sbr->bs_extension_id = (uint8_t)faad_getbits(ld, 2
362 DEBUGVAR(1,227,"sbr_single_channel_element(): bs_extension_id")); 411 DEBUGVAR(1,227,"sbr_single_channel_element(): bs_extension_id"));
363 nr_bits_left -= 2; 412 tmp_nr_bits += 2;
364 nr_bits_left -= sbr_extension(ld, sbr, sbr->bs_extension_id, nr_bits_left); 413
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;
365 } 446 }
366 447
367 /* Corrigendum */ 448 /* Corrigendum */
368 if (nr_bits_left > 0) 449 if (nr_bits_left > 0)
369 { 450 {
435 sbr->bs_add_harmonic_flag[1] = faad_get1bit(ld 516 sbr->bs_add_harmonic_flag[1] = faad_get1bit(ld
436 DEBUGVAR(1,232,"sbr_channel_pair_element(): bs_add_harmonic_flag[1]")); 517 DEBUGVAR(1,232,"sbr_channel_pair_element(): bs_add_harmonic_flag[1]"));
437 if (sbr->bs_add_harmonic_flag[1]) 518 if (sbr->bs_add_harmonic_flag[1])
438 sinusoidal_coding(ld, sbr, 1); 519 sinusoidal_coding(ld, sbr, 1);
439 } else { 520 } 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
440 if ((result = sbr_grid(ld, sbr, 0)) > 0) 531 if ((result = sbr_grid(ld, sbr, 0)) > 0)
441 return result; 532 return result;
442 if ((result = sbr_grid(ld, sbr, 1)) > 0) 533 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
443 return result; 544 return result;
545 }
444 sbr_dtdf(ld, sbr, 0); 546 sbr_dtdf(ld, sbr, 0);
445 sbr_dtdf(ld, sbr, 1); 547 sbr_dtdf(ld, sbr, 1);
446 invf_mode(ld, sbr, 0); 548 invf_mode(ld, sbr, 0);
447 invf_mode(ld, sbr, 1); 549 invf_mode(ld, sbr, 1);
448 sbr_envelope(ld, sbr, 0); 550 sbr_envelope(ld, sbr, 0);
461 sbr->bs_add_harmonic_flag[1] = faad_get1bit(ld 563 sbr->bs_add_harmonic_flag[1] = faad_get1bit(ld
462 DEBUGVAR(1,240,"sbr_channel_pair_element(): bs_add_harmonic_flag[1]")); 564 DEBUGVAR(1,240,"sbr_channel_pair_element(): bs_add_harmonic_flag[1]"));
463 if (sbr->bs_add_harmonic_flag[1]) 565 if (sbr->bs_add_harmonic_flag[1])
464 sinusoidal_coding(ld, sbr, 1); 566 sinusoidal_coding(ld, sbr, 1);
465 } 567 }
568 #ifndef FIXED_POINT
466 envelope_noise_dequantisation(sbr, 0); 569 envelope_noise_dequantisation(sbr, 0);
467 envelope_noise_dequantisation(sbr, 1); 570 envelope_noise_dequantisation(sbr, 1);
468 571
469 if (sbr->bs_coupling) 572 if (sbr->bs_coupling)
470 unmap_envelope_noise(sbr); 573 unmap_envelope_noise(sbr);
574 #endif
471 575
472 sbr->bs_extended_data = faad_get1bit(ld 576 sbr->bs_extended_data = faad_get1bit(ld
473 DEBUGVAR(1,233,"sbr_channel_pair_element(): bs_extended_data[0]")); 577 DEBUGVAR(1,233,"sbr_channel_pair_element(): bs_extended_data[0]"));
474 if (sbr->bs_extended_data) 578 if (sbr->bs_extended_data)
475 { 579 {
483 } 587 }
484 588
485 nr_bits_left = 8 * cnt; 589 nr_bits_left = 8 * cnt;
486 while (nr_bits_left > 7) 590 while (nr_bits_left > 7)
487 { 591 {
592 uint16_t tmp_nr_bits = 0;
593
488 sbr->bs_extension_id = (uint8_t)faad_getbits(ld, 2 594 sbr->bs_extension_id = (uint8_t)faad_getbits(ld, 2
489 DEBUGVAR(1,236,"sbr_channel_pair_element(): bs_extension_id")); 595 DEBUGVAR(1,236,"sbr_channel_pair_element(): bs_extension_id"));
490 nr_bits_left -= 2; 596 tmp_nr_bits += 2;
491 sbr_extension(ld, sbr, sbr->bs_extension_id, nr_bits_left); 597 tmp_nr_bits += 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;
492 } 604 }
493 605
494 /* Corrigendum */ 606 /* Corrigendum */
495 if (nr_bits_left > 0) 607 if (nr_bits_left > 0)
496 { 608 {
517 static uint8_t sbr_grid(bitfile *ld, sbr_info *sbr, uint8_t ch) 629 static uint8_t sbr_grid(bitfile *ld, sbr_info *sbr, uint8_t ch)
518 { 630 {
519 uint8_t i, env, rel, result; 631 uint8_t i, env, rel, result;
520 uint8_t bs_abs_bord, bs_abs_bord_1; 632 uint8_t bs_abs_bord, bs_abs_bord_1;
521 uint8_t bs_num_env = 0; 633 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];
522 637
523 sbr->bs_frame_class[ch] = (uint8_t)faad_getbits(ld, 2 638 sbr->bs_frame_class[ch] = (uint8_t)faad_getbits(ld, 2
524 DEBUGVAR(1,248,"sbr_grid(): bs_frame_class")); 639 DEBUGVAR(1,248,"sbr_grid(): bs_frame_class"));
525 640
526 switch (sbr->bs_frame_class[ch]) 641 switch (sbr->bs_frame_class[ch])
648 else 763 else
649 sbr->L_Q[ch] = 1; 764 sbr->L_Q[ch] = 1;
650 765
651 /* TODO: this code can probably be integrated into the code above! */ 766 /* TODO: this code can probably be integrated into the code above! */
652 if ((result = envelope_time_border_vector(sbr, ch)) > 0) 767 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;
653 return result; 772 return result;
773 }
654 noise_floor_time_border_vector(sbr, ch); 774 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
655 782
656 return 0; 783 return 0;
657 } 784 }
658 785
659 /* table 8 */ 786 /* table 8 */
687 } 814 }
688 815
689 static uint16_t sbr_extension(bitfile *ld, sbr_info *sbr, 816 static uint16_t sbr_extension(bitfile *ld, sbr_info *sbr,
690 uint8_t bs_extension_id, uint16_t num_bits_left) 817 uint8_t bs_extension_id, uint16_t num_bits_left)
691 { 818 {
819 #ifdef PS_DEC
820 uint8_t header;
821 uint16_t ret;
822 #endif
823
692 switch (bs_extension_id) 824 switch (bs_extension_id)
693 { 825 {
694 #ifdef PS_DEC 826 #ifdef PS_DEC
695 case EXTENSION_ID_PS: 827 case EXTENSION_ID_PS:
696 sbr->ps_used = 1; 828 if (!sbr->ps)
697 return ps_data(&(sbr->ps), ld); 829 {
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;
698 #endif 841 #endif
699 #ifdef DRM_PS 842 #ifdef DRM_PS
700 case DRM_PARAMETRIC_STEREO: 843 case DRM_PARAMETRIC_STEREO:
701 sbr->ps_used = 1; 844 sbr->ps_used = 1;
702 return drm_ps_data(&(sbr->drm_ps), ld); 845 if (!sbr->drm_ps)
846 {
847 sbr->drm_ps = drm_ps_init();
848 }
849 return drm_ps_data(sbr->drm_ps, ld);
703 #endif 850 #endif
704 default: 851 default:
705 sbr->bs_extension_data = (uint8_t)faad_getbits(ld, 6 852 sbr->bs_extension_data = (uint8_t)faad_getbits(ld, 6
706 DEBUGVAR(1,279,"sbr_single_channel_element(): bs_extension_data")); 853 DEBUGVAR(1,279,"sbr_single_channel_element(): bs_extension_data"));
707 return 6; 854 return 6;