Version 0.1.1 from FTP
[asterisk/asterisk.git] / codecs / mp3 / src / isbtb.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 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 /****  isbtb.c  ***************************************************
28
29 include to isbt.c
30
31
32 MPEG audio decoder, integer dct and window, 8 bit output
33
34
35 ******************************************************************/
36 /* asm is quick only, c code does not need separate window for right */
37 /* full is opposite of quick */
38 #ifdef  FULL_INTEGER
39 #define i_windowB_dual_right   i_windowB_dual
40 #define i_windowB16_dual_right i_windowB16_dual
41 #define i_windowB8_dual_right  i_windowB8_dual
42 #endif
43
44 void i_windowB(WININT * vbuf, int vb_ptr, unsigned char *pcm);
45 void i_windowB_dual(WININT * vbuf, int vb_ptr, unsigned char *pcm);
46 void i_windowB_dual_right(WININT * vbuf, int vb_ptr, unsigned char *pcm);
47 void i_windowB16(WININT * vbuf, int vb_ptr, unsigned char *pcm);
48 void i_windowB16_dual(WININT * vbuf, int vb_ptr, unsigned char *pcm);
49 void i_windowB16_dual_right(WININT * vbuf, int vb_ptr, unsigned char *pcm);
50 void i_windowB8(WININT * vbuf, int vb_ptr, unsigned char *pcm);
51 void i_windowB8_dual(WININT * vbuf, int vb_ptr, unsigned char *pcm);
52 void i_windowB8_dual_right(WININT * vbuf, int vb_ptr, unsigned char *pcm);
53
54
55
56 /*==============================================================*/
57 /*==============================================================*/
58 /*==============================================================*/
59 void i_sbtB_mono(SAMPLEINT * sample, unsigned char *pcm, int n)
60 {
61    int i;
62
63    for (i = 0; i < n; i++)
64    {
65       i_dct32(sample, vbuf + vb_ptr);
66       i_windowB(vbuf, vb_ptr, pcm);
67       sample += 64;
68       vb_ptr = (vb_ptr - 32) & 511;
69       pcm += 32;
70    }
71
72 }
73 /*------------------------------------------------------------*/
74 void i_sbtB_dual(SAMPLEINT * sample, unsigned char *pcm, int n)
75 {
76    int i;
77
78    for (i = 0; i < n; i++)
79    {
80       i_dct32_dual(sample, vbuf + vb_ptr);
81       i_dct32_dual(sample + 1, vbuf2 + vb_ptr);
82       i_windowB_dual(vbuf, vb_ptr, pcm);
83       i_windowB_dual_right(vbuf2, vb_ptr, pcm + 1);
84       sample += 64;
85       vb_ptr = (vb_ptr - 32) & 511;
86       pcm += 64;
87    }
88 }
89 /*------------------------------------------------------------*/
90 /* convert dual to mono */
91 void i_sbtB_dual_mono(SAMPLEINT * sample, unsigned char *pcm, int n)
92 {
93    int i;
94
95    for (i = 0; i < n; i++)
96    {
97       i_dct32_dual_mono(sample, vbuf + vb_ptr);
98       i_windowB(vbuf, vb_ptr, pcm);
99       sample += 64;
100       vb_ptr = (vb_ptr - 32) & 511;
101       pcm += 32;
102    }
103 }
104 /*------------------------------------------------------------*/
105 /* convert dual to left */
106 void i_sbtB_dual_left(SAMPLEINT * sample, unsigned char *pcm, int n)
107 {
108    int i;
109
110    for (i = 0; i < n; i++)
111    {
112       i_dct32_dual(sample, vbuf + vb_ptr);
113       i_windowB(vbuf, vb_ptr, pcm);
114       sample += 64;
115       vb_ptr = (vb_ptr - 32) & 511;
116       pcm += 32;
117    }
118 }
119 /*------------------------------------------------------------*/
120 /* convert dual to right */
121 void i_sbtB_dual_right(SAMPLEINT * sample, unsigned char *pcm, int n)
122 {
123    int i;
124
125    sample++;                    /* point to right chan */
126    for (i = 0; i < n; i++)
127    {
128       i_dct32_dual(sample, vbuf + vb_ptr);
129       i_windowB(vbuf, vb_ptr, pcm);
130       sample += 64;
131       vb_ptr = (vb_ptr - 32) & 511;
132       pcm += 32;
133    }
134 }
135 /*------------------------------------------------------------*/
136 /*---------------- 16 pt sbt's  -------------------------------*/
137 /*------------------------------------------------------------*/
138 void i_sbtB16_mono(SAMPLEINT * sample, unsigned char *pcm, int n)
139 {
140    int i;
141
142    for (i = 0; i < n; i++)
143    {
144       i_dct16(sample, vbuf + vb_ptr);
145       i_windowB16(vbuf, vb_ptr, pcm);
146       sample += 64;
147       vb_ptr = (vb_ptr - 16) & 255;
148       pcm += 16;
149    }
150
151 }
152 /*------------------------------------------------------------*/
153 void i_sbtB16_dual(SAMPLEINT * sample, unsigned char *pcm, int n)
154 {
155    int i;
156
157    for (i = 0; i < n; i++)
158    {
159       i_dct16_dual(sample, vbuf + vb_ptr);
160       i_dct16_dual(sample + 1, vbuf2 + vb_ptr);
161       i_windowB16_dual(vbuf, vb_ptr, pcm);
162       i_windowB16_dual_right(vbuf2, vb_ptr, pcm + 1);
163       sample += 64;
164       vb_ptr = (vb_ptr - 16) & 255;
165       pcm += 32;
166    }
167
168 }
169 /*------------------------------------------------------------*/
170 void i_sbtB16_dual_mono(SAMPLEINT * sample, unsigned char *pcm, int n)
171 {
172    int i;
173
174    for (i = 0; i < n; i++)
175    {
176       i_dct16_dual_mono(sample, vbuf + vb_ptr);
177       i_windowB16(vbuf, vb_ptr, pcm);
178       sample += 64;
179       vb_ptr = (vb_ptr - 16) & 255;
180       pcm += 16;
181    }
182 }
183 /*------------------------------------------------------------*/
184 void i_sbtB16_dual_left(SAMPLEINT * sample, unsigned char *pcm, int n)
185 {
186    int i;
187
188    for (i = 0; i < n; i++)
189    {
190       i_dct16_dual(sample, vbuf + vb_ptr);
191       i_windowB16(vbuf, vb_ptr, pcm);
192       sample += 64;
193       vb_ptr = (vb_ptr - 16) & 255;
194       pcm += 16;
195    }
196 }
197 /*------------------------------------------------------------*/
198 void i_sbtB16_dual_right(SAMPLEINT * sample, unsigned char *pcm, int n)
199 {
200    int i;
201
202    sample++;
203    for (i = 0; i < n; i++)
204    {
205       i_dct16_dual(sample, vbuf + vb_ptr);
206       i_windowB16(vbuf, vb_ptr, pcm);
207       sample += 64;
208       vb_ptr = (vb_ptr - 16) & 255;
209       pcm += 16;
210    }
211 }
212 /*------------------------------------------------------------*/
213 /*---------------- 8 pt sbt's  -------------------------------*/
214 /*------------------------------------------------------------*/
215 void i_sbtB8_mono(SAMPLEINT * sample, unsigned char *pcm, int n)
216 {
217    int i;
218
219    for (i = 0; i < n; i++)
220    {
221       i_dct8(sample, vbuf + vb_ptr);
222       i_windowB8(vbuf, vb_ptr, pcm);
223       sample += 64;
224       vb_ptr = (vb_ptr - 8) & 127;
225       pcm += 8;
226    }
227
228 }
229 /*------------------------------------------------------------*/
230 void i_sbtB8_dual(SAMPLEINT * sample, unsigned char *pcm, int n)
231 {
232    int i;
233
234    for (i = 0; i < n; i++)
235    {
236       i_dct8_dual(sample, vbuf + vb_ptr);
237       i_dct8_dual(sample + 1, vbuf2 + vb_ptr);
238       i_windowB8_dual(vbuf, vb_ptr, pcm);
239       i_windowB8_dual_right(vbuf2, vb_ptr, pcm + 1);
240       sample += 64;
241       vb_ptr = (vb_ptr - 8) & 127;
242       pcm += 16;
243    }
244 }
245 /*------------------------------------------------------------*/
246 void i_sbtB8_dual_mono(SAMPLEINT * sample, unsigned char *pcm, int n)
247 {
248    int i;
249
250    for (i = 0; i < n; i++)
251    {
252       i_dct8_dual_mono(sample, vbuf + vb_ptr);
253       i_windowB8(vbuf, vb_ptr, pcm);
254       sample += 64;
255       vb_ptr = (vb_ptr - 8) & 127;
256       pcm += 8;
257    }
258 }
259 /*------------------------------------------------------------*/
260 void i_sbtB8_dual_left(SAMPLEINT * sample, unsigned char *pcm, int n)
261 {
262    int i;
263
264    for (i = 0; i < n; i++)
265    {
266       i_dct8_dual(sample, vbuf + vb_ptr);
267       i_windowB8(vbuf, vb_ptr, pcm);
268       sample += 64;
269       vb_ptr = (vb_ptr - 8) & 127;
270       pcm += 8;
271    }
272 }
273 /*------------------------------------------------------------*/
274 void i_sbtB8_dual_right(SAMPLEINT * sample, unsigned char *pcm, int n)
275 {
276    int i;
277
278    sample++;
279    for (i = 0; i < n; i++)
280    {
281       i_dct8_dual(sample, vbuf + vb_ptr);
282       i_windowB8(vbuf, vb_ptr, pcm);
283       sample += 64;
284       vb_ptr = (vb_ptr - 8) & 127;
285       pcm += 8;
286    }
287 }
288 /*------------------------------------------------------------*/