diff Plugins/Input/aac/libfaad2/sbr_syntax.c @ 199:0a2ad94e8607 trunk

[svn] Synced with bmp-mp4. Build system is fragile, but should work now.

--- a/Plugins/Input/aac/libfaad2/sbr_syntax.c	Wed Nov 16 01:12:05 2005 -0800
+++ b/Plugins/Input/aac/libfaad2/sbr_syntax.c	Wed Nov 16 16:21:11 2005 -0800
@@ -1,6 +1,6 @@
 /*
 ** FAAD2 - Freeware Advanced Audio (AAC) Decoder including SBR decoding
-** Copyright (C) 2003 M. Bakker, Ahead Software AG, http://www.nero.com
+** Copyright (C) 2003-2004 M. Bakker, Ahead Software AG, http://www.nero.com
 **  
 ** This program is free software; you can redistribute it and/or modify
 ** it under the terms of the GNU General Public License as published by
@@ -22,7 +22,7 @@
 ** Commercial non-GPL licensing of this software is possible.
 ** For more info contact Ahead Software through [e-mail].
 **
-** $Id: sbr_syntax.c,v 1.15 2003/11/12 20:47:58 menno Exp $
+** $Id: sbr_syntax.c,v 1.34 2004/09/04 14:56:28 menno Exp $
 **/
 
 #include "common.h"
@@ -37,8 +37,30 @@
 #include "sbr_tf_grid.h"
 #include "sbr_e_nf.h"
 #include "bits.h"
+#ifdef PS_DEC
+#include "ps_dec.h"
+#endif
+#ifdef DRM_PS
+#include "drm_dec.h"
+#endif
 #include "analysis.h"
 
+/* static function declarations */
+static void sbr_header(bitfile *ld, sbr_info *sbr);
+static uint8_t calc_sbr_tables(sbr_info *sbr, uint8_t start_freq, uint8_t stop_freq,
+                               uint8_t samplerate_mode, uint8_t freq_scale,
+                               uint8_t alter_scale, uint8_t xover_band);
+static uint8_t sbr_data(bitfile *ld, sbr_info *sbr);
+static uint16_t sbr_extension(bitfile *ld, sbr_info *sbr,
+                              uint8_t bs_extension_id, uint16_t num_bits_left);
+static uint8_t sbr_single_channel_element(bitfile *ld, sbr_info *sbr);
+static uint8_t sbr_channel_pair_element(bitfile *ld, sbr_info *sbr);
+static uint8_t sbr_grid(bitfile *ld, sbr_info *sbr, uint8_t ch);
+static void sbr_dtdf(bitfile *ld, sbr_info *sbr, uint8_t ch);
+static void invf_mode(bitfile *ld, sbr_info *sbr, uint8_t ch);
+static void sinusoidal_coding(bitfile *ld, sbr_info *sbr, uint8_t ch);
+
+
 static void sbr_reset(sbr_info *sbr)
 {
 #if 0
@@ -54,16 +76,6 @@
     if ((sbr->bs_start_freq != sbr->bs_start_freq_prev) ||
         (sbr->bs_stop_freq != sbr->bs_stop_freq_prev) ||
         (sbr->bs_freq_scale != sbr->bs_freq_scale_prev) ||
-        (sbr->bs_alter_scale != sbr->bs_alter_scale_prev))
-    {
-        sbr->Reset = 1;
-    } else {
-        sbr->Reset = 0;
-    }
-
-    if ((sbr->bs_start_freq != sbr->bs_start_freq_prev) ||
-        (sbr->bs_stop_freq != sbr->bs_stop_freq_prev) ||
-        (sbr->bs_freq_scale != sbr->bs_freq_scale_prev) ||
         (sbr->bs_alter_scale != sbr->bs_alter_scale_prev) ||
         (sbr->bs_xover_band != sbr->bs_xover_band_prev) ||
         (sbr->bs_noise_bands != sbr->bs_noise_bands_prev))
@@ -79,23 +91,58 @@
     sbr->bs_alter_scale_prev = sbr->bs_alter_scale;
     sbr->bs_xover_band_prev = sbr->bs_xover_band;
     sbr->bs_noise_bands_prev = sbr->bs_noise_bands;
+}
 
-    if (sbr->frame == 0)
+static uint8_t calc_sbr_tables(sbr_info *sbr, uint8_t start_freq, uint8_t stop_freq,
+                               uint8_t samplerate_mode, uint8_t freq_scale,
+                               uint8_t alter_scale, uint8_t xover_band)
+{
+    uint8_t result = 0;
+    uint8_t k2;
+
+    /* calculate the Master Frequency Table */
+    sbr->k0 = qmf_start_channel(start_freq, samplerate_mode, sbr->sample_rate);
+    k2 = qmf_stop_channel(stop_freq, sbr->sample_rate, sbr->k0);
+
+    /* check k0 and k2 */
+    if (sbr->sample_rate >= 48000)
     {
-        sbr->Reset = 1;
+        if ((k2 - sbr->k0) > 32)
+            result += 1;
+    } else if (sbr->sample_rate <= 32000) {
+        if ((k2 - sbr->k0) > 48)
+            result += 1;
+    } else { /* (sbr->sample_rate == 44100) */
+        if ((k2 - sbr->k0) > 45)
+            result += 1;
     }
+
+    if (freq_scale == 0)
+    {
+        result += master_frequency_table_fs0(sbr, sbr->k0, k2, alter_scale);
+    } else {
+        result += master_frequency_table(sbr, sbr->k0, k2, freq_scale, alter_scale);
+    }
+    result += derived_frequency_table(sbr, xover_band, k2);
+
+    result = (result > 0) ? 1 : 0;
+
+    return result;
 }
 
 /* table 2 */
