1 /*
2 * DTMF decoder.
3 *
4 * Copyright by Andreas Eversberg (jolly@eversberg.eu)
5 * based on different decoders such as ISDN4Linux
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/mISDNif.h>
13 #include <linux/mISDNdsp.h>
14 #include "core.h"
15 #include "dsp.h"
16
17 #define NCOEFF 8 /* number of frequencies to be analyzed */
18
19 /* For DTMF recognition:
20 * 2 * cos(2 * PI * k / N) precalculated for all k
21 */
22 static u64 cos2pik[NCOEFF] =
23 {
24 /* k << 15 (source: hfc-4s/8s documentation (www.colognechip.de)) */
25 55960, 53912, 51402, 48438, 38146, 32650, 26170, 18630
26 };
27
28 /* digit matrix */
29 static char dtmf_matrix[4][4] =
30 {
31 {'1', '2', '3', 'A'},
32 {'4', '5', '6', 'B'},
33 {'7', '8', '9', 'C'},
34 {'*', '0', '#', 'D'}
35 };
36
37 /* dtmf detection using goertzel algorithm
38 * init function
39 */
40 void dsp_dtmf_goertzel_init(struct dsp *dsp)
41 {
42 dsp->dtmf.size = 0;
43 dsp->dtmf.lastwhat = '\0';
44 dsp->dtmf.lastdigit = '\0';
45 dsp->dtmf.count = 0;
46 }
47
48 /* check for hardware or software features
49 */
50 void dsp_dtmf_hardware(struct dsp *dsp)
51 {
52 int hardware = 1;
53
54 if (!dsp->dtmf.enable)
55 return;
56
57 if (!dsp->features.hfc_dtmf)
58 hardware = 0;
59
60 /* check for volume change */
61 if (dsp->tx_volume) {
62 if (dsp_debug & DEBUG_DSP_DTMF)
63 printk(KERN_DEBUG "%s dsp %s cannot do hardware DTMF, "
64 "because tx_volume is changed\n",
65 __func__, dsp->name);
66 hardware = 0;
67 }
68 if (dsp->rx_volume) {
69 if (dsp_debug & DEBUG_DSP_DTMF)
70 printk(KERN_DEBUG "%s dsp %s cannot do hardware DTMF, "
71 "because rx_volume is changed\n",
72 __func__, dsp->name);
73 hardware = 0;
74 }
75 /* check if encryption is enabled */
76 if (dsp->bf_enable) {
77 if (dsp_debug & DEBUG_DSP_DTMF)
78 printk(KERN_DEBUG "%s dsp %s cannot do hardware DTMF, "
79 "because encryption is enabled\n",
80 __func__, dsp->name);
81 hardware = 0;
82 }
83 /* check if pipeline exists */
84 if (dsp->pipeline.inuse) {
85 if (dsp_debug & DEBUG_DSP_DTMF)
86 printk(KERN_DEBUG "%s dsp %s cannot do hardware DTMF, "
87 "because pipeline exists.\n",
88 __func__, dsp->name);
89 hardware = 0;
90 }
91
92 dsp->dtmf.hardware = hardware;
93 dsp->dtmf.software = !hardware;
94 }
95
96
97 /*************************************************************
98 * calculate the coefficients of the given sample and decode *
99 *************************************************************/
100
101 /* the given sample is decoded. if the sample is not long enough for a
102 * complete frame, the decoding is finished and continued with the next
103 * call of this function.
104 *
105 * the algorithm is very good for detection with a minimum of errors. i
106 * tested it allot. it even works with very short tones (40ms). the only
107 * disadvantage is, that it doesn't work good with different volumes of both
108 * tones. this will happen, if accoustically coupled dialers are used.
109 * it sometimes detects tones during speech, which is normal for decoders.
110 * use sequences to given commands during calls.
111 *
112 * dtmf - points to a structure of the current dtmf state
113 * spl and len - the sample
114 * fmt - 0 = alaw, 1 = ulaw, 2 = coefficients from HFC DTMF hw-decoder
115 */
116
117 u8
118 *dsp_dtmf_goertzel_decode(struct dsp *dsp, u8 *data, int len, int fmt)
119 {
120 u8 what;
121 int size;
122 signed short *buf;
123 s32 sk, sk1, sk2;
124 int k, n, i;
125 s32 *hfccoeff;
126 s32 result[NCOEFF], tresh, treshl;
127 int lowgroup, highgroup;
128 s64 cos2pik_;
129
130 dsp->dtmf.digits[0] = '\0';
131
132 /* Note: The function will loop until the buffer has not enough samples
133 * left to decode a full frame.
134 */
135 again:
136 /* convert samples */
137 size = dsp->dtmf.size;
138 buf = dsp->dtmf.buffer;
139 switch (fmt) {
140 case 0: /* alaw */
141 case 1: /* ulaw */
142 while (size < DSP_DTMF_NPOINTS && len) {
143 buf[size++] = dsp_audio_law_to_s32[*data++];
144 len--;
145 }
146 break;
147
148 case 2: /* HFC coefficients */
149 default:
150 if (len < 64) {
151 if (len > 0)
152 printk(KERN_ERR "%s: coefficients have invalid "
153 "size. (is=%d < must=%d)\n",
154 __func__, len, 64);
155 return dsp->dtmf.digits;
156 }
157 hfccoeff = (s32 *)data;
158 for (k = 0; k < NCOEFF; k++) {
159 sk2 = (*hfccoeff++) >> 4;
160 sk = (*hfccoeff++) >> 4;
161 if (sk > 32767 || sk < -32767 || sk2 > 32767
162 || sk2 < -32767)
163 printk(KERN_WARNING
164 "DTMF-Detection overflow\n");
165 /* compute |X(k)|**2 */
166 result[k] =
167 (sk * sk) -
168 (((cos2pik[k] * sk) >> 15) * sk2) +
169 (sk2 * sk2);
170 }
171 data += 64;
172 len -= 64;
173 goto coefficients;
174 break;
175 }
176 dsp->dtmf.size = size;
177
178 if (size < DSP_DTMF_NPOINTS)
179 return dsp->dtmf.digits;
180
181 dsp->dtmf.size = 0;
182
183 /* now we have a full buffer of signed long samples - we do goertzel */
184 for (k = 0; k < NCOEFF; k++) {
185 sk = 0;
186 sk1 = 0;
187 sk2 = 0;
188 buf = dsp->dtmf.buffer;
189 cos2pik_ = cos2pik[k];
190 for (n = 0; n < DSP_DTMF_NPOINTS; n++) {
191 sk = ((cos2pik_ * sk1) >> 15) - sk2 + (*buf++);
192 sk2 = sk1;
193 sk1 = sk;
194 }
195 sk >>= 8;
196 sk2 >>= 8;
197 if (sk > 32767 || sk < -32767 || sk2 > 32767 || sk2 < -32767)
198 printk(KERN_WARNING "DTMF-Detection overflow\n");
199 /* compute |X(k)|**2 */
200 result[k] =
201 (sk * sk) -
202 (((cos2pik[k] * sk) >> 15) * sk2) +
203 (sk2 * sk2);
204 }
205
206 /* our (squared) coefficients have been calculated, we need to process
207 * them.
208 */
209 coefficients:
210 tresh = 0;
211 for (i = 0; i < NCOEFF; i++) {
212 if (result[i] < 0)
213 result[i] = 0;
214 if (result[i] > dsp->dtmf.treshold) {
215 if (result[i] > tresh)
216 tresh = result[i];
217 }
218 }
219
220 if (tresh == 0) {
221 what = 0;
222 goto storedigit;
223 }
224
225 if (dsp_debug & DEBUG_DSP_DTMFCOEFF) {
226 s32 tresh_100 = tresh/100;
227
228 if (tresh_100 == 0) {
229 tresh_100 = 1;
230 printk(KERN_DEBUG
231 "tresh(%d) too small set tresh/100 to 1\n",
232 tresh);
233 }
234 printk(KERN_DEBUG "a %3d %3d %3d %3d %3d %3d %3d %3d"
235 " tr:%3d r %3d %3d %3d %3d %3d %3d %3d %3d\n",
236 result[0] / 10000, result[1] / 10000, result[2] / 10000,
237 result[3] / 10000, result[4] / 10000, result[5] / 10000,
238 result[6] / 10000, result[7] / 10000, tresh / 10000,
239 result[0] / (tresh_100), result[1] / (tresh_100),
240 result[2] / (tresh_100), result[3] / (tresh_100),
241 result[4] / (tresh_100), result[5] / (tresh_100),
242 result[6] / (tresh_100), result[7] / (tresh_100));
243 }
244
245 /* calc digit (lowgroup/highgroup) */
246 lowgroup = -1;
247 highgroup = -1;
248 treshl = tresh >> 3; /* tones which are not on, must be below 9 dB */
249 tresh = tresh >> 2; /* touchtones must match within 6 dB */
250 for (i = 0; i < NCOEFF; i++) {
251 if (result[i] < treshl)
252 continue; /* ignore */
253 if (result[i] < tresh) {
254 lowgroup = -1;
255 highgroup = -1;
256 break; /* noise in between */
257 }
258 /* good level found. This is allowed only one time per group */
259 if (i < NCOEFF / 2) {
260 /* lowgroup */
261 if (lowgroup >= 0) {
262 /* Bad. Another tone found. */
263 lowgroup = -1;
264 break;
265 } else
266 lowgroup = i;
267 } else {
268 /* higroup */
269 if (highgroup >= 0) {
270 /* Bad. Another tone found. */
271 highgroup = -1;
272 break;
273 } else
274 highgroup = i - (NCOEFF / 2);
275 }
276 }
277
278 /* get digit or null */
279 what = 0;
280 if (lowgroup >= 0 && highgroup >= 0)
281 what = dtmf_matrix[lowgroup][highgroup];
282
283 storedigit:
284 if (what && (dsp_debug & DEBUG_DSP_DTMF))
285 printk(KERN_DEBUG "DTMF what: %c\n", what);
286
287 if (dsp->dtmf.lastwhat != what)
288 dsp->dtmf.count = 0;
289
290 /* the tone (or no tone) must remain 3 times without change */
291 if (dsp->dtmf.count == 2) {
292 if (dsp->dtmf.lastdigit != what) {
293 dsp->dtmf.lastdigit = what;
294 if (what) {
295 if (dsp_debug & DEBUG_DSP_DTMF)
296 printk(KERN_DEBUG "DTMF digit: %c\n",
297 what);
298 if ((strlen(dsp->dtmf.digits) + 1)
299 < sizeof(dsp->dtmf.digits)) {
300 dsp->dtmf.digits[strlen(
301 dsp->dtmf.digits) + 1] = '\0';
302 dsp->dtmf.digits[strlen(
303 dsp->dtmf.digits)] = what;
304 }
305 }
306 }
307 } else
308 dsp->dtmf.count++;
309
310 dsp->dtmf.lastwhat = what;
311
312 goto again;
313 }