8dd2fcc79eb0c3b056b2e00629246aff9aea38c9
[asterisk/asterisk.git] / codecs / mp3 / src / iup.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 /****  iup.c  ***************************************************
28
29 MPEG audio decoder Layer I/II, mpeg1 and mpeg2
30 should be portable ANSI C, should be endian independent
31
32 icup integer version of cup.c
33
34
35
36 mod 10/18/95   mod grouped sample unpack for:
37                Overflow possible in grouped if native int is 16 bit.
38                Rare occurance.  16x16-->32 mult needed.
39
40 mods 11/15/95 for Layer I
41
42
43 1/5/95    Quick fix,  cs_factor can overflow int16 (why?).  Typed to int32.
44
45 mods 1/7/97 warnings
46
47 ******************************************************************/
48 /******************************************************************
49
50        MPEG audio software decoder portable ANSI c.
51        Decodes all Layer II to 16 bit linear pcm.
52        Optional stereo to mono conversion.  Optional
53        output sample rate conversion to half or quarter of
54        native mpeg rate.
55
56 -------------------------------------
57 int i_audio_decode_init(MPEG *m, MPEG_HEAD *h, int framebytes_arg,
58          int reduction_code, int transform_code, int convert_code,
59          int freq_limit)
60
61 initilize decoder:
62        return 0 = fail, not 0 = success
63
64 MPEG_HEAD *h    input, mpeg header info (returned by call to head_info)
65 framebytes      input, mpeg frame size (returned by call to head_info)
66 reduction_code  input, sample rate reduction code
67                     0 = full rate
68                     1 = half rate
69                     0 = quarter rate
70
71 transform_code  input, ignored
72 convert_code    input, channel conversion
73                   convert_code:  0 = two chan output
74                                  1 = convert two chan to mono
75                                  2 = convert two chan to left chan
76                                  3 = convert two chan to right chan
77 freq_limit      input, limits bandwidth of pcm output to specified
78                 frequency.  Special use. Set to 24000 for normal use.
79
80
81 ---------------------------------
82 void i_audio_decode_info( MPEG *m, DEC_INFO *info)
83
84 information return:
85           Call after audio_decode_init.  See mhead.h for
86           information returned in DEC_INFO structure.
87
88
89 ---------------------------------
90 IN_OUT i_audio_decode(MPEG *m, unsigned char *bs, void *pcmbuf)
91
92 decode one mpeg audio frame:
93 bs        input, mpeg bitstream, must start with
94           sync word.  Caution: may read up to 3 bytes
95           beyond end of frame.
96 pcmbuf    output, pcm samples.
97
98 IN_OUT structure returns:
99           Number bytes conceptually removed from mpeg bitstream.
100           Returns 0 if sync loss.
101           Number bytes of pcm output.
102
103 *******************************************************************/
104 #include <stdlib.h>
105 #include <stdio.h>
106 #include <float.h>
107 #include <math.h>
108 #include "L3.h"
109 #include "mhead.h"              /* mpeg header structure */
110 #include "jdw.h"
111
112 /*-------------------------------------------------------
113 NOTE:  Decoder may read up to three bytes beyond end of
114 frame.  Calling application must ensure that this does
115 not cause a memory access violation (protection fault)
116 ---------------------------------------------------------*/
117
118
119 #ifdef _MSC_VER
120 #pragma warning(disable: 4709)
121 #endif
122
123
124 /* Okay to be global -- is read/only */
125 static int look_joint[16] =
126 {                               /* lookup stereo sb's by mode+ext */
127    64, 64, 64, 64,              /* stereo */
128    2 * 4, 2 * 8, 2 * 12, 2 * 16,        /* joint */
129    64, 64, 64, 64,              /* dual */
130    32, 32, 32, 32,              /* mono */
131 };
132
133 /* Okay to be global -- is read/only */
134 static int bat_bit_master[] =
135 {
136    0, 5, 7, 9, 10, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42, 45, 48};
137
138 void i_sbt_mono(SAMPLEINT * sample, short *pcm, int n);
139 void i_sbt_dual(SAMPLEINT * sample, short *pcm, int n);
140
141 static void unpack();
142
143 /*------------- initialize bit getter -------------*/
144 static void load_init(MPEGI *m, unsigned char *buf)
145 {
146    m->iup.bs_ptr = buf;
147    m->iup.bits = 0;
148    m->iup.bitbuf = 0;
149 }
150 /*------------- get n bits from bitstream -------------*/
151 static INT32 load(MPEGI *m, int n)
152 {
153    UINT32 x;
154
155    if (m->iup.bits < n)
156    {                            /* refill bit buf if necessary */
157       while (m->iup.bits <= 24)
158       {
159          m->iup.bitbuf = (m->iup.bitbuf << 8) | *m->iup.bs_ptr++;
160          m->iup.bits += 8;
161       }
162    }
163    m->iup.bits -= n;
164    x = m->iup.bitbuf >> m->iup.bits;
165    m->iup.bitbuf -= x << m->iup.bits;
166    return x;
167 }
168 /*------------- skip over n bits in bitstream -------------*/
169 static void skip(MPEGI *m, int n)
170 {
171    int k;
172
173    if (m->iup.bits < n)
174    {
175       n -= m->iup.bits;
176       k = n >> 3;
177 /*--- bytes = n/8 --*/
178       m->iup.bs_ptr += k;
179       n -= k << 3;
180       m->iup.bitbuf = *m->iup.bs_ptr++;
181       m->iup.bits = 8;
182    }
183    m->iup.bits -= n;
184    m->iup.bitbuf -= (m->iup.bitbuf >> m->iup.bits) << m->iup.bits;
185 }
186 /*--------------------------------------------------------------*/
187 #define mac_load_check(n)                     \
188    if( m->iup.bits < (n) ) {                           \
189           while( m->iup.bits <= 24 ) {               \
190              m->iup.bitbuf = (m->iup.bitbuf << 8) | *m->iup.bs_ptr++;  \
191              m->iup.bits += 8;                       \
192           }                                   \
193    }
194 /*--------------------------------------------------------------*/
195 #define mac_load(n)                    \
196        ( m->iup.bits -= n,                    \
197          m->iup.bitval = m->iup.bitbuf >> m->iup.bits,      \
198          m->iup.bitbuf -= m->iup.bitval << m->iup.bits,     \
199          m->iup.bitval )
200 /*======================================================================*/
201 static void unpack_ba(MPEGI *m)
202 {
203    int i, j, k;
204    static int nbit[4] =
205    {4, 4, 3, 2};
206    int nstereo;
207    int n;
208
209    m->iup.bit_skip = 0;
210    nstereo = m->iup.stereo_sb;
211    k = 0;
212    for (i = 0; i < 4; i++)
213    {
214       for (j = 0; j < m->iup.nbat[i]; j++, k++)
215       {
216          mac_load_check(4);
217          n = m->iup.ballo[k] = m->iup.samp_dispatch[k] = m->iup.bat[i][mac_load(nbit[i])];
218          if (k >= m->iup.nsb_limit)
219             m->iup.bit_skip += bat_bit_master[m->iup.samp_dispatch[k]];
220          m->iup.c_value[k] = m->iup.look_c_value[n];
221          m->iup.c_shift[k] = m->iup.look_c_shift[n];
222          if (--nstereo < 0)
223          {
224             m->iup.ballo[k + 1] = m->iup.ballo[k];
225             m->iup.samp_dispatch[k] += 18;      /* flag as joint */
226             m->iup.samp_dispatch[k + 1] = m->iup.samp_dispatch[k];      /* flag for sf */
227             m->iup.c_value[k + 1] = m->iup.c_value[k];
228             m->iup.c_shift[k + 1] = m->iup.c_shift[k];
229             k++;
230             j++;
231          }
232       }
233    }
234    m->iup.samp_dispatch[m->iup.nsb_limit] = 37; /* terminate the dispatcher with skip */
235    m->iup.samp_dispatch[k] = 36;        /* terminate the dispatcher */
236
237 }
238 /*-------------------------------------------------------------------------*/
239 static void unpack_sfs(MPEGI *m)        /* unpack scale factor selectors */
240 {
241    int i;
242
243    for (i = 0; i < m->iup.max_sb; i++)
244    {
245       mac_load_check(2);
246       if (m->iup.ballo[i])
247          m->iup.sf_dispatch[i] = mac_load(2);
248       else
249          m->iup.sf_dispatch[i] = 4;     /* no allo */
250    }
251    m->iup.sf_dispatch[i] = 5;           /* terminate dispatcher */
252 }
253 /*-------------------------------------------------------------------------*/
254 /*--- multiply note -------------------------------------------------------*/
255 /*--- 16bit x 16bit mult --> 32bit >> 15 --> 16 bit  or better  -----------*/
256 static void unpack_sf(MPEGI *m)         /* unpack scale factor */
257 {                               /* combine dequant and scale factors */
258    int i, n;
259    INT32 tmp;                   /* only reason tmp is 32 bit is to get 32 bit mult result */
260
261    i = -1;
262  dispatch:switch (m->iup.sf_dispatch[++i])
263    {
264       case 0:                   /* 3 factors 012 */
265          mac_load_check(18);
266          tmp = m->iup.c_value[i];
267          n = m->iup.c_shift[i];
268          m->iup.cs_factor[0][i] = (tmp * m->iup.sf_table[mac_load(6)]) >> n;
269          m->iup.cs_factor[1][i] = (tmp * m->iup.sf_table[mac_load(6)]) >> n;
270          m->iup.cs_factor[2][i] = (tmp * m->iup.sf_table[mac_load(6)]) >> n;
271          goto dispatch;
272       case 1:                   /* 2 factors 002 */
273          mac_load_check(12);
274          tmp = m->iup.c_value[i];
275          n = m->iup.c_shift[i];
276          m->iup.cs_factor[1][i] = m->iup.cs_factor[0][i] =
277             (tmp * m->iup.sf_table[mac_load(6)]) >> n;
278          m->iup.cs_factor[2][i] = (tmp * m->iup.sf_table[mac_load(6)]) >> n;
279          goto dispatch;
280       case 2:                   /* 1 factor 000 */
281          mac_load_check(6);
282          tmp = m->iup.c_value[i];
283          n = m->iup.c_shift[i];
284          m->iup.cs_factor[2][i] = m->iup.cs_factor[1][i] = m->iup.cs_factor[0][i] =
285             (tmp * m->iup.sf_table[mac_load(6)]) >> n;
286          goto dispatch;
287       case 3:                   /* 2 factors 022 */
288          mac_load_check(12);
289          tmp = m->iup.c_value[i];
290          n = m->iup.c_shift[i];
291          m->iup.cs_factor[0][i] = (tmp * m->iup.sf_table[mac_load(6)]) >> n;
292          m->iup.cs_factor[2][i] = m->iup.cs_factor[1][i] =
293             (tmp * m->iup.sf_table[mac_load(6)]) >> n;
294          goto dispatch;
295       case 4:                   /* no allo */
296          goto dispatch;
297       case 5:                   /* all done */
298          ;
299    }                            /* end switch */
300 }
301 /*-------------------------------------------------------------------------*/
302 /*-------------------------------------------------------------------------*/
303 /*--- unpack multiply note ------------------------------------------------*/
304 /*--- 16bit x 16bit mult --> 32bit  or better required---------------------*/
305 #define UNPACK_N(n)                                          \
306     s[k]     =  ((m->iup.cs_factor[i][k]*(load(m,n)-((1 << (n-1)) -1)))>>(n-1));   \
307     s[k+64]  =  ((m->iup.cs_factor[i][k]*(load(m,n)-((1 << (n-1)) -1)))>>(n-1));   \
308     s[k+128] =  ((m->iup.cs_factor[i][k]*(load(m,n)-((1 << (n-1)) -1)))>>(n-1));   \
309     goto dispatch;
310 #define UNPACK_N2(n)                                             \
311     mac_load_check(3*n);                                         \
312     s[k]     =  (m->iup.cs_factor[i][k]*(mac_load(n)-((1 << (n-1)) -1)))>>(n-1);   \
313     s[k+64]  =  (m->iup.cs_factor[i][k]*(mac_load(n)-((1 << (n-1)) -1)))>>(n-1);   \
314     s[k+128] =  (m->iup.cs_factor[i][k]*(mac_load(n)-((1 << (n-1)) -1)))>>(n-1);   \
315     goto dispatch;
316 #define UNPACK_N3(n)                                             \
317     mac_load_check(2*n);                                         \
318     s[k]     =  (m->iup.cs_factor[i][k]*(mac_load(n)-((1 << (n-1)) -1)))>>(n-1);   \
319     s[k+64]  =  (m->iup.cs_factor[i][k]*(mac_load(n)-((1 << (n-1)) -1)))>>(n-1);   \
320     mac_load_check(n);                                           \
321     s[k+128] =  (m->iup.cs_factor[i][k]*(mac_load(n)-((1 << (n-1)) -1)))>>(n-1);   \
322     goto dispatch;
323 #define UNPACKJ_N(n)                                         \
324     tmp        =  (load(m,n)-((1 << (n-1)) -1));                 \
325     s[k]       =  (m->iup.cs_factor[i][k]*tmp)>>(n-1);                       \
326     s[k+1]     =  (m->iup.cs_factor[i][k+1]*tmp)>>(n-1);                     \
327     tmp        =  (load(m,n)-((1 << (n-1)) -1));                 \
328     s[k+64]    =  (m->iup.cs_factor[i][k]*tmp)>>(n-1);                       \
329     s[k+64+1]  =  (m->iup.cs_factor[i][k+1]*tmp)>>(n-1);                     \
330     tmp        =  (load(m,n)-((1 << (n-1)) -1));                 \
331     s[k+128]   =  (m->iup.cs_factor[i][k]*tmp)>>(n-1);                       \
332     s[k+128+1] =  (m->iup.cs_factor[i][k+1]*tmp)>>(n-1);                     \
333     k++;       /* skip right chan dispatch */                \
334     goto dispatch;
335 /*-------------------------------------------------------------------------*/
336 static void unpack_samp(MPEGI *m)       /* unpack samples */
337 {
338    int i, j, k;
339    SAMPLEINT *s;
340    int n;
341    INT32 tmp;
342
343    s = m->iup.sample;
344    for (i = 0; i < 3; i++)
345    {                            /* 3 groups of scale factors */
346       for (j = 0; j < 4; j++)
347       {
348          k = -1;
349        dispatch:switch (m->iup.samp_dispatch[++k])
350          {
351             case 0:
352                s[k + 128] = s[k + 64] = s[k] = 0;
353                goto dispatch;
354             case 1:             /* 3 levels grouped 5 bits */
355                mac_load_check(5);
356                n = mac_load(5);
357                s[k] = ((INT32) m->iup.cs_factor[i][k] * m->iup.group3_table[n][0]) >> 1;
358                s[k + 64] = ((INT32) m->iup.cs_factor[i][k] * m->iup.group3_table[n][1]) >> 1;
359                s[k + 128] = ((INT32) m->iup.cs_factor[i][k] * m->iup.group3_table[n][2]) >> 1;
360                goto dispatch;
361             case 2:             /* 5 levels grouped 7 bits */
362                mac_load_check(7);
363                n = mac_load(7);
364                s[k] = ((INT32) m->iup.cs_factor[i][k] * m->iup.group5_table[n][0]) >> 2;
365                s[k + 64] = ((INT32) m->iup.cs_factor[i][k] * m->iup.group5_table[n][1]) >> 2;
366                s[k + 128] = ((INT32) m->iup.cs_factor[i][k] * m->iup.group5_table[n][2]) >> 2;
367                goto dispatch;
368             case 3:
369                UNPACK_N2(3)     /* 7 levels */
370             case 4:             /* 9 levels grouped 10 bits */
371                mac_load_check(10);
372                n = mac_load(10);
373                s[k] = ((INT32) m->iup.cs_factor[i][k] * m->iup.group9_table[n][0]) >> 3;
374                s[k + 64] = ((INT32) m->iup.cs_factor[i][k] * m->iup.group9_table[n][1]) >> 3;
375                s[k + 128] = ((INT32) m->iup.cs_factor[i][k] * m->iup.group9_table[n][2]) >> 3;
376                goto dispatch;
377             case 5:
378                UNPACK_N2(4)     /* 15 levels */
379             case 6:
380                UNPACK_N2(5)     /* 31 levels */
381             case 7:
382                UNPACK_N2(6)     /* 63 levels */
383             case 8:
384                UNPACK_N2(7)     /* 127 levels */
385             case 9:
386                UNPACK_N2(8)     /* 255 levels */
387             case 10:
388                UNPACK_N3(9)     /* 511 levels */
389             case 11:
390                UNPACK_N3(10)    /* 1023 levels */
391             case 12:
392                UNPACK_N3(11)    /* 2047 levels */
393             case 13:
394                UNPACK_N3(12)    /* 4095 levels */
395             case 14:
396                UNPACK_N(13)     /* 8191 levels */
397             case 15:
398                UNPACK_N(14)     /* 16383 levels */
399             case 16:
400                UNPACK_N(15)     /* 32767 levels */
401             case 17:
402                UNPACK_N(16)     /* 65535 levels */
403 /* -- joint ---- */
404             case 18 + 0:
405                s[k + 128 + 1] = s[k + 128] = s[k + 64 + 1] = s[k + 64] = s[k + 1] = s[k] = 0;
406                k++;             /* skip right chan dispatch */
407                goto dispatch;
408             case 18 + 1:        /* 3 levels grouped 5 bits */
409                n = load(m,5);
410                s[k] = ((INT32) m->iup.cs_factor[i][k] * m->iup.group3_table[n][0]) >> 1;
411                s[k + 1] = ((INT32) m->iup.cs_factor[i][k + 1] * m->iup.group3_table[n][0]) >> 1;
412                s[k + 64] = ((INT32) m->iup.cs_factor[i][k] * m->iup.group3_table[n][1]) >> 1;
413                s[k + 64 + 1] = ((INT32) m->iup.cs_factor[i][k + 1] * m->iup.group3_table[n][1]) >> 1;
414                s[k + 128] = ((INT32) m->iup.cs_factor[i][k] * m->iup.group3_table[n][2]) >> 1;
415                s[k + 128 + 1] = ((INT32) m->iup.cs_factor[i][k + 1] * m->iup.group3_table[n][2]) >> 1;
416                k++;             /* skip right chan dispatch */
417                goto dispatch;
418             case 18 + 2:        /* 5 levels grouped 7 bits */
419                n = load(m,7);
420                s[k] = ((INT32) m->iup.cs_factor[i][k] * m->iup.group5_table[n][0]) >> 2;
421                s[k + 1] = ((INT32) m->iup.cs_factor[i][k + 1] * m->iup.group5_table[n][0]) >> 2;
422                s[k + 64] = ((INT32) m->iup.cs_factor[i][k] * m->iup.group5_table[n][1]) >> 2;
423                s[k + 64 + 1] = ((INT32) m->iup.cs_factor[i][k + 1] * m->iup.group5_table[n][1]) >> 2;
424                s[k + 128] = ((INT32) m->iup.cs_factor[i][k] * m->iup.group5_table[n][2]) >> 2;
425                s[k + 128 + 1] = ((INT32) m->iup.cs_factor[i][k + 1] * m->iup.group5_table[n][2]) >> 2;
426                k++;             /* skip right chan dispatch */
427                goto dispatch;
428             case 18 + 3:
429                UNPACKJ_N(3)     /* 7 levels */
430             case 18 + 4:        /* 9 levels grouped 10 bits */
431                n = load(m,10);
432                s[k] = ((INT32) m->iup.cs_factor[i][k] * m->iup.group9_table[n][0]) >> 3;
433                s[k + 1] = ((INT32) m->iup.cs_factor[i][k + 1] * m->iup.group9_table[n][0]) >> 3;
434                s[k + 64] = ((INT32) m->iup.cs_factor[i][k] * m->iup.group9_table[n][1]) >> 3;
435                s[k + 64 + 1] = ((INT32) m->iup.cs_factor[i][k + 1] * m->iup.group9_table[n][1]) >> 3;
436                s[k + 128] = ((INT32) m->iup.cs_factor[i][k] * m->iup.group9_table[n][2]) >> 3;
437                s[k + 128 + 1] = ((INT32) m->iup.cs_factor[i][k + 1] * m->iup.group9_table[n][2]) >> 3;
438                k++;             /* skip right chan dispatch */
439                goto dispatch;
440             case 18 + 5:
441                UNPACKJ_N(4)     /* 15 levels */
442             case 18 + 6:
443                UNPACKJ_N(5)     /* 31 levels */
444             case 18 + 7:
445                UNPACKJ_N(6)     /* 63 levels */
446             case 18 + 8:
447                UNPACKJ_N(7)     /* 127 levels */
448             case 18 + 9:
449                UNPACKJ_N(8)     /* 255 levels */
450             case 18 + 10:
451                UNPACKJ_N(9)     /* 511 levels */
452             case 18 + 11:
453                UNPACKJ_N(10)    /* 1023 levels */
454             case 18 + 12:
455                UNPACKJ_N(11)    /* 2047 levels */
456             case 18 + 13:
457                UNPACKJ_N(12)    /* 4095 levels */
458             case 18 + 14:
459                UNPACKJ_N(13)    /* 8191 levels */
460             case 18 + 15:
461                UNPACKJ_N(14)    /* 16383 levels */
462             case 18 + 16:
463                UNPACKJ_N(15)    /* 32767 levels */
464             case 18 + 17:
465                UNPACKJ_N(16)    /* 65535 levels */
466 /* -- end of dispatch -- */
467             case 37:
468                skip(m, m->iup.bit_skip);
469             case 36:
470                s += 3 * 64;
471          }                      /* end switch */
472       }                         /* end j loop */
473    }                            /* end i loop */
474
475
476 }
477 /*-------------------------------------------------------------------------*/
478 static void unpack(MPEGI *m)
479 {
480    int prot;
481
482 /* at entry bit getter points at id, sync skipped by caller */
483
484    load(m,3);                   /* skip id and option (checked by init) */
485    prot = load(m,1);            /* load prot bit */
486    load(m,6);                   /* skip to pad */
487    m->iup.pad = load(m,1);
488    load(m,1);                   /* skip to mode */
489    m->iup.stereo_sb = look_joint[load(m,4)];
490    if (prot)
491       load(m,4);                        /* skip to data */
492    else
493       load(m,20);                       /* skip crc */
494
495    unpack_ba(m);                        /* unpack bit allocation */
496    unpack_sfs(m);               /* unpack scale factor selectors */
497    unpack_sf(m);                        /* unpack scale factor */
498    unpack_samp(m);              /* unpack samples */
499
500
501 }
502 /*-------------------------------------------------------------------------*/
503 IN_OUT i_audio_decode(MPEGI *m, unsigned char *bs, signed short *pcm)
504 {
505    int sync;
506    IN_OUT in_out;
507
508    load_init(m,bs);             /* initialize bit getter */
509 /* test sync */
510    in_out.in_bytes = 0;         /* assume fail */
511    in_out.out_bytes = 0;
512    sync = load(m,12);
513
514    if (sync != 0xFFF)
515       return in_out;            /* sync fail */
516 /*-----------*/
517    m->iup.unpack_routine();
518
519
520    m->iup.sbt(m->iup.sample, pcm, m->iup.nsbt);
521 /*-----------*/
522    in_out.in_bytes = m->iup.framebytes + m->iup.pad;
523    in_out.out_bytes = m->iup.outbytes;
524    return in_out;
525 }
526 /*-------------------------------------------------------------------------*/
527 #include "iupini.c"             /* initialization */
528 #include "iupL1.c"              /* Layer 1 */
529 /*-------------------------------------------------------------------------*/