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