/* 

 * layer2.c: Mpeg Layer-2 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: layer2.c,v 1.34 2017/08/22 23:31:07 robert Exp $ */

#ifdef HAVE_CONFIG_H

# include <config.h>

#endif

#include "common.h"

#include "layer2.h"

#include "l2tables.h"

#include "decode_i386.h"

#ifdef WITH_DMALLOC

#include <dmalloc.h>

#endif

#include <assert.h>

static int gd_are_hip_tables_layer2_initialized = 0;

static unsigned char grp_3tab[32 * 3] = { 0, }; /* used: 27 */

static unsigned char grp_5tab[128 * 3] = { 0, }; /* used: 125 */

static unsigned char grp_9tab[1024 * 3] = { 0, }; /* used: 729 */

void

hip_init_tables_layer2(void)

{

    static const double mulmul[27] = {

        0.0, -2.0 / 3.0, 2.0 / 3.0,

        2.0 / 7.0, 2.0 / 15.0, 2.0 / 31.0, 2.0 / 63.0, 2.0 / 127.0, 2.0 / 255.0,

        2.0 / 511.0, 2.0 / 1023.0, 2.0 / 2047.0, 2.0 / 4095.0, 2.0 / 8191.0,

        2.0 / 16383.0, 2.0 / 32767.0, 2.0 / 65535.0,

        -4.0 / 5.0, -2.0 / 5.0, 2.0 / 5.0, 4.0 / 5.0,

        -8.0 / 9.0, -4.0 / 9.0, -2.0 / 9.0, 2.0 / 9.0, 4.0 / 9.0, 8.0 / 9.0

    };

    static const unsigned char base[3][9] = {

        {1, 0, 2,},

        {17, 18, 0, 19, 20,},

        {21, 1, 22, 23, 0, 24, 25, 2, 26}

    };

    int     i, j, k, l, len;

    real   *table;

    static const int tablen[3] = { 3, 5, 9 };

    static unsigned char *itable, *tables[3] = { grp_3tab, grp_5tab, grp_9tab };

    if (gd_are_hip_tables_layer2_initialized) {

        return;

    }

    gd_are_hip_tables_layer2_initialized = 1;

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

        itable = tables[i];

        len = tablen[i];

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

            for (k = 0; k < len; k++)

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

                    *itable++ = base[i][l];

                    *itable++ = base[i][k];

                    *itable++ = base[i][j];

                }

    }

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

        double  m = mulmul[k];

        table = muls[k];

        for (j = 3, i = 0; i < 63; i++, j--)

            *table++ = (real) (m * pow(2.0, (double) j / 3.0));

        *table++ = 0.0;

    }

}

static unsigned char*

grp_table_select(short d1, unsigned int idx)

{

    /* RH: it seems to be common, that idx is larger than the table's sizes.

           is it OK to return a zero vector in this case? FIXME

    /*/

    static unsigned char dummy_table[] = { 0,0,0 };

    unsigned int x;

    switch (d1) {

        case 3:

            x = 3*3*3;

            idx = idx < x ? idx : x;

            return &grp_3tab[3 * idx]; 

        case 5: 

            x = 5*5*5;

            idx = idx < x ? idx : x;

            return &grp_5tab[3 * idx]; 

        case 9:

            x = 9*9*9;

            idx = idx < x ? idx : x;

            return &grp_9tab[3 * idx];

        default:

            /* fatal error */

            assert(0);

    }

    return &dummy_table[0];

}

typedef struct sideinfo_layer_II_struct

{

    unsigned char allocation[SBLIMIT][2]; 

    unsigned char scalefactor[SBLIMIT][2][3]; /* subband / channel / block */

} sideinfo_layer_II;

static void

II_step_one(PMPSTR mp, sideinfo_layer_II *si, struct frame *fr)

