← Back to branch summary

~ubuntu-branches/ubuntu/lucid/mpg123/lucid

« back to all changes in this revision

Viewing changes to layer2.c

Tags: upstream-0.60
Import upstream version 0.60

Show diffs side-by-side

added added

removed removed

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