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 */
22static 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 */
29static 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 */
40void 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 */
50void 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
117u8
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	 */
135again:
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	 */
209coefficients:
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
283storedigit:
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}
314