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 } 314