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