/* 

 * layer3.c: Mpeg Layer-3 audio decoder 

 *

 * Copyright (C) 1999-2010 The L.A.M.E. project

 *

 * Initially written by Michael Hipp, see also AUTHORS and README.

 *  

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Library General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

 * Library General Public License for more details.

 *

 * You should have received a copy of the GNU Library General Public

 * License along with this library; if not, write to the

 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

 */

/* $Id: layer3.c,v 1.69 2017/08/20 20:06:57 robert Exp $ */

#ifdef HAVE_CONFIG_H

# include <config.h>

#endif

#include <stdlib.h>

#include "common.h"

#include "huffman.h"

#include "lame.h"

#include "machine.h"

#include "encoder.h"

#include "lame-analysis.h"

#include "decode_i386.h"

#include "layer3.h"

#ifdef WITH_DMALLOC

#include <dmalloc.h>

#endif

static int gd_are_hip_tables_layer3_initialized = 0;

static real ispow[8207];

static real aa_ca[8], aa_cs[8];

static real COS1[12][6];

static real win[4][36];

static real win1[4][36];

static real gainpow2[256 + 118 + 4];

static real COS9[9];

static real COS6_1, COS6_2;

static real tfcos36[9];

static real tfcos12[3];

struct bandInfoStruct {

    short   longIdx[23];

    short   longDiff[22];

    short   shortIdx[14];

    short   shortDiff[13];

};

static int longLimit[9][23];

static int shortLimit[9][14];

/* *INDENT-OFF* */

static const struct bandInfoStruct bandInfo[9] = { 

/* MPEG 1.0 */

 { {0,4,8,12,16,20,24,30,36,44,52,62,74, 90,110,134,162,196,238,288,342,418,576},

   {4,4,4,4,4,4,6,6,8, 8,10,12,16,20,24,28,34,42,50,54, 76,158},

   {0,4*3,8*3,12*3,16*3,22*3,30*3,40*3,52*3,66*3, 84*3,106*3,136*3,192*3},

   {4,4,4,4,6,8,10,12,14,18,22,30,56} } ,

 { {0,4,8,12,16,20,24,30,36,42,50,60,72, 88,106,128,156,190,230,276,330,384,576},

   {4,4,4,4,4,4,6,6,6, 8,10,12,16,18,22,28,34,40,46,54, 54,192},

   {0,4*3,8*3,12*3,16*3,22*3,28*3,38*3,50*3,64*3, 80*3,100*3,126*3,192*3},

   {4,4,4,4,6,6,10,12,14,16,20,26,66} } ,

 { {0,4,8,12,16,20,24,30,36,44,54,66,82,102,126,156,194,240,296,364,448,550,576} ,

   {4,4,4,4,4,4,6,6,8,10,12,16,20,24,30,38,46,56,68,84,102, 26} ,

   {0,4*3,8*3,12*3,16*3,22*3,30*3,42*3,58*3,78*3,104*3,138*3,180*3,192*3} ,

   {4,4,4,4,6,8,12,16,20,26,34,42,12} }  ,

/* MPEG 2.0 */

 { {0,6,12,18,24,30,36,44,54,66,80,96,116,140,168,200,238,284,336,396,464,522,576},

   {6,6,6,6,6,6,8,10,12,14,16,20,24,28,32,38,46,52,60,68,58,54 } ,

   {0,4*3,8*3,12*3,18*3,24*3,32*3,42*3,56*3,74*3,100*3,132*3,174*3,192*3} ,

   {4,4,4,6,6,8,10,14,18,26,32,42,18 } } ,

                                             /* docs: 332. mpg123: 330 */

 { {0,6,12,18,24,30,36,44,54,66,80,96,114,136,162,194,232,278,332,394,464,540,576},

   {6,6,6,6,6,6,8,10,12,14,16,18,22,26,32,38,46,54,62,70,76,36 } ,

   {0,4*3,8*3,12*3,18*3,26*3,36*3,48*3,62*3,80*3,104*3,136*3,180*3,192*3} ,

   {4,4,4,6,8,10,12,14,18,24,32,44,12 } } ,

 { {0,6,12,18,24,30,36,44,54,66,80,96,116,140,168,200,238,284,336,396,464,522,576},

   {6,6,6,6,6,6,8,10,12,14,16,20,24,28,32,38,46,52,60,68,58,54 },

   {0,4*3,8*3,12*3,18*3,26*3,36*3,48*3,62*3,80*3,104*3,134*3,174*3,192*3},

   {4,4,4,6,8,10,12,14,18,24,30,40,18 } } ,

/* MPEG 2.5 */

 { {0,6,12,18,24,30,36,44,54,66,80,96,116,140,168,200,238,284,336,396,464,522,576} ,

   {6,6,6,6,6,6,8,10,12,14,16,20,24,28,32,38,46,52,60,68,58,54},

   {0,12,24,36,54,78,108,144,186,240,312,402,522,576},

   {4,4,4,6,8,10,12,14,18,24,30,40,18} },

 { {0,6,12,18,24,30,36,44,54,66,80,96,116,140,168,200,238,284,336,396,464,522,576} ,

   {6,6,6,6,6,6,8,10,12,14,16,20,24,28,32,38,46,52,60,68,58,54},

   {0,12,24,36,54,78,108,144,186,240,312,402,522,576},

   {4,4,4,6,8,10,12,14,18,24,30,40,18} },

 { {0,12,24,36,48,60,72,88,108,132,160,192,232,280,336,400,476,566,568,570,572,574,576},

   {12,12,12,12,12,12,16,20,24,28,32,40,48,56,64,76,90,2,2,2,2,2},

   {0, 24, 48, 72,108,156,216,288,372,480,486,492,498,576},

   {8,8,8,12,16,20,24,28,36,2,2,2,26} } ,

};

