Code cleanups (bug #66)
[asterisk/asterisk.git] / codecs / mp3 / src / isbt.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 /****  isbt.c  ***************************************************
28
29 MPEG audio decoder, dct and window
30 portable C       integer version of csbt.c
31
32 mods 11/15/95 for Layer I
33
34 mods 1/7/97 warnings
35
36 ******************************************************************/
37
38 #include <stdlib.h>
39 #include <stdio.h>
40 #include <float.h>
41 #include <math.h>
42 #include "itype.h"
43
44
45 #ifdef _MSC_VER
46 #pragma warning(disable: 4244)
47 #pragma warning(disable: 4056)
48 #endif
49
50
51
52 /* asm is quick only, c code does not need separate window for right */
53 /* full is opposite of quick */
54 #ifdef  FULL_INTEGER
55 #define i_window_dual_right   i_window_dual
56 #define i_window16_dual_right i_window16_dual
57 #define i_window8_dual_right  i_window8_dual
58 #endif
59
60
61 void i_dct32(SAMPLEINT * sample, WININT * vbuf);
62 void i_dct32_dual(SAMPLEINT * sample, WININT * vbuf);
63 void i_dct32_dual_mono(SAMPLEINT * sample, WININT * vbuf);
64
65 void i_dct16(SAMPLEINT * sample, WININT * vbuf);
66 void i_dct16_dual(SAMPLEINT * sample, WININT * vbuf);
67 void i_dct16_dual_mono(SAMPLEINT * sample, WININT * vbuf);
68
69 void i_dct8(SAMPLEINT * sample, WININT * vbuf);
70 void i_dct8_dual(SAMPLEINT * sample, WININT * vbuf);
71 void i_dct8_dual_mono(SAMPLEINT * sample, WININT * vbuf);
72
73
74 void i_window(WININT * vbuf, int vb_ptr, short *pcm);
75 void i_window_dual(WININT * vbuf, int vb_ptr, short *pcm);
76 void i_window_dual_right(WININT * vbuf, int vb_ptr, short *pcm);
77
78 void i_window16(WININT * vbuf, int vb_ptr, short *pcm);
79 void i_window16_dual(WININT * vbuf, int vb_ptr, short *pcm);
80 void i_window16_dual_right(WININT * vbuf, int vb_ptr, short *pcm);
81
82 void i_window8(WININT * vbuf, int vb_ptr, short *pcm);
83 void i_window8_dual(WININT * vbuf, int vb_ptr, short *pcm);
84 void i_window8_dual_right(WININT * vbuf, int vb_ptr, short *pcm);
85
86 /*--------------------------------------------------------------------*/
87 /*--  floating point window coefs  ---*/
88 /*--  for integer-quick window, table used to generate integer coefs --*/
89 static float wincoef[264] =
90 {
91 #include "tableawd.h"
92 };
93
94 /* circular window buffers */
95 /* extern windows because of asm */
96 static signed int vb_ptr;
97
98 // static WININT vbuf[512];
99 //static WININT vbuf2[512];
100 extern WININT vbuf[512];
101 extern WININT vbuf2[512];
102
103 DCTCOEF *i_dct_coef_addr(void);
104
105 /*======================================================================*/
106 static void gencoef(void)               /* gen coef for N=32 */
107 {
108    int p, n, i, k;
109    double t, pi;
110    DCTCOEF *coef32;
111
112    coef32 = i_dct_coef_addr();
113
114
115    pi = 4.0 * atan(1.0);
116    n = 16;
117    k = 0;
118    for (i = 0; i < 5; i++, n = n / 2)
119    {
120       for (p = 0; p < n; p++, k++)
121       {
122          t = (pi / (4 * n)) * (2 * p + 1);
123          coef32[k] = (1 << DCTBITS) * (0.50 / cos(t)) + 0.5;
124       }
125    }
126 }
127 /*------------------------------------------------------------*/
128 WINCOEF *i_wincoef_addr(void);
129 static void genwincoef_q(void)  /* gen int window coefs from floating table */
130 {
131    int i, j, k, m;
132    float x;
133    WINCOEF *iwincoef;
134
135    iwincoef = i_wincoef_addr();
136
137
138 /*--- coefs generated inline for quick window ---*/
139 /*-- quick uses only 116 coefs --*/
140
141    k = 0;
142    m = 0;
143    for (i = 0; i < 16; i++)
144    {
145       k += 5;
146       for (j = 0; j < 7; j++)
147       {
148          x = (1 << WINBITS) * wincoef[k++];
149          if (x > 0.0)
150             x += 0.5;
151          else
152             x -= 0.5;
153          iwincoef[m++] = x;
154       }
155       k += 4;
156    }
157    k++;
158    for (j = 0; j < 4; j++)
159    {
160       x = (1 << WINBITS) * wincoef[k++];
161       if (x > 0.0)
162          x += 0.5;
163       else
164          x -= 0.5;
165       iwincoef[m++] = x;
166    }
167 }
168 /*------------------------------------------------------------*/
169 static void genwincoef(void)    /* gen int window coefs from floating table */
170 {
171    int i;
172    float x;
173    WINCOEF *iwincoef;
174
175    iwincoef = i_wincoef_addr();
176
177    for (i = 0; i < 264; i++)
178    {
179       x = (1 << WINBITS) * wincoef[i];
180       if (x > 0.0)
181          x += 0.5;
182       else
183          x -= 0.5;
184       iwincoef[i] = x;
185    }
186 }
187 /*------------------------------------------------------------*/
188 void i_sbt_init(void)
189 {
190    int i;
191    static int first_pass = 1;
192
193 #ifdef FULL_INTEGER
194    static int full_integer = 1;
195
196 #else
197    static int full_integer = 0;
198
199 #endif
200
201    if (first_pass)
202    {
203       gencoef();
204       if (full_integer)
205          genwincoef();
206       else
207          genwincoef_q();
208       first_pass = 0;
209    }
210
211 /* clear window vbuf */
212    for (i = 0; i < 512; i++)
213       vbuf[i] = vbuf2[i] = 0;
214    vb_ptr = 0;
215
216 }
217 /*==============================================================*/
218 /*==============================================================*/
219 /*==============================================================*/
220 void i_sbt_mono(SAMPLEINT * sample, short *pcm, int n)
221 {
222    int i;
223
224    for (i = 0; i < n; i++)
225    {
226       i_dct32(sample, vbuf + vb_ptr);
227       i_window(vbuf, vb_ptr, pcm);
228       sample += 64;
229       vb_ptr = (vb_ptr - 32) & 511;
230       pcm += 32;
231    }
232
233 }
234 /*------------------------------------------------------------*/
235 void i_sbt_dual(SAMPLEINT * sample, short *pcm, int n)
236 {
237    int i;
238
239    for (i = 0; i < n; i++)
240    {
241       i_dct32_dual(sample, vbuf + vb_ptr);
242       i_dct32_dual(sample + 1, vbuf2 + vb_ptr);
243       i_window_dual(vbuf, vb_ptr, pcm);
244       i_window_dual_right(vbuf2, vb_ptr, pcm + 1);
245       sample += 64;
246       vb_ptr = (vb_ptr - 32) & 511;
247       pcm += 64;
248    }
249 }
250 /*------------------------------------------------------------*/
251 /* convert dual to mono */
252 void i_sbt_dual_mono(SAMPLEINT * sample, short *pcm, int n)
253 {
254    int i;
255
256    for (i = 0; i < n; i++)
257    {
258       i_dct32_dual_mono(sample, vbuf + vb_ptr);
259       i_window(vbuf, vb_ptr, pcm);
260       sample += 64;
261       vb_ptr = (vb_ptr - 32) & 511;
262       pcm += 32;
263    }
264 }
265 /*------------------------------------------------------------*/
266 /* convert dual to left */
267 void i_sbt_dual_left(SAMPLEINT * sample, short *pcm, int n)
268 {
269    int i;
270
271    for (i = 0; i < n; i++)
272    {
273       i_dct32_dual(sample, vbuf + vb_ptr);
274       i_window(vbuf, vb_ptr, pcm);
275       sample += 64;
276       vb_ptr = (vb_ptr - 32) & 511;
277       pcm += 32;
278    }
279 }
280 /*------------------------------------------------------------*/
281 /* convert dual to right */
282 void i_sbt_dual_right(SAMPLEINT * sample, short *pcm, int n)
283 {
284    int i;
285
286    sample++;                    /* point to right chan */
287    for (i = 0; i < n; i++)
288    {
289       i_dct32_dual(sample, vbuf + vb_ptr);
290       i_window(vbuf, vb_ptr, pcm);
291       sample += 64;
292       vb_ptr = (vb_ptr - 32) & 511;
293       pcm += 32;
294    }
295 }
296 /*------------------------------------------------------------*/
297 /*---------------- 16 pt sbt's  -------------------------------*/
298 /*------------------------------------------------------------*/
299 void i_sbt16_mono(SAMPLEINT * sample, short *pcm, int n)
300 {
301    int i;
302
303    for (i = 0; i < n; i++)
304    {
305       i_dct16(sample, vbuf + vb_ptr);
306       i_window16(vbuf, vb_ptr, pcm);
307       sample += 64;
308       vb_ptr = (vb_ptr - 16) & 255;
309       pcm += 16;
310    }
311
312 }
313 /*------------------------------------------------------------*/
314 void i_sbt16_dual(SAMPLEINT * sample, short *pcm, int n)
315 {
316    int i;
317
318    for (i = 0; i < n; i++)
319    {
320       i_dct16_dual(sample, vbuf + vb_ptr);
321       i_dct16_dual(sample + 1, vbuf2 + vb_ptr);
322       i_window16_dual(vbuf, vb_ptr, pcm);
323       i_window16_dual_right(vbuf2, vb_ptr, pcm + 1);
324       sample += 64;
325       vb_ptr = (vb_ptr - 16) & 255;
326       pcm += 32;
327    }
328
329 }
330 /*------------------------------------------------------------*/
331 void i_sbt16_dual_mono(SAMPLEINT * sample, short *pcm, int n)
332 {
333    int i;
334
335    for (i = 0; i < n; i++)
336    {
337       i_dct16_dual_mono(sample, vbuf + vb_ptr);
338       i_window16(vbuf, vb_ptr, pcm);
339       sample += 64;
340       vb_ptr = (vb_ptr - 16) & 255;
341       pcm += 16;
342    }
343 }
344 /*------------------------------------------------------------*/
345 void i_sbt16_dual_left(SAMPLEINT * sample, short *pcm, int n)
346 {
347    int i;
348
349    for (i = 0; i < n; i++)
350    {
351       i_dct16_dual(sample, vbuf + vb_ptr);
352       i_window16(vbuf, vb_ptr, pcm);
353       sample += 64;
354       vb_ptr = (vb_ptr - 16) & 255;
355       pcm += 16;
356    }
357 }
358 /*------------------------------------------------------------*/
359 void i_sbt16_dual_right(SAMPLEINT * sample, short *pcm, int n)
360 {
361    int i;
362
363    sample++;
364    for (i = 0; i < n; i++)
365    {
366       i_dct16_dual(sample, vbuf + vb_ptr);
367       i_window16(vbuf, vb_ptr, pcm);
368       sample += 64;
369       vb_ptr = (vb_ptr - 16) & 255;
370       pcm += 16;
371    }
372 }
373 /*------------------------------------------------------------*/
374 /*---------------- 8 pt sbt's  -------------------------------*/
375 /*------------------------------------------------------------*/
376 void i_sbt8_mono(SAMPLEINT * sample, short *pcm, int n)
377 {
378    int i;
379
380    for (i = 0; i < n; i++)
381    {
382       i_dct8(sample, vbuf + vb_ptr);
383       i_window8(vbuf, vb_ptr, pcm);
384       sample += 64;
385       vb_ptr = (vb_ptr - 8) & 127;
386       pcm += 8;
387    }
388
389 }
390 /*------------------------------------------------------------*/
391 void i_sbt8_dual(SAMPLEINT * sample, short *pcm, int n)
392 {
393    int i;
394
395    for (i = 0; i < n; i++)
396    {
397       i_dct8_dual(sample, vbuf + vb_ptr);
398       i_dct8_dual(sample + 1, vbuf2 + vb_ptr);
399       i_window8_dual(vbuf, vb_ptr, pcm);
400       i_window8_dual_right(vbuf2, vb_ptr, pcm + 1);
401       sample += 64;
402       vb_ptr = (vb_ptr - 8) & 127;
403       pcm += 16;
404    }
405 }
406 /*------------------------------------------------------------*/
407 void i_sbt8_dual_mono(SAMPLEINT * sample, short *pcm, int n)
408 {
409    int i;
410
411    for (i = 0; i < n; i++)
412    {
413       i_dct8_dual_mono(sample, vbuf + vb_ptr);
414       i_window8(vbuf, vb_ptr, pcm);
415       sample += 64;
416       vb_ptr = (vb_ptr - 8) & 127;
417       pcm += 8;
418    }
419 }
420 /*------------------------------------------------------------*/
421 void i_sbt8_dual_left(SAMPLEINT * sample, short *pcm, int n)
422 {
423    int i;
424
425    for (i = 0; i < n; i++)
426    {
427       i_dct8_dual(sample, vbuf + vb_ptr);
428       i_window8(vbuf, vb_ptr, pcm);
429       sample += 64;
430       vb_ptr = (vb_ptr - 8) & 127;
431       pcm += 8;
432    }
433 }
434 /*------------------------------------------------------------*/
435 void i_sbt8_dual_right(SAMPLEINT * sample, short *pcm, int n)
436 {
437    int i;
438
439    sample++;
440    for (i = 0; i < n; i++)
441    {
442       i_dct8_dual(sample, vbuf + vb_ptr);
443       i_window8(vbuf, vb_ptr, pcm);
444       sample += 64;
445       vb_ptr = (vb_ptr - 8) & 127;
446       pcm += 8;
447    }
448 }
449 /*------------------------------------------------------------*/
450 /*--- 8 bit output ----------------*/
451 #include "isbtb.c"
452 /*----------------------------------*/
453
454 #ifdef _MSC_VER
455 #pragma warning(default: 4244)
456 #pragma warning(default: 4056)
457 #endif