Version 0.1.1 from FTP
[asterisk/asterisk.git] / codecs / mp3 / src / iupini.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 /*=========================================================
28  initialization for iup.c - include to iup.c
29  mpeg audio decoder portable "c"      integer
30
31
32 mods 11/15/95 for Layer I
33
34 mods 1/8/97 warnings
35
36 =========================================================*/
37 #include <limits.h>
38
39 /* Read only */
40 static long steps[18] =
41 {
42    0, 3, 5, 7, 9, 15, 31, 63, 127,
43    255, 511, 1023, 2047, 4095, 8191, 16383, 32767, 65535};
44
45 /* Read only */
46 static int stepbits[18] =
47 {
48    0, 2, 3, 3, 4, 4, 5, 6, 7,
49    8, 9, 10, 11, 12, 13, 14, 15, 16};
50
51 /* ABCD_INDEX = lookqt[mode][sr_index][br_index]  */
52 /* -1 = invalid  */
53 /* Read only */
54 static signed char lookqt[4][3][16] =
55 {
56  {{1, -1, -1, -1, 2, -1, 2, 0, 0, 0, 1, 1, 1, 1, 1, -1},        /*  44ks stereo */
57   {0, -1, -1, -1, 2, -1, 2, 0, 0, 0, 0, 0, 0, 0, 0, -1},        /*  48ks */
58   {1, -1, -1, -1, 3, -1, 3, 0, 0, 0, 1, 1, 1, 1, 1, -1}},       /*  32ks */
59  {{1, -1, -1, -1, 2, -1, 2, 0, 0, 0, 1, 1, 1, 1, 1, -1},        /*  44ks joint stereo */
60   {0, -1, -1, -1, 2, -1, 2, 0, 0, 0, 0, 0, 0, 0, 0, -1},        /*  48ks */
61   {1, -1, -1, -1, 3, -1, 3, 0, 0, 0, 1, 1, 1, 1, 1, -1}},       /*  32ks */
62  {{1, -1, -1, -1, 2, -1, 2, 0, 0, 0, 1, 1, 1, 1, 1, -1},        /*  44ks dual chan */
63   {0, -1, -1, -1, 2, -1, 2, 0, 0, 0, 0, 0, 0, 0, 0, -1},        /*  48ks */
64   {1, -1, -1, -1, 3, -1, 3, 0, 0, 0, 1, 1, 1, 1, 1, -1}},       /*  32ks */
65  {{1, 2, 2, 0, 0, 0, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1},        /*  44ks single chan */
66   {0, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, -1, -1, -1, -1, -1},        /*  48ks */
67   {1, 3, 3, 0, 0, 0, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1}},       /*  32ks */
68 };
69
70 /* Read only */
71 static long sr_table[8] =
72 {22050L, 24000L, 16000L, 1L,
73  44100L, 48000L, 32000L, 1L};
74
75 /* bit allocation table look up */
76 /* table per mpeg spec tables 3b2a/b/c/d  /e is mpeg2 */
77 /* look_bat[abcd_index][4][16]  */
78 /* Read only */
79 static unsigned char look_bat[5][4][16] =
80 {
81 /* LOOK_BATA */
82  {{0, 1, 3, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17},
83   {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 17},
84   {0, 1, 2, 3, 4, 5, 6, 17, 0, 0, 0, 0, 0, 0, 0, 0},
85   {0, 1, 2, 17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
86 /* LOOK_BATB */
87  {{0, 1, 3, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17},
88   {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 17},
89   {0, 1, 2, 3, 4, 5, 6, 17, 0, 0, 0, 0, 0, 0, 0, 0},
90   {0, 1, 2, 17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
91 /* LOOK_BATC */
92  {{0, 1, 2, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16},
93   {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
94   {0, 1, 2, 4, 5, 6, 7, 8, 0, 0, 0, 0, 0, 0, 0, 0},
95   {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
96 /* LOOK_BATD */
97  {{0, 1, 2, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16},
98   {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
99   {0, 1, 2, 4, 5, 6, 7, 8, 0, 0, 0, 0, 0, 0, 0, 0},
100   {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
101 /* LOOK_BATE */
102  {{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15},
103   {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
104   {0, 1, 2, 4, 5, 6, 7, 8, 0, 0, 0, 0, 0, 0, 0, 0},
105   {0, 1, 2, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
106 };
107
108 /* look_nbat[abcd_index]][4] */
109 /* Read only */
110 static unsigned char look_nbat[5][4] =
111 {
112   {3, 8, 12, 4},
113   {3, 8, 12, 7},
114   {2, 0, 6, 0},
115   {2, 0, 10, 0},
116   {4, 0, 7, 19},
117 };
118
119
120 void i_sbt_mono(SAMPLEINT * sample, short *pcm, int n);
121 void i_sbt_dual(SAMPLEINT * sample, short *pcm, int n);
122 void i_sbt_dual_mono(SAMPLEINT * sample, short *pcm, int n);
123 void i_sbt_dual_left(SAMPLEINT * sample, short *pcm, int n);
124 void i_sbt_dual_right(SAMPLEINT * sample, short *pcm, int n);
125 void i_sbt16_mono(SAMPLEINT * sample, short *pcm, int n);
126 void i_sbt16_dual(SAMPLEINT * sample, short *pcm, int n);
127 void i_sbt16_dual_mono(SAMPLEINT * sample, short *pcm, int n);
128 void i_sbt16_dual_left(SAMPLEINT * sample, short *pcm, int n);
129 void i_sbt16_dual_right(SAMPLEINT * sample, short *pcm, int n);
130 void i_sbt8_mono(SAMPLEINT * sample, short *pcm, int n);
131 void i_sbt8_dual(SAMPLEINT * sample, short *pcm, int n);
132 void i_sbt8_dual_mono(SAMPLEINT * sample, short *pcm, int n);
133 void i_sbt8_dual_left(SAMPLEINT * sample, short *pcm, int n);
134 void i_sbt8_dual_right(SAMPLEINT * sample, short *pcm, int n);
135
136 /*--- 8 bit output ---*/
137 void i_sbtB_mono(SAMPLEINT * sample, unsigned char *pcm, int n);
138 void i_sbtB_dual(SAMPLEINT * sample, unsigned char *pcm, int n);
139 void i_sbtB_dual_mono(SAMPLEINT * sample, unsigned char *pcm, int n);
140 void i_sbtB_dual_left(SAMPLEINT * sample, unsigned char *pcm, int n);
141 void i_sbtB_dual_right(SAMPLEINT * sample, unsigned char *pcm, int n);
142 void i_sbtB16_mono(SAMPLEINT * sample, unsigned char *pcm, int n);
143 void i_sbtB16_dual(SAMPLEINT * sample, unsigned char *pcm, int n);
144 void i_sbtB16_dual_mono(SAMPLEINT * sample, unsigned char *pcm, int n);
145 void i_sbtB16_dual_left(SAMPLEINT * sample, unsigned char *pcm, int n);
146 void i_sbtB16_dual_right(SAMPLEINT * sample, unsigned char *pcm, int n);
147 void i_sbtB8_mono(SAMPLEINT * sample, unsigned char *pcm, int n);
148 void i_sbtB8_dual(SAMPLEINT * sample, unsigned char *pcm, int n);
149 void i_sbtB8_dual_mono(SAMPLEINT * sample, unsigned char *pcm, int n);
150 void i_sbtB8_dual_left(SAMPLEINT * sample, unsigned char *pcm, int n);
151 void i_sbtB8_dual_right(SAMPLEINT * sample, unsigned char *pcm, int n);
152
153
154 /* Read Only */
155 static SBT_FUNCTION sbt_table[2][3][5] =
156 {
157  {{i_sbt_mono, i_sbt_dual, i_sbt_dual_mono, i_sbt_dual_left, i_sbt_dual_right},
158   {i_sbt16_mono, i_sbt16_dual, i_sbt16_dual_mono, i_sbt16_dual_left, i_sbt16_dual_right},
159   {i_sbt8_mono, i_sbt8_dual, i_sbt8_dual_mono, i_sbt8_dual_left, i_sbt8_dual_right}},
160
161  {{(SBT_FUNCTION) i_sbtB_mono,
162    (SBT_FUNCTION) i_sbtB_dual,
163    (SBT_FUNCTION) i_sbtB_dual_mono,
164    (SBT_FUNCTION) i_sbtB_dual_left,
165    (SBT_FUNCTION) i_sbtB_dual_right},
166   {(SBT_FUNCTION) i_sbtB16_mono,
167    (SBT_FUNCTION) i_sbtB16_dual,
168    (SBT_FUNCTION) i_sbtB16_dual_mono,
169    (SBT_FUNCTION) i_sbtB16_dual_left,
170    (SBT_FUNCTION) i_sbtB16_dual_right},
171   {(SBT_FUNCTION) i_sbtB8_mono,
172    (SBT_FUNCTION) i_sbtB8_dual,
173    (SBT_FUNCTION) i_sbtB8_dual_mono,
174    (SBT_FUNCTION) i_sbtB8_dual_left,
175    (SBT_FUNCTION) i_sbtB8_dual_right}},
176 };
177 /* Read Only */
178 static int out_chans[5] =
179 {1, 2, 1, 1, 1};
180
181 /*---------------------------------------------------------*/
182
183 #ifdef _MSC_VER
184 #pragma warning(disable: 4056)
185 #endif
186
187 void i_mpeg_init(MPEGI *m)
188 {
189         memset(&m->iup, 0, sizeof(m->iup));
190         m->iup.nsb_limit = 6;
191         m->iup.nbat[0] = 3;
192         m->iup.nbat[1] = 8;
193         m->iup.nbat[3] = 12;
194         m->iup.nbat[4] = 7;
195         m->iup.nsbt = 36;
196         m->iup.sbt = i_sbt_mono;
197         m->iup.unpack_routine = unpack;
198         m->iup.first_pass = 1;
199         m->iup.first_pass_L1 = 1;
200         m->iup.nbatL1 = 32;
201         m->iup.cs_factorL1 = m->iup.cs_factor[0];
202 }
203
204 static void table_init(MPEGI *m)
205 {
206    int i, j;
207    int code;
208    int bits;
209    long tmp, sfmax;
210
211 /*--  c_values (dequant) --*/
212    for (i = 1; i < 18; i++)
213       m->iup.look_c_value[i] = (int) (32768.0 * 2.0 / steps[i]);
214    for (i = 1; i < 18; i++)
215       m->iup.look_c_shift[i] = 16 - stepbits[i];
216
217 /*--  scale factor table, scale by 32768 for 16 pcm output  --*/
218    bits = min(8 * sizeof(SAMPLEINT), 8 * sizeof(m->iup.sf_table[0]));
219    tmp = 1L << (bits - 2);
220    sfmax = tmp + (tmp - 1);
221    for (i = 0; i < 64; i++)
222    {
223       tmp = (long) (32768.0 * 2.0 * pow(2.0, -i / 3.0));
224       if (tmp > sfmax)
225          tmp = sfmax;
226       m->iup.sf_table[i] = tmp;
227    }
228 /*--  grouped 3 level lookup table 5 bit token --*/
229    for (i = 0; i < 32; i++)
230    {
231       code = i;
232       for (j = 0; j < 3; j++)
233       {
234          m->iup.group3_table[i][j] = (char) ((code % 3) - 1);
235          code /= 3;
236       }
237    }
238 /*--  grouped 5 level lookup table 7 bit token --*/
239    for (i = 0; i < 128; i++)
240    {
241       code = i;
242       for (j = 0; j < 3; j++)
243       {
244          m->iup.group5_table[i][j] = (char) ((code % 5) - 2);
245          code /= 5;
246       }
247    }
248 /*--  grouped 9 level lookup table 10 bit token --*/
249    for (i = 0; i < 1024; i++)
250    {
251       code = i;
252       for (j = 0; j < 3; j++)
253       {
254          m->iup.group9_table[i][j] = (short) ((code % 9) - 4);
255          code /= 9;
256       }
257    }
258
259
260 }
261
262 #ifdef _MSC_VER
263 #pragma warning(default: 4056)
264 #endif
265
266 /*---------------------------------------------------------*/
267 int i_audio_decode_initL1(MPEGI *m, MPEG_HEAD * h, int framebytes_arg,
268                    int reduction_code, int transform_code, int convert_code,
269                           int freq_limit);
270 void i_sbt_init();
271
272 /*---------------------------------------------------------*/
273 /* mpeg_head defined in mhead.h  frame bytes is without pad */
274 int i_audio_decode_init(MPEGI *m, MPEG_HEAD * h, int framebytes_arg,
275                    int reduction_code, int transform_code, int convert_code,
276                         int freq_limit)
277 {
278    int i, j, k;
279    int abcd_index;
280    long samprate;
281    int limit;
282    int bit_code;
283
284    if (m->iup.first_pass)
285    {
286       table_init(m);
287       m->iup.first_pass = 0;
288    }
289
290 /* check if code handles */
291    if (h->option == 3)          /* layer I */
292       return i_audio_decode_initL1(m, h, framebytes_arg,
293                   reduction_code, transform_code, convert_code, freq_limit);
294    if (h->option != 2)
295       return 0;                 /* layer II only */
296
297
298    m->iup.unpack_routine = unpack;
299
300    transform_code = transform_code;     /* not used, asm compatability */
301    bit_code = 0;
302    if (convert_code & 8)
303       bit_code = 1;
304    convert_code = convert_code & 3;     /* higher bits used by dec8 freq cvt */
305    if (reduction_code < 0)
306       reduction_code = 0;
307    if (reduction_code > 2)
308       reduction_code = 2;
309    if (freq_limit < 1000)
310       freq_limit = 1000;
311
312
313    m->iup.framebytes = framebytes_arg;
314
315 /* compute abcd index for bit allo table selection */
316    if (h->id)                   /* mpeg 1 */
317       abcd_index = lookqt[h->mode][h->sr_index][h->br_index];
318    else
319       abcd_index = 4;           /* mpeg 2 */
320    for (i = 0; i < 4; i++)
321       for (j = 0; j < 16; j++)
322          m->iup.bat[i][j] = look_bat[abcd_index][i][j];
323    for (i = 0; i < 4; i++)
324       m->iup.nbat[i] = look_nbat[abcd_index][i];
325    m->iup.max_sb = m->iup.nbat[0] + m->iup.nbat[1] + m->iup.nbat[2] + m->iup.nbat[3];
326 /*----- compute nsb_limit --------*/
327    samprate = sr_table[4 * h->id + h->sr_index];
328    m->iup.nsb_limit = (freq_limit * 64L + samprate / 2) / samprate;
329 /*- caller limit -*/
330 /*---- limit = 0.94*(32>>reduction_code);  ----*/
331    limit = (32 >> reduction_code);
332    if (limit > 8)
333       limit--;
334    if (m->iup.nsb_limit > limit)
335       m->iup.nsb_limit = limit;
336    if (m->iup.nsb_limit > m->iup.max_sb)
337       m->iup.nsb_limit = m->iup.max_sb;
338
339    m->iup.outvalues = 1152 >> reduction_code;
340    if (h->mode != 3)
341    {                            /* adjust for 2 channel modes */
342       for (i = 0; i < 4; i++)
343           m->iup.nbat[i] *= 2;
344       m->iup.max_sb *= 2;
345       m->iup.nsb_limit *= 2;
346    }
347
348 /* set sbt function */
349    m->iup.nsbt = 36;
350    k = 1 + convert_code;
351    if (h->mode == 3)
352    {
353       k = 0;
354    }
355    m->iup.sbt = sbt_table[bit_code][reduction_code][k];
356    m->iup.outvalues *= out_chans[k];
357    if (bit_code != 0)
358       m->iup.outbytes = m->iup.outvalues;
359    else
360       m->iup.outbytes = sizeof(short) * m->iup.outvalues;
361
362    m->iup.decinfo.channels = out_chans[k];
363    m->iup.decinfo.outvalues = m->iup.outvalues;
364    m->iup.decinfo.samprate = samprate >> reduction_code;
365    if (bit_code != 0)
366       m->iup.decinfo.bits = 8;
367    else
368       m->iup.decinfo.bits = sizeof(short) * 8;
369
370    m->iup.decinfo.framebytes = m->iup.framebytes;
371    m->iup.decinfo.type = 0;
372
373
374 /* clear sample buffer, unused sub bands must be 0 */
375    for (i = 0; i < 2304; i++)
376       m->iup.sample[i] = 0;
377
378
379 /* init sub-band transform */
380    i_sbt_init();
381
382    return 1;
383 }
384 /*---------------------------------------------------------*/
385 void i_audio_decode_info(MPEGI *m, DEC_INFO * info)
386 {
387    *info = m->iup.decinfo;              /* info return, call after init */
388 }
389 /*---------------------------------------------------------*/