/* *INDENT-ON* */

static int mapbuf0[9][152];

static int mapbuf1[9][156];

static int mapbuf2[9][44];

static int *map[9][3];

static int *mapend[9][3];

static unsigned int n_slen2[512]; /* MPEG 2.0 slen for 'normal' mode */

static unsigned int i_slen2[256]; /* MPEG 2.0 slen for intensity stereo */

static real tan1_1[16], tan2_1[16], tan1_2[16], tan2_2[16];

static real pow1_1[2][16], pow2_1[2][16], pow1_2[2][16], pow2_2[2][16];

static unsigned int

get1bit(PMPSTR mp)

{

    unsigned char rval;

    rval = *mp->wordpointer << mp->bitindex;

    mp->bitindex++;

    mp->wordpointer += (mp->bitindex >> 3);

    mp->bitindex &= 7;

    return rval >> 7;

}

static real

get_gain(real const* gain_ptr, int idx, int* overflow)

{

    static const real* const gainpow2_end_ptr = gainpow2 + (sizeof(gainpow2)/sizeof(gainpow2[0])) -1;

    real const * ptr = &gain_ptr[idx];

    if (&gain_ptr[idx] > gainpow2_end_ptr) {

        ptr = gainpow2_end_ptr;

        if (overflow) *overflow = 1;

    }

    return *ptr;

}

/* 

 * init tables for layer-3 

 */

void

hip_init_tables_layer3(void)

