dlls/winemp3.acm/layer2.c

   1 /*
   2  * Mpeg Layer-2 audio decoder
   3  * --------------------------
   4  * copyright (c) 1995 by Michael Hipp, All rights reserved. See also 'README'
   5  * This file has been copied from mpglib.
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include "mpg123.h"
  23 #include "l2tables.h"
  24
  25 static int grp_3tab[32 * 3] = { 0, };   /* used: 27 */
  26 static int grp_5tab[128 * 3] = { 0, };  /* used: 125 */
  27 static int grp_9tab[1024 * 3] = { 0, }; /* used: 729 */
  28
  29 real muls[27][64];      /* also used by layer 1 */
  30
  31 void init_layer2(void)
  32 {
  33   static const double mulmul[27] = {
  34     0.0 , -2.0/3.0 , 2.0/3.0 ,
  35     2.0/7.0 , 2.0/15.0 , 2.0/31.0, 2.0/63.0 , 2.0/127.0 , 2.0/255.0 ,
  36     2.0/511.0 , 2.0/1023.0 , 2.0/2047.0 , 2.0/4095.0 , 2.0/8191.0 ,
  37     2.0/16383.0 , 2.0/32767.0 , 2.0/65535.0 ,
  38     -4.0/5.0 , -2.0/5.0 , 2.0/5.0, 4.0/5.0 ,
  39     -8.0/9.0 , -4.0/9.0 , -2.0/9.0 , 2.0/9.0 , 4.0/9.0 , 8.0/9.0 };
  40   static const int base[3][9] = {
  41      { 1 , 0, 2 , } ,
  42      { 17, 18, 0 , 19, 20 , } ,
  43      { 21, 1, 22, 23, 0, 24, 25, 2, 26 } };
  44   int i,j,k,l,len;
  45   real *table;
  46   static const int tablen[3] = { 3 , 5 , 9 };
  47   static int *itable,*tables[3] = { grp_3tab , grp_5tab , grp_9tab };
  48
  49   for(i=0;i<3;i++)
  50   {
  51     itable = tables[i];
  52     len = tablen[i];
  53     for(j=0;j<len;j++)
  54       for(k=0;k<len;k++)
  55         for(l=0;l<len;l++)
  56         {
  57           *itable++ = base[i][l];
  58           *itable++ = base[i][k];
  59           *itable++ = base[i][j];
  60         }
  61   }
  62
  63   for(k=0;k<27;k++)
  64   {
  65     double m=mulmul[k];
  66     table = muls[k];
  67     for(j=3,i=0;i<63;i++,j--)
  68       *table++ = m * pow(2.0,(double) j / 3.0);
  69     *table++ = 0.0;
  70   }
  71 }
  72
  73
  74 void II_step_one(unsigned int *bit_alloc,int *scale,struct frame *fr)
  75 {
  76     int stereo = fr->stereo-1;
  77     int sblimit = fr->II_sblimit;
  78     int jsbound = fr->jsbound;
  79     int sblimit2 = fr->II_sblimit<<stereo;
  80     const struct al_table *alloc1 = fr->alloc;
  81     int i;
  82     static unsigned int scfsi_buf[64];
  83     unsigned int *scfsi,*bita;
  84     int sc,step;
  85
  86     bita = bit_alloc;
  87     if(stereo)
  88     {
  89       for (i=jsbound;i;i--,alloc1+=(1<<step))
  90       {
  91         *bita++ = (char) getbits(step=alloc1->bits);
  92         *bita++ = (char) getbits(step);
  93       }
  94       for (i=sblimit-jsbound;i;i--,alloc1+=(1<<step))
  95       {
  96         bita[0] = (char) getbits(step=alloc1->bits);
  97         bita[1] = bita[0];
  98         bita+=2;
  99       }
 100       bita = bit_alloc;
 101       scfsi=scfsi_buf;
 102       for (i=sblimit2;i;i--)
 103         if (*bita++)
 104           *scfsi++ = (char) getbits_fast(2);
 105     }
 106     else /* mono */
 107     {
 108       for (i=sblimit;i;i--,alloc1+=(1<<step))
 109         *bita++ = (char) getbits(step=alloc1->bits);
 110       bita = bit_alloc;
 111       scfsi=scfsi_buf;
 112       for (i=sblimit;i;i--)
 113         if (*bita++)
 114           *scfsi++ = (char) getbits_fast(2);
 115     }
 116
 117     bita = bit_alloc;
 118     scfsi=scfsi_buf;
 119     for (i=sblimit2;i;i--)
 120       if (*bita++)
 121         switch (*scfsi++)
 122         {
 123           case 0:
 124                 *scale++ = getbits_fast(6);
 125                 *scale++ = getbits_fast(6);
 126                 *scale++ = getbits_fast(6);
 127                 break;
 128           case 1 :
 129                 *scale++ = sc = getbits_fast(6);
 130                 *scale++ = sc;
 131                 *scale++ = getbits_fast(6);
 132                 break;
 133           case 2:
 134                 *scale++ = sc = getbits_fast(6);
 135                 *scale++ = sc;
 136                 *scale++ = sc;
 137                 break;
 138           default:              /* case 3 */
 139                 *scale++ = getbits_fast(6);
 140                 *scale++ = sc = getbits_fast(6);
 141                 *scale++ = sc;
 142                 break;
 143         }
 144
 145 }
 146
 147 void II_step_two(unsigned int *bit_alloc,real fraction[2][4][SBLIMIT],int *scale,struct frame *fr,int x1)
 148 {
 149     int i,j,k,ba;
 150     int stereo = fr->stereo;
 151     int sblimit = fr->II_sblimit;
 152     int jsbound = fr->jsbound;
 153     const struct al_table *alloc2,*alloc1 = fr->alloc;
 154     unsigned int *bita=bit_alloc;
 155     int d1,step;
 156
 157     for (i=0;i<jsbound;i++,alloc1+=(1<<step))
 158     {
 159       step = alloc1->bits;
 160       for (j=0;j<stereo;j++)
 161       {
 162         if ( (ba=*bita++) )
 163         {
 164           k=(alloc2 = alloc1+ba)->bits;
 165           if( (d1=alloc2->d) < 0)
 166           {
 167             real cm=muls[k][scale[x1]];
 168             fraction[j][0][i] = ((real) ((int)getbits(k) + d1)) * cm;
 169             fraction[j][1][i] = ((real) ((int)getbits(k) + d1)) * cm;
 170             fraction[j][2][i] = ((real) ((int)getbits(k) + d1)) * cm;
 171           }
 172           else
 173           {
 174             static int *table[] = { 0,0,0,grp_3tab,0,grp_5tab,0,0,0,grp_9tab };
 175             unsigned int idx,*tab,m=scale[x1];
 176             idx = (unsigned int) getbits(k);
 177             tab = (unsigned int *) (table[d1] + idx + idx + idx);
 178             fraction[j][0][i] = muls[*tab++][m];
 179             fraction[j][1][i] = muls[*tab++][m];
 180             fraction[j][2][i] = muls[*tab][m];
 181           }
 182           scale+=3;
 183         }
 184         else
 185           fraction[j][0][i] = fraction[j][1][i] = fraction[j][2][i] = 0.0;
 186       }
 187     }
 188
 189     for (i=jsbound;i<sblimit;i++,alloc1+=(1<<step))
 190     {
 191       step = alloc1->bits;
 192       bita++;   /* channel 1 and channel 2 bitalloc are the same */
 193       if ( (ba=*bita++) )
 194       {
 195         k=(alloc2 = alloc1+ba)->bits;
 196         if( (d1=alloc2->d) < 0)
 197         {
 198           real cm;
 199           cm=muls[k][scale[x1+3]];
 200           fraction[1][0][i] = (fraction[0][0][i] = (real) ((int)getbits(k) + d1) ) * cm;
 201           fraction[1][1][i] = (fraction[0][1][i] = (real) ((int)getbits(k) + d1) ) * cm;
 202           fraction[1][2][i] = (fraction[0][2][i] = (real) ((int)getbits(k) + d1) ) * cm;
 203           cm=muls[k][scale[x1]];
 204           fraction[0][0][i] *= cm; fraction[0][1][i] *= cm; fraction[0][2][i] *= cm;
 205         }
 206         else
 207         {
 208           static int *table[] = { 0,0,0,grp_3tab,0,grp_5tab,0,0,0,grp_9tab };
 209           unsigned int idx,*tab,m1,m2;
 210           m1 = scale[x1]; m2 = scale[x1+3];
 211           idx = (unsigned int) getbits(k);
 212           tab = (unsigned int *) (table[d1] + idx + idx + idx);
 213           fraction[0][0][i] = muls[*tab][m1]; fraction[1][0][i] = muls[*tab++][m2];
 214           fraction[0][1][i] = muls[*tab][m1]; fraction[1][1][i] = muls[*tab++][m2];
 215           fraction[0][2][i] = muls[*tab][m1]; fraction[1][2][i] = muls[*tab][m2];
 216         }
 217         scale+=6;
 218       }
 219       else {
 220         fraction[0][0][i] = fraction[0][1][i] = fraction[0][2][i] =
 221         fraction[1][0][i] = fraction[1][1][i] = fraction[1][2][i] = 0.0;
 222       }
 223 /*
 224    should we use individual scalefac for channel 2 or
 225    is the current way the right one , where we just copy channel 1 to
 226    channel 2 ??
 227    The current 'strange' thing is, that we throw away the scalefac
 228    values for the second channel ...!!
 229 -> changed .. now we use the scalefac values of channel one !!
 230 */
 231     }
 232
 233     for(i=sblimit;i<SBLIMIT;i++)
 234       for (j=0;j<stereo;j++)
 235         fraction[j][0][i] = fraction[j][1][i] = fraction[j][2][i] = 0.0;
 236
 237 }
 238
 239 static void II_select_table(struct frame *fr)
 240 {
 241   static const int translate[3][2][16] =
 242    { { { 0,2,2,2,2,2,2,0,0,0,1,1,1,1,1,0 } ,
 243        { 0,2,2,0,0,0,1,1,1,1,1,1,1,1,1,0 } } ,
 244      { { 0,2,2,2,2,2,2,0,0,0,0,0,0,0,0,0 } ,
 245        { 0,2,2,0,0,0,0,0,0,0,0,0,0,0,0,0 } } ,
 246      { { 0,3,3,3,3,3,3,0,0,0,1,1,1,1,1,0 } ,
 247        { 0,3,3,0,0,0,1,1,1,1,1,1,1,1,1,0 } } };
 248
 249   int table,sblim;
 250   static const struct al_table *tables[5] =
 251        { alloc_0, alloc_1, alloc_2, alloc_3 , alloc_4 };
 252   static const int sblims[5] = { 27 , 30 , 8, 12 , 30 };
 253
 254   if(fr->lsf)
 255     table = 4;
 256   else
 257     table = translate[fr->sampling_frequency][2-fr->stereo][fr->bitrate_index];
 258   sblim = sblims[table];
 259
 260   fr->alloc      = tables[table];
 261   fr->II_sblimit = sblim;
 262 }
 263
 264 int do_layer2(struct frame *fr,unsigned char *pcm_sample,int *pcm_point)
 265 {
 266   int clip=0;
 267   int i,j;
 268   int stereo = fr->stereo;
 269   real fraction[2][4][SBLIMIT]; /* pick_table clears unused subbands */
 270   unsigned int bit_alloc[64];
 271   int scale[192];
 272   int single = fr->single;
 273
 274   II_select_table(fr);
 275   fr->jsbound = (fr->mode == MPG_MD_JOINT_STEREO) ?
 276      (fr->mode_ext<<2)+4 : fr->II_sblimit;
 277
 278   if(stereo == 1 || single == 3)
 279     single = 0;
 280
 281   II_step_one(bit_alloc, scale, fr);
 282
 283   for (i=0;i<SCALE_BLOCK;i++)
 284   {
 285     II_step_two(bit_alloc,fraction,scale,fr,i>>2);
 286     for (j=0;j<3;j++) {
 287       if(single >= 0) {
 288         clip += synth_1to1_mono(fraction[0][j],pcm_sample,pcm_point);
 289       }
 290       else {
 291         int p1 = *pcm_point;
 292         clip += synth_1to1(fraction[0][j],0,pcm_sample,&p1);
 293         clip += synth_1to1(fraction[1][j],1,pcm_sample,pcm_point);
 294       }
 295
 296     }
 297   }
 298
 299   return clip;
 300 }