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