Keep track of digit duration, when we're decoding inband to pass DTMF frames.
[asterisk/asterisk.git] / main / dsp.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 1999 - 2005, Digium, Inc.
5  *
6  * Mark Spencer <markster@digium.com>
7  *
8  * Goertzel routines are borrowed from Steve Underwood's tremendous work on the
9  * DTMF detector.
10  *
11  * See http://www.asterisk.org for more information about
12  * the Asterisk project. Please do not directly contact
13  * any of the maintainers of this project for assistance;
14  * the project provides a web site, mailing lists and IRC
15  * channels for your use.
16  *
17  * This program is free software, distributed under the terms of
18  * the GNU General Public License Version 2. See the LICENSE file
19  * at the top of the source tree.
20  */
21
22 /*! \file
23  *
24  * \brief Convenience Signal Processing routines
25  *
26  * \author Mark Spencer <markster@digium.com>
27  * \author Steve Underwood <steveu@coppice.org>
28  */
29
30 /* Some routines from tone_detect.c by Steven Underwood as published under the zapata library */
31 /*
32         tone_detect.c - General telephony tone detection, and specific
33                                         detection of DTMF.
34
35         Copyright (C) 2001  Steve Underwood <steveu@coppice.org>
36
37         Despite my general liking of the GPL, I place this code in the
38         public domain for the benefit of all mankind - even the slimy
39         ones who might try to proprietize my work and use it to my
40         detriment.
41 */
42
43 #include "asterisk.h"
44
45 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
46
47 #include <math.h>
48
49 #include "asterisk/frame.h"
50 #include "asterisk/channel.h"
51 #include "asterisk/dsp.h"
52 #include "asterisk/ulaw.h"
53 #include "asterisk/alaw.h"
54 #include "asterisk/utils.h"
55 #include "asterisk/options.h"
56 #include "asterisk/config.h"
57
58 /*! Number of goertzels for progress detect */
59 enum gsamp_size {
60         GSAMP_SIZE_NA = 183,                    /*!< North America - 350, 440, 480, 620, 950, 1400, 1800 Hz */
61         GSAMP_SIZE_CR = 188,                    /*!< Costa Rica, Brazil - Only care about 425 Hz */
62         GSAMP_SIZE_UK = 160                     /*!< UK disconnect goertzel feed - should trigger 400hz */
63 };
64
65 enum prog_mode {
66         PROG_MODE_NA = 0,
67         PROG_MODE_CR,
68         PROG_MODE_UK
69 };
70
71 enum freq_index { 
72         /*! For US modes { */
73         HZ_350 = 0,
74         HZ_440,
75         HZ_480,
76         HZ_620,
77         HZ_950,
78         HZ_1400,
79         HZ_1800, /*!< } */
80
81         /*! For CR/BR modes */
82         HZ_425 = 0,
83
84         /*! For UK mode */
85         HZ_350UK = 0,
86         HZ_400UK,
87         HZ_440UK
88 };
89
90 static struct progalias {
91         char *name;
92         enum prog_mode mode;
93 } aliases[] = {
94         { "us", PROG_MODE_NA },
95         { "ca", PROG_MODE_NA },
96         { "cr", PROG_MODE_CR },
97         { "br", PROG_MODE_CR },
98         { "uk", PROG_MODE_UK },
99 };
100
101 static struct progress {
102         enum gsamp_size size;
103         int freqs[7];
104 } modes[] = {
105         { GSAMP_SIZE_NA, { 350, 440, 480, 620, 950, 1400, 1800 } },     /*!< North America */
106         { GSAMP_SIZE_CR, { 425 } },                                     /*!< Costa Rica, Brazil */
107         { GSAMP_SIZE_UK, { 350, 400, 440 } },                                   /*!< UK */
108 };
109
110 /*!\brief This value is the minimum threshold, calculated by averaging all
111  * of the samples within a frame, for which a frame is determined to either
112  * be silence (below the threshold) or noise (above the threshold).  Please
113  * note that while the default threshold is an even exponent of 2, there is
114  * no requirement that it be so.  The threshold will accept any value between
115  * 0 and 32767.
116  */
117 #define DEFAULT_THRESHOLD       512
118
119 enum busy_detect {
120         BUSY_PERCENT = 10,      /*!< The percentage difference between the two last silence periods */
121         BUSY_PAT_PERCENT = 7,   /*!< The percentage difference between measured and actual pattern */
122         BUSY_THRESHOLD = 100,   /*!< Max number of ms difference between max and min times in busy */
123         BUSY_MIN = 75,          /*!< Busy must be at least 80 ms in half-cadence */
124         BUSY_MAX =3100          /*!< Busy can't be longer than 3100 ms in half-cadence */
125 };
126
127 /*! Remember last 15 units */
128 #define DSP_HISTORY             15
129
130 #define TONE_THRESH             10.0    /*!< How much louder the tone should be than channel energy */
131 #define TONE_MIN_THRESH         1e8     /*!< How much tone there should be at least to attempt */
132
133 /*! All THRESH_XXX values are in GSAMP_SIZE chunks (us = 22ms) */
134 enum gsamp_thresh {
135         THRESH_RING = 8,                /*!< Need at least 150ms ring to accept */
136         THRESH_TALK = 2,                /*!< Talk detection does not work continuously */
137         THRESH_BUSY = 4,                /*!< Need at least 80ms to accept */
138         THRESH_CONGESTION = 4,          /*!< Need at least 80ms to accept */
139         THRESH_HANGUP = 60,             /*!< Need at least 1300ms to accept hangup */
140         THRESH_RING2ANSWER = 300        /*!< Timeout from start of ring to answer (about 6600 ms) */
141 };
142
143 #define MAX_DTMF_DIGITS         128
144
145 /* Basic DTMF specs:
146  *
147  * Minimum tone on = 40ms
148  * Minimum tone off = 50ms
149  * Maximum digit rate = 10 per second
150  * Normal twist <= 8dB accepted
151  * Reverse twist <= 4dB accepted
152  * S/N >= 15dB will detect OK
153  * Attenuation <= 26dB will detect OK
154  * Frequency tolerance +- 1.5% will detect, +-3.5% will reject
155  */
156
157 #define DTMF_THRESHOLD          8.0e7
158 #define FAX_THRESHOLD           8.0e7
159 #define FAX_2ND_HARMONIC        2.0     /* 4dB */
160 #define DTMF_NORMAL_TWIST       6.3     /* 8dB */
161 #ifdef  RADIO_RELAX
162 #define DTMF_REVERSE_TWIST          (relax ? 6.5 : 2.5)     /* 4dB normal */
163 #else
164 #define DTMF_REVERSE_TWIST          (relax ? 4.0 : 2.5)     /* 4dB normal */
165 #endif
166 #define DTMF_RELATIVE_PEAK_ROW  6.3     /* 8dB */
167 #define DTMF_RELATIVE_PEAK_COL  6.3     /* 8dB */
168 #define DTMF_2ND_HARMONIC_ROW       (relax ? 1.7 : 2.5)     /* 4dB normal */
169 #define DTMF_2ND_HARMONIC_COL   63.1    /* 18dB */
170 #define DTMF_TO_TOTAL_ENERGY    42.0
171
172 #define BELL_MF_THRESHOLD       1.6e9
173 #define BELL_MF_TWIST           4.0     /* 6dB */
174 #define BELL_MF_RELATIVE_PEAK   12.6    /* 11dB */
175
176 #if defined(BUSYDETECT_TONEONLY) && defined(BUSYDETECT_COMPARE_TONE_AND_SILENCE)
177 #error You cant use BUSYDETECT_TONEONLY together with BUSYDETECT_COMPARE_TONE_AND_SILENCE
178 #endif
179
180 /* The CNG signal consists of the transmission of 1100 Hz for 1/2 second,
181  * followed by a 3 second silent (2100 Hz OFF) period.
182  */
183 #define FAX_TONE_CNG_FREQ       1100
184 #define FAX_TONE_CNG_DURATION   500
185 #define FAX_TONE_CNG_DB         16
186
187 /* This signal may be sent by the Terminating FAX machine anywhere between
188  * 1.8 to 2.5 seconds AFTER answering the call.  The CED signal consists
189  * of a 2100 Hz tone that is from 2.6 to 4 seconds in duration.
190 */
191 #define FAX_TONE_CED_FREQ       2100
192 #define FAX_TONE_CED_DURATION   2600
193 #define FAX_TONE_CED_DB         16
194
195 #define SAMPLE_RATE             8000
196
197 /* How many samples a frame has.  This constant is used when calculating
198  * Goertzel block size for tone_detect.  It is only important if we want to
199  * remove (squelch) the tone. In this case it is important to have block
200  * size not to exceed size of voice frame.  Otherwise by the moment the tone
201  * is detected it is too late to squelch it from previous frames.
202  */
203 #define SAMPLES_IN_FRAME        160
204
205 /* MF goertzel size */
206 #define MF_GSIZE                120
207
208 /* DTMF goertzel size */
209 #define DTMF_GSIZE              102
210
211 /* How many successive hits needed to consider begin of a digit */
212 #define DTMF_HITS_TO_BEGIN      2
213 /* How many successive misses needed to consider end of a digit */
214 #define DTMF_MISSES_TO_END      3
215
216 #define CONFIG_FILE_NAME "dsp.conf"
217
218 typedef struct {
219         int v2;
220         int v3;
221         int chunky;
222         int fac;
223         int samples;
224 } goertzel_state_t;
225
226 typedef struct {
227         int value;
228         int power;
229 } goertzel_result_t;
230
231 typedef struct
232 {
233         int freq;
234         int block_size;
235         int squelch;            /* Remove (squelch) tone */
236         goertzel_state_t tone;
237         float energy;           /* Accumulated energy of the current block */
238         int samples_pending;    /* Samples remain to complete the current block */
239         int mute_samples;       /* How many additional samples needs to be muted to suppress already detected tone */
240
241         int hits_required;      /* How many successive blocks with tone we are looking for */
242         float threshold;        /* Energy of the tone relative to energy from all other signals to consider a hit */
243
244         int hit_count;          /* How many successive blocks we consider tone present */
245         int last_hit;           /* Indicates if the last processed block was a hit */
246
247 } tone_detect_state_t;
248
249 typedef struct
250 {
251         goertzel_state_t row_out[4];
252         goertzel_state_t col_out[4];
253         int hits_to_begin;              /* How many successive hits needed to consider begin of a digit */
254         int misses_to_end;              /* How many successive misses needed to consider end of a digit */
255         int hits;                       /* How many successive hits we have seen already */
256         int misses;                     /* How many successive misses we have seen already */
257         int lasthit;
258         int current_hit;
259         float energy;
260         int current_sample;
261         int mute_samples;
262 } dtmf_detect_state_t;
263
264 typedef struct
265 {
266         goertzel_state_t tone_out[6];
267         int current_hit;
268         int hits[5];
269         int current_sample;
270         int mute_samples;
271 } mf_detect_state_t;
272
273 typedef struct
274 {
275         char digits[MAX_DTMF_DIGITS + 1];
276         int current_digits;
277         /* Store lengths separately, because next digit may begin before last has
278          * ended (because hits_to_begin may be less than misses_to_end). */
279         int digitlen[MAX_DTMF_DIGITS + 1];
280         int current_len;
281         int detected_digits;
282         int lost_digits;
283
284         union {
285                 dtmf_detect_state_t dtmf;
286                 mf_detect_state_t mf;
287         } td;
288 } digit_detect_state_t;
289
290 static const float dtmf_row[] = {
291         697.0,  770.0,  852.0,  941.0
292 };
293 static const float dtmf_col[] = {
294         1209.0, 1336.0, 1477.0, 1633.0
295 };
296 static const float mf_tones[] = {
297         700.0, 900.0, 1100.0, 1300.0, 1500.0, 1700.0
298 };
299 static const char dtmf_positions[] = "123A" "456B" "789C" "*0#D";
300 static const char bell_mf_positions[] = "1247C-358A--69*---0B----#";
301 static int thresholds[THRESHOLD_MAX];
302
303 static inline void goertzel_sample(goertzel_state_t *s, short sample)
304 {
305         int v1;
306         
307         v1 = s->v2;
308         s->v2 = s->v3;
309         
310         s->v3 = (s->fac * s->v2) >> 15;
311         s->v3 = s->v3 - v1 + (sample >> s->chunky);
312         if (abs(s->v3) > 32768) {
313                 s->chunky++;
314                 s->v3 = s->v3 >> 1;
315                 s->v2 = s->v2 >> 1;
316                 v1 = v1 >> 1;
317         }
318 }
319
320 static inline void goertzel_update(goertzel_state_t *s, short *samps, int count)
321 {
322         int i;
323         
324         for (i = 0; i < count; i++) {
325                 goertzel_sample(s, samps[i]);
326         }
327 }
328
329
330 static inline float goertzel_result(goertzel_state_t *s)
331 {
332         goertzel_result_t r;
333         r.value = (s->v3 * s->v3) + (s->v2 * s->v2);
334         r.value -= ((s->v2 * s->v3) >> 15) * s->fac;
335         r.power = s->chunky * 2;
336         return (float)r.value * (float)(1 << r.power);
337 }
338
339 static inline void goertzel_init(goertzel_state_t *s, float freq, int samples)
340 {
341         s->v2 = s->v3 = s->chunky = 0.0;
342         s->fac = (int)(32768.0 * 2.0 * cos(2.0 * M_PI * freq / SAMPLE_RATE));
343         s->samples = samples;
344 }
345
346 static inline void goertzel_reset(goertzel_state_t *s)
347 {
348         s->v2 = s->v3 = s->chunky = 0.0;
349 }
350
351 typedef struct {
352         int start;
353         int end;
354 } fragment_t;
355
356 /* Note on tone suppression (squelching). Individual detectors (DTMF/MF/generic tone)
357  * report fragmens of the frame in which detected tone resides and which needs
358  * to be "muted" in order to suppress the tone. To mark fragment for muting,
359  * detectors call mute_fragment passing fragment_t there. Multiple fragments
360  * can be marked and ast_dsp_process later will mute all of them.
361  *
362  * Note: When tone starts in the middle of a Goertzel block, it won't be properly
363  * detected in that block, only in the next. If we only mute the next block
364  * where tone is actually detected, the user will still hear beginning
365  * of the tone in preceeding block. This is why we usually want to mute some amount
366  * of samples preceeding and following the block where tone was detected.
367 */
368
369 struct ast_dsp {
370         struct ast_frame f;
371         int threshold;
372         int totalsilence;
373         int totalnoise;
374         int features;
375         int ringtimeout;
376         int busymaybe;
377         int busycount;
378         int busy_tonelength;
379         int busy_quietlength;
380         int historicnoise[DSP_HISTORY];
381         int historicsilence[DSP_HISTORY];
382         goertzel_state_t freqs[7];
383         int freqcount;
384         int gsamps;
385         enum gsamp_size gsamp_size;
386         enum prog_mode progmode;
387         int tstate;
388         int tcount;
389         int digitmode;
390         int faxmode;
391         int dtmf_began;
392         int display_inband_dtmf_warning;
393         float genergy;
394         int mute_fragments;
395         fragment_t mute_data[5];
396         digit_detect_state_t digit_state;
397         tone_detect_state_t cng_tone_state;
398         tone_detect_state_t ced_tone_state;
399 };
400
401 static void mute_fragment(struct ast_dsp *dsp, fragment_t *fragment)
402 {
403         if (dsp->mute_fragments >= ARRAY_LEN(dsp->mute_data)) {
404                 ast_log(LOG_ERROR, "Too many fragments to mute. Ignoring\n");
405                 return;
406         }
407
408         dsp->mute_data[dsp->mute_fragments++] = *fragment;
409 }
410
411 static void ast_tone_detect_init(tone_detect_state_t *s, int freq, int duration, int amp)
412 {
413         int duration_samples;
414         float x;
415         int periods_in_block;
416
417         s->freq = freq;
418
419         /* Desired tone duration in samples */
420         duration_samples = duration * SAMPLE_RATE / 1000;
421         /* We want to allow 10% deviation of tone duration */
422         duration_samples = duration_samples * 9 / 10;
423
424         /* If we want to remove tone, it is important to have block size not
425            to exceed frame size. Otherwise by the moment tone is detected it is too late
426            to squelch it from previous frames */
427         s->block_size = SAMPLES_IN_FRAME;
428
429         periods_in_block = s->block_size * freq / SAMPLE_RATE;
430
431         /* Make sure we will have at least 5 periods at target frequency for analisys.
432            This may make block larger than expected packet and will make squelching impossible
433            but at least we will be detecting the tone */
434         if (periods_in_block < 5)
435                 periods_in_block = 5;
436
437         /* Now calculate final block size. It will contain integer number of periods */
438         s->block_size = periods_in_block * SAMPLE_RATE / freq;
439
440         /* tone_detect is currently only used to detect fax tones and we
441            do not need suqlching the fax tones */
442         s->squelch = 0;
443
444         /* Account for the first and the last block to be incomplete
445            and thus no tone will be detected in them */
446         s->hits_required = (duration_samples - (s->block_size - 1)) / s->block_size;
447
448         goertzel_init(&s->tone, freq, s->block_size);
449
450         s->samples_pending = s->block_size;
451         s->hit_count = 0;
452         s->last_hit = 0;
453         s->energy = 0.0;
454
455         /* We want tone energy to be amp decibels above the rest of the signal (the noise).
456            According to Parseval's theorem the energy computed in time domain equals to energy
457            computed in frequency domain. So subtracting energy in the frequency domain (Goertzel result)
458            from the energy in the time domain we will get energy of the remaining signal (without the tone
459            we are detecting). We will be checking that
460                 10*log(Ew / (Et - Ew)) > amp
461            Calculate threshold so that we will be actually checking
462                 Ew > Et * threshold
463         */
464
465         x = pow(10.0, amp / 10.0);
466         s->threshold = x / (x + 1);
467
468         ast_debug(1, "Setup tone %d Hz, %d ms, block_size=%d, hits_required=%d\n", freq, duration, s->block_size, s->hits_required);
469 }
470
471 static void ast_fax_detect_init(struct ast_dsp *s)
472 {
473         ast_tone_detect_init(&s->cng_tone_state, FAX_TONE_CNG_FREQ, FAX_TONE_CNG_DURATION, FAX_TONE_CNG_DB);
474         ast_tone_detect_init(&s->ced_tone_state, FAX_TONE_CED_FREQ, FAX_TONE_CED_DURATION, FAX_TONE_CED_DB);
475 }
476
477 static void ast_dtmf_detect_init (dtmf_detect_state_t *s)
478 {
479         int i;
480
481         s->lasthit = 0;
482         s->current_hit = 0;
483         for (i = 0;  i < 4;  i++) {
484                 goertzel_init(&s->row_out[i], dtmf_row[i], DTMF_GSIZE);
485                 goertzel_init(&s->col_out[i], dtmf_col[i], DTMF_GSIZE);
486                 s->energy = 0.0;
487         }
488         s->current_sample = 0;
489         s->hits = 0;
490         s->misses = 0;
491
492         s->hits_to_begin = DTMF_HITS_TO_BEGIN;
493         s->misses_to_end = DTMF_MISSES_TO_END;
494 }
495
496 static void ast_mf_detect_init (mf_detect_state_t *s)
497 {
498         int i;
499         s->hits[0] = s->hits[1] = s->hits[2] = s->hits[3] = s->hits[4] = 0;
500         for (i = 0;  i < 6;  i++) {
501                 goertzel_init (&s->tone_out[i], mf_tones[i], 160);
502         }
503         s->current_sample = 0;
504         s->current_hit = 0;
505 }
506
507 static void ast_digit_detect_init(digit_detect_state_t *s, int mf)
508 {
509         s->current_digits = 0;
510         s->current_len = 0;
511         s->detected_digits = 0;
512         s->lost_digits = 0;
513         s->digits[0] = '\0';
514
515         if (mf) {
516                 ast_mf_detect_init(&s->td.mf);
517         } else {
518                 ast_dtmf_detect_init(&s->td.dtmf);
519         }
520 }
521
522 static int tone_detect(struct ast_dsp *dsp, tone_detect_state_t *s, int16_t *amp, int samples)
523 {
524         float tone_energy;
525         int i;
526         int hit = 0;
527         int limit;
528         int res = 0;
529         int16_t *ptr;
530         int start, end;
531         fragment_t mute = {0, 0};
532
533         if (s->squelch && s->mute_samples > 0) {
534                 mute.end = (s->mute_samples < samples) ? s->mute_samples : samples;
535                 s->mute_samples -= mute.end;
536         }
537
538         for (start = 0;  start < samples;  start = end) {
539                 /* Process in blocks. */
540                 limit = samples - start;
541                 if (limit > s->samples_pending) {
542                         limit = s->samples_pending;
543                 }
544                 end = start + limit;
545
546                 for (i = limit, ptr = amp ; i > 0; i--, ptr++) {
547                         /* signed 32 bit int should be enough to suqare any possible signed 16 bit value */
548                         s->energy += (int32_t) *ptr * (int32_t) *ptr;
549
550                         goertzel_sample(&s->tone, *ptr);
551                 }
552
553                 s->samples_pending -= limit;
554
555                 if (s->samples_pending) {
556                         /* Finished incomplete (last) block */
557                         break;
558                 }
559
560                 tone_energy = goertzel_result(&s->tone);
561
562                 /* Scale to make comparable */
563                 tone_energy *= 2.0;
564                 s->energy *= s->block_size;
565
566                 ast_debug(10, "tone %d, Ew=%.2E, Et=%.2E, s/n=%10.2f\n", s->freq, tone_energy, s->energy, tone_energy / (s->energy - tone_energy));
567                 hit = 0;
568                 if (tone_energy > s->energy * s->threshold) {
569                         ast_debug(10, "Hit! count=%d\n", s->hit_count);
570                         hit = 1;
571                 }
572
573                 if (s->hit_count) {
574                         s->hit_count++;
575                 }
576
577                 if (hit == s->last_hit) {
578                         if (!hit) {
579                                 /* Two successive misses. Tone ended */
580                                 s->hit_count = 0;
581                         } else if (!s->hit_count) {
582                                 s->hit_count++;
583                         }
584
585                 }
586
587                 if (s->hit_count == s->hits_required) {
588                         ast_debug(1, "%d Hz done detected\n", s->freq);
589                         res = 1;
590                 }
591
592                 s->last_hit = hit;
593
594                 /* If we had a hit in this block, include it into mute fragment */
595                 if (s->squelch && hit) {
596                         if (mute.end < start - s->block_size) {
597                                 /* There is a gap between fragments */
598                                 mute_fragment(dsp, &mute);
599                                 mute.start = (start > s->block_size) ? (start - s->block_size) : 0;
600                         }
601                         mute.end = end + s->block_size;
602                 }
603
604                 /* Reinitialise the detector for the next block */
605                 /* Reset for the next block */
606                 goertzel_reset(&s->tone);
607
608                 /* Advance to the next block */
609                 s->energy = 0.0;
610                 s->samples_pending = s->block_size;
611
612                 amp += limit;
613         }
614
615         if (s->squelch && mute.end) {
616                 if (mute.end > samples) {
617                         s->mute_samples = mute.end - samples;
618                         mute.end = samples;
619                 }
620                 mute_fragment(dsp, &mute);
621         }
622
623         return res;
624 }
625
626 static void store_digit(digit_detect_state_t *s, char digit)
627 {
628         s->detected_digits++;
629         if (s->current_digits < MAX_DTMF_DIGITS) {
630                 s->digitlen[s->current_digits] = 0;
631                 s->digits[s->current_digits++] = digit;
632                 s->digits[s->current_digits] = '\0';
633         } else {
634                 ast_log(LOG_WARNING, "Digit lost due to full buffer\n");
635                 s->lost_digits++;
636         }
637 }
638
639 static int dtmf_detect(struct ast_dsp *dsp, digit_detect_state_t *s, int16_t amp[], int samples, int squelch, int relax)
640 {
641         float row_energy[4];
642         float col_energy[4];
643         float famp;
644         int i;
645         int j;
646         int sample;
647         int best_row;
648         int best_col;
649         int hit;
650         int limit;
651         fragment_t mute = {0, 0};
652
653         if (squelch && s->td.dtmf.mute_samples > 0) {
654                 mute.end = (s->td.dtmf.mute_samples < samples) ? s->td.dtmf.mute_samples : samples;
655                 s->td.dtmf.mute_samples -= mute.end;
656         }
657
658         hit = 0;
659         for (sample = 0; sample < samples; sample = limit) {
660                 /* DTMF_GSIZE is optimised to meet the DTMF specs. */
661                 if ((samples - sample) >= (DTMF_GSIZE - s->td.dtmf.current_sample)) {
662                         limit = sample + (DTMF_GSIZE - s->td.dtmf.current_sample);
663                 } else {
664                         limit = samples;
665                 }
666                 /* The following unrolled loop takes only 35% (rough estimate) of the 
667                    time of a rolled loop on the machine on which it was developed */
668                 for (j = sample; j < limit; j++) {
669                         famp = amp[j];
670                         s->td.dtmf.energy += famp*famp;
671                         /* With GCC 2.95, the following unrolled code seems to take about 35%
672                            (rough estimate) as long as a neat little 0-3 loop */
673                         goertzel_sample(s->td.dtmf.row_out, amp[j]);
674                         goertzel_sample(s->td.dtmf.col_out, amp[j]);
675                         goertzel_sample(s->td.dtmf.row_out + 1, amp[j]);
676                         goertzel_sample(s->td.dtmf.col_out + 1, amp[j]);
677                         goertzel_sample(s->td.dtmf.row_out + 2, amp[j]);
678                         goertzel_sample(s->td.dtmf.col_out + 2, amp[j]);
679                         goertzel_sample(s->td.dtmf.row_out + 3, amp[j]);
680                         goertzel_sample(s->td.dtmf.col_out + 3, amp[j]);
681                 }
682                 s->td.dtmf.current_sample += (limit - sample);
683                 if (s->td.dtmf.current_sample < DTMF_GSIZE) {
684                         continue;
685                 }
686                 /* We are at the end of a DTMF detection block */
687                 /* Find the peak row and the peak column */
688                 row_energy[0] = goertzel_result (&s->td.dtmf.row_out[0]);
689                 col_energy[0] = goertzel_result (&s->td.dtmf.col_out[0]);
690
691                 for (best_row = best_col = 0, i = 1;  i < 4;  i++) {
692                         row_energy[i] = goertzel_result (&s->td.dtmf.row_out[i]);
693                         if (row_energy[i] > row_energy[best_row]) {
694                                 best_row = i;
695                         }
696                         col_energy[i] = goertzel_result (&s->td.dtmf.col_out[i]);
697                         if (col_energy[i] > col_energy[best_col]) {
698                                 best_col = i;
699                         }
700                 }
701                 hit = 0;
702                 /* Basic signal level test and the twist test */
703                 if (row_energy[best_row] >= DTMF_THRESHOLD && 
704                     col_energy[best_col] >= DTMF_THRESHOLD &&
705                     col_energy[best_col] < row_energy[best_row] * DTMF_REVERSE_TWIST &&
706                     col_energy[best_col] * DTMF_NORMAL_TWIST > row_energy[best_row]) {
707                         /* Relative peak test */
708                         for (i = 0;  i < 4;  i++) {
709                                 if ((i != best_col &&
710                                     col_energy[i] * DTMF_RELATIVE_PEAK_COL > col_energy[best_col]) ||
711                                     (i != best_row 
712                                      && row_energy[i] * DTMF_RELATIVE_PEAK_ROW > row_energy[best_row])) {
713                                         break;
714                                 }
715                         }
716                         /* ... and fraction of total energy test */
717                         if (i >= 4 &&
718                             (row_energy[best_row] + col_energy[best_col]) > DTMF_TO_TOTAL_ENERGY * s->td.dtmf.energy) {
719                                 /* Got a hit */
720                                 hit = dtmf_positions[(best_row << 2) + best_col];
721                         }
722                 } 
723
724                 if (s->td.dtmf.current_hit) {
725                         /* We are in the middle of a digit already */
726                         if (hit != s->td.dtmf.current_hit) {
727                                 s->td.dtmf.misses++;
728                                 if (s->td.dtmf.misses == s->td.dtmf.misses_to_end) {
729                                         /* There were enough misses to consider digit ended */
730                                         s->td.dtmf.current_hit = 0;
731                                 }
732                         } else {
733                                 s->td.dtmf.misses = 0;
734                                 /* Current hit was same as last, so increment digit duration */
735                                 s->digitlen[s->current_len] += DTMF_GSIZE;
736                         }
737                 }
738
739                 /* Look for a start of a new digit no matter if we are already in the middle of some
740                    digit or not. This is because hits_to_begin may be smaller than misses_to_end
741                    and we may find begin of new digit before we consider last one ended. */
742                 if (hit) {
743                         if (hit == s->td.dtmf.lasthit) {
744                                 s->td.dtmf.hits++;
745                         } else {
746                                 s->td.dtmf.hits = 1;
747                         }
748
749                         if (s->td.dtmf.hits == s->td.dtmf.hits_to_begin && hit != s->td.dtmf.current_hit) {
750                                 store_digit(s, hit);
751                                 s->td.dtmf.current_hit = hit;
752                                 s->td.dtmf.misses = 0;
753                         }
754                 } else {
755                         s->td.dtmf.hits = 0;
756                 }
757
758                 s->td.dtmf.lasthit = hit;
759
760                 /* If we had a hit in this block, include it into mute fragment */
761                 if (squelch && hit) {
762                         if (mute.end < sample - DTMF_GSIZE) {
763                                 /* There is a gap between fragments */
764                                 mute_fragment(dsp, &mute);
765                                 mute.start = (sample > DTMF_GSIZE) ? (sample - DTMF_GSIZE) : 0;
766                         }
767                         mute.end = limit + DTMF_GSIZE;
768                 }
769
770                 /* Reinitialise the detector for the next block */
771                 for (i = 0; i < 4; i++) {
772                         goertzel_reset(&s->td.dtmf.row_out[i]);
773                         goertzel_reset(&s->td.dtmf.col_out[i]);
774                 }
775                 s->td.dtmf.energy = 0.0;
776                 s->td.dtmf.current_sample = 0;
777         }
778
779         if (squelch && mute.end) {
780                 if (mute.end > samples) {
781                         s->td.dtmf.mute_samples = mute.end - samples;
782                         mute.end = samples;
783                 }
784                 mute_fragment(dsp, &mute);
785         }
786
787         return (s->td.dtmf.current_hit);        /* return the debounced hit */
788 }
789
790 static int mf_detect(struct ast_dsp *dsp, digit_detect_state_t *s, int16_t amp[],
791                  int samples, int squelch, int relax)
792 {
793         float energy[6];
794         int best;
795         int second_best;
796         float famp;
797         int i;
798         int j;
799         int sample;
800         int hit;
801         int limit;
802         fragment_t mute = {0, 0};
803
804         if (squelch && s->td.mf.mute_samples > 0) {
805                 mute.end = (s->td.mf.mute_samples < samples) ? s->td.mf.mute_samples : samples;
806                 s->td.mf.mute_samples -= mute.end;
807         }
808
809         hit = 0;
810         for (sample = 0;  sample < samples;  sample = limit) {
811                 /* 80 is optimised to meet the MF specs. */
812                 /* XXX So then why is MF_GSIZE defined as 120? */
813                 if ((samples - sample) >= (MF_GSIZE - s->td.mf.current_sample)) {
814                         limit = sample + (MF_GSIZE - s->td.mf.current_sample);
815                 } else {
816                         limit = samples;
817                 }
818                 /* The following unrolled loop takes only 35% (rough estimate) of the 
819                    time of a rolled loop on the machine on which it was developed */
820                 for (j = sample;  j < limit;  j++) {
821                         famp = amp[j];
822                         /* With GCC 2.95, the following unrolled code seems to take about 35%
823                            (rough estimate) as long as a neat little 0-3 loop */
824                         goertzel_sample(s->td.mf.tone_out, amp[j]);
825                         goertzel_sample(s->td.mf.tone_out + 1, amp[j]);
826                         goertzel_sample(s->td.mf.tone_out + 2, amp[j]);
827                         goertzel_sample(s->td.mf.tone_out + 3, amp[j]);
828                         goertzel_sample(s->td.mf.tone_out + 4, amp[j]);
829                         goertzel_sample(s->td.mf.tone_out + 5, amp[j]);
830                 }
831                 s->td.mf.current_sample += (limit - sample);
832                 if (s->td.mf.current_sample < MF_GSIZE) {
833                         continue;
834                 }
835                 /* We're at the end of an MF detection block.  */
836                 /* Find the two highest energies. The spec says to look for
837                    two tones and two tones only. Taking this literally -ie
838                    only two tones pass the minimum threshold - doesn't work
839                    well. The sinc function mess, due to rectangular windowing
840                    ensure that! Find the two highest energies and ensure they
841                    are considerably stronger than any of the others. */
842                 energy[0] = goertzel_result(&s->td.mf.tone_out[0]);
843                 energy[1] = goertzel_result(&s->td.mf.tone_out[1]);
844                 if (energy[0] > energy[1]) {
845                         best = 0;
846                         second_best = 1;
847                 } else {
848                         best = 1;
849                         second_best = 0;
850                 }
851                 /*endif*/
852                 for (i = 2; i < 6; i++) {
853                         energy[i] = goertzel_result(&s->td.mf.tone_out[i]);
854                         if (energy[i] >= energy[best]) {
855                                 second_best = best;
856                                 best = i;
857                         } else if (energy[i] >= energy[second_best]) {
858                                 second_best = i;
859                         }
860                 }
861                 /* Basic signal level and twist tests */
862                 hit = 0;
863                 if (energy[best] >= BELL_MF_THRESHOLD && energy[second_best] >= BELL_MF_THRESHOLD
864                     && energy[best] < energy[second_best]*BELL_MF_TWIST
865                     && energy[best] * BELL_MF_TWIST > energy[second_best]) {
866                         /* Relative peak test */
867                         hit = -1;
868                         for (i = 0; i < 6; i++) {
869                                 if (i != best && i != second_best) {
870                                         if (energy[i]*BELL_MF_RELATIVE_PEAK >= energy[second_best]) {
871                                                 /* The best two are not clearly the best */
872                                                 hit = 0;
873                                                 break;
874                                         }
875                                 }
876                         }
877                 }
878                 if (hit) {
879                         /* Get the values into ascending order */
880                         if (second_best < best) {
881                                 i = best;
882                                 best = second_best;
883                                 second_best = i;
884                         }
885                         best = best * 5 + second_best - 1;
886                         hit = bell_mf_positions[best];
887                         /* Look for two successive similar results */
888                         /* The logic in the next test is:
889                            For KP we need 4 successive identical clean detects, with
890                            two blocks of something different preceeding it. For anything
891                            else we need two successive identical clean detects, with
892                            two blocks of something different preceeding it. */
893                         if (hit == s->td.mf.hits[4] && hit == s->td.mf.hits[3] &&
894                            ((hit != '*' && hit != s->td.mf.hits[2] && hit != s->td.mf.hits[1])||
895                             (hit == '*' && hit == s->td.mf.hits[2] && hit != s->td.mf.hits[1] && 
896                             hit != s->td.mf.hits[0]))) {
897                                 store_digit(s, hit);
898                         }
899                 }
900
901
902                 if (hit != s->td.mf.hits[4] && hit != s->td.mf.hits[3]) {
903                         /* Two successive block without a hit terminate current digit */
904                         s->td.mf.current_hit = 0;
905                 }
906
907                 s->td.mf.hits[0] = s->td.mf.hits[1];
908                 s->td.mf.hits[1] = s->td.mf.hits[2];
909                 s->td.mf.hits[2] = s->td.mf.hits[3];
910                 s->td.mf.hits[3] = s->td.mf.hits[4];
911                 s->td.mf.hits[4] = hit;
912
913                 /* If we had a hit in this block, include it into mute fragment */
914                 if (squelch && hit) {
915                         if (mute.end < sample - MF_GSIZE) {
916                                 /* There is a gap between fragments */
917                                 mute_fragment(dsp, &mute);
918                                 mute.start = (sample > MF_GSIZE) ? (sample - MF_GSIZE) : 0;
919                         }
920                         mute.end = limit + DTMF_GSIZE;
921                 }
922
923                 /* Reinitialise the detector for the next block */
924                 for (i = 0;  i < 6;  i++)
925                         goertzel_reset(&s->td.mf.tone_out[i]);
926                 s->td.mf.current_sample = 0;
927         }
928
929         if (squelch && mute.end) {
930                 if (mute.end > samples) {
931                         s->td.mf.mute_samples = mute.end - samples;
932                         mute.end = samples;
933                 }
934                 mute_fragment(dsp, &mute);
935         }
936
937         return (s->td.mf.current_hit); /* return the debounced hit */
938 }
939
940 static inline int pair_there(float p1, float p2, float i1, float i2, float e)
941 {
942         /* See if p1 and p2 are there, relative to i1 and i2 and total energy */
943         /* Make sure absolute levels are high enough */
944         if ((p1 < TONE_MIN_THRESH) || (p2 < TONE_MIN_THRESH)) {
945                 return 0;
946         }
947         /* Amplify ignored stuff */
948         i2 *= TONE_THRESH;
949         i1 *= TONE_THRESH;
950         e *= TONE_THRESH;
951         /* Check first tone */
952         if ((p1 < i1) || (p1 < i2) || (p1 < e)) {
953                 return 0;
954         }
955         /* And second */
956         if ((p2 < i1) || (p2 < i2) || (p2 < e)) {
957                 return 0;
958         }
959         /* Guess it's there... */
960         return 1;
961 }
962
963 static int __ast_dsp_call_progress(struct ast_dsp *dsp, short *s, int len)
964 {
965         int x;
966         int y;
967         int pass;
968         int newstate = DSP_TONE_STATE_SILENCE;
969         int res = 0;
970         while (len) {
971                 /* Take the lesser of the number of samples we need and what we have */
972                 pass = len;
973                 if (pass > dsp->gsamp_size - dsp->gsamps) {
974                         pass = dsp->gsamp_size - dsp->gsamps;
975                 }
976                 for (x = 0; x < pass; x++) {
977                         for (y = 0; y < dsp->freqcount; y++) {
978                                 goertzel_sample(&dsp->freqs[y], s[x]);
979                         }
980                         dsp->genergy += s[x] * s[x];
981                 }
982                 s += pass;
983                 dsp->gsamps += pass;
984                 len -= pass;
985                 if (dsp->gsamps == dsp->gsamp_size) {
986                         float hz[7];
987                         for (y = 0; y < 7; y++) {
988                                 hz[y] = goertzel_result(&dsp->freqs[y]);
989                         }
990                         switch (dsp->progmode) {
991                         case PROG_MODE_NA:
992                                 if (pair_there(hz[HZ_480], hz[HZ_620], hz[HZ_350], hz[HZ_440], dsp->genergy)) {
993                                         newstate = DSP_TONE_STATE_BUSY;
994                                 } else if (pair_there(hz[HZ_440], hz[HZ_480], hz[HZ_350], hz[HZ_620], dsp->genergy)) {
995                                         newstate = DSP_TONE_STATE_RINGING;
996                                 } else if (pair_there(hz[HZ_350], hz[HZ_440], hz[HZ_480], hz[HZ_620], dsp->genergy)) {
997                                         newstate = DSP_TONE_STATE_DIALTONE;
998                                 } else if (hz[HZ_950] > TONE_MIN_THRESH * TONE_THRESH) {
999                                         newstate = DSP_TONE_STATE_SPECIAL1;
1000                                 } else if (hz[HZ_1400] > TONE_MIN_THRESH * TONE_THRESH) {
1001                                         /* End of SPECIAL1 or middle of SPECIAL2 */
1002                                         if (dsp->tstate == DSP_TONE_STATE_SPECIAL1 || dsp->tstate == DSP_TONE_STATE_SPECIAL2) {
1003                                                 newstate = DSP_TONE_STATE_SPECIAL2;
1004                                         }
1005                                 } else if (hz[HZ_1800] > TONE_MIN_THRESH * TONE_THRESH) {
1006                                         /* End of SPECIAL2 or middle of SPECIAL3 */
1007                                         if (dsp->tstate == DSP_TONE_STATE_SPECIAL2 || dsp->tstate == DSP_TONE_STATE_SPECIAL3) {
1008                                                 newstate = DSP_TONE_STATE_SPECIAL3;
1009                                         }
1010                                 } else if (dsp->genergy > TONE_MIN_THRESH * TONE_THRESH) {
1011                                         newstate = DSP_TONE_STATE_TALKING;
1012                                 } else {
1013                                         newstate = DSP_TONE_STATE_SILENCE;
1014                                 }
1015                                 break;
1016                         case PROG_MODE_CR:
1017                                 if (hz[HZ_425] > TONE_MIN_THRESH * TONE_THRESH) {
1018                                         newstate = DSP_TONE_STATE_RINGING;
1019                                 } else if (dsp->genergy > TONE_MIN_THRESH * TONE_THRESH) {
1020                                         newstate = DSP_TONE_STATE_TALKING;
1021                                 } else {
1022                                         newstate = DSP_TONE_STATE_SILENCE;
1023                                 }
1024                                 break;
1025                         case PROG_MODE_UK:
1026                                 if (hz[HZ_400UK] > TONE_MIN_THRESH * TONE_THRESH) {
1027                                         newstate = DSP_TONE_STATE_HUNGUP;
1028                                 } else if (pair_there(hz[HZ_350UK], hz[HZ_440UK], hz[HZ_400UK], hz[HZ_400UK], dsp->genergy)) {
1029                                         newstate = DSP_TONE_STATE_DIALTONE;
1030                                 }
1031                                 break;
1032                         default:
1033                                 ast_log(LOG_WARNING, "Can't process in unknown prog mode '%d'\n", dsp->progmode);
1034                         }
1035                         if (newstate == dsp->tstate) {
1036                                 dsp->tcount++;
1037                                 if (dsp->ringtimeout) {
1038                                         dsp->ringtimeout++;
1039                                 }
1040                                 switch (dsp->tstate) {
1041                                 case DSP_TONE_STATE_RINGING:
1042                                         if ((dsp->features & DSP_PROGRESS_RINGING) &&
1043                                             (dsp->tcount == THRESH_RING)) {
1044                                                 res = AST_CONTROL_RINGING;
1045                                                 dsp->ringtimeout = 1;
1046                                         }
1047                                         break;
1048                                 case DSP_TONE_STATE_BUSY:
1049                                         if ((dsp->features & DSP_PROGRESS_BUSY) &&
1050                                             (dsp->tcount == THRESH_BUSY)) {
1051                                                 res = AST_CONTROL_BUSY;
1052                                                 dsp->features &= ~DSP_FEATURE_CALL_PROGRESS;
1053                                         }
1054                                         break;
1055                                 case DSP_TONE_STATE_TALKING:
1056                                         if ((dsp->features & DSP_PROGRESS_TALK) &&
1057                                             (dsp->tcount == THRESH_TALK)) {
1058                                                 res = AST_CONTROL_ANSWER;
1059                                                 dsp->features &= ~DSP_FEATURE_CALL_PROGRESS;
1060                                         }
1061                                         break;
1062                                 case DSP_TONE_STATE_SPECIAL3:
1063                                         if ((dsp->features & DSP_PROGRESS_CONGESTION) &&
1064                                             (dsp->tcount == THRESH_CONGESTION)) {
1065                                                 res = AST_CONTROL_CONGESTION;
1066                                                 dsp->features &= ~DSP_FEATURE_CALL_PROGRESS;
1067                                         }
1068                                         break;
1069                                 case DSP_TONE_STATE_HUNGUP:
1070                                         if ((dsp->features & DSP_FEATURE_CALL_PROGRESS) &&
1071                                             (dsp->tcount == THRESH_HANGUP)) {
1072                                                 res = AST_CONTROL_HANGUP;
1073                                                 dsp->features &= ~DSP_FEATURE_CALL_PROGRESS;
1074                                         }
1075                                         break;
1076                                 }
1077                                 if (dsp->ringtimeout == THRESH_RING2ANSWER) {
1078                                         ast_debug(1, "Consider call as answered because of timeout after last ring\n");
1079                                         res = AST_CONTROL_ANSWER;
1080                                         dsp->features &= ~DSP_FEATURE_CALL_PROGRESS;
1081                                 }
1082                         } else {
1083                                 ast_debug(5, "Stop state %d with duration %d\n", dsp->tstate, dsp->tcount);
1084                                 ast_debug(5, "Start state %d\n", newstate);
1085                                 dsp->tstate = newstate;
1086                                 dsp->tcount = 1;
1087                         }
1088
1089                         /* Reset goertzel */
1090                         for (x = 0; x < 7; x++) {
1091                                 dsp->freqs[x].v2 = dsp->freqs[x].v3 = 0.0;
1092                         }
1093                         dsp->gsamps = 0;
1094                         dsp->genergy = 0.0;
1095                 }
1096         }
1097
1098         return res;
1099 }
1100
1101 int ast_dsp_call_progress(struct ast_dsp *dsp, struct ast_frame *inf)
1102 {
1103         if (inf->frametype != AST_FRAME_VOICE) {
1104                 ast_log(LOG_WARNING, "Can't check call progress of non-voice frames\n");
1105                 return 0;
1106         }
1107         if (inf->subclass.codec != AST_FORMAT_SLINEAR) {
1108                 ast_log(LOG_WARNING, "Can only check call progress in signed-linear frames\n");
1109                 return 0;
1110         }
1111         return __ast_dsp_call_progress(dsp, inf->data.ptr, inf->datalen / 2);
1112 }
1113
1114 static int __ast_dsp_silence_noise(struct ast_dsp *dsp, short *s, int len, int *totalsilence, int *totalnoise)
1115 {
1116         int accum;
1117         int x;
1118         int res = 0;
1119
1120         if (!len) {
1121                 return 0;
1122         }
1123         accum = 0;
1124         for (x = 0; x < len; x++) {
1125                 accum += abs(s[x]);
1126         }
1127         accum /= len;
1128         if (accum < dsp->threshold) {
1129                 /* Silent */
1130                 dsp->totalsilence += len / 8;
1131                 if (dsp->totalnoise) {
1132                         /* Move and save history */
1133                         memmove(dsp->historicnoise + DSP_HISTORY - dsp->busycount, dsp->historicnoise + DSP_HISTORY - dsp->busycount + 1, dsp->busycount * sizeof(dsp->historicnoise[0]));
1134                         dsp->historicnoise[DSP_HISTORY - 1] = dsp->totalnoise;
1135 /* we don't want to check for busydetect that frequently */
1136 #if 0
1137                         dsp->busymaybe = 1;
1138 #endif
1139                 }
1140                 dsp->totalnoise = 0;
1141                 res = 1;
1142         } else {
1143                 /* Not silent */
1144                 dsp->totalnoise += len / 8;
1145                 if (dsp->totalsilence) {
1146                         int silence1 = dsp->historicsilence[DSP_HISTORY - 1];
1147                         int silence2 = dsp->historicsilence[DSP_HISTORY - 2];
1148                         /* Move and save history */
1149                         memmove(dsp->historicsilence + DSP_HISTORY - dsp->busycount, dsp->historicsilence + DSP_HISTORY - dsp->busycount + 1, dsp->busycount * sizeof(dsp->historicsilence[0]));
1150                         dsp->historicsilence[DSP_HISTORY - 1] = dsp->totalsilence;
1151                         /* check if the previous sample differs only by BUSY_PERCENT from the one before it */
1152                         if (silence1 < silence2) {
1153                                 if (silence1 + silence1 * BUSY_PERCENT / 100 >= silence2) {
1154                                         dsp->busymaybe = 1;
1155                                 } else {
1156                                         dsp->busymaybe = 0;
1157                                 }
1158                         } else {
1159                                 if (silence1 - silence1 * BUSY_PERCENT / 100 <= silence2) {
1160                                         dsp->busymaybe = 1;
1161                                 } else {
1162                                         dsp->busymaybe = 0;
1163                                 }
1164                         }
1165                 }
1166                 dsp->totalsilence = 0;
1167         }
1168         if (totalsilence) {
1169                 *totalsilence = dsp->totalsilence;
1170         }
1171         if (totalnoise) {
1172                 *totalnoise = dsp->totalnoise;
1173         }
1174         return res;
1175 }
1176
1177 int ast_dsp_busydetect(struct ast_dsp *dsp)
1178 {
1179         int res = 0, x;
1180 #ifndef BUSYDETECT_TONEONLY
1181         int avgsilence = 0, hitsilence = 0;
1182 #endif
1183         int avgtone = 0, hittone = 0;
1184         if (!dsp->busymaybe) {
1185                 return res;
1186         }
1187         for (x = DSP_HISTORY - dsp->busycount; x < DSP_HISTORY; x++) {
1188 #ifndef BUSYDETECT_TONEONLY
1189                 avgsilence += dsp->historicsilence[x];
1190 #endif
1191                 avgtone += dsp->historicnoise[x];
1192         }
1193 #ifndef BUSYDETECT_TONEONLY
1194         avgsilence /= dsp->busycount;
1195 #endif
1196         avgtone /= dsp->busycount;
1197         for (x = DSP_HISTORY - dsp->busycount; x < DSP_HISTORY; x++) {
1198 #ifndef BUSYDETECT_TONEONLY
1199                 if (avgsilence > dsp->historicsilence[x]) {
1200                         if (avgsilence - (avgsilence * BUSY_PERCENT / 100) <= dsp->historicsilence[x]) {
1201                                 hitsilence++;
1202                         }
1203                 } else {
1204                         if (avgsilence + (avgsilence * BUSY_PERCENT / 100) >= dsp->historicsilence[x]) {
1205                                 hitsilence++;
1206                         }
1207                 }
1208 #endif
1209                 if (avgtone > dsp->historicnoise[x]) {
1210                         if (avgtone - (avgtone * BUSY_PERCENT / 100) <= dsp->historicnoise[x]) {
1211                                 hittone++;
1212                         }
1213                 } else {
1214                         if (avgtone + (avgtone * BUSY_PERCENT / 100) >= dsp->historicnoise[x]) {
1215                                 hittone++;
1216                         }
1217                 }
1218         }
1219 #ifndef BUSYDETECT_TONEONLY
1220         if ((hittone >= dsp->busycount - 1) && (hitsilence >= dsp->busycount - 1) && 
1221             (avgtone >= BUSY_MIN && avgtone <= BUSY_MAX) && 
1222             (avgsilence >= BUSY_MIN && avgsilence <= BUSY_MAX)) {
1223 #else
1224         if ((hittone >= dsp->busycount - 1) && (avgtone >= BUSY_MIN && avgtone <= BUSY_MAX)) {
1225 #endif
1226 #ifdef BUSYDETECT_COMPARE_TONE_AND_SILENCE
1227                 if (avgtone > avgsilence) {
1228                         if (avgtone - avgtone*BUSY_PERCENT/100 <= avgsilence) {
1229                                 res = 1;
1230                         }
1231                 } else {
1232                         if (avgtone + avgtone*BUSY_PERCENT/100 >= avgsilence) {
1233                                 res = 1;
1234                         }
1235                 }
1236 #else
1237                 res = 1;
1238 #endif
1239         }
1240         /* If we know the expected busy tone length, check we are in the range */
1241         if (res && (dsp->busy_tonelength > 0)) {
1242                 if (abs(avgtone - dsp->busy_tonelength) > (dsp->busy_tonelength*BUSY_PAT_PERCENT/100)) {
1243 #ifdef BUSYDETECT_DEBUG
1244                         ast_debug(5, "busy detector: avgtone of %d not close enough to desired %d\n",
1245                                 avgtone, dsp->busy_tonelength);
1246 #endif
1247                         res = 0;
1248                 }
1249         }
1250 #ifndef BUSYDETECT_TONEONLY
1251         /* If we know the expected busy tone silent-period length, check we are in the range */
1252         if (res && (dsp->busy_quietlength > 0)) {
1253                 if (abs(avgsilence - dsp->busy_quietlength) > (dsp->busy_quietlength*BUSY_PAT_PERCENT/100)) {
1254 #ifdef BUSYDETECT_DEBUG
1255                 ast_debug(5, "busy detector: avgsilence of %d not close enough to desired %d\n",
1256                         avgsilence, dsp->busy_quietlength);
1257 #endif
1258                         res = 0;
1259                 }
1260         }
1261 #endif
1262 #if !defined(BUSYDETECT_TONEONLY) && defined(BUSYDETECT_DEBUG)
1263         if (res) {
1264                 ast_debug(5, "ast_dsp_busydetect detected busy, avgtone: %d, avgsilence %d\n", avgtone, avgsilence);
1265         } else {
1266                 ast_debug(5, "busy detector: FAILED with avgtone: %d, avgsilence %d\n", avgtone, avgsilence);
1267         }
1268 #endif
1269         return res;
1270 }
1271
1272 int ast_dsp_silence(struct ast_dsp *dsp, struct ast_frame *f, int *totalsilence)
1273 {
1274         short *s;
1275         int len;
1276         
1277         if (f->frametype != AST_FRAME_VOICE) {
1278                 ast_log(LOG_WARNING, "Can't calculate silence on a non-voice frame\n");
1279                 return 0;
1280         }
1281         if (f->subclass.codec != AST_FORMAT_SLINEAR) {
1282                 ast_log(LOG_WARNING, "Can only calculate silence on signed-linear frames :(\n");
1283                 return 0;
1284         }
1285         s = f->data.ptr;
1286         len = f->datalen/2;
1287         return __ast_dsp_silence_noise(dsp, s, len, totalsilence, NULL);
1288 }
1289
1290 int ast_dsp_noise(struct ast_dsp *dsp, struct ast_frame *f, int *totalnoise)
1291 {
1292        short *s;
1293        int len;
1294
1295        if (f->frametype != AST_FRAME_VOICE) {
1296                ast_log(LOG_WARNING, "Can't calculate noise on a non-voice frame\n");
1297                return 0;
1298        }
1299        if (f->subclass.codec != AST_FORMAT_SLINEAR) {
1300                ast_log(LOG_WARNING, "Can only calculate noise on signed-linear frames :(\n");
1301                return 0;
1302        }
1303        s = f->data.ptr;
1304        len = f->datalen/2;
1305        return __ast_dsp_silence_noise(dsp, s, len, NULL, totalnoise);
1306 }
1307
1308
1309 struct ast_frame *ast_dsp_process(struct ast_channel *chan, struct ast_dsp *dsp, struct ast_frame *af)
1310 {
1311         int silence;
1312         int res;
1313         int digit = 0, fax_digit = 0;
1314         int x;
1315         short *shortdata;
1316         unsigned char *odata;
1317         int len;
1318         struct ast_frame *outf = NULL;
1319
1320         if (!af) {
1321                 return NULL;
1322         }
1323         if (af->frametype != AST_FRAME_VOICE) {
1324                 return af;
1325         }
1326
1327         odata = af->data.ptr;
1328         len = af->datalen;
1329         /* Make sure we have short data */
1330         switch (af->subclass.codec) {
1331         case AST_FORMAT_SLINEAR:
1332                 shortdata = af->data.ptr;
1333                 len = af->datalen / 2;
1334                 break;
1335         case AST_FORMAT_ULAW:
1336         case AST_FORMAT_TESTLAW:
1337                 shortdata = alloca(af->datalen * 2);
1338                 for (x = 0;x < len; x++) {
1339                         shortdata[x] = AST_MULAW(odata[x]);
1340                 }
1341                 break;
1342         case AST_FORMAT_ALAW:
1343                 shortdata = alloca(af->datalen * 2);
1344                 for (x = 0; x < len; x++) {
1345                         shortdata[x] = AST_ALAW(odata[x]);
1346                 }
1347                 break;
1348         default:
1349                 /*Display warning only once. Otherwise you would get hundreds of warnings every second */
1350                 if (dsp->display_inband_dtmf_warning)
1351                         ast_log(LOG_WARNING, "Inband DTMF is not supported on codec %s. Use RFC2833\n", ast_getformatname(af->subclass.codec));
1352                 dsp->display_inband_dtmf_warning = 0;
1353                 return af;
1354         }
1355
1356         /* Initially we do not want to mute anything */
1357         dsp->mute_fragments = 0;
1358
1359         /* Need to run the silence detection stuff for silence suppression and busy detection */
1360         if ((dsp->features & DSP_FEATURE_SILENCE_SUPPRESS) || (dsp->features & DSP_FEATURE_BUSY_DETECT)) {
1361                 res = __ast_dsp_silence_noise(dsp, shortdata, len, &silence, NULL);
1362         }
1363
1364         if ((dsp->features & DSP_FEATURE_SILENCE_SUPPRESS) && silence) {
1365                 memset(&dsp->f, 0, sizeof(dsp->f));
1366                 dsp->f.frametype = AST_FRAME_NULL;
1367                 ast_frfree(af);
1368                 return ast_frisolate(&dsp->f);
1369         }
1370         if ((dsp->features & DSP_FEATURE_BUSY_DETECT) && ast_dsp_busydetect(dsp)) {
1371                 chan->_softhangup |= AST_SOFTHANGUP_DEV;
1372                 memset(&dsp->f, 0, sizeof(dsp->f));
1373                 dsp->f.frametype = AST_FRAME_CONTROL;
1374                 dsp->f.subclass.integer = AST_CONTROL_BUSY;
1375                 ast_frfree(af);
1376                 ast_debug(1, "Requesting Hangup because the busy tone was detected on channel %s\n", chan->name);
1377                 return ast_frisolate(&dsp->f);
1378         }
1379
1380         if ((dsp->features & DSP_FEATURE_FAX_DETECT)) {
1381                 if ((dsp->faxmode & DSP_FAXMODE_DETECT_CNG) && tone_detect(dsp, &dsp->cng_tone_state, shortdata, len)) {
1382                         fax_digit = 'f';
1383                 }
1384
1385                 if ((dsp->faxmode & DSP_FAXMODE_DETECT_CED) && tone_detect(dsp, &dsp->ced_tone_state, shortdata, len)) {
1386                         fax_digit = 'e';
1387                 }
1388         }
1389
1390         if (dsp->features & (DSP_FEATURE_DIGIT_DETECT | DSP_FEATURE_BUSY_DETECT)) {
1391                 if (dsp->digitmode & DSP_DIGITMODE_MF)
1392                         digit = mf_detect(dsp, &dsp->digit_state, shortdata, len, (dsp->digitmode & DSP_DIGITMODE_NOQUELCH) == 0, (dsp->digitmode & DSP_DIGITMODE_RELAXDTMF));
1393                 else
1394                         digit = dtmf_detect(dsp, &dsp->digit_state, shortdata, len, (dsp->digitmode & DSP_DIGITMODE_NOQUELCH) == 0, (dsp->digitmode & DSP_DIGITMODE_RELAXDTMF));
1395
1396                 if (dsp->digit_state.current_digits) {
1397                         int event = 0, event_len = 0;
1398                         char event_digit = 0;
1399
1400                         if (!dsp->dtmf_began) {
1401                                 /* We have not reported DTMF_BEGIN for anything yet */
1402
1403                                 if (dsp->features & DSP_FEATURE_DIGIT_DETECT) {
1404                                         event = AST_FRAME_DTMF_BEGIN;
1405                                         event_digit = dsp->digit_state.digits[0];
1406                                 }
1407                                 dsp->dtmf_began = 1;
1408
1409                         } else if (dsp->digit_state.current_digits > 1 || digit != dsp->digit_state.digits[0]) {
1410                                 /* Digit changed. This means digit we have reported with DTMF_BEGIN ended */
1411                                 if (dsp->features & DSP_FEATURE_DIGIT_DETECT) {
1412                                         event = AST_FRAME_DTMF_END;
1413                                         event_digit = dsp->digit_state.digits[0];
1414                                         event_len = dsp->digit_state.digitlen[0] * 1000 / SAMPLE_RATE;
1415                                 }
1416                                 memmove(&dsp->digit_state.digits[0], &dsp->digit_state.digits[1], dsp->digit_state.current_digits);
1417                                 dsp->digit_state.current_digits--;
1418                                 memmove(&dsp->digit_state.digitlen[0], &dsp->digit_state.digitlen[1], dsp->digit_state.current_len * sizeof(dsp->digit_state.digitlen[0]));
1419                                 dsp->digit_state.current_len--;
1420                                 dsp->dtmf_began = 0;
1421
1422                                 if (dsp->features & DSP_FEATURE_BUSY_DETECT) {
1423                                         /* Reset Busy Detector as we have some confirmed activity */ 
1424                                         memset(dsp->historicsilence, 0, sizeof(dsp->historicsilence));
1425                                         memset(dsp->historicnoise, 0, sizeof(dsp->historicnoise));
1426                                         ast_debug(1, "DTMF Detected - Reset busydetector\n");
1427                                 }
1428                         }
1429
1430                         if (event) {
1431                                 memset(&dsp->f, 0, sizeof(dsp->f));
1432                                 dsp->f.frametype = event;
1433                                 dsp->f.subclass.integer = event_digit;
1434                                 dsp->f.len = event_len;
1435                                 outf = &dsp->f;
1436                                 goto done;
1437                         }
1438                 }
1439         }
1440
1441         if (fax_digit) {
1442                 /* Fax was detected - digit is either 'f' or 'e' */
1443
1444                 memset(&dsp->f, 0, sizeof(dsp->f));
1445                 dsp->f.frametype = AST_FRAME_DTMF;
1446                 dsp->f.subclass.integer = fax_digit;
1447                 outf = &dsp->f;
1448                 goto done;
1449         }
1450
1451         if ((dsp->features & DSP_FEATURE_CALL_PROGRESS)) {
1452                 res = __ast_dsp_call_progress(dsp, shortdata, len);
1453                 if (res) {
1454                         switch (res) {
1455                         case AST_CONTROL_ANSWER:
1456                         case AST_CONTROL_BUSY:
1457                         case AST_CONTROL_RINGING:
1458                         case AST_CONTROL_CONGESTION:
1459                         case AST_CONTROL_HANGUP:
1460                                 memset(&dsp->f, 0, sizeof(dsp->f));
1461                                 dsp->f.frametype = AST_FRAME_CONTROL;
1462                                 dsp->f.subclass.integer = res;
1463                                 dsp->f.src = "dsp_progress";
1464                                 if (chan) 
1465                                         ast_queue_frame(chan, &dsp->f);
1466                                 break;
1467                         default:
1468                                 ast_log(LOG_WARNING, "Don't know how to represent call progress message %d\n", res);
1469                         }
1470                 }
1471         } else if ((dsp->features & DSP_FEATURE_WAITDIALTONE)) {
1472                 res = __ast_dsp_call_progress(dsp, shortdata, len);
1473         }
1474
1475 done:
1476         /* Mute fragment of the frame */
1477         for (x = 0; x < dsp->mute_fragments; x++) {
1478                 memset(shortdata + dsp->mute_data[x].start, 0, sizeof(int16_t) * (dsp->mute_data[x].end - dsp->mute_data[x].start));
1479         }
1480
1481         switch (af->subclass.codec) {
1482         case AST_FORMAT_SLINEAR:
1483                 break;
1484         case AST_FORMAT_ULAW:
1485                 for (x = 0; x < len; x++) {
1486                         odata[x] = AST_LIN2MU((unsigned short) shortdata[x]);
1487                 }
1488                 break;
1489         case AST_FORMAT_ALAW:
1490                 for (x = 0; x < len; x++) {
1491                         odata[x] = AST_LIN2A((unsigned short) shortdata[x]);
1492                 }
1493                 break;
1494         }
1495
1496         if (outf) {
1497                 if (chan) {
1498                         ast_queue_frame(chan, af);
1499                 }
1500                 ast_frfree(af);
1501                 return ast_frisolate(outf);
1502         } else {
1503                 return af;
1504         }
1505 }
1506
1507 static void ast_dsp_prog_reset(struct ast_dsp *dsp)
1508 {
1509         int max = 0;
1510         int x;
1511         
1512         dsp->gsamp_size = modes[dsp->progmode].size;
1513         dsp->gsamps = 0;
1514         for (x = 0; x < ARRAY_LEN(modes[dsp->progmode].freqs); x++) {
1515                 if (modes[dsp->progmode].freqs[x]) {
1516                         goertzel_init(&dsp->freqs[x], (float)modes[dsp->progmode].freqs[x], dsp->gsamp_size);
1517                         max = x + 1;
1518                 }
1519         }
1520         dsp->freqcount = max;
1521         dsp->ringtimeout= 0;
1522 }
1523
1524 struct ast_dsp *ast_dsp_new(void)
1525 {
1526         struct ast_dsp *dsp;
1527         
1528         if ((dsp = ast_calloc(1, sizeof(*dsp)))) {              
1529                 dsp->threshold = DEFAULT_THRESHOLD;
1530                 dsp->features = DSP_FEATURE_SILENCE_SUPPRESS;
1531                 dsp->busycount = DSP_HISTORY;
1532                 dsp->digitmode = DSP_DIGITMODE_DTMF;
1533                 dsp->faxmode = DSP_FAXMODE_DETECT_CNG;
1534                 /* Initialize digit detector */
1535                 ast_digit_detect_init(&dsp->digit_state, dsp->digitmode & DSP_DIGITMODE_MF);
1536                 dsp->display_inband_dtmf_warning = 1;
1537                 /* Initialize initial DSP progress detect parameters */
1538                 ast_dsp_prog_reset(dsp);
1539                 /* Initialize fax detector */
1540                 ast_fax_detect_init(dsp);
1541         }
1542         return dsp;
1543 }
1544
1545 void ast_dsp_set_features(struct ast_dsp *dsp, int features)
1546 {
1547         dsp->features = features;
1548 }
1549
1550 void ast_dsp_free(struct ast_dsp *dsp)
1551 {
1552         ast_free(dsp);
1553 }
1554
1555 void ast_dsp_set_threshold(struct ast_dsp *dsp, int threshold)
1556 {
1557         dsp->threshold = threshold;
1558 }
1559
1560 void ast_dsp_set_busy_count(struct ast_dsp *dsp, int cadences)
1561 {
1562         if (cadences < 4) {
1563                 cadences = 4;
1564         }
1565         if (cadences > DSP_HISTORY) {
1566                 cadences = DSP_HISTORY;
1567         }
1568         dsp->busycount = cadences;
1569 }
1570
1571 void ast_dsp_set_busy_pattern(struct ast_dsp *dsp, int tonelength, int quietlength)
1572 {
1573         dsp->busy_tonelength = tonelength;
1574         dsp->busy_quietlength = quietlength;
1575         ast_debug(1, "dsp busy pattern set to %d,%d\n", tonelength, quietlength);
1576 }
1577
1578 void ast_dsp_digitreset(struct ast_dsp *dsp)
1579 {
1580         int i;
1581         
1582         dsp->dtmf_began = 0;
1583         if (dsp->digitmode & DSP_DIGITMODE_MF) {
1584                 mf_detect_state_t *s = &dsp->digit_state.td.mf;
1585                 /* Reinitialise the detector for the next block */
1586                 for (i = 0;  i < 6;  i++) {
1587                         goertzel_reset(&s->tone_out[i]);
1588                 }
1589                 s->hits[4] = s->hits[3] = s->hits[2] = s->hits[1] = s->hits[0] = s->current_hit = 0;
1590                 s->current_sample = 0;
1591         } else {
1592                 dtmf_detect_state_t *s = &dsp->digit_state.td.dtmf;
1593                 /* Reinitialise the detector for the next block */
1594                 for (i = 0;  i < 4;  i++) {
1595                         goertzel_reset(&s->row_out[i]);
1596                         goertzel_reset(&s->col_out[i]);
1597                 }
1598                 s->lasthit = s->current_hit = 0;
1599                 s->energy = 0.0;
1600                 s->current_sample = 0;
1601                 s->hits = 0;
1602                 s->misses = 0;
1603         }
1604
1605         dsp->digit_state.digits[0] = '\0';
1606         dsp->digit_state.current_digits = 0;
1607 }
1608
1609 void ast_dsp_reset(struct ast_dsp *dsp)
1610 {
1611         int x;
1612         
1613         dsp->totalsilence = 0;
1614         dsp->gsamps = 0;
1615         for (x = 0; x < 4; x++) {
1616                 dsp->freqs[x].v2 = dsp->freqs[x].v3 = 0.0;
1617         }
1618         memset(dsp->historicsilence, 0, sizeof(dsp->historicsilence));
1619         memset(dsp->historicnoise, 0, sizeof(dsp->historicnoise));      
1620         dsp->ringtimeout= 0;
1621 }
1622
1623 int ast_dsp_set_digitmode(struct ast_dsp *dsp, int digitmode)
1624 {
1625         int new;
1626         int old;
1627         
1628         old = dsp->digitmode & (DSP_DIGITMODE_DTMF | DSP_DIGITMODE_MF | DSP_DIGITMODE_MUTECONF | DSP_DIGITMODE_MUTEMAX);
1629         new = digitmode & (DSP_DIGITMODE_DTMF | DSP_DIGITMODE_MF | DSP_DIGITMODE_MUTECONF | DSP_DIGITMODE_MUTEMAX);
1630         if (old != new) {
1631                 /* Must initialize structures if switching from MF to DTMF or vice-versa */
1632                 ast_digit_detect_init(&dsp->digit_state, new & DSP_DIGITMODE_MF);
1633         }
1634         dsp->digitmode = digitmode;
1635         return 0;
1636 }
1637
1638 int ast_dsp_set_faxmode(struct ast_dsp *dsp, int faxmode)
1639 {
1640         if (dsp->faxmode != faxmode) {
1641                 ast_fax_detect_init(dsp);
1642         }
1643         dsp->faxmode = faxmode;
1644         return 0;
1645 }
1646
1647 int ast_dsp_set_call_progress_zone(struct ast_dsp *dsp, char *zone)
1648 {
1649         int x;
1650         
1651         for (x = 0; x < ARRAY_LEN(aliases); x++) {
1652                 if (!strcasecmp(aliases[x].name, zone)) {
1653                         dsp->progmode = aliases[x].mode;
1654                         ast_dsp_prog_reset(dsp);
1655                         return 0;
1656                 }
1657         }
1658         return -1;
1659 }
1660
1661 int ast_dsp_was_muted(struct ast_dsp *dsp)
1662 {
1663         return (dsp->mute_fragments > 0);
1664 }
1665
1666 int ast_dsp_get_tstate(struct ast_dsp *dsp) 
1667 {
1668         return dsp->tstate;
1669 }
1670
1671 int ast_dsp_get_tcount(struct ast_dsp *dsp) 
1672 {
1673         return dsp->tcount;
1674 }
1675
1676 static int _dsp_init(int reload)
1677 {
1678         struct ast_flags config_flags = { reload ? CONFIG_FLAG_FILEUNCHANGED : 0 };
1679         struct ast_config *cfg;
1680
1681         cfg = ast_config_load2(CONFIG_FILE_NAME, "dsp", config_flags);
1682         if (cfg == CONFIG_STATUS_FILEMISSING || cfg == CONFIG_STATUS_FILEUNCHANGED || cfg == CONFIG_STATUS_FILEINVALID) {
1683                 return 0;
1684         }
1685
1686         if (cfg && cfg != CONFIG_STATUS_FILEUNCHANGED) {
1687                 const char *value;
1688
1689                 value = ast_variable_retrieve(cfg, "default", "silencethreshold");
1690                 if (value && sscanf(value, "%30d", &thresholds[THRESHOLD_SILENCE]) != 1) {
1691                         ast_log(LOG_WARNING, "%s: '%s' is not a valid silencethreshold value\n", CONFIG_FILE_NAME, value);
1692                         thresholds[THRESHOLD_SILENCE] = 256;
1693                 } else if (!value) {
1694                         thresholds[THRESHOLD_SILENCE] = 256;
1695                 }
1696
1697                 ast_config_destroy(cfg);
1698         }
1699         return 0;
1700 }
1701
1702 int ast_dsp_get_threshold_from_settings(enum threshold which)
1703 {
1704         return thresholds[which];
1705 }
1706
1707 int ast_dsp_init(void)
1708 {
1709         return _dsp_init(0);
1710 }
1711
1712 int ast_dsp_reload(void)
1713 {
1714         return _dsp_init(1);
1715 }
1716