Commit | Line | Data |
---|---|---|
960366cf KK |
1 | /* |
2 | * Audio support data for mISDN_dsp. | |
3 | * | |
4 | * Copyright 2002/2003 by Andreas Eversberg (jolly@eversberg.eu) | |
5 | * Rewritten by Peter | |
6 | * | |
7 | * This software may be used and distributed according to the terms | |
8 | * of the GNU General Public License, incorporated herein by reference. | |
9 | * | |
10 | */ | |
11 | ||
12 | #include <linux/delay.h> | |
13 | #include <linux/mISDNif.h> | |
14 | #include <linux/mISDNdsp.h> | |
15 | #include "core.h" | |
16 | #include "dsp.h" | |
17 | ||
18 | /* ulaw[unsigned char] -> signed 16-bit */ | |
19 | s32 dsp_audio_ulaw_to_s32[256]; | |
20 | /* alaw[unsigned char] -> signed 16-bit */ | |
21 | s32 dsp_audio_alaw_to_s32[256]; | |
22 | ||
23 | s32 *dsp_audio_law_to_s32; | |
24 | EXPORT_SYMBOL(dsp_audio_law_to_s32); | |
25 | ||
26 | /* signed 16-bit -> law */ | |
27 | u8 dsp_audio_s16_to_law[65536]; | |
28 | EXPORT_SYMBOL(dsp_audio_s16_to_law); | |
29 | ||
30 | /* alaw -> ulaw */ | |
31 | u8 dsp_audio_alaw_to_ulaw[256]; | |
32 | /* ulaw -> alaw */ | |
5b834354 | 33 | static u8 dsp_audio_ulaw_to_alaw[256]; |
960366cf KK |
34 | u8 dsp_silence; |
35 | ||
36 | ||
37 | /***************************************************** | |
38 | * generate table for conversion of s16 to alaw/ulaw * | |
39 | *****************************************************/ | |
40 | ||
41 | #define AMI_MASK 0x55 | |
42 | ||
43 | static inline unsigned char linear2alaw(short int linear) | |
44 | { | |
45 | int mask; | |
46 | int seg; | |
47 | int pcm_val; | |
48 | static int seg_end[8] = { | |
49 | 0xFF, 0x1FF, 0x3FF, 0x7FF, 0xFFF, 0x1FFF, 0x3FFF, 0x7FFF | |
50 | }; | |
51 | ||
52 | pcm_val = linear; | |
53 | if (pcm_val >= 0) { | |
54 | /* Sign (7th) bit = 1 */ | |
55 | mask = AMI_MASK | 0x80; | |
56 | } else { | |
57 | /* Sign bit = 0 */ | |
58 | mask = AMI_MASK; | |
59 | pcm_val = -pcm_val; | |
60 | } | |
61 | ||
62 | /* Convert the scaled magnitude to segment number. */ | |
63 | for (seg = 0; seg < 8; seg++) { | |
64 | if (pcm_val <= seg_end[seg]) | |
65 | break; | |
66 | } | |
67 | /* Combine the sign, segment, and quantization bits. */ | |
68 | return ((seg << 4) | | |
69 | ((pcm_val >> ((seg) ? (seg + 3) : 4)) & 0x0F)) ^ mask; | |
70 | } | |
71 | ||
72 | ||
73 | static inline short int alaw2linear(unsigned char alaw) | |
74 | { | |
75 | int i; | |
76 | int seg; | |
77 | ||
78 | alaw ^= AMI_MASK; | |
79 | i = ((alaw & 0x0F) << 4) + 8 /* rounding error */; | |
80 | seg = (((int) alaw & 0x70) >> 4); | |
81 | if (seg) | |
82 | i = (i + 0x100) << (seg - 1); | |
83 | return (short int) ((alaw & 0x80) ? i : -i); | |
84 | } | |
85 | ||
86 | static inline short int ulaw2linear(unsigned char ulaw) | |
87 | { | |
88 | short mu, e, f, y; | |
89 | static short etab[] = {0, 132, 396, 924, 1980, 4092, 8316, 16764}; | |
90 | ||
91 | mu = 255 - ulaw; | |
92 | e = (mu & 0x70) / 16; | |
93 | f = mu & 0x0f; | |
94 | y = f * (1 << (e + 3)); | |
95 | y += etab[e]; | |
96 | if (mu & 0x80) | |
97 | y = -y; | |
98 | return y; | |
99 | } | |
100 | ||
101 | #define BIAS 0x84 /*!< define the add-in bias for 16 bit samples */ | |
102 | ||
103 | static unsigned char linear2ulaw(short sample) | |
104 | { | |
105 | static int exp_lut[256] = { | |
106 | 0, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, | |
107 | 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, | |
108 | 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, | |
109 | 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, | |
110 | 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, | |
111 | 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, | |
112 | 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, | |
113 | 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, | |
114 | 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, | |
115 | 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, | |
116 | 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, | |
117 | 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, | |
118 | 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, | |
119 | 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, | |
120 | 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, | |
121 | 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7}; | |
122 | int sign, exponent, mantissa; | |
123 | unsigned char ulawbyte; | |
124 | ||
125 | /* Get the sample into sign-magnitude. */ | |
126 | sign = (sample >> 8) & 0x80; /* set aside the sign */ | |
127 | if (sign != 0) | |
128 | sample = -sample; /* get magnitude */ | |
129 | ||
130 | /* Convert from 16 bit linear to ulaw. */ | |
131 | sample = sample + BIAS; | |
132 | exponent = exp_lut[(sample >> 7) & 0xFF]; | |
133 | mantissa = (sample >> (exponent + 3)) & 0x0F; | |
134 | ulawbyte = ~(sign | (exponent << 4) | mantissa); | |
135 | ||
136 | return ulawbyte; | |
137 | } | |
138 | ||
139 | static int reverse_bits(int i) | |
140 | { | |
141 | int z, j; | |
142 | z = 0; | |
143 | ||
144 | for (j = 0; j < 8; j++) { | |
145 | if ((i & (1 << j)) != 0) | |
146 | z |= 1 << (7 - j); | |
147 | } | |
148 | return z; | |
149 | } | |
150 | ||
151 | ||
152 | void dsp_audio_generate_law_tables(void) | |
153 | { | |
154 | int i; | |
155 | for (i = 0; i < 256; i++) | |
156 | dsp_audio_alaw_to_s32[i] = alaw2linear(reverse_bits(i)); | |
157 | ||
158 | for (i = 0; i < 256; i++) | |
159 | dsp_audio_ulaw_to_s32[i] = ulaw2linear(reverse_bits(i)); | |
160 | ||
161 | for (i = 0; i < 256; i++) { | |
162 | dsp_audio_alaw_to_ulaw[i] = | |
163 | linear2ulaw(dsp_audio_alaw_to_s32[i]); | |
164 | dsp_audio_ulaw_to_alaw[i] = | |
165 | linear2alaw(dsp_audio_ulaw_to_s32[i]); | |
166 | } | |
167 | } | |
168 | ||
169 | void | |
170 | dsp_audio_generate_s2law_table(void) | |
171 | { | |
172 | int i; | |
173 | ||
174 | if (dsp_options & DSP_OPT_ULAW) { | |
175 | /* generating ulaw-table */ | |
176 | for (i = -32768; i < 32768; i++) { | |
177 | dsp_audio_s16_to_law[i & 0xffff] = | |
178 | reverse_bits(linear2ulaw(i)); | |
179 | } | |
180 | } else { | |
181 | /* generating alaw-table */ | |
182 | for (i = -32768; i < 32768; i++) { | |
183 | dsp_audio_s16_to_law[i & 0xffff] = | |
184 | reverse_bits(linear2alaw(i)); | |
185 | } | |
186 | } | |
187 | } | |
188 | ||
189 | ||
190 | /* | |
191 | * the seven bit sample is the number of every second alaw-sample ordered by | |
192 | * aplitude. 0x00 is negative, 0x7f is positive amplitude. | |
193 | */ | |
194 | u8 dsp_audio_seven2law[128]; | |
195 | u8 dsp_audio_law2seven[256]; | |
196 | ||
197 | /******************************************************************** | |
198 | * generate table for conversion law from/to 7-bit alaw-like sample * | |
199 | ********************************************************************/ | |
200 | ||
201 | void | |
202 | dsp_audio_generate_seven(void) | |
203 | { | |
204 | int i, j, k; | |
205 | u8 spl; | |
206 | u8 sorted_alaw[256]; | |
207 | ||
208 | /* generate alaw table, sorted by the linear value */ | |
209 | for (i = 0; i < 256; i++) { | |
210 | j = 0; | |
211 | for (k = 0; k < 256; k++) { | |
212 | if (dsp_audio_alaw_to_s32[k] | |
eac74af9 KK |
213 | < dsp_audio_alaw_to_s32[i]) |
214 | j++; | |
960366cf KK |
215 | } |
216 | sorted_alaw[j] = i; | |
217 | } | |
218 | ||
219 | /* generate tabels */ | |
220 | for (i = 0; i < 256; i++) { | |
221 | /* spl is the source: the law-sample (converted to alaw) */ | |
222 | spl = i; | |
223 | if (dsp_options & DSP_OPT_ULAW) | |
224 | spl = dsp_audio_ulaw_to_alaw[i]; | |
225 | /* find the 7-bit-sample */ | |
226 | for (j = 0; j < 256; j++) { | |
227 | if (sorted_alaw[j] == spl) | |
228 | break; | |
229 | } | |
230 | /* write 7-bit audio value */ | |
231 | dsp_audio_law2seven[i] = j >> 1; | |
232 | } | |
233 | for (i = 0; i < 128; i++) { | |
234 | spl = sorted_alaw[i << 1]; | |
235 | if (dsp_options & DSP_OPT_ULAW) | |
236 | spl = dsp_audio_alaw_to_ulaw[spl]; | |
237 | dsp_audio_seven2law[i] = spl; | |
238 | } | |
239 | } | |
240 | ||
241 | ||
242 | /* mix 2*law -> law */ | |
243 | u8 dsp_audio_mix_law[65536]; | |
244 | ||
245 | /****************************************************** | |
246 | * generate mix table to mix two law samples into one * | |
247 | ******************************************************/ | |
248 | ||
249 | void | |
250 | dsp_audio_generate_mix_table(void) | |
251 | { | |
252 | int i, j; | |
253 | s32 sample; | |
254 | ||
255 | i = 0; | |
256 | while (i < 256) { | |
257 | j = 0; | |
258 | while (j < 256) { | |
259 | sample = dsp_audio_law_to_s32[i]; | |
260 | sample += dsp_audio_law_to_s32[j]; | |
261 | if (sample > 32767) | |
262 | sample = 32767; | |
263 | if (sample < -32768) | |
264 | sample = -32768; | |
265 | dsp_audio_mix_law[(i<<8)|j] = | |
266 | dsp_audio_s16_to_law[sample & 0xffff]; | |
267 | j++; | |
268 | } | |
269 | i++; | |
270 | } | |
271 | } | |
272 | ||
273 | ||
274 | /************************************* | |
275 | * generate different volume changes * | |
276 | *************************************/ | |
277 | ||
278 | static u8 dsp_audio_reduce8[256]; | |
279 | static u8 dsp_audio_reduce7[256]; | |
280 | static u8 dsp_audio_reduce6[256]; | |
281 | static u8 dsp_audio_reduce5[256]; | |
282 | static u8 dsp_audio_reduce4[256]; | |
283 | static u8 dsp_audio_reduce3[256]; | |
284 | static u8 dsp_audio_reduce2[256]; | |
285 | static u8 dsp_audio_reduce1[256]; | |
286 | static u8 dsp_audio_increase1[256]; | |
287 | static u8 dsp_audio_increase2[256]; | |
288 | static u8 dsp_audio_increase3[256]; | |
289 | static u8 dsp_audio_increase4[256]; | |
290 | static u8 dsp_audio_increase5[256]; | |
291 | static u8 dsp_audio_increase6[256]; | |
292 | static u8 dsp_audio_increase7[256]; | |
293 | static u8 dsp_audio_increase8[256]; | |
294 | ||
295 | static u8 *dsp_audio_volume_change[16] = { | |
296 | dsp_audio_reduce8, | |
297 | dsp_audio_reduce7, | |
298 | dsp_audio_reduce6, | |
299 | dsp_audio_reduce5, | |
300 | dsp_audio_reduce4, | |
301 | dsp_audio_reduce3, | |
302 | dsp_audio_reduce2, | |
303 | dsp_audio_reduce1, | |
304 | dsp_audio_increase1, | |
305 | dsp_audio_increase2, | |
306 | dsp_audio_increase3, | |
307 | dsp_audio_increase4, | |
308 | dsp_audio_increase5, | |
309 | dsp_audio_increase6, | |
310 | dsp_audio_increase7, | |
311 | dsp_audio_increase8, | |
312 | }; | |
313 | ||
314 | void | |
315 | dsp_audio_generate_volume_changes(void) | |
316 | { | |
317 | register s32 sample; | |
318 | int i; | |
319 | int num[] = { 110, 125, 150, 175, 200, 300, 400, 500 }; | |
320 | int denum[] = { 100, 100, 100, 100, 100, 100, 100, 100 }; | |
321 | ||
322 | i = 0; | |
323 | while (i < 256) { | |
324 | dsp_audio_reduce8[i] = dsp_audio_s16_to_law[ | |
325 | (dsp_audio_law_to_s32[i] * denum[7] / num[7]) & 0xffff]; | |
326 | dsp_audio_reduce7[i] = dsp_audio_s16_to_law[ | |
327 | (dsp_audio_law_to_s32[i] * denum[6] / num[6]) & 0xffff]; | |
328 | dsp_audio_reduce6[i] = dsp_audio_s16_to_law[ | |
329 | (dsp_audio_law_to_s32[i] * denum[5] / num[5]) & 0xffff]; | |
330 | dsp_audio_reduce5[i] = dsp_audio_s16_to_law[ | |
331 | (dsp_audio_law_to_s32[i] * denum[4] / num[4]) & 0xffff]; | |
332 | dsp_audio_reduce4[i] = dsp_audio_s16_to_law[ | |
333 | (dsp_audio_law_to_s32[i] * denum[3] / num[3]) & 0xffff]; | |
334 | dsp_audio_reduce3[i] = dsp_audio_s16_to_law[ | |
335 | (dsp_audio_law_to_s32[i] * denum[2] / num[2]) & 0xffff]; | |
336 | dsp_audio_reduce2[i] = dsp_audio_s16_to_law[ | |
337 | (dsp_audio_law_to_s32[i] * denum[1] / num[1]) & 0xffff]; | |
338 | dsp_audio_reduce1[i] = dsp_audio_s16_to_law[ | |
339 | (dsp_audio_law_to_s32[i] * denum[0] / num[0]) & 0xffff]; | |
340 | sample = dsp_audio_law_to_s32[i] * num[0] / denum[0]; | |
341 | if (sample < -32768) | |
342 | sample = -32768; | |
343 | else if (sample > 32767) | |
344 | sample = 32767; | |
345 | dsp_audio_increase1[i] = dsp_audio_s16_to_law[sample & 0xffff]; | |
346 | sample = dsp_audio_law_to_s32[i] * num[1] / denum[1]; | |
347 | if (sample < -32768) | |
348 | sample = -32768; | |
349 | else if (sample > 32767) | |
350 | sample = 32767; | |
351 | dsp_audio_increase2[i] = dsp_audio_s16_to_law[sample & 0xffff]; | |
352 | sample = dsp_audio_law_to_s32[i] * num[2] / denum[2]; | |
353 | if (sample < -32768) | |
354 | sample = -32768; | |
355 | else if (sample > 32767) | |
356 | sample = 32767; | |
357 | dsp_audio_increase3[i] = dsp_audio_s16_to_law[sample & 0xffff]; | |
358 | sample = dsp_audio_law_to_s32[i] * num[3] / denum[3]; | |
359 | if (sample < -32768) | |
360 | sample = -32768; | |
361 | else if (sample > 32767) | |
362 | sample = 32767; | |
363 | dsp_audio_increase4[i] = dsp_audio_s16_to_law[sample & 0xffff]; | |
364 | sample = dsp_audio_law_to_s32[i] * num[4] / denum[4]; | |
365 | if (sample < -32768) | |
366 | sample = -32768; | |
367 | else if (sample > 32767) | |
368 | sample = 32767; | |
369 | dsp_audio_increase5[i] = dsp_audio_s16_to_law[sample & 0xffff]; | |
370 | sample = dsp_audio_law_to_s32[i] * num[5] / denum[5]; | |
371 | if (sample < -32768) | |
372 | sample = -32768; | |
373 | else if (sample > 32767) | |
374 | sample = 32767; | |
375 | dsp_audio_increase6[i] = dsp_audio_s16_to_law[sample & 0xffff]; | |
376 | sample = dsp_audio_law_to_s32[i] * num[6] / denum[6]; | |
377 | if (sample < -32768) | |
378 | sample = -32768; | |
379 | else if (sample > 32767) | |
380 | sample = 32767; | |
381 | dsp_audio_increase7[i] = dsp_audio_s16_to_law[sample & 0xffff]; | |
382 | sample = dsp_audio_law_to_s32[i] * num[7] / denum[7]; | |
383 | if (sample < -32768) | |
384 | sample = -32768; | |
385 | else if (sample > 32767) | |
386 | sample = 32767; | |
387 | dsp_audio_increase8[i] = dsp_audio_s16_to_law[sample & 0xffff]; | |
388 | ||
389 | i++; | |
390 | } | |
391 | } | |
392 | ||
393 | ||
394 | /************************************** | |
395 | * change the volume of the given skb * | |
396 | **************************************/ | |
397 | ||
398 | /* this is a helper function for changing volume of skb. the range may be | |
399 | * -8 to 8, which is a shift to the power of 2. 0 == no volume, 3 == volume*8 | |
400 | */ | |
401 | void | |
402 | dsp_change_volume(struct sk_buff *skb, int volume) | |
403 | { | |
404 | u8 *volume_change; | |
405 | int i, ii; | |
406 | u8 *p; | |
407 | int shift; | |
408 | ||
409 | if (volume == 0) | |
410 | return; | |
411 | ||
412 | /* get correct conversion table */ | |
413 | if (volume < 0) { | |
414 | shift = volume + 8; | |
415 | if (shift < 0) | |
416 | shift = 0; | |
417 | } else { | |
418 | shift = volume + 7; | |
419 | if (shift > 15) | |
420 | shift = 15; | |
421 | } | |
422 | volume_change = dsp_audio_volume_change[shift]; | |
423 | i = 0; | |
424 | ii = skb->len; | |
425 | p = skb->data; | |
426 | /* change volume */ | |
427 | while (i < ii) { | |
428 | *p = volume_change[*p]; | |
429 | p++; | |
430 | i++; | |
431 | } | |
432 | } | |
433 |