{

    int     i, j, k;

    if (gd_are_hip_tables_layer3_initialized) {

        return;

    }

    gd_are_hip_tables_layer3_initialized = 1;

    for (i = -256; i < 118 + 4; i++)

        gainpow2[i + 256] = pow((double) 2.0, -0.25 * (double) (i + 210));

    for (i = 0; i < 8207; i++)

        ispow[i] = pow((double) i, (double) 4.0 / 3.0);

    for (i = 0; i < 8; i++) {

        static const double Ci[8] = { -0.6, -0.535, -0.33, -0.185, -0.095, -0.041, -0.0142, -0.0037 };

        double  sq = sqrt(1.0 + Ci[i] * Ci[i]);

        aa_cs[i] = 1.0 / sq;

        aa_ca[i] = Ci[i] / sq;

    }

    for (i = 0; i < 18; i++) {

        win[0][i] = win[1][i] =

            0.5 * sin(M_PI / 72.0 * (double) (2 * (i + 0) + 1)) / cos(M_PI *

                                                                      (double) (2 * (i + 0) +

                                                                                19) / 72.0);

        win[0][i + 18] = win[3][i + 18] =

            0.5 * sin(M_PI / 72.0 * (double) (2 * (i + 18) + 1)) / cos(M_PI *

                                                                       (double) (2 * (i + 18) +

                                                                                 19) / 72.0);

    }

    for (i = 0; i < 6; i++) {

        win[1][i + 18] = 0.5 / cos(M_PI * (double) (2 * (i + 18) + 19) / 72.0);

        win[3][i + 12] = 0.5 / cos(M_PI * (double) (2 * (i + 12) + 19) / 72.0);

        win[1][i + 24] =

            0.5 * sin(M_PI / 24.0 * (double) (2 * i + 13)) / cos(M_PI *

                                                                 (double) (2 * (i + 24) +

                                                                           19) / 72.0);

        win[1][i + 30] = win[3][i] = 0.0;

        win[3][i + 6] =

            0.5 * sin(M_PI / 24.0 * (double) (2 * i + 1)) / cos(M_PI * (double) (2 * (i + 6) + 19) /

                                                                72.0);

    }

    for (i = 0; i < 9; i++)

        COS9[i] = cos(M_PI / 18.0 * (double) i);

    for (i = 0; i < 9; i++)

        tfcos36[i] = 0.5 / cos(M_PI * (double) (i * 2 + 1) / 36.0);

    for (i = 0; i < 3; i++)

        tfcos12[i] = 0.5 / cos(M_PI * (double) (i * 2 + 1) / 12.0);

    COS6_1 = cos(M_PI / 6.0 * (double) 1);

    COS6_2 = cos(M_PI / 6.0 * (double) 2);

    for (i = 0; i < 12; i++) {

        win[2][i] =

            0.5 * sin(M_PI / 24.0 * (double) (2 * i + 1)) / cos(M_PI * (double) (2 * i + 7) / 24.0);

        for (j = 0; j < 6; j++)

            COS1[i][j] = cos(M_PI / 24.0 * (double) ((2 * i + 7) * (2 * j + 1)));

    }

    for (j = 0; j < 4; j++) {

        static int const len[4] = { 36, 36, 12, 36 };

        for (i = 0; i < len[j]; i += 2)

            win1[j][i] = +win[j][i];

        for (i = 1; i < len[j]; i += 2)

            win1[j][i] = -win[j][i];

    }

    for (i = 0; i < 16; i++) {

        double  t = tan((double) i * M_PI / 12.0);

        tan1_1[i] = t / (1.0 + t);

        tan2_1[i] = 1.0 / (1.0 + t);

        tan1_2[i] = M_SQRT2 * t / (1.0 + t);

        tan2_2[i] = M_SQRT2 / (1.0 + t);

        for (j = 0; j < 2; j++) {

            double  base = pow(2.0, -0.25 * (j + 1.0));

            double  p1 = 1.0, p2 = 1.0;

            if (i > 0) {

                if (i & 1)

                    p1 = pow(base, (i + 1.0) * 0.5);

                else

                    p2 = pow(base, i * 0.5);

            }

            pow1_1[j][i] = p1;

            pow2_1[j][i] = p2;

            pow1_2[j][i] = M_SQRT2 * p1;

            pow2_2[j][i] = M_SQRT2 * p2;

        }

    }

    for (j = 0; j < 9; j++) {

        struct bandInfoStruct const *bi = (struct bandInfoStruct const *) &bandInfo[j];

        int    *mp;

        int     cb, lwin;

        short const *bdf;

        int switch_idx = (j < 3) ? 8 : 6;

        mp = map[j][0] = mapbuf0[j];

        bdf = bi->longDiff;

        for (i = 0, cb = 0; cb < switch_idx; cb++, i += *bdf++) {

            *mp++ = (*bdf) >> 1;

            *mp++ = i;

            *mp++ = 3;

            *mp++ = cb;

        }

        bdf = bi->shortDiff + 3;

        for (cb = 3; cb < 13; cb++) {

            int     l = (*bdf++) >> 1;

            for (lwin = 0; lwin < 3; lwin++) {

                *mp++ = l;

                *mp++ = i + lwin;

                *mp++ = lwin;

                *mp++ = cb;

            }

            i += 6 * l;

        }

        mapend[j][0] = mp;

        mp = map[j][1] = mapbuf1[j];

        bdf = bi->shortDiff + 0;

        for (i = 0, cb = 0; cb < 13; cb++) {

            int     l = (*bdf++) >> 1;

            for (lwin = 0; lwin < 3; lwin++) {

                *mp++ = l;

                *mp++ = i + lwin;

                *mp++ = lwin;

                *mp++ = cb;

            }

            i += 6 * l;

        }

        mapend[j][1] = mp;

        mp = map[j][2] = mapbuf2[j];

        bdf = bi->longDiff;

        for (cb = 0; cb < 22; cb++) {

            *mp++ = (*bdf++) >> 1;

            *mp++ = cb;

        }

        mapend[j][2] = mp;

    }

    for (j = 0; j < 9; j++) {

        for (i = 0; i < 23; i++) {

            longLimit[j][i] = (bandInfo[j].longIdx[i] - 1 + 8) / 18 + 1;

            if (longLimit[j][i] > SBLIMIT)

                longLimit[j][i] = SBLIMIT;

        }

        for (i = 0; i < 14; i++) {

            shortLimit[j][i] = (bandInfo[j].shortIdx[i] - 1) / 18 + 1;

            if (shortLimit[j][i] > SBLIMIT)

                shortLimit[j][i] = SBLIMIT;

        }

    }

    for (i = 0; i < 5; i++) {

        for (j = 0; j < 6; j++) {

            for (k = 0; k < 6; k++) {

                int     n = k + j * 6 + i * 36;

                i_slen2[n] = i | (j << 3) | (k << 6) | (3 << 12);

            }

        }

    }

    for (i = 0; i < 4; i++) {

        for (j = 0; j < 4; j++) {

            for (k = 0; k < 4; k++) {

                int     n = k + j * 4 + i * 16;

                i_slen2[n + 180] = i | (j << 3) | (k << 6) | (4 << 12);

            }

        }

    }

    for (i = 0; i < 4; i++) {

        for (j = 0; j < 3; j++) {

            int     n = j + i * 3;

            i_slen2[n + 244] = i | (j << 3) | (5 << 12);

            n_slen2[n + 500] = i | (j << 3) | (2 << 12) | (1 << 15);

        }

    }

    for (i = 0; i < 5; i++) {

        for (j = 0; j < 5; j++) {

            for (k = 0; k < 4; k++) {

                int     l;

                for (l = 0; l < 4; l++) {

                    int     n = l + k * 4 + j * 16 + i * 80;

                    n_slen2[n] = i | (j << 3) | (k << 6) | (l << 9) | (0 << 12);

                }

            }

        }

    }

    for (i = 0; i < 5; i++) {

        for (j = 0; j < 5; j++) {

            for (k = 0; k < 4; k++) {

                int     n = k + j * 4 + i * 20;

                n_slen2[n + 400] = i | (j << 3) | (k << 6) | (1 << 12);

            }

        }

    }

}

