7d387b65dac234c1ecda0ddc78439168266d7512
[asterisk/asterisk.git] / codecs / mp3 / src / cupl3.c
1 /*____________________________________________________________________________
2         
3         FreeAmp - The Free MP3 Player
4
5         MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
6         Corp.  http://www.xingtech.com
7
8         Portions Copyright (C) 1998-1999 EMusic.com
9
10         This program is free software; you can redistribute it and/or modify
11         it under the terms of the GNU General Public License as published by
12         the Free Software Foundation; either version 2 of the License, or
13         (at your option) any later version.
14
15         This program is distributed in the hope that it will be useful,
16         but WITHOUT ANY WARRANTY; without even the implied warranty of
17         MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18         GNU General Public License for more details.
19
20         You should have received a copy of the GNU General Public License
21         along with this program; if not, write to the Free Software
22         Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23         
24         $Id$
25 ____________________________________________________________________________*/
26
27 /****  cupL3.c  ***************************************************
28 unpack Layer III
29
30
31 mod 8/18/97  bugfix crc problem
32
33 mod 10/9/97  add band_limit12 for short blocks
34
35 mod 10/22/97  zero buf_ptrs in init
36
37 mod 5/15/98 mpeg 2.5
38
39 mod 8/19/98 decode 22 sf bands
40
41 ******************************************************************/
42
43 /*---------------------------------------
44 TO DO: Test mixed blocks (mixed long/short)
45   No mixed blocks in mpeg-1 test stream being used for development
46
47 -----------------------------------------*/
48
49 #include <stdlib.h>
50 #include <stdio.h>
51 #include <float.h>
52 #include <math.h>
53 #include <memory.h>
54 #include <string.h>
55 #include <assert.h>
56 #include "L3.h"
57 #include "mhead.h"              /* mpeg header structure */
58 #include "jdw.h"
59 #include "protos.h"
60
61
62 /*====================================================================*/
63 static int mp_sr20_table[2][4] =
64 {{441, 480, 320, -999}, {882, 960, 640, -999}};
65 static int mp_br_tableL3[2][16] =
66 {{0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, 0},     /* mpeg 2 */
67  {0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 0}};
68
69 /*====================================================================*/
70
71 /*-- global band tables */
72 /*-- short portion is 3*x !! --*/
73
74 /*====================================================================*/
75
76 /*---------------------------------*/
77 /*---------------------------------*/
78 /*- sample union of int/float  sample[ch][gr][576] */
79 /* Sample is the same as cup.sample */
80
81 void sbt_dual_L3(MPEG *m, float *sample, short *pcm, int n);
82
83 IN_OUT L3audio_decode_MPEG1(void *mv, unsigned char *bs, unsigned char *pcm);
84 IN_OUT L3audio_decode_MPEG2(void *mv, unsigned char *bs, unsigned char *pcm);
85 /*
86 static DECODE_FUNCTION decode_function = L3audio_decode_MPEG1;
87 */
88
89 /*====================================================================*/
90 /* get bits from bitstream in endian independent way */
91
92 BITDAT bitdat;                  /* global for inline use by Huff */
93
94 /*------------- initialize bit getter -------------*/
95 static void bitget_init(unsigned char *buf)
96 {
97    bitdat.bs_ptr0 = bitdat.bs_ptr = buf;
98    bitdat.bits = 0;
99    bitdat.bitbuf = 0;
100 }
101 /*------------- initialize bit getter -------------*/
102 static void bitget_init_end(unsigned char *buf_end)
103 {
104    bitdat.bs_ptr_end = buf_end;
105 }
106 /*------------- get n bits from bitstream -------------*/
107 int bitget_bits_used()
108 {
109    int n;                       /* compute bits used from last init call */
110
111    n = ((bitdat.bs_ptr - bitdat.bs_ptr0) << 3) - bitdat.bits;
112    return n;
113 }
114 /*------------- check for n bits in bitbuf -------------*/
115 void bitget_check(int n)
116 {
117    if (bitdat.bits < n)
118    {
119       while (bitdat.bits <= 24)
120       {
121          bitdat.bitbuf = (bitdat.bitbuf << 8) | *bitdat.bs_ptr++;
122          bitdat.bits += 8;
123       }
124    }
125 }
126 /*------------- get n bits from bitstream -------------*/
127 unsigned int bitget(int n)
128 {
129    unsigned int x;
130
131    if (bitdat.bits < n)
132    {                            /* refill bit buf if necessary */
133       while (bitdat.bits <= 24)
134       {
135          bitdat.bitbuf = (bitdat.bitbuf << 8) | *bitdat.bs_ptr++;
136          bitdat.bits += 8;
137       }
138    }
139    bitdat.bits -= n;
140    x = bitdat.bitbuf >> bitdat.bits;
141    bitdat.bitbuf -= x << bitdat.bits;
142    return x;
143 }
144 /*------------- get 1 bit from bitstream -------------*/
145 unsigned int bitget_1bit()
146 {
147    unsigned int x;
148
149    if (bitdat.bits <= 0)
150    {                            /* refill bit buf if necessary */
151       while (bitdat.bits <= 24)
152       {
153          bitdat.bitbuf = (bitdat.bitbuf << 8) | *bitdat.bs_ptr++;
154          bitdat.bits += 8;
155       }
156    }
157    bitdat.bits--;
158    x = bitdat.bitbuf >> bitdat.bits;
159    bitdat.bitbuf -= x << bitdat.bits;
160    return x;
161 }
162 /*====================================================================*/
163 static void Xform_mono(void *mv, void *pcm, int igr)
164 {
165    MPEG *m = mv;
166    int igr_prev, n1, n2;
167
168 /*--- hybrid + sbt ---*/
169    n1 = n2 = m->cupl.nsamp[igr][0];     /* total number bands */
170    if (m->cupl.side_info.gr[igr][0].block_type == 2)
171    {                            /* long bands */
172       n1 = 0;
173       if (m->cupl.side_info.gr[igr][0].mixed_block_flag)
174          n1 = m->cupl.sfBandIndex[0][m->cupl.ncbl_mixed - 1];
175    }
176    if (n1 > m->cupl.band_limit)
177       n1 = m->cupl.band_limit;
178    if (n2 > m->cupl.band_limit)
179       n2 = m->cupl.band_limit;
180    igr_prev = igr ^ 1;
181
182    m->cupl.nsamp[igr][0] = hybrid(m,m->cupl.sample[0][igr], m->cupl.sample[0][igr_prev],
183          m->cupl.yout, m->cupl.side_info.gr[igr][0].block_type, n1, n2, m->cupl.nsamp[igr_prev][0]);
184    FreqInvert(m->cupl.yout, m->cupl.nsamp[igr][0]);
185    m->cupl.sbt_L3(m,m->cupl.yout, pcm, 0);
186
187 }
188
189 /*--------------------------------------------------------------------*/
190 static void Xform_dual_right(void *mv, void *pcm, int igr)
191 {
192    MPEG *m = mv;
193    int igr_prev, n1, n2;
194
195 /*--- hybrid + sbt ---*/
196    n1 = n2 = m->cupl.nsamp[igr][1];     /* total number bands */
197    if (m->cupl.side_info.gr[igr][1].block_type == 2)
198    {                            /* long bands */
199       n1 = 0;
200       if (m->cupl.side_info.gr[igr][1].mixed_block_flag)
201          n1 = m->cupl.sfBandIndex[0][m->cupl.ncbl_mixed - 1];
202    }
203    if (n1 > m->cupl.band_limit)
204       n1 = m->cupl.band_limit;
205    if (n2 > m->cupl.band_limit)
206       n2 = m->cupl.band_limit;
207    igr_prev = igr ^ 1;
208    m->cupl.nsamp[igr][1] = hybrid(m,m->cupl.sample[1][igr], m->cupl.sample[1][igr_prev],
209          m->cupl.yout, m->cupl.side_info.gr[igr][1].block_type, n1, n2, m->cupl.nsamp[igr_prev][1]);
210    FreqInvert(m->cupl.yout, m->cupl.nsamp[igr][1]);
211    m->cupl.sbt_L3(m,m->cupl.yout, pcm, 0);
212
213 }
214 /*--------------------------------------------------------------------*/
215 static void Xform_dual(void *mv, void *pcm, int igr)
216 {
217    MPEG *m = mv;
218    int ch;
219    int igr_prev, n1, n2;
220
221 /*--- hybrid + sbt ---*/
222    igr_prev = igr ^ 1;
223    for (ch = 0; ch < m->cupl.nchan; ch++)
224    {
225       n1 = n2 = m->cupl.nsamp[igr][ch]; /* total number bands */
226       if (m->cupl.side_info.gr[igr][ch].block_type == 2)
227       {                         /* long bands */
228          n1 = 0;
229          if (m->cupl.side_info.gr[igr][ch].mixed_block_flag)
230             n1 = m->cupl.sfBandIndex[0][m->cupl.ncbl_mixed - 1];
231       }
232       if (n1 > m->cupl.band_limit)
233          n1 = m->cupl.band_limit;
234       if (n2 > m->cupl.band_limit)
235          n2 = m->cupl.band_limit;
236       m->cupl.nsamp[igr][ch] = hybrid(m,m->cupl.sample[ch][igr], m->cupl.sample[ch][igr_prev],
237        m->cupl.yout, m->cupl.side_info.gr[igr][ch].block_type, n1, n2, m->cupl.nsamp[igr_prev][ch]);
238       FreqInvert(m->cupl.yout, m->cupl.nsamp[igr][ch]);
239       m->cupl.sbt_L3(m,m->cupl.yout, pcm, ch);
240    }
241
242 }
243 /*--------------------------------------------------------------------*/
244 static void Xform_dual_mono(void *mv, void *pcm, int igr)
245 {
246    MPEG *m = mv;
247    int igr_prev, n1, n2, n3;
248
249 /*--- hybrid + sbt ---*/
250    igr_prev = igr ^ 1;
251    if ((m->cupl.side_info.gr[igr][0].block_type == m->cupl.side_info.gr[igr][1].block_type)
252        && (m->cupl.side_info.gr[igr][0].mixed_block_flag == 0)
253        && (m->cupl.side_info.gr[igr][1].mixed_block_flag == 0))
254    {
255
256       n2 = m->cupl.nsamp[igr][0];       /* total number bands max of L R */
257       if (n2 < m->cupl.nsamp[igr][1])
258          n2 = m->cupl.nsamp[igr][1];
259       if (n2 > m->cupl.band_limit)
260          n2 = m->cupl.band_limit;
261       n1 = n2;                  /* n1 = number long bands */
262       if (m->cupl.side_info.gr[igr][0].block_type == 2)
263          n1 = 0;
264       sum_f_bands(m->cupl.sample[0][igr], m->cupl.sample[1][igr], n2);
265       n3 = m->cupl.nsamp[igr][0] = hybrid(m,m->cupl.sample[0][igr], m->cupl.sample[0][igr_prev],
266          m->cupl.yout, m->cupl.side_info.gr[igr][0].block_type, n1, n2, m->cupl.nsamp[igr_prev][0]);
267    }
268    else
269    {                            /* transform and then sum (not tested - never happens in test) */
270 /*-- left chan --*/
271       n1 = n2 = m->cupl.nsamp[igr][0];  /* total number bands */
272       if (m->cupl.side_info.gr[igr][0].block_type == 2)
273       {
274          n1 = 0;                /* long bands */
275          if (m->cupl.side_info.gr[igr][0].mixed_block_flag)
276             n1 = m->cupl.sfBandIndex[0][m->cupl.ncbl_mixed - 1];
277       }
278       n3 = m->cupl.nsamp[igr][0] = hybrid(m,m->cupl.sample[0][igr], m->cupl.sample[0][igr_prev],
279          m->cupl.yout, m->cupl.side_info.gr[igr][0].block_type, n1, n2, m->cupl.nsamp[igr_prev][0]);
280 /*-- right chan --*/
281       n1 = n2 = m->cupl.nsamp[igr][1];  /* total number bands */
282       if (m->cupl.side_info.gr[igr][1].block_type == 2)
283       {
284          n1 = 0;                /* long bands */
285          if (m->cupl.side_info.gr[igr][1].mixed_block_flag)
286             n1 = m->cupl.sfBandIndex[0][m->cupl.ncbl_mixed - 1];
287       }
288       m->cupl.nsamp[igr][1] = hybrid_sum(m, m->cupl.sample[1][igr], m->cupl.sample[0][igr],
289                              m->cupl.yout, m->cupl.side_info.gr[igr][1].block_type, n1, n2);
290       if (n3 < m->cupl.nsamp[igr][1])
291          n1 = m->cupl.nsamp[igr][1];
292    }
293
294 /*--------*/
295    FreqInvert(m->cupl.yout, n3);
296    m->cupl.sbt_L3(m,m->cupl.yout, pcm, 0);
297
298 }
299 /*--------------------------------------------------------------------*/
300 /*====================================================================*/
301 static int unpack_side_MPEG1(MPEG *m)
302 {
303    int prot;
304    int br_index;
305    int igr, ch;
306    int side_bytes;
307
308 /* decode partial header plus initial side info */
309 /* at entry bit getter points at id, sync skipped by caller */
310
311    m->cupl.id = bitget(1);              /* id */
312    bitget(2);                   /* skip layer */
313    prot = bitget(1);            /* bitget prot bit */
314    br_index = bitget(4);
315    m->cupl.sr_index = bitget(2);
316    m->cupl.pad = bitget(1);
317    bitget(1);                   /* skip to mode */
318    m->cupl.side_info.mode = bitget(2);  /* mode */
319    m->cupl.side_info.mode_ext = bitget(2);      /* mode ext */
320
321    if (m->cupl.side_info.mode != 1)
322       m->cupl.side_info.mode_ext = 0;
323
324 /* adjust global gain in ms mode to avoid having to mult by 1/sqrt(2) */
325    m->cupl.ms_mode = m->cupl.side_info.mode_ext >> 1;
326    m->cupl.is_mode = m->cupl.side_info.mode_ext & 1;
327
328
329    m->cupl.crcbytes = 0;
330    if (prot)
331       bitget(4);                /* skip to data */
332    else
333    {
334       bitget(20);               /* skip crc */
335       m->cupl.crcbytes = 2;
336    }
337
338    if (br_index > 0)            /* framebytes fixed for free format */
339         {
340       m->cupl.framebytes =
341          2880 * mp_br_tableL3[m->cupl.id][br_index] / mp_sr20_table[m->cupl.id][m->cupl.sr_index];
342    }
343
344    m->cupl.side_info.main_data_begin = bitget(9);
345    if (m->cupl.side_info.mode == 3)
346    {
347       m->cupl.side_info.private_bits = bitget(5);
348       m->cupl.nchan = 1;
349       m->cupl.stereo_flag = 0;
350       side_bytes = (4 + 17);
351 /*-- with header --*/
352    }
353    else
354    {
355       m->cupl.side_info.private_bits = bitget(3);
356       m->cupl.nchan = 2;
357       m->cupl.stereo_flag = 1;
358       side_bytes = (4 + 32);
359 /*-- with header --*/
360    }
361    for (ch = 0; ch < m->cupl.nchan; ch++)
362       m->cupl.side_info.scfsi[ch] = bitget(4);
363 /* this always 0 (both igr) for short blocks */
364
365    for (igr = 0; igr < 2; igr++)
366    {
367       for (ch = 0; ch < m->cupl.nchan; ch++)
368       {
369          m->cupl.side_info.gr[igr][ch].part2_3_length = bitget(12);
370          m->cupl.side_info.gr[igr][ch].big_values = bitget(9);
371          m->cupl.side_info.gr[igr][ch].global_gain = bitget(8) + m->cupl.gain_adjust;
372          if (m->cupl.ms_mode)
373             m->cupl.side_info.gr[igr][ch].global_gain -= 2;
374          m->cupl.side_info.gr[igr][ch].scalefac_compress = bitget(4);
375          m->cupl.side_info.gr[igr][ch].window_switching_flag = bitget(1);
376          if (m->cupl.side_info.gr[igr][ch].window_switching_flag)
377          {
378             m->cupl.side_info.gr[igr][ch].block_type = bitget(2);
379             m->cupl.side_info.gr[igr][ch].mixed_block_flag = bitget(1);
380             m->cupl.side_info.gr[igr][ch].table_select[0] = bitget(5);
381             m->cupl.side_info.gr[igr][ch].table_select[1] = bitget(5);
382             m->cupl.side_info.gr[igr][ch].subblock_gain[0] = bitget(3);
383             m->cupl.side_info.gr[igr][ch].subblock_gain[1] = bitget(3);
384             m->cupl.side_info.gr[igr][ch].subblock_gain[2] = bitget(3);
385           /* region count set in terms of long block cb's/bands */
386           /* r1 set so r0+r1+1 = 21 (lookup produces 576 bands ) */
387           /* if(window_switching_flag) always 36 samples in region0 */
388             m->cupl.side_info.gr[igr][ch].region0_count = (8 - 1);      /* 36 samples */
389             m->cupl.side_info.gr[igr][ch].region1_count = 20 - (8 - 1);
390          }
391          else
392          {
393             m->cupl.side_info.gr[igr][ch].mixed_block_flag = 0;
394             m->cupl.side_info.gr[igr][ch].block_type = 0;
395             m->cupl.side_info.gr[igr][ch].table_select[0] = bitget(5);
396             m->cupl.side_info.gr[igr][ch].table_select[1] = bitget(5);
397             m->cupl.side_info.gr[igr][ch].table_select[2] = bitget(5);
398             m->cupl.side_info.gr[igr][ch].region0_count = bitget(4);
399             m->cupl.side_info.gr[igr][ch].region1_count = bitget(3);
400          }
401          m->cupl.side_info.gr[igr][ch].preflag = bitget(1);
402          m->cupl.side_info.gr[igr][ch].scalefac_scale = bitget(1);
403          m->cupl.side_info.gr[igr][ch].count1table_select = bitget(1);
404       }
405    }
406
407
408
409 /* return  bytes in header + side info */
410    return side_bytes;
411 }
412 /*====================================================================*/
413 static int unpack_side_MPEG2(MPEG *m, int igr)
414 {
415    int prot;
416    int br_index;
417    int ch;
418    int side_bytes;
419
420 /* decode partial header plus initial side info */
421 /* at entry bit getter points at id, sync skipped by caller */
422
423    m->cupl.id = bitget(1);              /* id */
424    bitget(2);                   /* skip layer */
425    prot = bitget(1);            /* bitget prot bit */
426    br_index = bitget(4);
427    m->cupl.sr_index = bitget(2);
428    m->cupl.pad = bitget(1);
429    bitget(1);                   /* skip to mode */
430    m->cupl.side_info.mode = bitget(2);  /* mode */
431    m->cupl.side_info.mode_ext = bitget(2);      /* mode ext */
432
433    if (m->cupl.side_info.mode != 1)
434       m->cupl.side_info.mode_ext = 0;
435
436 /* adjust global gain in ms mode to avoid having to mult by 1/sqrt(2) */
437    m->cupl.ms_mode = m->cupl.side_info.mode_ext >> 1;
438    m->cupl.is_mode = m->cupl.side_info.mode_ext & 1;
439
440    m->cupl.crcbytes = 0;
441    if (prot)
442       bitget(4);                /* skip to data */
443    else
444    {
445       bitget(20);               /* skip crc */
446       m->cupl.crcbytes = 2;
447    }
448
449    if (br_index > 0)
450    {                            /* framebytes fixed for free format */
451       if (m->cupl.mpeg25_flag == 0)
452       {
453          m->cupl.framebytes =
454             1440 * mp_br_tableL3[m->cupl.id][br_index] / mp_sr20_table[m->cupl.id][m->cupl.sr_index];
455       }
456       else
457       {
458          m->cupl.framebytes =
459             2880 * mp_br_tableL3[m->cupl.id][br_index] / mp_sr20_table[m->cupl.id][m->cupl.sr_index];
460        //if( sr_index == 2 ) return 0;  // fail mpeg25 8khz
461       }
462    }
463    m->cupl.side_info.main_data_begin = bitget(8);
464    if (m->cupl.side_info.mode == 3)
465    {
466       m->cupl.side_info.private_bits = bitget(1);
467       m->cupl.nchan = 1;
468       m->cupl.stereo_flag = 0;
469       side_bytes = (4 + 9);
470 /*-- with header --*/
471    }
472    else
473    {
474       m->cupl.side_info.private_bits = bitget(2);
475       m->cupl.nchan = 2;
476       m->cupl.stereo_flag = 1;
477       side_bytes = (4 + 17);
478 /*-- with header --*/
479    }
480    m->cupl.side_info.scfsi[1] = m->cupl.side_info.scfsi[0] = 0;
481
482
483    for (ch = 0; ch < m->cupl.nchan; ch++)
484    {
485       m->cupl.side_info.gr[igr][ch].part2_3_length = bitget(12);
486       m->cupl.side_info.gr[igr][ch].big_values = bitget(9);
487       m->cupl.side_info.gr[igr][ch].global_gain = bitget(8) + m->cupl.gain_adjust;
488       if (m->cupl.ms_mode)
489          m->cupl.side_info.gr[igr][ch].global_gain -= 2;
490       m->cupl.side_info.gr[igr][ch].scalefac_compress = bitget(9);
491       m->cupl.side_info.gr[igr][ch].window_switching_flag = bitget(1);
492       if (m->cupl.side_info.gr[igr][ch].window_switching_flag)
493       {
494          m->cupl.side_info.gr[igr][ch].block_type = bitget(2);
495          m->cupl.side_info.gr[igr][ch].mixed_block_flag = bitget(1);
496          m->cupl.side_info.gr[igr][ch].table_select[0] = bitget(5);
497          m->cupl.side_info.gr[igr][ch].table_select[1] = bitget(5);
498          m->cupl.side_info.gr[igr][ch].subblock_gain[0] = bitget(3);
499          m->cupl.side_info.gr[igr][ch].subblock_gain[1] = bitget(3);
500          m->cupl.side_info.gr[igr][ch].subblock_gain[2] = bitget(3);
501        /* region count set in terms of long block cb's/bands  */
502        /* r1 set so r0+r1+1 = 21 (lookup produces 576 bands ) */
503        /* bt=1 or 3       54 samples */
504        /* bt=2 mixed=0    36 samples */
505        /* bt=2 mixed=1    54 (8 long sf) samples? or maybe 36 */
506        /* region0 discussion says 54 but this would mix long */
507        /* and short in region0 if scale factors switch */
508        /* at band 36 (6 long scale factors) */
509          if ((m->cupl.side_info.gr[igr][ch].block_type == 2))
510          {
511             m->cupl.side_info.gr[igr][ch].region0_count = (6 - 1);      /* 36 samples */
512             m->cupl.side_info.gr[igr][ch].region1_count = 20 - (6 - 1);
513          }
514          else
515          {                      /* long block type 1 or 3 */
516             m->cupl.side_info.gr[igr][ch].region0_count = (8 - 1);      /* 54 samples */
517             m->cupl.side_info.gr[igr][ch].region1_count = 20 - (8 - 1);
518          }
519       }
520       else
521       {
522          m->cupl.side_info.gr[igr][ch].mixed_block_flag = 0;
523          m->cupl.side_info.gr[igr][ch].block_type = 0;
524          m->cupl.side_info.gr[igr][ch].table_select[0] = bitget(5);
525          m->cupl.side_info.gr[igr][ch].table_select[1] = bitget(5);
526          m->cupl.side_info.gr[igr][ch].table_select[2] = bitget(5);
527          m->cupl.side_info.gr[igr][ch].region0_count = bitget(4);
528          m->cupl.side_info.gr[igr][ch].region1_count = bitget(3);
529       }
530       m->cupl.side_info.gr[igr][ch].preflag = 0;
531       m->cupl.side_info.gr[igr][ch].scalefac_scale = bitget(1);
532       m->cupl.side_info.gr[igr][ch].count1table_select = bitget(1);
533    }
534
535 /* return  bytes in header + side info */
536    return side_bytes;
537 }
538 /*-----------------------------------------------------------------*/
539 static void unpack_main(MPEG *m, unsigned char *pcm, int igr)
540 {
541    int ch;
542    int bit0;
543    int n1, n2, n3, n4, nn2, nn3;
544    int nn4;
545    int qbits;
546    int m0;
547
548
549    for (ch = 0; ch < m->cupl.nchan; ch++)
550    {
551       bitget_init(m->cupl.buf + (m->cupl.main_pos_bit >> 3));
552       bit0 = (m->cupl.main_pos_bit & 7);
553       if (bit0)
554          bitget(bit0);
555       m->cupl.main_pos_bit += m->cupl.side_info.gr[igr][ch].part2_3_length;
556       bitget_init_end(m->cupl.buf + ((m->cupl.main_pos_bit + 39) >> 3));
557 /*-- scale factors --*/
558       if (m->cupl.id)
559          unpack_sf_sub_MPEG1(&m->cupl.sf[igr][ch],
560                           &m->cupl.side_info.gr[igr][ch], m->cupl.side_info.scfsi[ch], igr);
561       else
562          unpack_sf_sub_MPEG2(&m->cupl.sf[igr][ch],
563                          &m->cupl.side_info.gr[igr][ch], m->cupl.is_mode & ch, &m->cupl.is_sf_info);
564 /*--- huff data ---*/
565       n1 = m->cupl.sfBandIndex[0][m->cupl.side_info.gr[igr][ch].region0_count];
566       n2 = m->cupl.sfBandIndex[0][m->cupl.side_info.gr[igr][ch].region0_count
567                           + m->cupl.side_info.gr[igr][ch].region1_count + 1];
568       n3 = m->cupl.side_info.gr[igr][ch].big_values;
569       n3 = n3 + n3;
570
571
572       if (n3 > m->cupl.band_limit)
573          n3 = m->cupl.band_limit;
574       if (n2 > n3)
575          n2 = n3;
576       if (n1 > n3)
577          n1 = n3;
578       nn3 = n3 - n2;
579       nn2 = n2 - n1;
580       unpack_huff(m->cupl.sample[ch][igr], n1, m->cupl.side_info.gr[igr][ch].table_select[0]);
581       unpack_huff(m->cupl.sample[ch][igr] + n1, nn2, m->cupl.side_info.gr[igr][ch].table_select[1]);
582       unpack_huff(m->cupl.sample[ch][igr] + n2, nn3, m->cupl.side_info.gr[igr][ch].table_select[2]);
583       qbits = m->cupl.side_info.gr[igr][ch].part2_3_length - (bitget_bits_used() - bit0);
584       nn4 = unpack_huff_quad(m->cupl.sample[ch][igr] + n3, m->cupl.band_limit - n3, qbits,
585                              m->cupl.side_info.gr[igr][ch].count1table_select);
586       n4 = n3 + nn4;
587       m->cupl.nsamp[igr][ch] = n4;
588     //limit n4 or allow deqaunt to sf band 22
589       if (m->cupl.side_info.gr[igr][ch].block_type == 2)
590          n4 = min(n4, m->cupl.band_limit12);
591       else
592          n4 = min(n4, m->cupl.band_limit21);
593       if (n4 < 576)
594          memset(m->cupl.sample[ch][igr] + n4, 0, sizeof(SAMPLE) * (576 - n4));
595       if (bitdat.bs_ptr > bitdat.bs_ptr_end)
596       {                         // bad data overrun
597
598          memset(m->cupl.sample[ch][igr], 0, sizeof(SAMPLE) * (576));
599       }
600    }
601
602
603
604 /*--- dequant ---*/
605    for (ch = 0; ch < m->cupl.nchan; ch++)
606    {
607       dequant(m,m->cupl.sample[ch][igr],
608               &m->cupl.nsamp[igr][ch],  /* nsamp updated for shorts */
609               &m->cupl.sf[igr][ch], &m->cupl.side_info.gr[igr][ch],
610               &m->cupl.cb_info[igr][ch], m->cupl.ncbl_mixed);
611    }
612
613 /*--- ms stereo processing  ---*/
614    if (m->cupl.ms_mode)
615    {
616       if (m->cupl.is_mode == 0)
617       {
618          m0 = m->cupl.nsamp[igr][0];    /* process to longer of left/right */
619          if (m0 < m->cupl.nsamp[igr][1])
620             m0 = m->cupl.nsamp[igr][1];
621       }
622       else
623       {                         /* process to last cb in right */
624          m0 = m->cupl.sfBandIndex[m->cupl.cb_info[igr][1].cbtype][m->cupl.cb_info[igr][1].cbmax];
625       }
626       ms_process(m->cupl.sample[0][igr], m0);
627    }
628
629 /*--- is stereo processing  ---*/
630    if (m->cupl.is_mode)
631    {
632       if (m->cupl.id)
633          is_process_MPEG1(m, m->cupl.sample[0][igr], &m->cupl.sf[igr][1],
634                           m->cupl.cb_info[igr], m->cupl.nsamp[igr][0], m->cupl.ms_mode);
635       else
636          is_process_MPEG2(m,m->cupl.sample[0][igr], &m->cupl.sf[igr][1],
637                           m->cupl.cb_info[igr], &m->cupl.is_sf_info,
638                           m->cupl.nsamp[igr][0], m->cupl.ms_mode);
639    }
640
641 /*-- adjust ms and is modes to max of left/right */
642    if (m->cupl.side_info.mode_ext)
643    {
644       if (m->cupl.nsamp[igr][0] < m->cupl.nsamp[igr][1])
645          m->cupl.nsamp[igr][0] = m->cupl.nsamp[igr][1];
646       else
647          m->cupl.nsamp[igr][1] = m->cupl.nsamp[igr][0];
648    }
649
650 /*--- antialias ---*/
651    for (ch = 0; ch < m->cupl.nchan; ch++)
652    {
653       if (m->cupl.cb_info[igr][ch].ncbl == 0)
654          continue;              /* have no long blocks */
655       if (m->cupl.side_info.gr[igr][ch].mixed_block_flag)
656          n1 = 1;                /* 1 -> 36 samples */
657       else
658          n1 = (m->cupl.nsamp[igr][ch] + 7) / 18;
659       if (n1 > 31)
660          n1 = 31;
661       antialias(m, m->cupl.sample[ch][igr], n1);
662       n1 = 18 * n1 + 8;         /* update number of samples */
663       if (n1 > m->cupl.nsamp[igr][ch])
664          m->cupl.nsamp[igr][ch] = n1;
665    }
666
667
668
669 /*--- hybrid + sbt ---*/
670    m->cupl.Xform(m, pcm, igr);
671
672
673 /*-- done --*/
674 }
675 /*--------------------------------------------------------------------*/
676 /*-----------------------------------------------------------------*/
677 IN_OUT L3audio_decode(void *mv, unsigned char *bs, unsigned char *pcm)
678 {
679    MPEG *m = mv;
680    return m->cupl.decode_function((MPEG *)mv, bs, pcm);
681 }
682
683 /*--------------------------------------------------------------------*/
684 IN_OUT L3audio_decode_MPEG1(void *mv, unsigned char *bs, unsigned char *pcm)
685 {
686    MPEG *m = mv;
687    int sync;
688    IN_OUT in_out;
689    int side_bytes;
690    int nbytes;
691    
692    m->cupl.iframe++;
693
694    bitget_init(bs);             /* initialize bit getter */
695 /* test sync */
696    in_out.in_bytes = 0;         /* assume fail */
697    in_out.out_bytes = 0;
698    sync = bitget(12);
699
700    if (sync != 0xFFF)
701       return in_out;            /* sync fail */
702 /*-----------*/
703
704 /*-- unpack side info --*/
705    side_bytes = unpack_side_MPEG1(m);
706    m->cupl.padframebytes = m->cupl.framebytes + m->cupl.pad;
707    in_out.in_bytes = m->cupl.padframebytes;
708
709 /*-- load main data and update buf pointer --*/
710 /*------------------------------------------- 
711    if start point < 0, must just cycle decoder 
712    if jumping into middle of stream, 
713 w---------------------------------------------*/
714    m->cupl.buf_ptr0 = m->cupl.buf_ptr1 - m->cupl.side_info.main_data_begin;     /* decode start point */
715    if (m->cupl.buf_ptr1 > BUF_TRIGGER)
716    {                            /* shift buffer */
717       memmove(m->cupl.buf, m->cupl.buf + m->cupl.buf_ptr0, m->cupl.side_info.main_data_begin);
718       m->cupl.buf_ptr0 = 0;
719       m->cupl.buf_ptr1 = m->cupl.side_info.main_data_begin;
720    }
721    nbytes = m->cupl.padframebytes - side_bytes - m->cupl.crcbytes;
722
723    // RAK: This is no bueno. :-(
724         if (nbytes < 0 || nbytes > NBUF)
725         {
726             in_out.in_bytes = 0;
727                  return in_out;
728    }
729
730    memmove(m->cupl.buf + m->cupl.buf_ptr1, bs + side_bytes + m->cupl.crcbytes, nbytes);
731    m->cupl.buf_ptr1 += nbytes;
732 /*-----------------------*/
733
734    if (m->cupl.buf_ptr0 >= 0)
735    {
736 // dump_frame(buf+buf_ptr0, 64);
737       m->cupl.main_pos_bit = m->cupl.buf_ptr0 << 3;
738       unpack_main(m,pcm, 0);
739       unpack_main(m,pcm + m->cupl.half_outbytes, 1);
740       in_out.out_bytes = m->cupl.outbytes;
741    }
742    else
743    {
744       memset(pcm, m->cupl.zero_level_pcm, m->cupl.outbytes);    /* fill out skipped frames */
745       in_out.out_bytes = m->cupl.outbytes;
746 /* iframe--;  in_out.out_bytes = 0;  // test test */
747    }
748
749    return in_out;
750 }
751 /*--------------------------------------------------------------------*/
752 /*--------------------------------------------------------------------*/
753 IN_OUT L3audio_decode_MPEG2(void *mv, unsigned char *bs, unsigned char *pcm)
754 {
755    MPEG *m = mv;
756    int sync;
757    IN_OUT in_out;
758    int side_bytes;
759    int nbytes;
760    static int igr = 0;
761
762    m->cupl.iframe++;
763
764
765    bitget_init(bs);             /* initialize bit getter */
766 /* test sync */
767    in_out.in_bytes = 0;         /* assume fail */
768    in_out.out_bytes = 0;
769    sync = bitget(12);
770
771 // if( sync != 0xFFF ) return in_out;       /* sync fail */
772
773    m->cupl.mpeg25_flag = 0;
774    if (sync != 0xFFF)
775    {
776       m->cupl.mpeg25_flag = 1;          /* mpeg 2.5 sync */
777       if (sync != 0xFFE)
778          return in_out;         /* sync fail */
779    }
780 /*-----------*/
781
782
783 /*-- unpack side info --*/
784    side_bytes = unpack_side_MPEG2(m,igr);
785    m->cupl.padframebytes = m->cupl.framebytes + m->cupl.pad;
786    in_out.in_bytes = m->cupl.padframebytes;
787
788    m->cupl.buf_ptr0 = m->cupl.buf_ptr1 - m->cupl.side_info.main_data_begin;     /* decode start point */
789    if (m->cupl.buf_ptr1 > BUF_TRIGGER)
790    {                            /* shift buffer */
791       memmove(m->cupl.buf, m->cupl.buf + m->cupl.buf_ptr0, m->cupl.side_info.main_data_begin);
792       m->cupl.buf_ptr0 = 0;
793       m->cupl.buf_ptr1 = m->cupl.side_info.main_data_begin;
794    }
795    nbytes = m->cupl.padframebytes - side_bytes - m->cupl.crcbytes;
796    // RAK: This is no bueno. :-(
797         if (nbytes < 0 || nbytes > NBUF)
798         {
799             in_out.in_bytes = 0;
800                  return in_out;
801    }
802    memmove(m->cupl.buf + m->cupl.buf_ptr1, bs + side_bytes + m->cupl.crcbytes, nbytes);
803    m->cupl.buf_ptr1 += nbytes;
804 /*-----------------------*/
805
806    if (m->cupl.buf_ptr0 >= 0)
807    {
808       m->cupl.main_pos_bit = m->cupl.buf_ptr0 << 3;
809       unpack_main(m,pcm, igr);
810       in_out.out_bytes = m->cupl.outbytes;
811    }
812    else
813    {
814       memset(pcm, m->cupl.zero_level_pcm, m->cupl.outbytes);    /* fill out skipped frames */
815       in_out.out_bytes = m->cupl.outbytes;
816 // iframe--;  in_out.out_bytes = 0; return in_out;// test test */
817    }
818
819
820
821    igr = igr ^ 1;
822    return in_out;
823 }
824 /*--------------------------------------------------------------------*/
825 /*--------------------------------------------------------------------*/
826 /*--------------------------------------------------------------------*/
827 static int const sr_table[8] =
828 {22050, 24000, 16000, 1,
829  44100, 48000, 32000, 1};
830
831 static const struct
832 {
833    int l[23];
834    int s[14];
835 }
836 sfBandIndexTable[3][3] =
837 {
838 /* mpeg-2 */
839    {
840       {
841          {
842             0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 116, 140, 168, 200, 238, 284, 336, 396, 464, 522, 576
843          }
844          ,
845          {
846             0, 4, 8, 12, 18, 24, 32, 42, 56, 74, 100, 132, 174, 192
847          }
848       }
849       ,
850       {
851          {
852             0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 114, 136, 162, 194, 232, 278, 332, 394, 464, 540, 576
853          }
854          ,
855          {
856             0, 4, 8, 12, 18, 26, 36, 48, 62, 80, 104, 136, 180, 192
857          }
858       }
859       ,
860       {
861          {
862             0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 116, 140, 168, 200, 238, 284, 336, 396, 464, 522, 576
863          }
864          ,
865          {
866             0, 4, 8, 12, 18, 26, 36, 48, 62, 80, 104, 134, 174, 192
867          }
868       }
869       ,
870    }
871    ,
872 /* mpeg-1 */
873    {
874       {
875          {
876             0, 4, 8, 12, 16, 20, 24, 30, 36, 44, 52, 62, 74, 90, 110, 134, 162, 196, 238, 288, 342, 418, 576
877          }
878          ,
879          {
880             0, 4, 8, 12, 16, 22, 30, 40, 52, 66, 84, 106, 136, 192
881          }
882       }
883       ,
884       {
885          {
886             0, 4, 8, 12, 16, 20, 24, 30, 36, 42, 50, 60, 72, 88, 106, 128, 156, 190, 230, 276, 330, 384, 576
887          }
888          ,
889          {
890             0, 4, 8, 12, 16, 22, 28, 38, 50, 64, 80, 100, 126, 192
891          }
892       }
893       ,
894       {
895          {
896             0, 4, 8, 12, 16, 20, 24, 30, 36, 44, 54, 66, 82, 102, 126, 156, 194, 240, 296, 364, 448, 550, 576
897          }
898          ,
899          {
900             0, 4, 8, 12, 16, 22, 30, 42, 58, 78, 104, 138, 180, 192
901          }
902       }
903    }
904    ,
905
906 /* mpeg-2.5, 11 & 12 KHz seem ok, 8 ok */
907    {
908       {
909          {
910             0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 116, 140, 168, 200, 238, 284, 336, 396, 464, 522, 576
911          }
912          ,
913          {
914             0, 4, 8, 12, 18, 26, 36, 48, 62, 80, 104, 134, 174, 192
915          }
916       }
917       ,
918       {
919          {
920             0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 116, 140, 168, 200, 238, 284, 336, 396, 464, 522, 576
921          }
922          ,
923          {
924             0, 4, 8, 12, 18, 26, 36, 48, 62, 80, 104, 134, 174, 192
925          }
926       }
927       ,
928 // this 8khz table, and only 8khz, from mpeg123)
929       {
930          {
931             0, 12, 24, 36, 48, 60, 72, 88, 108, 132, 160, 192, 232, 280, 336, 400, 476, 566, 568, 570, 572, 574, 576
932          }
933          ,
934          {
935             0, 8, 16, 24, 36, 52, 72, 96, 124, 160, 162, 164, 166, 192
936          }
937       }
938       ,
939    }
940    ,
941 };
942
943
944 void sbt_mono_L3(MPEG *m, float *sample, signed short *pcm, int ch);
945 void sbt_dual_L3(MPEG *m, float *sample, signed short *pcm, int ch);
946 void sbt16_mono_L3(MPEG *m, float *sample, signed short *pcm, int ch);
947 void sbt16_dual_L3(MPEG *m, float *sample, signed short *pcm, int ch);
948 void sbt8_mono_L3(MPEG *m, float *sample, signed short *pcm, int ch);
949 void sbt8_dual_L3(MPEG *m, float *sample, signed short *pcm, int ch);
950
951 void sbtB_mono_L3(MPEG *m, float *sample, unsigned char *pcm, int ch);
952 void sbtB_dual_L3(MPEG *m, float *sample, unsigned char *pcm, int ch);
953 void sbtB16_mono_L3(MPEG *m, float *sample, unsigned char *pcm, int ch);
954 void sbtB16_dual_L3(MPEG *m, float *sample, unsigned char *pcm, int ch);
955 void sbtB8_mono_L3(MPEG *m, float *sample, unsigned char *pcm, int ch);
956 void sbtB8_dual_L3(MPEG *m, float *sample, unsigned char *pcm, int ch);
957
958
959
960 static SBT_FUNCTION_F sbt_table[2][3][2] =
961 {
962 {{ (SBT_FUNCTION_F) sbt_mono_L3,
963    (SBT_FUNCTION_F) sbt_dual_L3 } ,
964  { (SBT_FUNCTION_F) sbt16_mono_L3,
965    (SBT_FUNCTION_F) sbt16_dual_L3 } ,
966  { (SBT_FUNCTION_F) sbt8_mono_L3,
967    (SBT_FUNCTION_F) sbt8_dual_L3 }} ,
968 /*-- 8 bit output -*/
969 {{ (SBT_FUNCTION_F) sbtB_mono_L3,
970    (SBT_FUNCTION_F) sbtB_dual_L3 },
971  { (SBT_FUNCTION_F) sbtB16_mono_L3,
972    (SBT_FUNCTION_F) sbtB16_dual_L3 },
973  { (SBT_FUNCTION_F) sbtB8_mono_L3,
974    (SBT_FUNCTION_F) sbtB8_dual_L3 }}
975 };
976
977
978 void Xform_mono(void *mv, void *pcm, int igr);
979 void Xform_dual(void *mv, void *pcm, int igr);
980 void Xform_dual_mono(void *mv, void *pcm, int igr);
981 void Xform_dual_right(void *mv, void *pcm, int igr);
982
983 static XFORM_FUNCTION xform_table[5] =
984 {
985    Xform_mono,
986    Xform_dual,
987    Xform_dual_mono,
988    Xform_mono,                  /* left */
989    Xform_dual_right,
990 };
991 int L3table_init(MPEG *m);
992 void msis_init(MPEG *m);
993 void sbt_init(MPEG *m);
994 #if 0
995 typedef int iARRAY22[22];
996 #endif
997 iARRAY22 *quant_init_band_addr();
998 iARRAY22 *msis_init_band_addr();
999
1000 /*---------------------------------------------------------*/
1001 /* mpeg_head defined in mhead.h  frame bytes is without pad */
1002 int L3audio_decode_init(void *mv, MPEG_HEAD * h, int framebytes_arg,
1003                    int reduction_code, int transform_code, int convert_code,
1004                         int freq_limit)
1005 {
1006    MPEG *m = mv;
1007    int i, j, k;
1008    // static int first_pass = 1;
1009    int samprate;
1010    int limit;
1011    int bit_code;
1012    int out_chans;
1013
1014    m->cupl.buf_ptr0 = 0;
1015    m->cupl.buf_ptr1 = 0;
1016
1017 /* check if code handles */
1018    if (h->option != 1)
1019       return 0;                 /* layer III only */
1020
1021    if (h->id)
1022       m->cupl.ncbl_mixed = 8;           /* mpeg-1 */
1023    else
1024       m->cupl.ncbl_mixed = 6;           /* mpeg-2 */
1025
1026    m->cupl.framebytes = framebytes_arg;
1027
1028    transform_code = transform_code;     /* not used, asm compatability */
1029    bit_code = 0;
1030    if (convert_code & 8)
1031       bit_code = 1;
1032    convert_code = convert_code & 3;     /* higher bits used by dec8 freq cvt */
1033    if (reduction_code < 0)
1034       reduction_code = 0;
1035    if (reduction_code > 2)
1036       reduction_code = 2;
1037    if (freq_limit < 1000)
1038       freq_limit = 1000;
1039
1040
1041    samprate = sr_table[4 * h->id + h->sr_index];
1042    if ((h->sync & 1) == 0)
1043       samprate = samprate / 2;  // mpeg 2.5 
1044 /*----- compute nsb_limit --------*/
1045    m->cupl.nsb_limit = (freq_limit * 64L + samprate / 2) / samprate;
1046 /*- caller limit -*/
1047    limit = (32 >> reduction_code);
1048    if (limit > 8)
1049       limit--;
1050    if (m->cupl.nsb_limit > limit)
1051       m->cupl.nsb_limit = limit;
1052    limit = 18 * m->cupl.nsb_limit;
1053
1054    k = h->id;
1055    if ((h->sync & 1) == 0)
1056       k = 2;                    // mpeg 2.5 
1057
1058    if (k == 1)
1059    {
1060       m->cupl.band_limit12 = 3 * sfBandIndexTable[k][h->sr_index].s[13];
1061       m->cupl.band_limit = m->cupl.band_limit21 = sfBandIndexTable[k][h->sr_index].l[22];
1062    }
1063    else
1064    {
1065       m->cupl.band_limit12 = 3 * sfBandIndexTable[k][h->sr_index].s[12];
1066       m->cupl.band_limit = m->cupl.band_limit21 = sfBandIndexTable[k][h->sr_index].l[21];
1067    }
1068    m->cupl.band_limit += 8;             /* allow for antialias */
1069    if (m->cupl.band_limit > limit)
1070       m->cupl.band_limit = limit;
1071
1072    if (m->cupl.band_limit21 > m->cupl.band_limit)
1073       m->cupl.band_limit21 = m->cupl.band_limit;
1074    if (m->cupl.band_limit12 > m->cupl.band_limit)
1075       m->cupl.band_limit12 = m->cupl.band_limit;
1076
1077
1078    m->cupl.band_limit_nsb = (m->cupl.band_limit + 17) / 18;     /* limit nsb's rounded up */
1079 /*----------------------------------------------*/
1080    m->cupl.gain_adjust = 0;             /* adjust gain e.g. cvt to mono sum channel */
1081    if ((h->mode != 3) && (convert_code == 1))
1082       m->cupl.gain_adjust = -4;
1083
1084    m->cupl.outvalues = 1152 >> reduction_code;
1085    if (h->id == 0)
1086       m->cupl.outvalues /= 2;
1087
1088    out_chans = 2;
1089    if (h->mode == 3)
1090       out_chans = 1;
1091    if (convert_code)
1092       out_chans = 1;
1093
1094    m->cupl.sbt_L3 = sbt_table[bit_code][reduction_code][out_chans - 1];
1095    k = 1 + convert_code;
1096    if (h->mode == 3)
1097       k = 0;
1098    m->cupl.Xform = xform_table[k];
1099
1100
1101    m->cupl.outvalues *= out_chans;
1102
1103    if (bit_code)
1104       m->cupl.outbytes = m->cupl.outvalues;
1105    else
1106       m->cupl.outbytes = sizeof(short) * m->cupl.outvalues;
1107
1108    if (bit_code)
1109       m->cupl.zero_level_pcm = 128;     /* 8 bit output */
1110    else
1111       m->cupl.zero_level_pcm = 0;
1112
1113
1114    m->cup.decinfo.channels = out_chans;
1115    m->cup.decinfo.outvalues = m->cupl.outvalues;
1116    m->cup.decinfo.samprate = samprate >> reduction_code;
1117    if (bit_code)
1118       m->cup.decinfo.bits = 8;
1119    else
1120       m->cup.decinfo.bits = sizeof(short) * 8;
1121
1122    m->cup.decinfo.framebytes = m->cupl.framebytes;
1123    m->cup.decinfo.type = 0;
1124
1125    m->cupl.half_outbytes = m->cupl.outbytes / 2;
1126 /*------------------------------------------*/
1127
1128 /*- init band tables --*/
1129
1130
1131    k = h->id;
1132    if ((h->sync & 1) == 0)
1133       k = 2;                    // mpeg 2.5 
1134
1135    for (i = 0; i < 22; i++)
1136       m->cupl.sfBandIndex[0][i] = sfBandIndexTable[k][h->sr_index].l[i + 1];
1137    for (i = 0; i < 13; i++)
1138       m->cupl.sfBandIndex[1][i] = 3 * sfBandIndexTable[k][h->sr_index].s[i + 1];
1139    for (i = 0; i < 22; i++)
1140       m->cupl.nBand[0][i] =
1141          sfBandIndexTable[k][h->sr_index].l[i + 1]
1142          - sfBandIndexTable[k][h->sr_index].l[i];
1143    for (i = 0; i < 13; i++)
1144       m->cupl.nBand[1][i] =
1145          sfBandIndexTable[k][h->sr_index].s[i + 1]
1146          - sfBandIndexTable[k][h->sr_index].s[i];
1147
1148
1149 /* init tables */
1150    L3table_init(m);
1151 /* init ms and is stereo modes */
1152    msis_init(m);
1153
1154 /*----- init sbt ---*/
1155    sbt_init(m);
1156
1157
1158
1159 /*--- clear buffers --*/
1160    for (i = 0; i < 576; i++)
1161       m->cupl.yout[i] = 0.0f;
1162    for (j = 0; j < 2; j++)
1163    {
1164       for (k = 0; k < 2; k++)
1165       {
1166          for (i = 0; i < 576; i++)
1167          {
1168             m->cupl.sample[j][k][i].x = 0.0f;
1169             m->cupl.sample[j][k][i].s = 0;
1170          }
1171       }
1172    }
1173
1174    if (h->id == 1)
1175       m->cupl.decode_function = L3audio_decode_MPEG1;
1176    else
1177       m->cupl.decode_function = L3audio_decode_MPEG2;
1178
1179    return 1;
1180 }
1181 /*---------------------------------------------------------*/
1182 /*==========================================================*/
1183 void cup3_init(MPEG *m)
1184 {
1185         m->cupl.sbt_L3 = sbt_dual_L3;
1186         m->cupl.Xform = Xform_dual;
1187         m->cupl.sbt_L3 = sbt_dual_L3;
1188         m->cupl.decode_function = L3audio_decode_MPEG1;
1189 }