{

    int     nch = fr->stereo;

    int     sblimit = fr->II_sblimit;

    int     jsbound = (fr->mode == MPG_MD_JOINT_STEREO) ? (fr->mode_ext << 2) + 4 : fr->II_sblimit;

    struct al_table2 const *alloc1 = fr->alloc;

    unsigned char scfsi[SBLIMIT][2];

    int     i, ch;

    memset(si, 0, sizeof(*si));

    if (jsbound > sblimit)

        jsbound = sblimit;

    if (nch == 2) {

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

            short   step = alloc1->bits;

            unsigned char b0 = get_leq_8_bits(mp, step);

            unsigned char b1 = get_leq_8_bits(mp, step);

            alloc1 += ((size_t)1 << step);

            si->allocation[i][0] = b0;

            si->allocation[i][1] = b1;

        }

        for (i = jsbound; i < sblimit; ++i) {

            short   step = alloc1->bits;

            unsigned char b0 = get_leq_8_bits(mp, step);

            alloc1 += ((size_t)1 << step);

            si->allocation[i][0] = b0;

            si->allocation[i][1] = b0;

        }

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

            unsigned char n0 = si->allocation[i][0];

            unsigned char n1 = si->allocation[i][1];

            unsigned char b0 = n0 ? get_leq_8_bits(mp, 2) : 0;

            unsigned char b1 = n1 ? get_leq_8_bits(mp, 2) : 0;

            scfsi[i][0] = b0;

            scfsi[i][1] = b1;

        }

    }

    else {              /* mono */

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

            short   step = alloc1->bits;

            unsigned char b0 = get_leq_8_bits(mp, step);

            alloc1 += ((size_t)1 << step);

            si->allocation[i][0] = b0;

        }

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

            unsigned char n0 = si->allocation[i][0];

            unsigned char b0 = n0 ? get_leq_8_bits(mp, 2) : 0;

            scfsi[i][0] = b0;

        }

    }

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

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

            unsigned char s0 = 0, s1 = 0, s2 = 0;

            if (si->allocation[i][ch]) {

                switch (scfsi[i][ch]) {

                    case 0:

                        s0 = get_leq_8_bits(mp, 6);

                        s1 = get_leq_8_bits(mp, 6);

                        s2 = get_leq_8_bits(mp, 6);

                        break;

                    case 1:

                        s0 = get_leq_8_bits(mp, 6);

                        s1 = s0;

                        s2 = get_leq_8_bits(mp, 6);

                        break;

                    case 2:

                        s0 = get_leq_8_bits(mp, 6);

                        s1 = s0;

                        s2 = s0;

                        break;

                    case 3:

                        s0 = get_leq_8_bits(mp, 6); 

                        s1 = get_leq_8_bits(mp, 6);

                        s2 = s1;

                        break;

                    default:

                        assert(0);

                }

            }

            si->scalefactor[i][ch][0] = s0;

            si->scalefactor[i][ch][1] = s1;

            si->scalefactor[i][ch][2] = s2;

        }

    }

}

static void

II_step_two(PMPSTR mp, sideinfo_layer_II* si, struct frame *fr, int gr, real fraction[2][4][SBLIMIT])