/*

 * read additional side information

 */

static void

III_get_side_info_1(PMPSTR mp, int stereo,

                    int ms_stereo, long sfreq, int single)

{

    int     ch, gr;

    int     powdiff = (single == 3) ? 4 : 0;

    mp->sideinfo.main_data_begin = getbits(mp, 9);

    if (stereo == 1)

        mp->sideinfo.private_bits = getbits_fast(mp, 5);

    else

        mp->sideinfo.private_bits = getbits_fast(mp, 3);

    for (ch = 0; ch < stereo; ch++) {

        mp->sideinfo.ch[ch].gr[0].scfsi = -1;

        mp->sideinfo.ch[ch].gr[1].scfsi = getbits_fast(mp, 4);

    }

    for (gr = 0; gr < 2; gr++) {

        for (ch = 0; ch < stereo; ch++) {

            struct gr_info_s *gr_infos = &(mp->sideinfo.ch[ch].gr[gr]);

            gr_infos->part2_3_length = getbits(mp, 12);

            gr_infos->big_values = getbits_fast(mp, 9);

            if (gr_infos->big_values > 288) {

                lame_report_fnc(mp->report_err, "big_values too large! %i\n", gr_infos->big_values);

                gr_infos->big_values = 288;

            }

            {

                unsigned int qss = getbits_fast(mp, 8);

                gr_infos->pow2gain = gainpow2 + 256 - qss + powdiff;

                if (mp->pinfo != NULL) {

                    mp->pinfo->qss[gr][ch] = qss;

                }

            }

            if (ms_stereo)

                gr_infos->pow2gain += 2;

            gr_infos->scalefac_compress = getbits_fast(mp, 4);

/* window-switching flag == 1 for block_Type != 0 .. and block-type == 0 -> win-sw-flag = 0 */

            if (get1bit(mp)) {

                int     i;

                gr_infos->block_type = getbits_fast(mp, 2);

                gr_infos->mixed_block_flag = get1bit(mp);

                gr_infos->table_select[0] = getbits_fast(mp, 5);

                gr_infos->table_select[1] = getbits_fast(mp, 5);

                /*

                 * table_select[2] not needed, because there is no region2,

                 * but to satisfy some verifications tools we set it either.

                 */

                gr_infos->table_select[2] = 0;

                for (i = 0; i < 3; i++) {

                    unsigned int sbg = (getbits_fast(mp, 3) << 3);

                    gr_infos->full_gain[i] = gr_infos->pow2gain + sbg;

                    if (mp->pinfo != NULL)

                        mp->pinfo->sub_gain[gr][ch][i] = sbg / 8;

                }

                if (gr_infos->block_type == 0) {

                    lame_report_fnc(mp->report_err, "Blocktype == 0 and window-switching == 1 not allowed.\n");

                    /* error seems to be very good recoverable, so don't exit */

                    /* exit(1); */

                }

                /* region_count/start parameters are implicit in this case. */

                gr_infos->region1start = 36 >> 1;

                gr_infos->region2start = 576 >> 1;

            }

            else {

                unsigned int i, r0c, r1c, region0index, region1index;

                for (i = 0; i < 3; i++)

                    gr_infos->table_select[i] = getbits_fast(mp, 5);

                r0c = getbits_fast(mp, 4);

                r1c = getbits_fast(mp, 3);

                region0index = r0c+1;

                if (region0index > 22) {

                    lame_report_fnc(mp->report_err, "region0index=%d > 22\n", region0index);

                    region0index = 22;

                }

                region1index = r0c+1 + r1c+1;

                if (region1index > 22) {

                    lame_report_fnc(mp->report_err, "region1index=%d > 22\n", region1index);

                    region1index = 22;

                }

                gr_infos->region1start = bandInfo[sfreq].longIdx[region0index] >> 1;

                gr_infos->region2start = bandInfo[sfreq].longIdx[region1index] >> 1;

                gr_infos->block_type = 0;

                gr_infos->mixed_block_flag = 0;

            }

            gr_infos->preflag = get1bit(mp);

            gr_infos->scalefac_scale = get1bit(mp);

            gr_infos->count1table_select = get1bit(mp);

        }

    }

}