-uint8_t sbr_extension_data(bitfile *ld, sbr_info *sbr)
+uint8_t sbr_extension_data(bitfile *ld, sbr_info *sbr, uint16_t cnt)
 {
-    uint8_t result;
+    uint8_t result = 0;
+    uint16_t num_align_bits = 0;
+    uint16_t num_sbr_bits = (uint16_t)faad_get_processed_bits(ld);
+
+    uint8_t saved_start_freq, saved_samplerate_mode;
+    uint8_t saved_stop_freq, saved_freq_scale;
+    uint8_t saved_alter_scale, saved_xover_band;
+
 #ifdef DRM
-    uint8_t crc_len;
-
-    if (sbr->Is_DRM_SBR)
-        faad_getbits(ld, 8); /* 8-bit CRC */
-    else
+    if (!sbr->Is_DRM_SBR)
 #endif
     {
         uint8_t bs_extension_type = (uint8_t)faad_getbits(ld, 4
@@ -108,93 +155,91 @@
         }
     }
 
+    /* save old header values, in case the new ones are corrupted */
+    saved_start_freq = sbr->bs_start_freq;
+    saved_samplerate_mode = sbr->bs_samplerate_mode;
+    saved_stop_freq = sbr->bs_stop_freq;
+    saved_freq_scale = sbr->bs_freq_scale;
+    saved_alter_scale = sbr->bs_alter_scale;
+    saved_xover_band = sbr->bs_xover_band;
+
     sbr->bs_header_flag = faad_get1bit(ld
         DEBUGVAR(1,200,"sbr_bitstream(): bs_header_flag"));
 
-#ifdef DRM
-    if (sbr->Is_DRM_SBR)
-    {
-        /* Check CRC, get number of bits for check */
-        if (sbr->id_aac == ID_SCE)
-        {
-            if (sbr->lcstereo_flag)
-            {
-                if (sbr->bs_header_flag)
-                    crc_len = min(76, sbr->data_size_bits);
-                else
-                    crc_len = min(47, sbr->data_size_bits);
-            } else {
-                if (sbr->bs_header_flag)
-                    crc_len = min(74, sbr->data_size_bits);
-                else
-                    crc_len = min(47, sbr->data_size_bits);
-            }
-        } else {
-            if (sbr->bs_header_flag)
-                crc_len = min(120, sbr->data_size_bits);
-            else
-                crc_len = min(93, sbr->data_size_bits);
-        }
-
-        if ((result = faad_check_CRC(ld, crc_len)) > 0)
-            return result;
-
-        /* Rewind and read bits again to set correct position in bit-stream */
-        faad_rewindbits(ld);
-        faad_getbits(ld, 8);
-        faad_get1bit(ld);
-    }
-#endif
-
     if (sbr->bs_header_flag)
         sbr_header(ld, sbr);
 
-    /* TODO: Reset? */
+    /* Reset? */
     sbr_reset(sbr);
 
     /* first frame should have a header */
-    if (sbr->frame == 0 && sbr->bs_header_flag == 0)
-        return 1;
-
-
-    if (sbr->Reset || (sbr->bs_header_flag && sbr->just_seeked))
+    //if (!(sbr->frame == 0 && sbr->bs_header_flag == 0))
+    if (sbr->header_count != 0)
     {
-        uint8_t k2;
+        if (sbr->Reset || (sbr->bs_header_flag && sbr->just_seeked))
+        {
+            uint8_t rt = calc_sbr_tables(sbr, sbr->bs_start_freq, sbr->bs_stop_freq,
+                sbr->bs_samplerate_mode, sbr->bs_freq_scale,
+                sbr->bs_alter_scale, sbr->bs_xover_band);
 
-        /* calculate the Master Frequency Table */
-        sbr->k0 = qmf_start_channel(sbr->bs_start_freq, sbr->bs_samplerate_mode,
-            sbr->sample_rate);
-        k2 = qmf_stop_channel(sbr->bs_stop_freq, sbr->sample_rate, sbr->k0);
-
-        /* check k0 and k2 */
-        if (sbr->sample_rate >= 48000)
-        {
-            if ((k2 - sbr->k0) > 32)
-                return 1;
-        } else if (sbr->sample_rate <= 32000) {
-            if ((k2 - sbr->k0) > 48)
-                return 1;
-        } else { /* (sbr->sample_rate == 44100) */
-            if ((k2 - sbr->k0) > 45)
-                return 1;
+            /* if an error occured with the new header values revert to the old ones */
+            if (rt > 0)
+            {
+                calc_sbr_tables(sbr, saved_start_freq, saved_stop_freq,
+                    saved_samplerate_mode, saved_freq_scale,
+                    saved_alter_scale, saved_xover_band);
+            }
         }
 
-        if (sbr->bs_freq_scale == 0)
+        if (result == 0)
         {
-            master_frequency_table_fs0(sbr, sbr->k0, k2, sbr->bs_alter_scale);
-        } else {
-            master_frequency_table(sbr, sbr->k0, k2, sbr->bs_freq_scale,
-                sbr->bs_alter_scale);
+            result = sbr_data(ld, sbr);
+
+            /* sbr_data() returning an error means that there was an error in
+               envelope_time_border_vector().
+               In this case the old time border vector is saved and all the previous
+               data normally read after sbr_grid() is saved.
+            */
+            /* to be on the safe side, calculate old sbr tables in case of error */
+            if ((result > 0) &&
+                (sbr->Reset || (sbr->bs_header_flag && sbr->just_seeked)))
+            {
+                calc_sbr_tables(sbr, saved_start_freq, saved_stop_freq,
+                    saved_samplerate_mode, saved_freq_scale,
+                    saved_alter_scale, saved_xover_band);
+            }
+
+            /* we should be able to safely set result to 0 now */
+            result = 0;
         }
-        if ((result = derived_frequency_table(sbr, sbr->bs_xover_band, k2)) > 0)
-            return result;
+    } else {
+        result = 1;
     }
 
-    if ((result = sbr_data(ld, sbr)) > 0)
-        return result;
+#ifdef DRM
+    if (!sbr->Is_DRM_SBR)
+#endif
+    {
+        num_sbr_bits = (uint16_t)faad_get_processed_bits(ld) - num_sbr_bits;
+
+        /* check if we read more bits then were available for sbr */
+        if (8*cnt < num_sbr_bits)
+            return 1;
 
-    /* no error */
-    return 0;
+        /* -4 does not apply, bs_extension_type is re-read in this function */
+        num_align_bits = 8*cnt /*- 4*/ - num_sbr_bits;
+
+        while (num_align_bits > 7)
+        {
+            faad_getbits(ld, 8
+                DEBUGVAR(1,999,"sbr_bitstream(): num_align_bits"));
+            num_align_bits -= 8;
+        }
+        faad_getbits(ld, num_align_bits
+            DEBUGVAR(1,999,"sbr_bitstream(): num_align_bits"));
+    }
+
+    return result;
 }
 
 /* table 3 */
@@ -204,46 +249,31 @@
 
     sbr->header_count++;
 
-#ifdef DRM
-    /* protocol_version (should be 0) */
-    if (sbr->Is_DRM_SBR)
-        faad_getbits(ld, 2);
-#endif
-
     sbr->bs_amp_res = faad_get1bit(ld
         DEBUGVAR(1,203,"sbr_header(): bs_amp_res"));
 
     /* bs_start_freq and bs_stop_freq must define a fequency band that does
        not exceed 48 channels */
-    sbr->bs_start_freq = faad_getbits(ld, 4
+    sbr->bs_start_freq = (uint8_t)faad_getbits(ld, 4
         DEBUGVAR(1,204,"sbr_header(): bs_start_freq"));
-    sbr->bs_stop_freq = faad_getbits(ld, 4
+    sbr->bs_stop_freq = (uint8_t)faad_getbits(ld, 4
         DEBUGVAR(1,205,"sbr_header(): bs_stop_freq"));
-    sbr->bs_xover_band = faad_getbits(ld, 3
+    sbr->bs_xover_band = (uint8_t)faad_getbits(ld, 3
         DEBUGVAR(1,206,"sbr_header(): bs_xover_band"));
     faad_getbits(ld, 2
         DEBUGVAR(1,207,"sbr_header(): bs_reserved_bits_hdr"));
-#ifdef DRM
-    if (sbr->Is_DRM_SBR)
-        sbr->bs_dataextra = faad_getbits(ld, 1);
-#endif
-    bs_header_extra_1 = faad_get1bit(ld
+    bs_header_extra_1 = (uint8_t)faad_get1bit(ld
         DEBUGVAR(1,208,"sbr_header(): bs_header_extra_1"));
-    bs_header_extra_2 = faad_get1bit(ld
+    bs_header_extra_2 = (uint8_t)faad_get1bit(ld
         DEBUGVAR(1,209,"sbr_header(): bs_header_extra_2"));
-#ifdef DRM
-    /* No low complexity stereo support so far */
-    if ((sbr->lcstereo_flag) && (sbr->Is_DRM_SBR))
-        faad_getbits(ld, 2);
-#endif
 
     if (bs_header_extra_1)
     {
-        sbr->bs_freq_scale = faad_getbits(ld, 2
+        sbr->bs_freq_scale = (uint8_t)faad_getbits(ld, 2
             DEBUGVAR(1,211,"sbr_header(): bs_freq_scale"));
-        sbr->bs_alter_scale = faad_get1bit(ld
+        sbr->bs_alter_scale = (uint8_t)faad_get1bit(ld
             DEBUGVAR(1,212,"sbr_header(): bs_alter_scale"));
-        sbr->bs_noise_bands = faad_getbits(ld, 2
+        sbr->bs_noise_bands = (uint8_t)faad_getbits(ld, 2
             DEBUGVAR(1,213,"sbr_header(): bs_noise_bands"));
     } else {
         /* Default values */
@@ -254,19 +284,14 @@
 
     if (bs_header_extra_2)
     {
-        sbr->bs_limiter_bands = faad_getbits(ld, 2
+        sbr->bs_limiter_bands = (uint8_t)faad_getbits(ld, 2
             DEBUGVAR(1,214,"sbr_header(): bs_limiter_bands"));
-        sbr->bs_limiter_gains = faad_getbits(ld, 2
+        sbr->bs_limiter_gains = (uint8_t)faad_getbits(ld, 2
             DEBUGVAR(1,215,"sbr_header(): bs_limiter_gains"));
-        sbr->bs_interpol_freq = faad_get1bit(ld
+        sbr->bs_interpol_freq = (uint8_t)faad_get1bit(ld
             DEBUGVAR(1,216,"sbr_header(): bs_interpol_freq"));
-        sbr->bs_smoothing_mode = faad_get1bit(ld
+        sbr->bs_smoothing_mode = (uint8_t)faad_get1bit(ld
             DEBUGVAR(1,217,"sbr_header(): bs_smoothing_mode"));
-#ifdef DRM
-        /* reserved */
-        if (sbr->Is_DRM_SBR)
-            faad_get1bit(ld);
-#endif
     } else {
         /* Default values */
         sbr->bs_limiter_bands = 2;
@@ -309,11 +334,6 @@
 
     sbr->rate = (sbr->bs_samplerate_mode) ? 2 : 1;
 
-#ifdef DRM
-    if (sbr->Is_DRM_SBR)
-        sbr->rate = 2;
-#endif
-
     switch (sbr->id_aac)
     {
     case ID_SCE:
@@ -334,83 +354,103 @@
 {
     uint8_t result;
 
-#ifdef DRM
-    if (!sbr->Is_DRM_SBR)
-#endif
+    if (faad_get1bit(ld
+        DEBUGVAR(1,220,"sbr_single_channel_element(): bs_data_extra")))
     {
-        if (faad_get1bit(ld
-            DEBUGVAR(1,220,"sbr_single_channel_element(): bs_data_extra")))
-        {
-            faad_getbits(ld, 4
-                DEBUGVAR(1,221,"sbr_single_channel_element(): bs_reserved_bits_data"));
-        }
+        faad_getbits(ld, 4
+            DEBUGVAR(1,221,"sbr_single_channel_element(): bs_reserved_bits_data"));
     }
 
+#ifdef DRM
+    /* bs_coupling, from sbr_channel_pair_base_element(bs_amp_res) */
+    if (sbr->Is_DRM_SBR)
+        faad_get1bit(ld);
+#endif
+
     if ((result = sbr_grid(ld, sbr, 0)) > 0)
         return result;
     sbr_dtdf(ld, sbr, 0);
     invf_mode(ld, sbr, 0);
-#ifdef DRM
-    if (sbr->Is_DRM_SBR)
-    {
-        /* sbr mode not needed in V1.0. Should be set to 2 by a V1.0 encoder */
-        faad_getbits(ld, 2);
-
-        if (sbr->bs_dataextra)
-            faad_getbits(ld, 3); /* reserved */
-    }
-#endif
     sbr_envelope(ld, sbr, 0);
     sbr_noise(ld, sbr, 0);
 
+#ifndef FIXED_POINT
     envelope_noise_dequantisation(sbr, 0);
+#endif
 
     memset(sbr->bs_add_harmonic[0], 0, 64*sizeof(uint8_t));
 
-#ifdef DRM
-    if (sbr->Is_DRM_SBR)
-        sbr->bs_add_harmonic_flag[0] = 0;
-    else
-#endif
-    {
-        sbr->bs_add_harmonic_flag[0] = faad_get1bit(ld
-            DEBUGVAR(1,223,"sbr_single_channel_element(): bs_add_harmonic_flag[0]"));
-    }
+    sbr->bs_add_harmonic_flag[0] = faad_get1bit(ld
+        DEBUGVAR(1,223,"sbr_single_channel_element(): bs_add_harmonic_flag[0]"));
     if (sbr->bs_add_harmonic_flag[0])
         sinusoidal_coding(ld, sbr, 0);
 
     sbr->bs_extended_data = faad_get1bit(ld
         DEBUGVAR(1,224,"sbr_single_channel_element(): bs_extended_data[0]"));
+
     if (sbr->bs_extended_data)
     {
         uint16_t nr_bits_left;
-        uint16_t cnt = faad_getbits(ld, 4
+#if (defined(PS_DEC) || defined(DRM_PS))
+        uint8_t ps_ext_read = 0;
+#endif
+        uint16_t cnt = (uint16_t)faad_getbits(ld, 4
             DEBUGVAR(1,225,"sbr_single_channel_element(): bs_extension_size"));
         if (cnt == 15)
         {
-            cnt += faad_getbits(ld, 8
+            cnt += (uint16_t)faad_getbits(ld, 8
                 DEBUGVAR(1,226,"sbr_single_channel_element(): bs_esc_count"));
         }
 
         nr_bits_left = 8 * cnt;
         while (nr_bits_left > 7)
         {
-            sbr->bs_extension_id = faad_getbits(ld, 2
+            uint16_t tmp_nr_bits = 0;
+
+            sbr->bs_extension_id = (uint8_t)faad_getbits(ld, 2
                 DEBUGVAR(1,227,"sbr_single_channel_element(): bs_extension_id"));
-            nr_bits_left -= 2;
-            /* sbr_extension(ld, sbr, 0, nr_bits_left); */
-#ifdef DRM
-            if (!sbr->Is_DRM_SBR)
+            tmp_nr_bits += 2;
+
+            /* allow only 1 PS extension element per extension data */
+#if (defined(PS_DEC) || defined(DRM_PS))
+#if (defined(PS_DEC) && defined(DRM_PS))
+            if (sbr->bs_extension_id == EXTENSION_ID_PS || sbr->bs_extension_id == DRM_PARAMETRIC_STEREO)
+#else
+#ifdef PS_DEC
+            if (sbr->bs_extension_id == EXTENSION_ID_PS)
+#else
+#ifdef DRM_PS
+            if (sbr->bs_extension_id == DRM_PARAMETRIC_STEREO)
+#endif
+#endif
 #endif
             {
-                sbr->bs_extension_data = faad_getbits(ld, 6
-                    DEBUGVAR(1,279,"sbr_single_channel_element(): bs_extension_data"));
+                if (ps_ext_read == 0)
+                {
+                    ps_ext_read = 1;
+                } else {
+                    /* to be safe make it 3, will switch to "default"
+                     * in sbr_extension() */
+                    sbr->bs_extension_id = 3;
+                }
             }
+#endif
+
+            tmp_nr_bits += sbr_extension(ld, sbr, sbr->bs_extension_id, nr_bits_left);
+
+            /* check if the data read is bigger than the number of available bits */
+            if (tmp_nr_bits > nr_bits_left)
+                return 1;
+
+            nr_bits_left -= tmp_nr_bits;
         }
 
         /* Corrigendum */
-        faad_getbits(ld, nr_bits_left
-            DEBUGVAR(1,280,"sbr_single_channel_element(): nr_bits_left"));
+        if (nr_bits_left > 0)
+        {
+            faad_getbits(ld, nr_bits_left
+                DEBUGVAR(1,280,"sbr_single_channel_element(): nr_bits_left"));
+        }
     }
 
     return 0;
@@ -421,18 +461,13 @@
 {
     uint8_t n, result;
 
-#ifdef DRM
-    if (!sbr->Is_DRM_SBR)
-#endif
+    if (faad_get1bit(ld
+        DEBUGVAR(1,228,"sbr_single_channel_element(): bs_data_extra")))
     {
-        if (faad_get1bit(ld
-            DEBUGVAR(1,228,"sbr_single_channel_element(): bs_data_extra")))
-        {
-            faad_getbits(ld, 4
-                DEBUGVAR(1,228,"sbr_channel_pair_element(): bs_reserved_bits_data"));
-            faad_getbits(ld, 4
-                DEBUGVAR(1,228,"sbr_channel_pair_element(): bs_reserved_bits_data"));
-        }
+        faad_getbits(ld, 4
+            DEBUGVAR(1,228,"sbr_channel_pair_element(): bs_reserved_bits_data"));
+        faad_getbits(ld, 4
+            DEBUGVAR(1,228,"sbr_channel_pair_element(): bs_reserved_bits_data"));
     }
 
     sbr->bs_coupling = faad_get1bit(ld
@@ -460,16 +495,6 @@
         sbr_dtdf(ld, sbr, 0);
         sbr_dtdf(ld, sbr, 1);
         invf_mode(ld, sbr, 0);
-#ifdef DRM
-        if (sbr->Is_DRM_SBR)
-        {
-            /* sbr mode not needed in V1.0. Should be set to 2 by a V1.0 encoder */
-            faad_getbits(ld, 2);
-
-            if (sbr->bs_dataextra)
-                faad_getbits(ld, 3); /* reserved */
-        }
-#endif
 
         /* more copying */
         for (n = 0; n < sbr->N_Q; n++)
@@ -483,49 +508,45 @@
         memset(sbr->bs_add_harmonic[0], 0, 64*sizeof(uint8_t));
         memset(sbr->bs_add_harmonic[1], 0, 64*sizeof(uint8_t));
 
-#ifdef DRM
-        if (sbr->Is_DRM_SBR)
-            sbr->bs_add_harmonic_flag[0] = 0;
-        else
-#endif
-        {
-            sbr->bs_add_harmonic_flag[0] = faad_get1bit(ld
-                DEBUGVAR(1,231,"sbr_channel_pair_element(): bs_add_harmonic_flag[0]"));
-        }
+        sbr->bs_add_harmonic_flag[0] = faad_get1bit(ld
+            DEBUGVAR(1,231,"sbr_channel_pair_element(): bs_add_harmonic_flag[0]"));
         if (sbr->bs_add_harmonic_flag[0])
             sinusoidal_coding(ld, sbr, 0);
 
-#ifdef DRM
-        if (sbr->Is_DRM_SBR)
-            sbr->bs_add_harmonic_flag[1] = 0;
-        else
-#endif
-        {
-            sbr->bs_add_harmonic_flag[1] = faad_get1bit(ld
-                DEBUGVAR(1,232,"sbr_channel_pair_element(): bs_add_harmonic_flag[1]"));
-        }
+        sbr->bs_add_harmonic_flag[1] = faad_get1bit(ld
+            DEBUGVAR(1,232,"sbr_channel_pair_element(): bs_add_harmonic_flag[1]"));
         if (sbr->bs_add_harmonic_flag[1])
             sinusoidal_coding(ld, sbr, 1);
     } else {
+        uint8_t saved_t_E[6] = {0}, saved_t_Q[3] = {0};
+        uint8_t saved_L_E = sbr->L_E[0];
+        uint8_t saved_L_Q = sbr->L_Q[0];
+        uint8_t saved_frame_class = sbr->bs_frame_class[0];
+
+        for (n = 0; n < saved_L_E; n++)
+            saved_t_E[n] = sbr->t_E[0][n];
+        for (n = 0; n < saved_L_Q; n++)
+            saved_t_Q[n] = sbr->t_Q[0][n];
+
         if ((result = sbr_grid(ld, sbr, 0)) > 0)
             return result;
         if ((result = sbr_grid(ld, sbr, 1)) > 0)
+        {
+            /* restore first channel data as well */
+            sbr->bs_frame_class[0] = saved_frame_class;
+            sbr->L_E[0] = saved_L_E;
+            sbr->L_Q[0] = saved_L_Q;
+            for (n = 0; n < 6; n++)
+                sbr->t_E[0][n] = saved_t_E[n];
+            for (n = 0; n < 3; n++)
+                sbr->t_Q[0][n] = saved_t_Q[n];
+
             return result;
+        }
         sbr_dtdf(ld, sbr, 0);
         sbr_dtdf(ld, sbr, 1);
         invf_mode(ld, sbr, 0);
         invf_mode(ld, sbr, 1);
-#ifdef DRM
-        if (sbr->Is_DRM_SBR)
-        {
-            /* sbr mode not needed in V1.0. Should be set to 2 by a V1.0 encoder */
-            faad_getbits(ld, 2);
-            faad_getbits(ld, 2);
-
-            if (sbr->bs_dataextra)
-                faad_getbits(ld, 6); /* reserved */
-        }
-#endif
         sbr_envelope(ld, sbr, 0);
         sbr_envelope(ld, sbr, 1);
         sbr_noise(ld, sbr, 0);
@@ -534,92 +555,98 @@
         memset(sbr->bs_add_harmonic[0], 0, 64*sizeof(uint8_t));
         memset(sbr->bs_add_harmonic[1], 0, 64*sizeof(uint8_t));
 
-#ifdef DRM
-        if (sbr->Is_DRM_SBR)
-            sbr->bs_add_harmonic_flag[0] = 0;
-        else
-#endif
-        {
-            sbr->bs_add_harmonic_flag[0] = faad_get1bit(ld
-                DEBUGVAR(1,239,"sbr_channel_pair_element(): bs_add_harmonic_flag[0]"));
-        }
+        sbr->bs_add_harmonic_flag[0] = faad_get1bit(ld
+            DEBUGVAR(1,239,"sbr_channel_pair_element(): bs_add_harmonic_flag[0]"));
         if (sbr->bs_add_harmonic_flag[0])
             sinusoidal_coding(ld, sbr, 0);
 
-#ifdef DRM
-        if (sbr->Is_DRM_SBR)
-            sbr->bs_add_harmonic_flag[1] = 0;
-        else
-#endif
-        {
-            sbr->bs_add_harmonic_flag[1] = faad_get1bit(ld
-                DEBUGVAR(1,240,"sbr_channel_pair_element(): bs_add_harmonic_flag[1]"));
-        }
+        sbr->bs_add_harmonic_flag[1] = faad_get1bit(ld
+            DEBUGVAR(1,240,"sbr_channel_pair_element(): bs_add_harmonic_flag[1]"));
         if (sbr->bs_add_harmonic_flag[1])
             sinusoidal_coding(ld, sbr, 1);
     }
+#ifndef FIXED_POINT
     envelope_noise_dequantisation(sbr, 0);
     envelope_noise_dequantisation(sbr, 1);
 
     if (sbr->bs_coupling)
         unmap_envelope_noise(sbr);
+#endif
 
     sbr->bs_extended_data = faad_get1bit(ld
         DEBUGVAR(1,233,"sbr_channel_pair_element(): bs_extended_data[0]"));
     if (sbr->bs_extended_data)
     {
         uint16_t nr_bits_left;
-        uint16_t cnt = faad_getbits(ld, 4
+        uint16_t cnt = (uint16_t)faad_getbits(ld, 4
             DEBUGVAR(1,234,"sbr_channel_pair_element(): bs_extension_size"));
         if (cnt == 15)
         {
-            cnt += faad_getbits(ld, 8
+            cnt += (uint16_t)faad_getbits(ld, 8
                 DEBUGVAR(1,235,"sbr_channel_pair_element(): bs_esc_count"));
         }
 
         nr_bits_left = 8 * cnt;
         while (nr_bits_left > 7)
         {
-            sbr->bs_extension_id = faad_getbits(ld, 2
+            uint16_t tmp_nr_bits = 0;
+
+            sbr->bs_extension_id = (uint8_t)faad_getbits(ld, 2
                 DEBUGVAR(1,236,"sbr_channel_pair_element(): bs_extension_id"));
-            nr_bits_left -= 2;
-            /* sbr_extension(ld, sbr, 0, nr_bits_left); */
-#ifdef DRM
-            if (!sbr->Is_DRM_SBR)
-#endif
-            {
-                sbr->bs_extension_data = faad_getbits(ld, 6
-                    DEBUGVAR(1,280,"sbr_channel_pair_element(): bs_extension_data"));
-            }
+            tmp_nr_bits += 2;
+            tmp_nr_bits += sbr_extension(ld, sbr, sbr->bs_extension_id, nr_bits_left);
+
+            /* check if the data read is bigger than the number of available bits */
+            if (tmp_nr_bits > nr_bits_left)
+                return 1;
+
+            nr_bits_left -= tmp_nr_bits;
         }
 
         /* Corrigendum */
-        faad_getbits(ld, nr_bits_left
-            DEBUGVAR(1,280,"sbr_channel_pair_element(): nr_bits_left"));
+        if (nr_bits_left > 0)
+        {
+            faad_getbits(ld, nr_bits_left
+                DEBUGVAR(1,280,"sbr_channel_pair_element(): nr_bits_left"));
+        }
     }
 
     return 0;
 }
 
+/* integer log[2](x): input range [0,10) */
+static int8_t sbr_log2(const int8_t val)
+{
+    int8_t log2tab[] = { 0, 0, 1, 2, 2, 3, 3, 3, 3, 4 };
+    if (val < 10 && val >= 0)
+        return log2tab[val];
+    else
+        return 0;
+}
+
+
 /* table 7 */
 static uint8_t sbr_grid(bitfile *ld, sbr_info *sbr, uint8_t ch)
 {
     uint8_t i, env, rel, result;
     uint8_t bs_abs_bord, bs_abs_bord_1;
-    uint16_t bs_num_env;
+    uint8_t bs_num_env = 0;
+    uint8_t saved_L_E = sbr->L_E[ch];
+    uint8_t saved_L_Q = sbr->L_Q[ch];
+    uint8_t saved_frame_class = sbr->bs_frame_class[ch];
 
-    sbr->bs_frame_class[ch] = faad_getbits(ld, 2
+    sbr->bs_frame_class[ch] = (uint8_t)faad_getbits(ld, 2
         DEBUGVAR(1,248,"sbr_grid(): bs_frame_class"));
 
     switch (sbr->bs_frame_class[ch])
     {
     case FIXFIX:
-        i = faad_getbits(ld, 2
+        i = (uint8_t)faad_getbits(ld, 2
             DEBUGVAR(1,249,"sbr_grid(): bs_num_env_raw"));
 
         bs_num_env = min(1 << i, 5);
 
-        i = faad_get1bit(ld
+        i = (uint8_t)faad_get1bit(ld
             DEBUGVAR(1,250,"sbr_grid(): bs_freq_res_flag"));
         for (env = 0; env < bs_num_env; env++)
             sbr->f[ch][env] = i;
@@ -631,32 +658,23 @@
         break;
 
     case FIXVAR:
-#ifdef DRM
-        if (sbr->Is_DRM_SBR)
-        {
-            bs_abs_bord = faad_getbits(ld, 3
-                DEBUGVAR(1,251,"sbr_grid(): bs_abs_bord")) + sbr->numTimeSlots;
-        } else
-#endif
-        {
-            bs_abs_bord = faad_getbits(ld, 2
-                DEBUGVAR(1,251,"sbr_grid(): bs_abs_bord")) + sbr->numTimeSlots;
-        }
-        bs_num_env = faad_getbits(ld, 2
+        bs_abs_bord = (uint8_t)faad_getbits(ld, 2
+            DEBUGVAR(1,251,"sbr_grid(): bs_abs_bord")) + sbr->numTimeSlots;
+        bs_num_env = (uint8_t)faad_getbits(ld, 2
             DEBUGVAR(1,252,"sbr_grid(): bs_num_env")) + 1;
 
         for (rel = 0; rel < bs_num_env-1; rel++)
         {
-            sbr->bs_rel_bord[ch][rel] = 2 * faad_getbits(ld, 2
+            sbr->bs_rel_bord[ch][rel] = 2 * (uint8_t)faad_getbits(ld, 2
                 DEBUGVAR(1,253,"sbr_grid(): bs_rel_bord")) + 2;
         }
-        i = int_log2((int32_t)(bs_num_env + 1));
-        sbr->bs_pointer[ch] = faad_getbits(ld, i
+        i = sbr_log2(bs_num_env + 1);
+        sbr->bs_pointer[ch] = (uint8_t)faad_getbits(ld, i
             DEBUGVAR(1,254,"sbr_grid(): bs_pointer"));
 
         for (env = 0; env < bs_num_env; env++)
         {
-            sbr->f[ch][bs_num_env - env - 1] = faad_get1bit(ld
+            sbr->f[ch][bs_num_env - env - 1] = (uint8_t)faad_get1bit(ld
                 DEBUGVAR(1,255,"sbr_grid(): bs_freq_res"));
         }
 
@@ -667,32 +685,23 @@
         break;
 
     case VARFIX:
-#ifdef DRM
-        if (sbr->Is_DRM_SBR)
-        {
-            bs_abs_bord = faad_getbits(ld, 3
-                DEBUGVAR(1,256,"sbr_grid(): bs_abs_bord"));
-        } else
-#endif
-        {
-            bs_abs_bord = faad_getbits(ld, 2
-                DEBUGVAR(1,256,"sbr_grid(): bs_abs_bord"));
-        }
-        bs_num_env = faad_getbits(ld, 2
+        bs_abs_bord = (uint8_t)faad_getbits(ld, 2
+            DEBUGVAR(1,256,"sbr_grid(): bs_abs_bord"));
+        bs_num_env = (uint8_t)faad_getbits(ld, 2
             DEBUGVAR(1,257,"sbr_grid(): bs_num_env")) + 1;
 
         for (rel = 0; rel < bs_num_env-1; rel++)
         {
-            sbr->bs_rel_bord[ch][rel] = 2 * faad_getbits(ld, 2
+            sbr->bs_rel_bord[ch][rel] = 2 * (uint8_t)faad_getbits(ld, 2
                 DEBUGVAR(1,258,"sbr_grid(): bs_rel_bord")) + 2;
         }
-        i = int_log2((int32_t)(bs_num_env + 1));
-        sbr->bs_pointer[ch] = faad_getbits(ld, i
+        i = sbr_log2(bs_num_env + 1);
+        sbr->bs_pointer[ch] = (uint8_t)faad_getbits(ld, i
             DEBUGVAR(1,259,"sbr_grid(): bs_pointer"));
 
         for (env = 0; env < bs_num_env; env++)
         {
-            sbr->f[ch][env] = faad_get1bit(ld
+            sbr->f[ch][env] = (uint8_t)faad_get1bit(ld
                 DEBUGVAR(1,260,"sbr_grid(): bs_freq_res"));
         }
 
@@ -703,46 +712,34 @@
         break;
 
     case VARVAR:
-#ifdef DRM
-        if (sbr->Is_DRM_SBR)
-        {
-            bs_abs_bord = faad_getbits(ld, 3
-                DEBUGVAR(1,261,"sbr_grid(): bs_abs_bord_0"));
-            bs_abs_bord_1 = faad_getbits(ld, 3
-                DEBUGVAR(1,262,"sbr_grid(): bs_abs_bord_1")) + sbr->numTimeSlots;
-        }
-        else
-#endif
-        {
-            bs_abs_bord = faad_getbits(ld, 2
-                DEBUGVAR(1,261,"sbr_grid(): bs_abs_bord_0"));
-            bs_abs_bord_1 = faad_getbits(ld, 2
-                DEBUGVAR(1,262,"sbr_grid(): bs_abs_bord_1")) + sbr->numTimeSlots;
-        }
-        sbr->bs_num_rel_0[ch] = faad_getbits(ld, 2
+        bs_abs_bord = (uint8_t)faad_getbits(ld, 2
+            DEBUGVAR(1,261,"sbr_grid(): bs_abs_bord_0"));
+        bs_abs_bord_1 = (uint8_t)faad_getbits(ld, 2
+            DEBUGVAR(1,262,"sbr_grid(): bs_abs_bord_1")) + sbr->numTimeSlots;
+        sbr->bs_num_rel_0[ch] = (uint8_t)faad_getbits(ld, 2
             DEBUGVAR(1,263,"sbr_grid(): bs_num_rel_0"));
-        sbr->bs_num_rel_1[ch] = faad_getbits(ld, 2
+        sbr->bs_num_rel_1[ch] = (uint8_t)faad_getbits(ld, 2
             DEBUGVAR(1,264,"sbr_grid(): bs_num_rel_1"));
 
         bs_num_env = min(5, sbr->bs_num_rel_0[ch] + sbr->bs_num_rel_1[ch] + 1);
 
         for (rel = 0; rel < sbr->bs_num_rel_0[ch]; rel++)
         {
-            sbr->bs_rel_bord_0[ch][rel] = 2 * faad_getbits(ld, 2
+            sbr->bs_rel_bord_0[ch][rel] = 2 * (uint8_t)faad_getbits(ld, 2
                 DEBUGVAR(1,265,"sbr_grid(): bs_rel_bord")) + 2;
         }
         for(rel = 0; rel < sbr->bs_num_rel_1[ch]; rel++)
         {
-            sbr->bs_rel_bord_1[ch][rel] = 2 * faad_getbits(ld, 2
+            sbr->bs_rel_bord_1[ch][rel] = 2 * (uint8_t)faad_getbits(ld, 2
                 DEBUGVAR(1,266,"sbr_grid(): bs_rel_bord")) + 2;
         }
-        i = int_log2((int32_t)(sbr->bs_num_rel_0[ch] + sbr->bs_num_rel_1[ch] + 2));
-        sbr->bs_pointer[ch] = faad_getbits(ld, i
+        i = sbr_log2(sbr->bs_num_rel_0[ch] + sbr->bs_num_rel_1[ch] + 2);
+        sbr->bs_pointer[ch] = (uint8_t)faad_getbits(ld, i
             DEBUGVAR(1,267,"sbr_grid(): bs_pointer"));
 
         for (env = 0; env < bs_num_env; env++)
         {
-            sbr->f[ch][env] = faad_get1bit(ld
+            sbr->f[ch][env] = (uint8_t)faad_get1bit(ld
                 DEBUGVAR(1,268,"sbr_grid(): bs_freq_res"));
         }
 
@@ -758,6 +755,9 @@
     else
         sbr->L_E[ch] = min(bs_num_env, 4);
 
+    if (sbr->L_E[ch] <= 0)
+        return 1;
+
     if (sbr->L_E[ch] > 1)
         sbr->L_Q[ch] = 2;
     else
@@ -765,9 +765,21 @@
 
     /* TODO: this code can probably be integrated into the code above! */
     if ((result = envelope_time_border_vector(sbr, ch)) > 0)
+    {
+        sbr->bs_frame_class[ch] = saved_frame_class;
+        sbr->L_E[ch] = saved_L_E;
+        sbr->L_Q[ch] = saved_L_Q;
         return result;
+    }
     noise_floor_time_border_vector(sbr, ch);
 
+#if 0
+    for (env = 0; env < bs_num_env; env++)
+    {
+        printf("freq_res[ch:%d][env:%d]: %d\n", ch, env, sbr->f[ch][env]);
+    }
+#endif
+
     return 0;
 }
 
@@ -794,23 +806,52 @@
 {
     uint8_t n;
 
-#ifdef DRM
-    if (sbr->Is_DRM_SBR)
+    for (n = 0; n < sbr->N_Q; n++)
     {
-        /* Only one inv_mode in DRM */
-        uint8_t invf_mode;
-        invf_mode = faad_getbits(ld, 2
+        sbr->bs_invf_mode[ch][n] = (uint8_t)faad_getbits(ld, 2
             DEBUGVAR(1,271,"invf_mode(): bs_invf_mode"));
-        for (n = 0; n < sbr->N_Q; n++)
-            sbr->bs_invf_mode[ch][n] = invf_mode;
-    } else
+    }
+}
+
+static uint16_t sbr_extension(bitfile *ld, sbr_info *sbr,
+                              uint8_t bs_extension_id, uint16_t num_bits_left)
+{
+#ifdef PS_DEC
+    uint8_t header;
+    uint16_t ret;
 #endif
+
+    switch (bs_extension_id)
     {
-        for (n = 0; n < sbr->N_Q; n++)
+#ifdef PS_DEC
+    case EXTENSION_ID_PS:
+        if (!sbr->ps)
+        {
+            sbr->ps = ps_init(get_sr_index(sbr->sample_rate));
+        }
+        ret = ps_data(sbr->ps, ld, &header);
+
+        /* enable PS if and only if: a header has been decoded */
+        if (sbr->ps_used == 0 && header == 1)
         {
-            sbr->bs_invf_mode[ch][n] = faad_getbits(ld, 2
-                DEBUGVAR(1,271,"invf_mode(): bs_invf_mode"));
+            sbr->ps_used = 1;
         }
+
+        return ret;
+#endif
+#ifdef DRM_PS
+    case DRM_PARAMETRIC_STEREO:
+        sbr->ps_used = 1;
+        if (!sbr->drm_ps)
+        {
+            sbr->drm_ps = drm_ps_init();
+        }
+        return drm_ps_data(sbr->drm_ps, ld);
+#endif
+    default:
+        sbr->bs_extension_data = (uint8_t)faad_getbits(ld, 6
+            DEBUGVAR(1,279,"sbr_single_channel_element(): bs_extension_data"));
+        return 6;
     }
 }