src/lib/doslib/ext/faad/sbr_synt.c

   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 "common.h"
  32 #include "structs.h"
  33
  34 #ifdef SBR_DEC
  35
  36 #include "sbr_synt.h"
  37 #include "syntax.h"
  38 #include "sbr_huff.h"
  39 #include "sbr_fbt.h"
  40 #include "sbr_tfgr.h"
  41 #include "sbr_e_nf.h"
  42 #include "bits.h"
  43 #ifdef PS_DEC
  44 #include "ps_dec.h"
  45 #endif
  46 #ifdef DRM_PS
  47 #include "drm_dec.h"
  48 #endif
  49 #include "analysis.h"
  50
  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);
  66
  67
  68 static void sbr_reset(sbr_info *sbr)
  69 {
  70 #if 0
  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);
  77 #endif
  78
  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))
  86     {
  87         sbr->Reset = 1;
  88     } else {
  89         sbr->Reset = 0;
  90     }
  91
  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;
  98 }
  99
 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)
 103 {
 104     uint8_t result = 0;
 105     uint8_t k2;
 106
 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);
 110
 111     /* check k0 and k2 */
 112     if (sbr->sample_rate >= 48000)
 113     {
 114         if ((k2 - sbr->k0) > 32)
 115             result += 1;
 116     } else if (sbr->sample_rate <= 32000) {
 117         if ((k2 - sbr->k0) > 48)
 118             result += 1;
 119     } else { /* (sbr->sample_rate == 44100) */
 120         if ((k2 - sbr->k0) > 45)
 121             result += 1;
 122     }
 123
 124     if (freq_scale == 0)
 125     {
 126         result += master_frequency_table_fs0(sbr, sbr->k0, k2, alter_scale);
 127     } else {
 128         result += master_frequency_table(sbr, sbr->k0, k2, freq_scale, alter_scale);
 129     }
 130     result += derived_frequency_table(sbr, xover_band, k2);
 131
 132     result = (result > 0) ? 1 : 0;
 133
 134     return result;
 135 }
 136
 137 /* table 2 */
 138 uint8_t sbr_extension_data(bitfile *ld, sbr_info *sbr, uint16_t cnt,
 139                            uint8_t psResetFlag)
 140 {
 141     uint8_t result = 0;
 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;
 145
 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;
 149
 150 #if (defined(PS_DEC) || defined(DRM_PS))
 151     if (psResetFlag)
 152         sbr->psResetFlag = psResetFlag;
 153 #endif
 154
 155 #ifdef DRM
 156     if (!sbr->Is_DRM_SBR)
 157 #endif
 158     {
 159         uint8_t bs_extension_type = (uint8_t)faad_getbits(ld, 4
 160             DEBUGVAR(1,198,"sbr_bitstream(): bs_extension_type"));
 161
 162         if (bs_extension_type == EXT_SBR_DATA_CRC)
 163         {
 164             sbr->bs_sbr_crc_bits = (uint16_t)faad_getbits(ld, 10
 165                 DEBUGVAR(1,199,"sbr_bitstream(): bs_sbr_crc_bits"));
 166         }
 167     }
 168
 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;
 176
 177     sbr->bs_header_flag = faad_get1bit(ld
 178         DEBUGVAR(1,200,"sbr_bitstream(): bs_header_flag"));
 179
 180     if (sbr->bs_header_flag)
 181         sbr_header(ld, sbr);
 182
 183     /* Reset? */
 184     sbr_reset(sbr);
 185
 186     /* first frame should have a header */
 187     //if (!(sbr->frame == 0 && sbr->bs_header_flag == 0))
 188     if (sbr->header_count != 0)
 189     {
 190         if (sbr->Reset || (sbr->bs_header_flag && sbr->just_seeked))
 191         {
 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);
 195
 196             /* if an error occured with the new header values revert to the old ones */
 197             if (rt > 0)
 198             {
 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);
 202             }
 203         }
 204
 205         if (result == 0)
 206         {
 207             result = sbr_data(ld, sbr);
 208
 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.
 213             */
 214             /* to be on the safe side, calculate old sbr tables in case of error */
 215             if ((result > 0) &&
 216                 (sbr->Reset || (sbr->bs_header_flag && sbr->just_seeked)))
 217             {
 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);
 221             }
 222
 223             /* we should be able to safely set result to 0 now, */
 224             /* but practise indicates this doesn't work well */
 225         }
 226     } else {
 227         result = 1;
 228     }
 229
 230     num_sbr_bits2 = (uint16_t)faad_get_processed_bits(ld) - num_sbr_bits1;
 231
 232     /* check if we read more bits then were available for sbr */
 233     if (8*cnt < num_sbr_bits2)
 234     {
 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         {
 257             faad_getbits(ld, 8
 258                 DEBUGVAR(1,999,"sbr_bitstream(): num_align_bits"));
 259             num_align_bits -= 8;
 260         }
 261         faad_getbits(ld, num_align_bits
 262             DEBUGVAR(1,999,"sbr_bitstream(): num_align_bits"));
 263     }
 264
 265     return result;
 266 }
 267
 268 /* table 3 */
 269 static void sbr_header(bitfile *ld, sbr_info *sbr)
 270 {
 271     uint8_t bs_header_extra_1, bs_header_extra_2;
 272
 273     sbr->header_count++;
 274
 275     sbr->bs_amp_res = faad_get1bit(ld
 276         DEBUGVAR(1,203,"sbr_header(): bs_amp_res"));
 277
 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"));
 286     faad_getbits(ld, 2
 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"));
 292
 293     if (bs_header_extra_1)
 294     {
 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"));
 301     } else {
 302         /* Default values */
 303         sbr->bs_freq_scale = 2;
 304         sbr->bs_alter_scale = 1;
 305         sbr->bs_noise_bands = 2;
 306     }
 307
 308     if (bs_header_extra_2)
 309     {
 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"));
 318     } else {
 319         /* Default values */
 320         sbr->bs_limiter_bands = 2;
 321         sbr->bs_limiter_gains = 2;
 322         sbr->bs_interpol_freq = 1;
 323         sbr->bs_smoothing_mode = 1;
 324     }
 325
 326 #if 0
 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)
 333     {
 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);
 337     }
 338     if (bs_header_extra_2)
 339     {
 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);
 344     }
 345     printf("\n");
 346 #endif
 347 }
 348
 349 /* table 4 */
 350 static uint8_t sbr_data(bitfile *ld, sbr_info *sbr)
 351 {
 352     uint8_t result;
 353 #if 0
 354     sbr->bs_samplerate_mode = faad_get1bit(ld
 355         DEBUGVAR(1,219,"sbr_data(): bs_samplerate_mode"));
 356 #endif
 357
 358     sbr->rate = (sbr->bs_samplerate_mode) ? 2 : 1;
 359
 360     switch (sbr->id_aac)
 361     {
 362     case ID_SCE:
 363                 if ((result = sbr_single_channel_element(ld, sbr)) > 0)
 364                         return result;
 365         break;
 366     case ID_CPE:
 367                 if ((result = sbr_channel_pair_element(ld, sbr)) > 0)
 368                         return result;
 369         break;
 370     }
 371
 372         return 0;
 373 }
 374
 375 /* table 5 */
 376 static uint8_t sbr_single_channel_element(bitfile *ld, sbr_info *sbr)
 377 {
 378     uint8_t result;
 379
 380     if (faad_get1bit(ld
 381         DEBUGVAR(1,220,"sbr_single_channel_element(): bs_data_extra")))
 382     {
 383         faad_getbits(ld, 4
 384             DEBUGVAR(1,221,"sbr_single_channel_element(): bs_reserved_bits_data"));
 385     }
 386
 387 #ifdef DRM
 388     /* bs_coupling, from sbr_channel_pair_base_element(bs_amp_res) */
 389     if (sbr->Is_DRM_SBR)
 390     {
 391         faad_get1bit(ld);
 392     }
 393 #endif
 394
 395     if ((result = sbr_grid(ld, sbr, 0)) > 0)
 396         return result;
 397
 398     sbr_dtdf(ld, sbr, 0);
 399     invf_mode(ld, sbr, 0);
 400     sbr_envelope(ld, sbr, 0);
 401     sbr_noise(ld, sbr, 0);
 402
 403 #ifndef FIXED_POINT
 404     envelope_noise_dequantisation(sbr, 0);
 405 #endif
 406
 407     memset(sbr->bs_add_harmonic[0], 0, 64*sizeof(uint8_t));
 408
 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);
 413
 414     sbr->bs_extended_data = faad_get1bit(ld
 415         DEBUGVAR(1,224,"sbr_single_channel_element(): bs_extended_data[0]"));
 416
 417     if (sbr->bs_extended_data)
 418     {
 419         uint16_t nr_bits_left;
 420 #if (defined(PS_DEC) || defined(DRM_PS))
 421         uint8_t ps_ext_read = 0;
 422 #endif
 423         uint16_t cnt = (uint16_t)faad_getbits(ld, 4
 424             DEBUGVAR(1,225,"sbr_single_channel_element(): bs_extension_size"));
 425         if (cnt == 15)
 426         {
 427             cnt += (uint16_t)faad_getbits(ld, 8
 428                 DEBUGVAR(1,226,"sbr_single_channel_element(): bs_esc_count"));
 429         }
 430
 431         nr_bits_left = 8 * cnt;
 432         while (nr_bits_left > 7)
 433         {
 434             uint16_t tmp_nr_bits = 0;
 435
 436             sbr->bs_extension_id = (uint8_t)faad_getbits(ld, 2
 437                 DEBUGVAR(1,227,"sbr_single_channel_element(): bs_extension_id"));
 438             tmp_nr_bits += 2;
 439
 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)
 444 #else
 445 #ifdef PS_DEC
 446             if (sbr->bs_extension_id == EXTENSION_ID_PS)
 447 #else
 448 #ifdef DRM_PS
 449             if (sbr->bs_extension_id == DRM_PARAMETRIC_STEREO)
 450 #endif
 451 #endif
 452 #endif
 453             {
 454                 if (ps_ext_read == 0)
 455                 {
 456                     ps_ext_read = 1;
 457                 } else {
 458                     /* to be safe make it 3, will switch to "default"
 459                      * in sbr_extension() */
 460 #ifdef DRM
 461                     return 1;
 462 #else
 463                     sbr->bs_extension_id = 3;
 464 #endif
 465                 }
 466             }
 467 #endif
 468
 469             tmp_nr_bits += sbr_extension(ld, sbr, sbr->bs_extension_id, nr_bits_left);
 470
 471             /* check if the data read is bigger than the number of available bits */
 472             if (tmp_nr_bits > nr_bits_left)
 473                 return 1;
 474
 475             nr_bits_left -= tmp_nr_bits;
 476         }
 477
 478         /* Corrigendum */
 479         if (nr_bits_left > 0)
 480         {
 481             faad_getbits(ld, nr_bits_left
 482                 DEBUGVAR(1,280,"sbr_single_channel_element(): nr_bits_left"));
 483         }
 484     }
 485
 486     return 0;
 487 }
 488
 489 /* table 6 */
 490 static uint8_t sbr_channel_pair_element(bitfile *ld, sbr_info *sbr)
 491 {
 492     uint8_t n, result;
 493
 494     if (faad_get1bit(ld
 495         DEBUGVAR(1,228,"sbr_single_channel_element(): bs_data_extra")))
 496     {
 497         faad_getbits(ld, 4
 498             DEBUGVAR(1,228,"sbr_channel_pair_element(): bs_reserved_bits_data"));
 499         faad_getbits(ld, 4
 500             DEBUGVAR(1,228,"sbr_channel_pair_element(): bs_reserved_bits_data"));
 501     }
 502
 503     sbr->bs_coupling = faad_get1bit(ld
 504         DEBUGVAR(1,228,"sbr_channel_pair_element(): bs_coupling"));
 505
 506     if (sbr->bs_coupling)
 507     {
 508         if ((result = sbr_grid(ld, sbr, 0)) > 0)
 509             return result;
 510
 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];
 516
 517         for (n = 0; n <= sbr->L_E[0]; n++)
 518         {
 519             sbr->t_E[1][n] = sbr->t_E[0][n];
 520             sbr->f[1][n] = sbr->f[0][n];
 521         }
 522         for (n = 0; n <= sbr->L_Q[0]; n++)
 523             sbr->t_Q[1][n] = sbr->t_Q[0][n];
 524
 525         sbr_dtdf(ld, sbr, 0);
 526         sbr_dtdf(ld, sbr, 1);
 527         invf_mode(ld, sbr, 0);
 528
 529         /* more copying */
 530         for (n = 0; n < sbr->N_Q; n++)
 531             sbr->bs_invf_mode[1][n] = sbr->bs_invf_mode[0][n];
 532
 533         sbr_envelope(ld, sbr, 0);
 534         sbr_noise(ld, sbr, 0);
 535         sbr_envelope(ld, sbr, 1);
 536         sbr_noise(ld, sbr, 1);
 537
 538         memset(sbr->bs_add_harmonic[0], 0, 64*sizeof(uint8_t));
 539         memset(sbr->bs_add_harmonic[1], 0, 64*sizeof(uint8_t));
 540
 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);
 545
 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);
 550     } else {
 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];
 555
 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];
 560
 561         if ((result = sbr_grid(ld, sbr, 0)) > 0)
 562             return result;
 563         if ((result = sbr_grid(ld, sbr, 1)) > 0)
 564         {
 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];
 573
 574             return result;
 575         }
 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);
 584
 585         memset(sbr->bs_add_harmonic[0], 0, 64*sizeof(uint8_t));
 586         memset(sbr->bs_add_harmonic[1], 0, 64*sizeof(uint8_t));
 587
 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);
 592
 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);
 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 #endif
 605
 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)
 609     {
 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         {
 615             cnt += (uint16_t)faad_getbits(ld, 8
 616                 DEBUGVAR(1,235,"sbr_channel_pair_element(): bs_esc_count"));
 617         }
 618
 619         nr_bits_left = 8 * cnt;
 620         while (nr_bits_left > 7)
 621         {
 622             uint16_t tmp_nr_bits = 0;
 623
 624             sbr->bs_extension_id = (uint8_t)faad_getbits(ld, 2
 625                 DEBUGVAR(1,236,"sbr_channel_pair_element(): bs_extension_id"));
 626             tmp_nr_bits += 2;
 627             tmp_nr_bits += sbr_extension(ld, sbr, sbr->bs_extension_id, nr_bits_left);
 628
 629             /* check if the data read is bigger than the number of available bits */
 630             if (tmp_nr_bits > nr_bits_left)
 631                 return 1;
 632
 633             nr_bits_left -= tmp_nr_bits;
 634         }
 635
 636         /* Corrigendum */
 637         if (nr_bits_left > 0)
 638         {
 639             faad_getbits(ld, nr_bits_left
 640                 DEBUGVAR(1,280,"sbr_channel_pair_element(): nr_bits_left"));
 641         }
 642     }
 643
 644     return 0;
 645 }
 646
 647 /* integer log[2](x): input range [0,10) */
 648 static int8_t sbr_log2(const int8_t val)
 649 {
 650     int8_t log2tab[] = { 0, 0, 1, 2, 2, 3, 3, 3, 3, 4 };
 651     if (val < 10 && val >= 0)
 652         return log2tab[val];
 653     else
 654         return 0;
 655 }
 656
 657
 658 /* table 7 */
 659 static uint8_t sbr_grid(bitfile *ld, sbr_info *sbr, uint8_t ch)
 660 {
 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];
 667
 668     sbr->bs_frame_class[ch] = (uint8_t)faad_getbits(ld, 2
 669         DEBUGVAR(1,248,"sbr_grid(): bs_frame_class"));
 670
 671     switch (sbr->bs_frame_class[ch])
 672     {
 673     case FIXFIX:
 674         i = (uint8_t)faad_getbits(ld, 2
 675             DEBUGVAR(1,249,"sbr_grid(): bs_num_env_raw"));
 676
 677         bs_num_env = min(1 << i, 5);
 678
 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++)
 682             sbr->f[ch][env] = i;
 683
 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;
 688         break;
 689
 690     case FIXVAR:
 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;
 695
 696         for (rel = 0; rel < bs_num_env-1; rel++)
 697         {
 698             sbr->bs_rel_bord[ch][rel] = 2 * (uint8_t)faad_getbits(ld, 2
 699                 DEBUGVAR(1,253,"sbr_grid(): bs_rel_bord")) + 2;
 700         }
 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"));
 704
 705         for (env = 0; env < bs_num_env; env++)
 706         {
 707             sbr->f[ch][bs_num_env - env - 1] = (uint8_t)faad_get1bit(ld
 708                 DEBUGVAR(1,255,"sbr_grid(): bs_freq_res"));
 709         }
 710
 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;
 715         break;
 716
 717     case VARFIX:
 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;
 722
 723         for (rel = 0; rel < bs_num_env-1; rel++)
 724         {
 725             sbr->bs_rel_bord[ch][rel] = 2 * (uint8_t)faad_getbits(ld, 2
 726                 DEBUGVAR(1,258,"sbr_grid(): bs_rel_bord")) + 2;
 727         }
 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"));
 731
 732         for (env = 0; env < bs_num_env; env++)
 733         {
 734             sbr->f[ch][env] = (uint8_t)faad_get1bit(ld
 735                 DEBUGVAR(1,260,"sbr_grid(): bs_freq_res"));
 736         }
 737
 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;
 742         break;
 743
 744     case VARVAR:
 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"));
 753
 754         bs_num_env = min(5, sbr->bs_num_rel_0[ch] + sbr->bs_num_rel_1[ch] + 1);
 755
 756         for (rel = 0; rel < sbr->bs_num_rel_0[ch]; rel++)
 757         {
 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;
 760         }
 761         for(rel = 0; rel < sbr->bs_num_rel_1[ch]; rel++)
 762         {
 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;
 765         }
 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"));
 769
 770         for (env = 0; env < bs_num_env; env++)
 771         {
 772             sbr->f[ch][env] = (uint8_t)faad_get1bit(ld
 773                 DEBUGVAR(1,268,"sbr_grid(): bs_freq_res"));
 774         }
 775
 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];
 780         break;
 781     }
 782
 783     if (sbr->bs_frame_class[ch] == VARVAR)
 784         sbr->L_E[ch] = min(bs_num_env, 5);
 785     else
 786         sbr->L_E[ch] = min(bs_num_env, 4);
 787
 788     if (sbr->L_E[ch] <= 0)
 789         return 1;
 790
 791     if (sbr->L_E[ch] > 1)
 792         sbr->L_Q[ch] = 2;
 793     else
 794         sbr->L_Q[ch] = 1;
 795
 796     /* TODO: this code can probably be integrated into the code above! */
 797     if ((result = envelope_time_border_vector(sbr, ch)) > 0)
 798     {
 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;
 802         return result;
 803     }
 804     noise_floor_time_border_vector(sbr, ch);
 805
 806 #if 0
 807     for (env = 0; env < bs_num_env; env++)
 808     {
 809         printf("freq_res[ch:%d][env:%d]: %d\n", ch, env, sbr->f[ch][env]);
 810     }
 811 #endif
 812
 813     return 0;
 814 }
 815
 816 /* table 8 */
 817 static void sbr_dtdf(bitfile *ld, sbr_info *sbr, uint8_t ch)
 818 {
 819     uint8_t i;
 820
 821     for (i = 0; i < sbr->L_E[ch]; i++)
 822     {
 823         sbr->bs_df_env[ch][i] = faad_get1bit(ld
 824             DEBUGVAR(1,269,"sbr_dtdf(): bs_df_env"));
 825     }
 826
 827     for (i = 0; i < sbr->L_Q[ch]; i++)
 828     {
 829         sbr->bs_df_noise[ch][i] = faad_get1bit(ld
 830             DEBUGVAR(1,270,"sbr_dtdf(): bs_df_noise"));
 831     }
 832 }
 833
 834 /* table 9 */
 835 static void invf_mode(bitfile *ld, sbr_info *sbr, uint8_t ch)
 836 {
 837     uint8_t n;
 838
 839     for (n = 0; n < sbr->N_Q; n++)
 840     {
 841         sbr->bs_invf_mode[ch][n] = (uint8_t)faad_getbits(ld, 2
 842             DEBUGVAR(1,271,"invf_mode(): bs_invf_mode"));
 843     }
 844 }
 845
 846 static uint16_t sbr_extension(bitfile *ld, sbr_info *sbr,
 847                               uint8_t bs_extension_id, uint16_t num_bits_left)
 848 {
 849 #ifdef PS_DEC
 850     uint8_t header;
 851     uint16_t ret;
 852 #endif
 853
 854     switch (bs_extension_id)
 855     {
 856 #ifdef PS_DEC
 857     case EXTENSION_ID_PS:
 858         if (!sbr->ps)
 859         {
 860             sbr->ps = ps_init(get_sr_index(sbr->sample_rate), sbr->numTimeSlotsRate);
 861         }
 862         if (sbr->psResetFlag)
 863         {
 864             sbr->ps->header_read = 0;
 865         }
 866         ret = ps_data(sbr->ps, ld, &header);
 867
 868         /* enable PS if and only if: a header has been decoded */
 869         if (sbr->ps_used == 0 && header == 1)
 870         {
 871             sbr->ps_used = 1;
 872         }
 873
 874         if (header == 1)
 875         {
 876             sbr->psResetFlag = 0;
 877         }
 878
 879         return ret;
 880 #endif
 881 #ifdef DRM_PS
 882     case DRM_PARAMETRIC_STEREO:
 883         sbr->ps_used = 1;
 884         if (!sbr->drm_ps)
 885         {
 886             sbr->drm_ps = drm_ps_init();
 887         }
 888         return drm_ps_data(sbr->drm_ps, ld);
 889 #endif
 890     default:
 891         sbr->bs_extension_data = (uint8_t)faad_getbits(ld, 6
 892             DEBUGVAR(1,279,"sbr_single_channel_element(): bs_extension_data"));
 893         return 6;
 894     }
 895 }
 896
 897 /* table 12 */
 898 static void sinusoidal_coding(bitfile *ld, sbr_info *sbr, uint8_t ch)
 899 {
 900     uint8_t n;
 901
 902     for (n = 0; n < sbr->N_high; n++)
 903     {
 904         sbr->bs_add_harmonic[ch][n] = faad_get1bit(ld
 905             DEBUGVAR(1,278,"sinusoidal_coding(): bs_add_harmonic"));
 906     }
 907 }
 908
 909
 910 #endif /* SBR_DEC */