/*

 * Side Info for MPEG 2.0 / LSF

 */

static void

III_get_side_info_2(PMPSTR mp, int stereo, int ms_stereo, long sfreq, int single)

{

    int     ch;

    int     powdiff = (single == 3) ? 4 : 0;

    mp->sideinfo.main_data_begin = getbits(mp, 8);

    if (stereo == 1)

        mp->sideinfo.private_bits = get1bit(mp);

    else

        mp->sideinfo.private_bits = getbits_fast(mp, 2);

    for (ch = 0; ch < stereo; ch++) {

        struct gr_info_s *gr_infos = &(mp->sideinfo.ch[ch].gr[0]);

        unsigned int qss;

        gr_infos->part2_3_length = getbits(mp, 12);

        gr_infos->big_values = getbits_fast(mp, 9);

        if (gr_infos->big_values > 288) {

            lame_report_fnc(mp->report_err, "big_values too large! %i\n", gr_infos->big_values);

            gr_infos->big_values = 288;

        }

        qss = getbits_fast(mp, 8);

        gr_infos->pow2gain = gainpow2 + 256 - qss + powdiff;

        if (mp->pinfo != NULL) {

            mp->pinfo->qss[0][ch] = qss;

        }

        if (ms_stereo)

            gr_infos->pow2gain += 2;

        gr_infos->scalefac_compress = getbits(mp, 9);

/* window-switching flag == 1 for block_Type != 0 .. and block-type == 0 -> win-sw-flag = 0 */

        if (get1bit(mp)) {

            int     i;

            gr_infos->block_type = getbits_fast(mp, 2);

            gr_infos->mixed_block_flag = get1bit(mp);

            gr_infos->table_select[0] = getbits_fast(mp, 5);

            gr_infos->table_select[1] = getbits_fast(mp, 5);

            /*

             * table_select[2] not needed, because there is no region2,

             * but to satisfy some verifications tools we set it either.

             */

            gr_infos->table_select[2] = 0;

            for (i = 0; i < 3; i++) {

                unsigned int sbg = (getbits_fast(mp, 3) << 3);

                gr_infos->full_gain[i] = gr_infos->pow2gain + sbg;

                if (mp->pinfo != NULL)

                    mp->pinfo->sub_gain[0][ch][i] = sbg / 8;

            }

            if (gr_infos->block_type == 0) {

                lame_report_fnc(mp->report_err, "Blocktype == 0 and window-switching == 1 not allowed.\n");

                /* error seems to be very good recoverable, so don't exit */

                /* exit(1); */

            }

            /* region_count/start parameters are implicit in this case. */

            if (gr_infos->block_type == 2) {

                if (gr_infos->mixed_block_flag == 0)

                    gr_infos->region1start = 36 >> 1;

                else

                    gr_infos->region1start = 48 >> 1;

            }

            else

                gr_infos->region1start = 54 >> 1;

            if (sfreq == 8)

                gr_infos->region1start *= 2;

            gr_infos->region2start = 576 >> 1;

        }

        else {

            unsigned int i, r0c, r1c, region0index, region1index;

            for (i = 0; i < 3; i++)

                gr_infos->table_select[i] = getbits_fast(mp, 5);

            r0c = getbits_fast(mp, 4);

            r1c = getbits_fast(mp, 3);

            region0index = r0c+1;

            if (region0index > 22) {

                lame_report_fnc(mp->report_err, "region0index=%d > 22\n", region0index);

                region0index = 22;

            }

            region1index = r0c+1 + r1c+1;

            if (region1index > 22) {

                lame_report_fnc(mp->report_err, "region1index=%d > 22\n", region1index);

                region1index = 22;

            }

            gr_infos->region1start = bandInfo[sfreq].longIdx[region0index] >> 1;

            gr_infos->region2start = bandInfo[sfreq].longIdx[region1index] >> 1;

            gr_infos->block_type = 0;

            gr_infos->mixed_block_flag = 0;

        }

        gr_infos->scalefac_scale = get1bit(mp);

        gr_infos->count1table_select = get1bit(mp);

    }

}

