wined3d: We want to compare the old and the new format and not the old with the old.
[wine] / 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 static 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 static void II_step_two(unsigned int *bit_alloc, real fraction[2][4][SBLIMIT],
148                         int *scale, struct frame *fr, int x1)
149 {
150     int i,j,k,ba;
151     int stereo = fr->stereo;
152     int sblimit = fr->II_sblimit;
153     int jsbound = fr->jsbound;
154     const struct al_table *alloc2,*alloc1 = fr->alloc;
155     unsigned int *bita=bit_alloc;
156     int d1,step;
157
158     for (i=0;i<jsbound;i++,alloc1+=(1<<step))
159     {
160       step = alloc1->bits;
161       for (j=0;j<stereo;j++)
162       {
163         if ( (ba=*bita++) )
164         {
165           k=(alloc2 = alloc1+ba)->bits;
166           if( (d1=alloc2->d) < 0)
167           {
168             real cm=muls[k][scale[x1]];
169             fraction[j][0][i] = ((real) ((int)getbits(k) + d1)) * cm;
170             fraction[j][1][i] = ((real) ((int)getbits(k) + d1)) * cm;
171             fraction[j][2][i] = ((real) ((int)getbits(k) + d1)) * cm;
172           }
173           else
174           {
175             static int *table[] = { 0,0,0,grp_3tab,0,grp_5tab,0,0,0,grp_9tab };
176             unsigned int idx,*tab,m=scale[x1];
177             idx = getbits(k);
178             tab = (unsigned int *) (table[d1] + idx + idx + idx);
179             fraction[j][0][i] = muls[*tab++][m];
180             fraction[j][1][i] = muls[*tab++][m];
181             fraction[j][2][i] = muls[*tab][m];
182           }
183           scale+=3;
184         }
185         else
186           fraction[j][0][i] = fraction[j][1][i] = fraction[j][2][i] = 0.0;
187       }
188     }
189
190     for (i=jsbound;i<sblimit;i++,alloc1+=(1<<step))
191     {
192       step = alloc1->bits;
193       bita++;   /* channel 1 and channel 2 bitalloc are the same */
194       if ( (ba=*bita++) )
195       {
196         k=(alloc2 = alloc1+ba)->bits;
197         if( (d1=alloc2->d) < 0)
198         {
199           real cm;
200           cm=muls[k][scale[x1+3]];
201           fraction[1][0][i] = (fraction[0][0][i] = (real) ((int)getbits(k) + d1) ) * cm;
202           fraction[1][1][i] = (fraction[0][1][i] = (real) ((int)getbits(k) + d1) ) * cm;
203           fraction[1][2][i] = (fraction[0][2][i] = (real) ((int)getbits(k) + d1) ) * cm;
204           cm=muls[k][scale[x1]];
205           fraction[0][0][i] *= cm; fraction[0][1][i] *= cm; fraction[0][2][i] *= cm;
206         }
207         else
208         {
209           static int *table[] = { 0,0,0,grp_3tab,0,grp_5tab,0,0,0,grp_9tab };
210           unsigned int idx,*tab,m1,m2;
211           m1 = scale[x1]; m2 = scale[x1+3];
212           idx = getbits(k);
213           tab = (unsigned int *) (table[d1] + idx + idx + idx);
214           fraction[0][0][i] = muls[*tab][m1]; fraction[1][0][i] = muls[*tab++][m2];
215           fraction[0][1][i] = muls[*tab][m1]; fraction[1][1][i] = muls[*tab++][m2];
216           fraction[0][2][i] = muls[*tab][m1]; fraction[1][2][i] = muls[*tab][m2];
217         }
218         scale+=6;
219       }
220       else {
221         fraction[0][0][i] = fraction[0][1][i] = fraction[0][2][i] =
222         fraction[1][0][i] = fraction[1][1][i] = fraction[1][2][i] = 0.0;
223       }
224 /*
225    should we use individual scalefac for channel 2 or
226    is the current way the right one , where we just copy channel 1 to
227    channel 2 ??
228    The current 'strange' thing is, that we throw away the scalefac
229    values for the second channel ...!!
230 -> changed .. now we use the scalefac values of channel one !!
231 */
232     }
233
234     for(i=sblimit;i<SBLIMIT;i++)
235       for (j=0;j<stereo;j++)
236         fraction[j][0][i] = fraction[j][1][i] = fraction[j][2][i] = 0.0;
237
238 }
239
240 static void II_select_table(struct frame *fr)
241 {
242   static const int translate[3][2][16] =
243    { { { 0,2,2,2,2,2,2,0,0,0,1,1,1,1,1,0 } ,
244        { 0,2,2,0,0,0,1,1,1,1,1,1,1,1,1,0 } } ,
245      { { 0,2,2,2,2,2,2,0,0,0,0,0,0,0,0,0 } ,
246        { 0,2,2,0,0,0,0,0,0,0,0,0,0,0,0,0 } } ,
247      { { 0,3,3,3,3,3,3,0,0,0,1,1,1,1,1,0 } ,
248        { 0,3,3,0,0,0,1,1,1,1,1,1,1,1,1,0 } } };
249
250   int table,sblim;
251   static const struct al_table *tables[5] =
252        { alloc_0, alloc_1, alloc_2, alloc_3 , alloc_4 };
253   static const int sblims[5] = { 27 , 30 , 8, 12 , 30 };
254
255   if(fr->lsf)
256     table = 4;
257   else
258     table = translate[fr->sampling_frequency][2-fr->stereo][fr->bitrate_index];
259   sblim = sblims[table];
260
261   fr->alloc      = tables[table];
262   fr->II_sblimit = sblim;
263 }
264
265 int do_layer2(struct frame *fr,unsigned char *pcm_sample,int *pcm_point)
266 {
267   int clip=0;
268   int i,j;
269   int stereo = fr->stereo;
270   real fraction[2][4][SBLIMIT]; /* pick_table clears unused subbands */
271   unsigned int bit_alloc[64];
272   int scale[192];
273   int single = fr->single;
274
275   II_select_table(fr);
276   fr->jsbound = (fr->mode == MPG_MD_JOINT_STEREO) ?
277      (fr->mode_ext<<2)+4 : fr->II_sblimit;
278
279   if(stereo == 1 || single == 3)
280     single = 0;
281
282   II_step_one(bit_alloc, scale, fr);
283
284   for (i=0;i<SCALE_BLOCK;i++)
285   {
286     II_step_two(bit_alloc,fraction,scale,fr,i>>2);
287     for (j=0;j<3;j++) {
288       if(single >= 0) {
289         clip += synth_1to1_mono(fr->mp,fraction[0][j],pcm_sample,pcm_point);
290       }
291       else {
292         int p1 = *pcm_point;
293         clip += synth_1to1(fr->mp,fraction[0][j],0,pcm_sample,&p1);
294         clip += synth_1to1(fr->mp,fraction[1][j],1,pcm_sample,pcm_point);
295       }
296
297     }
298   }
299
300   return clip;
301 }