Code cleanups (bug #66)
[asterisk/asterisk.git] / codecs / mp3 / src / cupini.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 cup.c - include to cup.c
29  mpeg audio decoder portable "c"
30
31 mod 8/6/96 add 8 bit output
32
33 mod 5/10/95 add quick (low precision) window
34
35 mod 5/16/95 sb limit for reduced samprate output
36             changed from 94% to 100% of Nyquist sb
37
38 mod 11/15/95 for Layer I
39
40
41 =========================================================*/
42 /*-- compiler bug, floating constant overflow w/ansi --*/
43 #ifdef _MSC_VER
44 #pragma warning(disable:4056)
45 #endif
46
47 #include <string.h>
48
49 /* Read Only */
50 static long steps[18] =
51 {
52    0, 3, 5, 7, 9, 15, 31, 63, 127,
53    255, 511, 1023, 2047, 4095, 8191, 16383, 32767, 65535};
54
55
56 /* ABCD_INDEX = lookqt[mode][sr_index][br_index]  */
57 /* -1 = invalid  */
58 /* Read Only */
59 static signed char lookqt[4][3][16] =
60 {
61  {{1, -1, -1, -1, 2, -1, 2, 0, 0, 0, 1, 1, 1, 1, 1, -1},        /*  44ks stereo */
62   {0, -1, -1, -1, 2, -1, 2, 0, 0, 0, 0, 0, 0, 0, 0, -1},        /*  48ks */
63   {1, -1, -1, -1, 3, -1, 3, 0, 0, 0, 1, 1, 1, 1, 1, -1}},       /*  32ks */
64  {{1, -1, -1, -1, 2, -1, 2, 0, 0, 0, 1, 1, 1, 1, 1, -1},        /*  44ks joint stereo */
65   {0, -1, -1, -1, 2, -1, 2, 0, 0, 0, 0, 0, 0, 0, 0, -1},        /*  48ks */
66   {1, -1, -1, -1, 3, -1, 3, 0, 0, 0, 1, 1, 1, 1, 1, -1}},       /*  32ks */
67  {{1, -1, -1, -1, 2, -1, 2, 0, 0, 0, 1, 1, 1, 1, 1, -1},        /*  44ks dual chan */
68   {0, -1, -1, -1, 2, -1, 2, 0, 0, 0, 0, 0, 0, 0, 0, -1},        /*  48ks */
69   {1, -1, -1, -1, 3, -1, 3, 0, 0, 0, 1, 1, 1, 1, 1, -1}},       /*  32ks */
70 // mono extended beyond legal br index
71 //  1,2,2,0,0,0,1,1,1,1,1,1,1,1,1,-1,          /*  44ks single chan */
72 //  0,2,2,0,0,0,0,0,0,0,0,0,0,0,0,-1,          /*  48ks */
73 //  1,3,3,0,0,0,1,1,1,1,1,1,1,1,1,-1,          /*  32ks */
74 // legal mono
75  {{1, 2, 2, 0, 0, 0, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1},        /*  44ks single chan */
76   {0, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, -1, -1, -1, -1, -1},        /*  48ks */
77   {1, 3, 3, 0, 0, 0, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1}},       /*  32ks */
78 };
79 /* Read Only */
80 static long sr_table[8] =
81 {22050L, 24000L, 16000L, 1L,
82  44100L, 48000L, 32000L, 1L};
83
84 /* bit allocation table look up */
85 /* table per mpeg spec tables 3b2a/b/c/d  /e is mpeg2 */
86 /* look_bat[abcd_index][4][16]  */
87 /* Read Only */
88 static unsigned char look_bat[5][4][16] =
89 {
90 /* LOOK_BATA */
91  {{0, 1, 3, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17},
92   {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 17},
93   {0, 1, 2, 3, 4, 5, 6, 17, 0, 0, 0, 0, 0, 0, 0, 0},
94   {0, 1, 2, 17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
95 /* LOOK_BATB */
96  {{0, 1, 3, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17},
97   {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 17},
98   {0, 1, 2, 3, 4, 5, 6, 17, 0, 0, 0, 0, 0, 0, 0, 0},
99   {0, 1, 2, 17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
100 /* LOOK_BATC */
101  {{0, 1, 2, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16},
102   {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
103   {0, 1, 2, 4, 5, 6, 7, 8, 0, 0, 0, 0, 0, 0, 0, 0},
104   {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
105 /* LOOK_BATD */
106  {{0, 1, 2, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16},
107   {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
108   {0, 1, 2, 4, 5, 6, 7, 8, 0, 0, 0, 0, 0, 0, 0, 0},
109   {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
110 /* LOOK_BATE */
111  {{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15},
112   {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
113   {0, 1, 2, 4, 5, 6, 7, 8, 0, 0, 0, 0, 0, 0, 0, 0},
114   {0, 1, 2, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
115 };
116
117 /* look_nbat[abcd_index]][4] */
118 /* Read Only */
119 static unsigned char look_nbat[5][4] =
120 {
121   {3, 8, 12, 4},
122   {3, 8, 12, 7},
123   {2, 0, 6, 0},
124   {2, 0, 10, 0},
125   {4, 0, 7, 19},
126 };
127
128
129 void sbt_mono(MPEG *m, float *sample, short *pcm, int n);
130 void sbt_dual(MPEG *m, float *sample, short *pcm, int n);
131 void sbt_dual_mono(MPEG *m, float *sample, short *pcm, int n);
132 void sbt_dual_left(MPEG *m, float *sample, short *pcm, int n);
133 void sbt_dual_right(MPEG *m, float *sample, short *pcm, int n);
134 void sbt16_mono(MPEG *m, float *sample, short *pcm, int n);
135 void sbt16_dual(MPEG *m, float *sample, short *pcm, int n);
136 void sbt16_dual_mono(MPEG *m, float *sample, short *pcm, int n);
137 void sbt16_dual_left(MPEG *m, float *sample, short *pcm, int n);
138 void sbt16_dual_right(MPEG *m, float *sample, short *pcm, int n);
139 void sbt8_mono(MPEG *m, float *sample, short *pcm, int n);
140 void sbt8_dual(MPEG *m, float *sample, short *pcm, int n);
141 void sbt8_dual_mono(MPEG *m, float *sample, short *pcm, int n);
142 void sbt8_dual_left(MPEG *m, float *sample, short *pcm, int n);
143 void sbt8_dual_right(MPEG *m, float *sample, short *pcm, int n);
144
145 /*--- 8 bit output ---*/
146 void sbtB_mono(MPEG *m, float *sample, unsigned char *pcm, int n);
147 void sbtB_dual(MPEG *m, float *sample, unsigned char *pcm, int n);
148 void sbtB_dual_mono(MPEG *m, float *sample, unsigned char *pcm, int n);
149 void sbtB_dual_left(MPEG *m, float *sample, unsigned char *pcm, int n);
150 void sbtB_dual_right(MPEG *m, float *sample, unsigned char *pcm, int n);
151 void sbtB16_mono(MPEG *m, float *sample, unsigned char *pcm, int n);
152 void sbtB16_dual(MPEG *m, float *sample, unsigned char *pcm, int n);
153 void sbtB16_dual_mono(MPEG *m, float *sample, unsigned char *pcm, int n);
154 void sbtB16_dual_left(MPEG *m, float *sample, unsigned char *pcm, int n);
155 void sbtB16_dual_right(MPEG *m, float *sample, unsigned char *pcm, int n);
156 void sbtB8_mono(MPEG *m, float *sample, unsigned char *pcm, int n);
157 void sbtB8_dual(MPEG *m, float *sample, unsigned char *pcm, int n);
158 void sbtB8_dual_mono(MPEG *m, float *sample, unsigned char *pcm, int n);
159 void sbtB8_dual_left(MPEG *m, float *sample, unsigned char *pcm, int n);
160 void sbtB8_dual_right(MPEG *m, float *sample, unsigned char *pcm, int n);
161
162
163 static SBT_FUNCTION_F sbt_table[2][3][5] =
164 {
165  {{sbt_mono, sbt_dual, sbt_dual_mono, sbt_dual_left, sbt_dual_right},
166   {sbt16_mono, sbt16_dual, sbt16_dual_mono, sbt16_dual_left, sbt16_dual_right},
167   {sbt8_mono, sbt8_dual, sbt8_dual_mono, sbt8_dual_left, sbt8_dual_right}},
168  {{(SBT_FUNCTION_F) sbtB_mono,
169    (SBT_FUNCTION_F) sbtB_dual,
170    (SBT_FUNCTION_F) sbtB_dual_mono,
171    (SBT_FUNCTION_F) sbtB_dual_left,
172    (SBT_FUNCTION_F) sbtB_dual_right},
173   {(SBT_FUNCTION_F) sbtB16_mono,
174    (SBT_FUNCTION_F) sbtB16_dual,
175    (SBT_FUNCTION_F) sbtB16_dual_mono,
176    (SBT_FUNCTION_F) sbtB16_dual_left,
177    (SBT_FUNCTION_F) sbtB16_dual_right},
178   {(SBT_FUNCTION_F) sbtB8_mono,
179    (SBT_FUNCTION_F) sbtB8_dual,
180    (SBT_FUNCTION_F) sbtB8_dual_mono,
181    (SBT_FUNCTION_F) sbtB8_dual_left,
182    (SBT_FUNCTION_F) sbtB8_dual_right}},
183 };
184
185 static int out_chans[5] =
186 {1, 2, 1, 1, 1};
187
188
189 int audio_decode_initL1(MPEG_HEAD * h, int framebytes_arg,
190                    int reduction_code, int transform_code, int convert_code,
191                         int freq_limit);
192 void sbt_init(MPEG *m);
193
194
195 IN_OUT L1audio_decode(void *mv, unsigned char *bs, signed short *pcm);
196 IN_OUT L2audio_decode(void *mv, unsigned char *bs, signed short *pcm);
197 IN_OUT L3audio_decode(void *mv, unsigned char *bs, unsigned char *pcm);
198 static AUDIO_DECODE_ROUTINE decode_routine_table[4] =
199 {
200    L2audio_decode,
201    (AUDIO_DECODE_ROUTINE)L3audio_decode,
202    L2audio_decode,
203    L1audio_decode,};
204
205 extern void cup3_init(MPEG *m);
206
207 void mpeg_init(MPEG *m)
208 {
209         memset(m, 0, sizeof(MPEG));
210         m->cup.nsb_limit = 6;
211         m->cup.nbat[0] = 3;
212         m->cup.nbat[1] = 8;
213         m->cup.nbat[3] = 12;
214         m->cup.nbat[4] = 7;
215         m->cup.sbt = sbt_mono;
216         m->cup.first_pass = 1;
217         m->cup.first_pass_L1 = 1;
218         m->cup.audio_decode_routine = L2audio_decode;
219         m->cup.cs_factorL1 = m->cup.cs_factor[0];
220         m->cup.nbatL1 = 32;
221         m->cupl.band_limit = 576;
222         m->cupl.band_limit21 = 567;
223         m->cupl.band_limit12 = 576;
224         m->cupl.band_limit_nsb = 32;
225         m->cupl.nsb_limit=32;
226         m->cup.sample = (float *)&m->cupl.sample;
227         m->csbt.first_pass = 1;
228         cup3_init(m);
229 }
230
231 /*---------------------------------------------------------*/
232 static void table_init(MPEG *m)
233 {
234    int i, j;
235    int code;
236
237 /*--  c_values (dequant) --*/
238    for (i = 1; i < 18; i++)
239       m->cup.look_c_value[i] = 2.0F / steps[i];
240
241 /*--  scale factor table, scale by 32768 for 16 pcm output  --*/
242    for (i = 0; i < 64; i++)
243       m->cup.sf_table[i] = (float) (32768.0 * 2.0 * pow(2.0, -i / 3.0));
244
245 /*--  grouped 3 level lookup table 5 bit token --*/
246    for (i = 0; i < 32; i++)
247    {
248       code = i;
249       for (j = 0; j < 3; j++)
250       {
251          m->cup.group3_table[i][j] = (char) ((code % 3) - 1);
252          code /= 3;
253       }
254    }
255 /*--  grouped 5 level lookup table 7 bit token --*/
256    for (i = 0; i < 128; i++)
257    {
258       code = i;
259       for (j = 0; j < 3; j++)
260       {
261          m->cup.group5_table[i][j] = (char) ((code % 5) - 2);
262          code /= 5;
263       }
264    }
265 /*--  grouped 9 level lookup table 10 bit token --*/
266    for (i = 0; i < 1024; i++)
267    {
268       code = i;
269       for (j = 0; j < 3; j++)
270       {
271          m->cup.group9_table[i][j] = (short) ((code % 9) - 4);
272          code /= 9;
273       }
274    }
275
276
277 }
278 /*---------------------------------------------------------*/
279 int L1audio_decode_init(MPEG *m, MPEG_HEAD * h, int framebytes_arg,
280                    int reduction_code, int transform_code, int convert_code,
281                         int freq_limit);
282 int L3audio_decode_init(MPEG *m, MPEG_HEAD * h, int framebytes_arg,
283                    int reduction_code, int transform_code, int convert_code,
284                         int freq_limit);
285
286 /*---------------------------------------------------------*/
287 /* mpeg_head defined in mhead.h  frame bytes is without pad */
288 int audio_decode_init(MPEG *m, MPEG_HEAD * h, int framebytes_arg,
289                    int reduction_code, int transform_code, int convert_code,
290                       int freq_limit)
291 {
292    int i, j, k;
293    int abcd_index;
294    long samprate;
295    int limit;
296    int bit_code;
297
298    if (m->cup.first_pass)
299    {
300       table_init(m);
301       m->cup.first_pass = 0;
302    }
303
304 /* select decoder routine Layer I,II,III */
305    m->cup.audio_decode_routine = decode_routine_table[h->option & 3];
306
307
308    if (h->option == 3)          /* layer I */
309       return L1audio_decode_init(m, h, framebytes_arg,
310                   reduction_code, transform_code, convert_code, freq_limit);
311
312    if (h->option == 1)          /* layer III */
313       return L3audio_decode_init(m, h, framebytes_arg,
314                   reduction_code, transform_code, convert_code, freq_limit);
315
316
317
318    transform_code = transform_code;     /* not used, asm compatability */
319    bit_code = 0;
320    if (convert_code & 8)
321       bit_code = 1;
322    convert_code = convert_code & 3;     /* higher bits used by dec8 freq cvt */
323    if (reduction_code < 0)
324       reduction_code = 0;
325    if (reduction_code > 2)
326       reduction_code = 2;
327    if (freq_limit < 1000)
328       freq_limit = 1000;
329
330
331    m->cup.framebytes = framebytes_arg;
332 /* check if code handles */
333    if (h->option != 2)
334       return 0;                 /* layer II only */
335    if (h->sr_index == 3)
336       return 0;                 /* reserved */
337
338 /* compute abcd index for bit allo table selection */
339    if (h->id)                   /* mpeg 1 */
340       abcd_index = lookqt[h->mode][h->sr_index][h->br_index];
341    else
342       abcd_index = 4;           /* mpeg 2 */
343
344    if (abcd_index < 0)
345       return 0;                 // fail invalid Layer II bit rate index
346
347    for (i = 0; i < 4; i++)
348       for (j = 0; j < 16; j++)
349          m->cup.bat[i][j] = look_bat[abcd_index][i][j];
350    for (i = 0; i < 4; i++)
351       m->cup.nbat[i] = look_nbat[abcd_index][i];
352    m->cup.max_sb = m->cup.nbat[0] + m->cup.nbat[1] + m->cup.nbat[2] + m->cup.nbat[3];
353 /*----- compute nsb_limit --------*/
354    samprate = sr_table[4 * h->id + h->sr_index];
355    m->cup.nsb_limit = (freq_limit * 64L + samprate / 2) / samprate;
356 /*- caller limit -*/
357 /*---- limit = 0.94*(32>>reduction_code);  ----*/
358    limit = (32 >> reduction_code);
359    if (limit > 8)
360       limit--;
361    if (m->cup.nsb_limit > limit)
362       m->cup.nsb_limit = limit;
363    if (m->cup.nsb_limit > m->cup.max_sb)
364       m->cup.nsb_limit = m->cup.max_sb;
365
366    m->cup.outvalues = 1152 >> reduction_code;
367    if (h->mode != 3)
368    {                            /* adjust for 2 channel modes */
369       for (i = 0; i < 4; i++)
370          m->cup.nbat[i] *= 2;
371       m->cup.max_sb *= 2;
372       m->cup.nsb_limit *= 2;
373    }
374
375 /* set sbt function */
376    k = 1 + convert_code;
377    if (h->mode == 3)
378    {
379       k = 0;
380    }
381    m->cup.sbt = sbt_table[bit_code][reduction_code][k];
382    m->cup.outvalues *= out_chans[k];
383    if (bit_code)
384       m->cup.outbytes = m->cup.outvalues;
385    else
386       m->cup.outbytes = sizeof(short) * m->cup.outvalues;
387
388    m->cup.decinfo.channels = out_chans[k];
389    m->cup.decinfo.outvalues = m->cup.outvalues;
390    m->cup.decinfo.samprate = samprate >> reduction_code;
391    if (bit_code)
392       m->cup.decinfo.bits = 8;
393    else
394       m->cup.decinfo.bits = sizeof(short) * 8;
395
396    m->cup.decinfo.framebytes = m->cup.framebytes;
397    m->cup.decinfo.type = 0;
398
399
400
401 /* clear sample buffer, unused sub bands must be 0 */
402    for (i = 0; i < 2304; i++)
403       m->cup.sample[i] = 0.0F;
404
405
406 /* init sub-band transform */
407    sbt_init(m);
408
409    return 1;
410 }
411 /*---------------------------------------------------------*/
412 void audio_decode_info(MPEG *m, DEC_INFO * info)
413 {
414    *info = m->cup.decinfo;              /* info return, call after init */
415 }
416 /*---------------------------------------------------------*/
417 void decode_table_init(MPEG *m)
418 {
419 /* dummy for asm version compatability */
420 }
421 /*---------------------------------------------------------*/