/*

 * read scalefactors

 */

static int

III_get_scale_factors_1(PMPSTR mp, int *scf, struct gr_info_s *gr_infos)

{

    static const unsigned char slen[2][16] = {

        {0, 0, 0, 0, 3, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4},

        {0, 1, 2, 3, 0, 1, 2, 3, 1, 2, 3, 1, 2, 3, 2, 3}

    };

    int     numbits;

    int     num0 = slen[0][gr_infos->scalefac_compress];

    int     num1 = slen[1][gr_infos->scalefac_compress];

    if (gr_infos->block_type == 2) {

        int     i = 18;

        numbits = (num0 + num1) * 18;

        if (gr_infos->mixed_block_flag) {

            for (i = 8; i; i--)

                *scf++ = getbits_fast(mp, num0);

            i = 9;

            numbits -= num0; /* num0 * 17 + num1 * 18 */

        }

        for (; i; i--)

            *scf++ = getbits_fast(mp, num0);

        for (i = 18; i; i--)

            *scf++ = getbits_fast(mp, num1);

        *scf++ = 0;

        *scf++ = 0;

        *scf++ = 0;     /* short[13][0..2] = 0 */

    }

    else {

        int     i;

        int     scfsi = gr_infos->scfsi;

        if (scfsi < 0) { /* scfsi < 0 => granule == 0 */

            for (i = 11; i; i--)

                *scf++ = getbits_fast(mp, num0);

            for (i = 10; i; i--)

                *scf++ = getbits_fast(mp, num1);

            numbits = (num0 + num1) * 10 + num0;

        }

        else {

            numbits = 0;

            if (!(scfsi & 0x8)) {

                for (i = 6; i; i--)

                    *scf++ = getbits_fast(mp, num0);

                numbits += num0 * 6;

            }

            else {

                scf += 6;

            }

            if (!(scfsi & 0x4)) {

                for (i = 5; i; i--)

                    *scf++ = getbits_fast(mp, num0);

                numbits += num0 * 5;

            }

            else {

                scf += 5;

            }

            if (!(scfsi & 0x2)) {

                for (i = 5; i; i--)

                    *scf++ = getbits_fast(mp, num1);

                numbits += num1 * 5;

            }

            else {

                scf += 5;

            }

            if (!(scfsi & 0x1)) {

                for (i = 5; i; i--)

                    *scf++ = getbits_fast(mp, num1);

                numbits += num1 * 5;

            }

            else {

                scf += 5;

            }

        }

        *scf++ = 0;     /* no l[21] in original sources */

    }

    return numbits;

}