{

    struct al_table2 const *alloc1 = fr->alloc;

    int     sblimit = fr->II_sblimit;

    int     jsbound = (fr->mode == MPG_MD_JOINT_STEREO) ? (fr->mode_ext << 2) + 4 : fr->II_sblimit;

    int     i, ch, nch = fr->stereo;

    double  cm, r0, r1, r2;

    if (jsbound > sblimit)

        jsbound = sblimit;

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

        short   step = alloc1->bits;

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

            unsigned char ba = si->allocation[i][ch];

            if (ba) {

                unsigned char x1 = si->scalefactor[i][ch][gr];

                struct al_table2 const *alloc2 = alloc1 + ba;

                short   k = alloc2->bits;

                short   d1 = alloc2->d;

                assert( k <= 16 );

                k = (k <= 16) ? k : 16;

                assert( x1 < 64 );

                x1 = (x1 < 64) ? x1 : 63;

                if (d1 < 0) {

                    int v0 = getbits(mp, k);

                    int v1 = getbits(mp, k);

                    int v2 = getbits(mp, k);

                    cm = muls[k][x1];

                    r0 = (v0 + d1) * cm;

                    r1 = (v1 + d1) * cm;

                    r2 = (v2 + d1) * cm;

                }

                else {

                    unsigned int idx = getbits(mp, k);

                    unsigned char *tab = grp_table_select(d1, idx);

                    unsigned char k0 = tab[0];

                    unsigned char k1 = tab[1];

                    unsigned char k2 = tab[2];

                    r0 = muls[k0][x1];

                    r1 = muls[k1][x1];

                    r2 = muls[k2][x1];

                }

                fraction[ch][0][i] = (real) r0;

                fraction[ch][1][i] = (real) r1;

                fraction[ch][2][i] = (real) r2;

            }

            else {

                fraction[ch][0][i] = fraction[ch][1][i] = fraction[ch][2][i] = 0.0;

            }

        }

        alloc1 += ((size_t)1 << step);

    }

    for (i = jsbound; i < sblimit; i++) {

        short   step = alloc1->bits;

        unsigned char ba = si->allocation[i][0];

        if (ba) {

            struct al_table2 const *alloc2 = alloc1 + ba;

            short   k = alloc2->bits;

            short   d1 = alloc2->d;

            assert( k <= 16 );

            k = (k <= 16) ? k : 16;

            if (d1 < 0) {

                int v0 = getbits(mp, k);

                int v1 = getbits(mp, k);

                int v2 = getbits(mp, k);

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

                    unsigned char x1 = si->scalefactor[i][ch][gr];

                    assert( x1 < 64 );

                    x1 = (x1 < 64) ? x1 : 63;

                    cm = muls[k][x1];

                    r0 = (v0 + d1) * cm;

                    r1 = (v1 + d1) * cm;

                    r2 = (v2 + d1) * cm;

                    fraction[ch][0][i] = (real) r0;

                    fraction[ch][1][i] = (real) r1;

                    fraction[ch][2][i] = (real) r2;

                }

            }

            else {

                unsigned int idx = getbits(mp, k);

                unsigned char *tab = grp_table_select(d1, idx);

                unsigned char k0 = tab[0];

                unsigned char k1 = tab[1];

                unsigned char k2 = tab[2];

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

                    unsigned char x1 = si->scalefactor[i][ch][gr];

                    assert( x1 < 64 );

                    x1 = (x1 < 64) ? x1 : 63;

                    r0 = muls[k0][x1];

                    r1 = muls[k1][x1];

                    r2 = muls[k2][x1];

                    fraction[ch][0][i] = (real) r0;

                    fraction[ch][1][i] = (real) r1;

                    fraction[ch][2][i] = (real) r2;

                }

            }

        }

        else {

            fraction[0][0][i] = fraction[0][1][i] = fraction[0][2][i] = 0.0;

            fraction[1][0][i] = fraction[1][1][i] = fraction[1][2][i] = 0.0;

        }

        alloc1 += ((size_t)1 << step);

    }

    if (sblimit > fr->down_sample_sblimit) {

        sblimit = fr->down_sample_sblimit; 

    }

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

        for (i = sblimit; i < SBLIMIT; ++i) {

            fraction[ch][0][i] = fraction[ch][1][i] = fraction[ch][2][i] = 0.0;

        }

    }

}

static void

II_select_table(struct frame *fr)

{

    /* *INDENT-OFF* */

  static const int translate[3][2][16] =

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

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

     { { 0,2,2,2,2,2,2,0,0,0,0,0,0,0,0,0 } ,

       { 0,2,2,0,0,0,0,0,0,0,0,0,0,0,0,0 } } ,

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

       { 0,3,3,0,0,0,1,1,1,1,1,1,1,1,1,0 } } };

    /* *INDENT-ON* */

    int     table, sblim;

    static const struct al_table2 *tables[5] = { alloc_0, alloc_1, alloc_2, alloc_3, alloc_4 };

    static const int sblims[5] = { 27, 30, 8, 12, 30 };

    if (fr->lsf)

        table = 4;

    else

        table = translate[fr->sampling_frequency][2 - fr->stereo][fr->bitrate_index];

    sblim = sblims[table];

    fr->alloc = (struct al_table2 const *) tables[table];

    fr->II_sblimit = sblim;

}

int

decode_layer2_sideinfo(PMPSTR mp)

{

    (void) mp;

    /* FIXME: extract side information and check values */

    return 0;

}

int

decode_layer2_frame(PMPSTR mp, unsigned char *pcm_sample, int *pcm_point)

{

    real    fraction[2][4][SBLIMIT]; /* pick_table clears unused subbands */

    sideinfo_layer_II si;

    struct frame *fr = &(mp->fr);

    int     single = fr->single;

    int     i, j, clip = 0;

    II_select_table(fr);

    II_step_one(mp, &si, fr);

    if (fr->stereo == 1 || single == 3)

        single = 0;

    if (single >= 0) {

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

            II_step_two(mp, &si, fr, i >> 2, fraction);

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

                clip += synth_1to1_mono(mp, fraction[single][j], pcm_sample, pcm_point);

            }

        }

    }

    else {

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

            II_step_two(mp, &si, fr, i >> 2, fraction);

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

                int     p1 = *pcm_point;

                clip += synth_1to1(mp, fraction[0][j], 0, pcm_sample, &p1;;

                clip += synth_1to1(mp, fraction[1][j], 1, pcm_sample, pcm_point);

            }

        }

    }

    return clip;

}