static int

III_get_scale_factors_2(PMPSTR mp, int *scf, struct gr_info_s *gr_infos, int i_stereo)

{

    unsigned char const *pnt;

    int     i, j;

    unsigned int slen;

    int     n = 0;

    int     numbits = 0;

  /* *INDENT-OFF* */

  static const unsigned char stab[3][6][4] = {

   { { 6, 5, 5,5 } , { 6, 5, 7,3 } , { 11,10,0,0} ,

     { 7, 7, 7,0 } , { 6, 6, 6,3 } , {  8, 8,5,0} } ,

   { { 9, 9, 9,9 } , { 9, 9,12,6 } , { 18,18,0,0} ,

     {12,12,12,0 } , {12, 9, 9,6 } , { 15,12,9,0} } ,

   { { 6, 9, 9,9 } , { 6, 9,12,6 } , { 15,18,0,0} ,

     { 6,15,12,0 } , { 6,12, 9,6 } , {  6,18,9,0} } }; 

  /* *INDENT-ON* */

    if (i_stereo)       /* i_stereo AND second channel -> do_layer3() checks this */

        slen = i_slen2[gr_infos->scalefac_compress >> 1];

    else

        slen = n_slen2[gr_infos->scalefac_compress];

    gr_infos->preflag = (slen >> 15) & 0x1;

    n = 0;

    if (gr_infos->block_type == 2) {

        n++;

        if (gr_infos->mixed_block_flag)

            n++;

    }

    pnt = (unsigned char const *) stab[n][(slen >> 12) & 0x7];

    for (i = 0; i < 4; i++) {

        int     num = slen & 0x7;

        slen >>= 3;

        if (num) {

            for (j = 0; j < (int) (pnt[i]); j++)

                *scf++ = getbits_fast(mp, num);

            numbits += pnt[i] * num;

        }

        else {

            for (j = 0; j < (int) (pnt[i]); j++)

                *scf++ = 0;

        }

    }

    n = (n << 1) + 1;

    for (i = 0; i < n; i++)

        *scf++ = 0;

    return numbits;

}

/* *INDENT-OFF* */

static const int pretab1 [22] = {0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,2,2,3,3,3,2,0}; /* char enough ? */

static const int pretab2 [22] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};

/* *INDENT-ON* */

/*

 * don't forget to apply the same changes to III_dequantize_sample_ms() !!!

 */

static int

III_dequantize_sample(PMPSTR mp, real xr[SBLIMIT][SSLIMIT], int *scf,

                      struct gr_info_s *gr_infos, int sfreq, int part2bits)

{

    int     shift = 1 + gr_infos->scalefac_scale;

    real   *xrpnt = (real *) xr, xr_value=0;

    int     l[3], l3;

    int     part2remain = gr_infos->part2_3_length - part2bits;

    int    *me;

    real const * const xr_endptr = &xr[SBLIMIT-1][SSLIMIT-1];

    int isbug = 0;

    int bobug = 0;

    int bobug_sb = 0, bobug_l3=0;

#define BUFFER_OVERFLOW_BUG() if(!bobug){bobug=1;bobug_sb=cb;bobug_l3=l3;}else

    /* lame_report_fnc(mp->report_dbg,"part2remain = %d, gr_infos->part2_3_length = %d, part2bits = %d\n",

       part2remain, gr_infos->part2_3_length, part2bits); */

    {

        int     i;

        for (i = (&xr[SBLIMIT][0] - xrpnt) >> 1; i > 0; i--) {

            *xrpnt++ = 0.0;

            *xrpnt++ = 0.0;

        }

        xrpnt = (real *) xr;

    }

    {

        int     bv = gr_infos->big_values;

        int     region1 = gr_infos->region1start;

        int     region2 = gr_infos->region2start;

        l3 = ((576 >> 1) - bv) >> 1;

/*

 * we may lose the 'odd' bit here !! 

 * check this later again 

 */

        if (bv <= region1) {

            l[0] = bv;

            l[1] = 0;

            l[2] = 0;

        }

        else {

            l[0] = region1;

            if (bv <= region2) {

                l[1] = bv - l[0];

                l[2] = 0;

            }

            else {

                l[1] = region2 - l[0];

                l[2] = bv - region2;

            }

        }

    }

    /* MDH crash fix */

    {

        int     i;

        for (i = 0; i < 3; i++) {

            if (l[i] < 0) {

                lame_report_fnc(mp->report_err, "hip: Bogus region length (%d)\n", l[i]);

                l[i] = 0;

            }

        }

    }

    /* end MDH crash fix */

    if (gr_infos->block_type == 2) {

        /*

         * decoding with short or mixed mode BandIndex table 

         */

        int     i, max[4];

        int     step = 0, lwin = 0, cb = 0;

        real    v = 0.0;

        int    *m, mc;

        if (gr_infos->mixed_block_flag) {

            max[3] = -1;

            max[0] = max[1] = max[2] = 2;

            m = map[sfreq][0];

            me = mapend[sfreq][0];

        }

        else {

            max[0] = max[1] = max[2] = max[3] = -1;

            /* max[3] not really needed in this case */

            m = map[sfreq][1];

            me = mapend[sfreq][1];

        }

        mc = 0;

        for (i = 0; i < 2; i++) {

            int     lp = l[i];

            struct newhuff const *h = (struct newhuff const *) (ht + gr_infos->table_select[i]);

            for (; lp; lp--, mc--) {

                int     x, y;

                if ((!mc)) {

                    mc = *m++;

                    xrpnt = ((real *) xr) + (*m++);

                    lwin = *m++;

                    cb = *m++;

                    if (lwin == 3) {

                        v = get_gain(gr_infos->pow2gain, (*scf++) << shift, &isbug);

                        step = 1;

                    }

                    else {

                        v = get_gain(gr_infos->full_gain[lwin], (*scf++) << shift, &isbug);

                        step = 3;

                    }

                }

                {

                    short const *val = (short const *) h->table;

                    while ((y = *val++) < 0) {

                        if (get1bit(mp))

                            val -= y;

                        part2remain--;

                    }

                    x = y >> 4;

                    y &= 0xf;

                }

                if (x == 15) {

                    max[lwin] = cb;

                    part2remain -= h->linbits + 1;

                    x += getbits(mp, (int) h->linbits);

                    if (get1bit(mp))

                        xr_value = -ispow[x] * v;

                    else

                        xr_value = ispow[x] * v;

                }

                else if (x) {

                    max[lwin] = cb;

                    if (get1bit(mp))

                        xr_value = -ispow[x] * v;

                    else

                        xr_value = ispow[x] * v;

                    part2remain--;

                }

                else

                    xr_value = 0.0;

                if (xrpnt <= xr_endptr)

                    *xrpnt = xr_value;

                else

                    BUFFER_OVERFLOW_BUG();

                xrpnt += step;

                if (y == 15) {

                    max[lwin] = cb;

                    part2remain -= h->linbits + 1;

                    y += getbits(mp, (int) h->linbits);

                    if (get1bit(mp))

                        xr_value = -ispow[y] * v;

                    else

                        xr_value = ispow[y] * v;

                }

                else if (y) {

                    max[lwin] = cb;

                    if (get1bit(mp))

                        xr_value = -ispow[y] * v;

                    else

                        xr_value = ispow[y] * v;

                    part2remain--;

                }