585403786277a74b3b9fdc9eca78c387c059fed2
[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         int detected_digits;
278         int lost_digits;
279
280         union {
281                 dtmf_detect_state_t dtmf;
282                 mf_detect_state_t mf;
283         } td;
284 } digit_detect_state_t;
285
286 static const float dtmf_row[] = {
287         697.0,  770.0,  852.0,  941.0
288 };
289 static const float dtmf_col[] = {
290         1209.0, 1336.0, 1477.0, 1633.0
291 };
292 static const float mf_tones[] = {
293         700.0, 900.0, 1100.0, 1300.0, 1500.0, 1700.0
294 };
295 static const char dtmf_positions[] = "123A" "456B" "789C" "*0#D";
296 static const char bell_mf_positions[] = "1247C-358A--69*---0B----#";
297 static int thresholds[THRESHOLD_MAX];
298
299 static inline void goertzel_sample(goertzel_state_t *s, short sample)
300 {
301         int v1;
302         
303         v1 = s->v2;
304         s->v2 = s->v3;
305         
306         s->v3 = (s->fac * s->v2) >> 15;
307         s->v3 = s->v3 - v1 + (sample >> s->chunky);
308         if (abs(s->v3) > 32768) {
309                 s->chunky++;
310                 s->v3 = s->v3 >> 1;
311                 s->v2 = s->v2 >> 1;
312                 v1 = v1 >> 1;
313         }
314 }
315
316 static inline void goertzel_update(goertzel_state_t *s, short *samps, int count)
317 {
318         int i;
319         
320         for (i = 0; i < count; i++) {
321                 goertzel_sample(s, samps[i]);
322         }
323 }
324
325
326 static inline float goertzel_result(goertzel_state_t *s)
327 {
328         goertzel_result_t r;
329         r.value = (s->v3 * s->v3) + (s->v2 * s->v2);
330         r.value -= ((s->v2 * s->v3) >> 15) * s->fac;
331         r.power = s->chunky * 2;
332         return (float)r.value * (float)(1 << r.power);
333 }
334
335 static inline void goertzel_init(goertzel_state_t *s, float freq, int samples)
336 {
337         s->v2 = s->v3 = s->chunky = 0.0;
338         s->fac = (int)(32768.0 * 2.0 * cos(2.0 * M_PI * freq / SAMPLE_RATE));
339         s->samples = samples;
340 }
341
342 static inline void goertzel_reset(goertzel_state_t *s)
343 {
344         s->v2 = s->v3 = s->chunky = 0.0;
345 }
346
347 typedef struct {
348         int start;
349         int end;
350 } fragment_t;
351
352 /* Note on tone suppression (squelching). Individual detectors (DTMF/MF/generic tone)
353  * report fragmens of the frame in which detected tone resides and which needs
354  * to be "muted" in order to suppress the tone. To mark fragment for muting,
355  * detectors call mute_fragment passing fragment_t there. Multiple fragments
356  * can be marked and ast_dsp_process later will mute all of them.
357  *
358  * Note: When tone starts in the middle of a Goertzel block, it won't be properly
359  * detected in that block, only in the next. If we only mute the next block
360  * where tone is actually detected, the user will still hear beginning
361  * of the tone in preceeding block. This is why we usually want to mute some amount
362  * of samples preceeding and following the block where tone was detected.
363 */
364
365 struct ast_dsp {
366         struct ast_frame f;
367         int threshold;
368         int totalsilence;
369         int totalnoise;
370         int features;
371         int ringtimeout;
372         int busymaybe;
373         int busycount;
374         int busy_tonelength;
375         int busy_quietlength;
376         int historicnoise[DSP_HISTORY];
377         int historicsilence[DSP_HISTORY];
378         goertzel_state_t freqs[7];
379         int freqcount;
380         int gsamps;
381         enum gsamp_size gsamp_size;
382         enum prog_mode progmode;
383         int tstate;
384         int tcount;
385         int digitmode;
386         int faxmode;
387         int dtmf_began;
388         float genergy;
389         int mute_fragments;
390         fragment_t mute_data[5];
391         digit_detect_state_t digit_state;
392         tone_detect_state_t cng_tone_state;
393         tone_detect_state_t ced_tone_state;
394 };
395
396 static void mute_fragment(struct ast_dsp *dsp, fragment_t *fragment)
397 {
398         if (dsp->mute_fragments >= ARRAY_LEN(dsp->mute_data)) {
399                 ast_log(LOG_ERROR, "Too many fragments to mute. Ignoring\n");
400                 return;
401         }
402
403         dsp->mute_data[dsp->mute_fragments++] = *fragment;
404 }
405
406 static void ast_tone_detect_init(tone_detect_state_t *s, int freq, int duration, int amp)
407 {
408         int duration_samples;
409         float x;
410         int periods_in_block;
411
412         s->freq = freq;
413
414         /* Desired tone duration in samples */
415         duration_samples = duration * SAMPLE_RATE / 1000;
416         /* We want to allow 10% deviation of tone duration */
417         duration_samples = duration_samples * 9 / 10;
418
419         /* If we want to remove tone, it is important to have block size not
420            to exceed frame size. Otherwise by the moment tone is detected it is too late
421            to squelch it from previous frames */
422         s->block_size = SAMPLES_IN_FRAME;
423
424         periods_in_block = s->block_size * freq / SAMPLE_RATE;
425
426         /* Make sure we will have at least 5 periods at target frequency for analisys.
427            This may make block larger than expected packet and will make squelching impossible
428            but at least we will be detecting the tone */
429         if (periods_in_block < 5)
430                 periods_in_block = 5;
431
432         /* Now calculate final block size. It will contain integer number of periods */
433         s->block_size = periods_in_block * SAMPLE_RATE / freq;
434
435         /* tone_detect is currently only used to detect fax tones and we
436            do not need suqlching the fax tones */
437         s->squelch = 0;
438
439         /* Account for the first and the last block to be incomplete
440            and thus no tone will be detected in them */
441         s->hits_required = (duration_samples - (s->block_size - 1)) / s->block_size;
442
443         goertzel_init(&s->tone, freq, s->block_size);
444
445         s->samples_pending = s->block_size;
446         s->hit_count = 0;
447         s->last_hit = 0;
448         s->energy = 0.0;
449
450         /* We want tone energy to be amp decibels above the rest of the signal (the noise).
451            According to Parseval's theorem the energy computed in time domain equals to energy
452            computed in frequency domain. So subtracting energy in the frequency domain (Goertzel result)
453            from the energy in the time domain we will get energy of the remaining signal (without the tone
454            we are detecting). We will be checking that
455                 10*log(Ew / (Et - Ew)) > amp
456            Calculate threshold so that we will be actually checking
457                 Ew > Et * threshold
458         */
459
460         x = pow(10.0, amp / 10.0);
461         s->threshold = x / (x + 1);
462
463         ast_debug(1, "Setup tone %d Hz, %d ms, block_size=%d, hits_required=%d\n", freq, duration, s->block_size, s->hits_required);
464 }
465
466 static void ast_fax_detect_init(struct ast_dsp *s)
467 {
468         ast_tone_detect_init(&s->cng_tone_state, FAX_TONE_CNG_FREQ, FAX_TONE_CNG_DURATION, FAX_TONE_CNG_DB);
469         ast_tone_detect_init(&s->ced_tone_state, FAX_TONE_CED_FREQ, FAX_TONE_CED_DURATION, FAX_TONE_CED_DB);
470 }
471
472 static void ast_dtmf_detect_init (dtmf_detect_state_t *s)
473 {
474         int i;
475
476         s->lasthit = 0;
477         s->current_hit = 0;
478         for (i = 0;  i < 4;  i++) {
479                 goertzel_init(&s->row_out[i], dtmf_row[i], DTMF_GSIZE);
480                 goertzel_init(&s->col_out[i], dtmf_col[i], DTMF_GSIZE);
481                 s->energy = 0.0;
482         }
483         s->current_sample = 0;
484         s->hits = 0;
485         s->misses = 0;
486
487         s->hits_to_begin = DTMF_HITS_TO_BEGIN;
488         s->misses_to_end = DTMF_MISSES_TO_END;
489 }
490
491 static void ast_mf_detect_init (mf_detect_state_t *s)
492 {
493         int i;
494         s->hits[0] = s->hits[1] = s->hits[2] = s->hits[3] = s->hits[4] = 0;
495         for (i = 0;  i < 6;  i++) {
496                 goertzel_init (&s->tone_out[i], mf_tones[i], 160);
497         }
498         s->current_sample = 0;
499         s->current_hit = 0;
500 }
501
502 static void ast_digit_detect_init(digit_detect_state_t *s, int mf)
503 {
504         s->current_digits = 0;
505         s->detected_digits = 0;
506         s->lost_digits = 0;
507         s->digits[0] = '\0';
508
509         if (mf) {
510                 ast_mf_detect_init(&s->td.mf);
511         } else {
512                 ast_dtmf_detect_init(&s->td.dtmf);
513         }
514 }
515
516 static int tone_detect(struct ast_dsp *dsp, tone_detect_state_t *s, int16_t *amp, int samples)
517 {
518         float tone_energy;
519         int i;
520         int hit = 0;
521         int limit;
522         int res = 0;
523         int16_t *ptr;
524         int start, end;
525         fragment_t mute = {0, 0};
526
527         if (s->squelch && s->mute_samples > 0) {
528                 mute.end = (s->mute_samples < samples) ? s->mute_samples : samples;
529                 s->mute_samples -= mute.end;
530         }
531
532         for (start = 0;  start < samples;  start = end) {
533                 /* Process in blocks. */
534                 limit = samples - start;
535                 if (limit > s->samples_pending) {
536                         limit = s->samples_pending;
537                 }
538                 end = start + limit;
539
540                 for (i = limit, ptr = amp ; i > 0; i--, ptr++) {
541                         /* signed 32 bit int should be enough to suqare any possible signed 16 bit value */
542                         s->energy += (int32_t) *ptr * (int32_t) *ptr;
543
544                         goertzel_sample(&s->tone, *ptr);
545                 }
546
547                 s->samples_pending -= limit;
548
549                 if (s->samples_pending) {
550                         /* Finished incomplete (last) block */
551                         break;
552                 }
553
554                 tone_energy = goertzel_result(&s->tone);
555
556                 /* Scale to make comparable */
557                 tone_energy *= 2.0;
558                 s->energy *= s->block_size;
559
560                 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));
561                 hit = 0;
562                 if (tone_energy > s->energy * s->threshold) {
563                         ast_debug(10, "Hit! count=%d\n", s->hit_count);
564                         hit = 1;
565                 }
566
567                 if (s->hit_count) {
568                         s->hit_count++;
569                 }
570
571                 if (hit == s->last_hit) {
572                         if (!hit) {
573                                 /* Two successive misses. Tone ended */
574                                 s->hit_count = 0;
575                         } else if (!s->hit_count) {
576                                 s->hit_count++;
577                         }
578
579                 }
580
581                 if (s->hit_count == s->hits_required) {
582                         ast_debug(1, "%d Hz done detected\n", s->freq);
583                         res = 1;
584                 }
585
586                 s->last_hit = hit;
587
588                 /* If we had a hit in this block, include it into mute fragment */
589                 if (s->squelch && hit) {
590                         if (mute.end < start - s->block_size) {
591                                 /* There is a gap between fragments */
592                                 mute_fragment(dsp, &mute);
593                                 mute.start = (start > s->block_size) ? (start - s->block_size) : 0;
594                         }
595                         mute.end = end + s->block_size;
596                 }
597
598                 /* Reinitialise the detector for the next block */
599                 /* Reset for the next block */
600                 goertzel_reset(&s->tone);
601
602                 /* Advance to the next block */
603                 s->energy = 0.0;
604                 s->samples_pending = s->block_size;
605
606                 amp += limit;
607         }
608
609         if (s->squelch && mute.end) {
610                 if (mute.end > samples) {
611                         s->mute_samples = mute.end - samples;
612                         mute.end = samples;
613                 }
614                 mute_fragment(dsp, &mute);
615         }
616
617         return res;
618 }
619
620 static void store_digit(digit_detect_state_t *s, char digit)
621 {
622         s->detected_digits++;
623         if (s->current_digits < MAX_DTMF_DIGITS) {
624                 s->digits[s->current_digits++] = digit;
625                 s->digits[s->current_digits] = '\0';
626         } else {
627                 ast_log(LOG_WARNING, "Digit lost due to full buffer\n");
628                 s->lost_digits++;
629         }
630 }
631
632 static int dtmf_detect(struct ast_dsp *dsp, digit_detect_state_t *s, int16_t amp[], int samples, int squelch, int relax)
633 {
634         float row_energy[4];
635         float col_energy[4];
636         float famp;
637         int i;
638         int j;
639         int sample;
640         int best_row;
641         int best_col;
642         int hit;
643         int limit;
644         fragment_t mute = {0, 0};
645
646         if (squelch && s->td.dtmf.mute_samples > 0) {
647                 mute.end = (s->td.dtmf.mute_samples < samples) ? s->td.dtmf.mute_samples : samples;
648                 s->td.dtmf.mute_samples -= mute.end;
649         }
650
651         hit = 0;
652         for (sample = 0; sample < samples; sample = limit) {
653                 /* DTMF_GSIZE is optimised to meet the DTMF specs. */
654                 if ((samples - sample) >= (DTMF_GSIZE - s->td.dtmf.current_sample)) {
655                         limit = sample + (DTMF_GSIZE - s->td.dtmf.current_sample);
656                 } else {
657                         limit = samples;
658                 }
659                 /* The following unrolled loop takes only 35% (rough estimate) of the 
660                    time of a rolled loop on the machine on which it was developed */
661                 for (j = sample; j < limit; j++) {
662                         famp = amp[j];
663                         s->td.dtmf.energy += famp*famp;
664                         /* With GCC 2.95, the following unrolled code seems to take about 35%
665                            (rough estimate) as long as a neat little 0-3 loop */
666                         goertzel_sample(s->td.dtmf.row_out, amp[j]);
667                         goertzel_sample(s->td.dtmf.col_out, amp[j]);
668                         goertzel_sample(s->td.dtmf.row_out + 1, amp[j]);
669                         goertzel_sample(s->td.dtmf.col_out + 1, amp[j]);
670                         goertzel_sample(s->td.dtmf.row_out + 2, amp[j]);
671                         goertzel_sample(s->td.dtmf.col_out + 2, amp[j]);
672                         goertzel_sample(s->td.dtmf.row_out + 3, amp[j]);
673                         goertzel_sample(s->td.dtmf.col_out + 3, amp[j]);
674                 }
675                 s->td.dtmf.current_sample += (limit - sample);
676                 if (s->td.dtmf.current_sample < DTMF_GSIZE) {
677                         continue;
678                 }
679                 /* We are at the end of a DTMF detection block */
680                 /* Find the peak row and the peak column */
681                 row_energy[0] = goertzel_result (&s->td.dtmf.row_out[0]);
682                 col_energy[0] = goertzel_result (&s->td.dtmf.col_out[0]);
683
684                 for (best_row = best_col = 0, i = 1;  i < 4;  i++) {
685                         row_energy[i] = goertzel_result (&s->td.dtmf.row_out[i]);
686                         if (row_energy[i] > row_energy[best_row]) {
687                                 best_row = i;
688                         }
689                         col_energy[i] = goertzel_result (&s->td.dtmf.col_out[i]);
690                         if (col_energy[i] > col_energy[best_col]) {
691                                 best_col = i;
692                         }
693                 }
694                 hit = 0;
695                 /* Basic signal level test and the twist test */
696                 if (row_energy[best_row] >= DTMF_THRESHOLD && 
697                     col_energy[best_col] >= DTMF_THRESHOLD &&
698                     col_energy[best_col] < row_energy[best_row] * DTMF_REVERSE_TWIST &&
699                     col_energy[best_col] * DTMF_NORMAL_TWIST > row_energy[best_row]) {
700                         /* Relative peak test */
701                         for (i = 0;  i < 4;  i++) {
702                                 if ((i != best_col &&
703                                     col_energy[i] * DTMF_RELATIVE_PEAK_COL > col_energy[best_col]) ||
704                                     (i != best_row 
705                                      && row_energy[i] * DTMF_RELATIVE_PEAK_ROW > row_energy[best_row])) {
706                                         break;
707                                 }
708                         }
709                         /* ... and fraction of total energy test */
710                         if (i >= 4 &&
711                             (row_energy[best_row] + col_energy[best_col]) > DTMF_TO_TOTAL_ENERGY * s->td.dtmf.energy) {
712                                 /* Got a hit */
713                                 hit = dtmf_positions[(best_row << 2) + best_col];
714                         }
715                 } 
716
717                 if (s->td.dtmf.current_hit) {
718                         /* We are in the middle of a digit already */
719                         if (hit != s->td.dtmf.current_hit) {
720                                 s->td.dtmf.misses++;
721                                 if (s->td.dtmf.misses == s->td.dtmf.misses_to_end) {
722                                         /* There were enough misses to consider digit ended */
723                                         s->td.dtmf.current_hit = 0;
724                                 }
725                         } else {
726                                 s->td.dtmf.misses = 0;
727                         }
728                 }
729
730                 /* Look for a start of a new digit no matter if we are already in the middle of some
731                    digit or not. This is because hits_to_begin may be smaller than misses_to_end
732                    and we may find begin of new digit before we consider last one ended. */
733                 if (hit) {
734                         if (hit == s->td.dtmf.lasthit) {
735                                 s->td.dtmf.hits++;
736                         } else {
737                                 s->td.dtmf.hits = 1;
738                         }
739
740                         if (s->td.dtmf.hits == s->td.dtmf.hits_to_begin && hit != s->td.dtmf.current_hit) {
741                                 store_digit(s, hit);
742                                 s->td.dtmf.current_hit = hit;
743                                 s->td.dtmf.misses = 0;
744                         }
745                 } else {
746                         s->td.dtmf.hits = 0;
747                 }
748
749                 s->td.dtmf.lasthit = hit;
750
751                 /* If we had a hit in this block, include it into mute fragment */
752                 if (squelch && hit) {
753                         if (mute.end < sample - DTMF_GSIZE) {
754                                 /* There is a gap between fragments */
755                                 mute_fragment(dsp, &mute);
756                                 mute.start = (sample > DTMF_GSIZE) ? (sample - DTMF_GSIZE) : 0;
757                         }
758                         mute.end = limit + DTMF_GSIZE;
759                 }
760
761                 /* Reinitialise the detector for the next block */
762                 for (i = 0; i < 4; i++) {
763                         goertzel_reset(&s->td.dtmf.row_out[i]);
764                         goertzel_reset(&s->td.dtmf.col_out[i]);
765                 }
766                 s->td.dtmf.energy = 0.0;
767                 s->td.dtmf.current_sample = 0;
768         }
769
770         if (squelch && mute.end) {
771                 if (mute.end > samples) {
772                         s->td.dtmf.mute_samples = mute.end - samples;
773                         mute.end = samples;
774                 }
775                 mute_fragment(dsp, &mute);
776         }
777
778         return (s->td.dtmf.current_hit);        /* return the debounced hit */
779 }
780
781 static int mf_detect(struct ast_dsp *dsp, digit_detect_state_t *s, int16_t amp[],
782                  int samples, int squelch, int relax)
783 {
784         float energy[6];
785         int best;
786         int second_best;
787         float famp;
788         int i;
789         int j;
790         int sample;
791         int hit;
792         int limit;
793         fragment_t mute = {0, 0};
794
795         if (squelch && s->td.mf.mute_samples > 0) {
796                 mute.end = (s->td.mf.mute_samples < samples) ? s->td.mf.mute_samples : samples;
797                 s->td.mf.mute_samples -= mute.end;
798         }
799
800         hit = 0;
801         for (sample = 0;  sample < samples;  sample = limit) {
802                 /* 80 is optimised to meet the MF specs. */
803                 /* XXX So then why is MF_GSIZE defined as 120? */
804                 if ((samples - sample) >= (MF_GSIZE - s->td.mf.current_sample)) {
805                         limit = sample + (MF_GSIZE - s->td.mf.current_sample);
806                 } else {
807                         limit = samples;
808                 }
809                 /* The following unrolled loop takes only 35% (rough estimate) of the 
810                    time of a rolled loop on the machine on which it was developed */
811                 for (j = sample;  j < limit;  j++) {
812                         famp = amp[j];
813                         /* With GCC 2.95, the following unrolled code seems to take about 35%
814                            (rough estimate) as long as a neat little 0-3 loop */
815                         goertzel_sample(s->td.mf.tone_out, amp[j]);
816                         goertzel_sample(s->td.mf.tone_out + 1, amp[j]);
817                         goertzel_sample(s->td.mf.tone_out + 2, amp[j]);
818                         goertzel_sample(s->td.mf.tone_out + 3, amp[j]);
819                         goertzel_sample(s->td.mf.tone_out + 4, amp[j]);
820                         goertzel_sample(s->td.mf.tone_out + 5, amp[j]);
821                 }
822                 s->td.mf.current_sample += (limit - sample);
823                 if (s->td.mf.current_sample < MF_GSIZE) {
824                         continue;
825                 }
826                 /* We're at the end of an MF detection block.  */
827                 /* Find the two highest energies. The spec says to look for
828                    two tones and two tones only. Taking this literally -ie
829                    only two tones pass the minimum threshold - doesn't work
830                    well. The sinc function mess, due to rectangular windowing
831                    ensure that! Find the two highest energies and ensure they
832                    are considerably stronger than any of the others. */
833                 energy[0] = goertzel_result(&s->td.mf.tone_out[0]);
834                 energy[1] = goertzel_result(&s->td.mf.tone_out[1]);
835                 if (energy[0] > energy[1]) {
836                         best = 0;
837                         second_best = 1;
838                 } else {
839                         best = 1;
840                         second_best = 0;
841                 }
842                 /*endif*/
843                 for (i = 2; i < 6; i++) {
844                         energy[i] = goertzel_result(&s->td.mf.tone_out[i]);
845                         if (energy[i] >= energy[best]) {
846                                 second_best = best;
847                                 best = i;
848                         } else if (energy[i] >= energy[second_best]) {
849                                 second_best = i;
850                         }
851                 }
852                 /* Basic signal level and twist tests */
853                 hit = 0;
854                 if (energy[best] >= BELL_MF_THRESHOLD && energy[second_best] >= BELL_MF_THRESHOLD
855                     && energy[best] < energy[second_best]*BELL_MF_TWIST
856                     && energy[best] * BELL_MF_TWIST > energy[second_best]) {
857                         /* Relative peak test */
858                         hit = -1;
859                         for (i = 0; i < 6; i++) {
860                                 if (i != best && i != second_best) {
861                                         if (energy[i]*BELL_MF_RELATIVE_PEAK >= energy[second_best]) {
862                                                 /* The best two are not clearly the best */
863                                                 hit = 0;
864                                                 break;
865                                         }
866                                 }
867                         }
868                 }
869                 if (hit) {
870                         /* Get the values into ascending order */
871                         if (second_best < best) {
872                                 i = best;
873                                 best = second_best;
874                                 second_best = i;
875                         }
876                         best = best * 5 + second_best - 1;
877                         hit = bell_mf_positions[best];
878                         /* Look for two successive similar results */
879                         /* The logic in the next test is:
880                            For KP we need 4 successive identical clean detects, with
881                            two blocks of something different preceeding it. For anything
882                            else we need two successive identical clean detects, with
883                            two blocks of something different preceeding it. */
884                         if (hit == s->td.mf.hits[4] && hit == s->td.mf.hits[3] &&
885                            ((hit != '*' && hit != s->td.mf.hits[2] && hit != s->td.mf.hits[1])||
886                             (hit == '*' && hit == s->td.mf.hits[2] && hit != s->td.mf.hits[1] && 
887                             hit != s->td.mf.hits[0]))) {
888                                 store_digit(s, hit);
889                         }
890                 }
891
892
893                 if (hit != s->td.mf.hits[4] && hit != s->td.mf.hits[3]) {
894                         /* Two successive block without a hit terminate current digit */
895                         s->td.mf.current_hit = 0;
896                 }
897
898                 s->td.mf.hits[0] = s->td.mf.hits[1];
899                 s->td.mf.hits[1] = s->td.mf.hits[2];
900                 s->td.mf.hits[2] = s->td.mf.hits[3];
901                 s->td.mf.hits[3] = s->td.mf.hits[4];
902                 s->td.mf.hits[4] = hit;
903
904                 /* If we had a hit in this block, include it into mute fragment */
905                 if (squelch && hit) {
906                         if (mute.end < sample - MF_GSIZE) {
907                                 /* There is a gap between fragments */
908                                 mute_fragment(dsp, &mute);
909                                 mute.start = (sample > MF_GSIZE) ? (sample - MF_GSIZE) : 0;
910                         }
911                         mute.end = limit + DTMF_GSIZE;
912                 }
913
914                 /* Reinitialise the detector for the next block */
915                 for (i = 0;  i < 6;  i++)
916                         goertzel_reset(&s->td.mf.tone_out[i]);
917                 s->td.mf.current_sample = 0;
918         }
919
920         if (squelch && mute.end) {
921                 if (mute.end > samples) {
922                         s->td.mf.mute_samples = mute.end - samples;
923                         mute.end = samples;
924                 }
925                 mute_fragment(dsp, &mute);
926         }
927
928         return (s->td.mf.current_hit); /* return the debounced hit */
929 }
930
931 static inline int pair_there(float p1, float p2, float i1, float i2, float e)
932 {
933         /* See if p1 and p2 are there, relative to i1 and i2 and total energy */
934         /* Make sure absolute levels are high enough */
935         if ((p1 < TONE_MIN_THRESH) || (p2 < TONE_MIN_THRESH)) {
936                 return 0;
937         }
938         /* Amplify ignored stuff */
939         i2 *= TONE_THRESH;
940         i1 *= TONE_THRESH;
941         e *= TONE_THRESH;
942         /* Check first tone */
943         if ((p1 < i1) || (p1 < i2) || (p1 < e)) {
944                 return 0;
945         }
946         /* And second */
947         if ((p2 < i1) || (p2 < i2) || (p2 < e)) {
948                 return 0;
949         }
950         /* Guess it's there... */
951         return 1;
952 }
953
954 static int __ast_dsp_call_progress(struct ast_dsp *dsp, short *s, int len)
955 {
956         int x;
957         int y;
958         int pass;
959         int newstate = DSP_TONE_STATE_SILENCE;
960         int res = 0;
961         while (len) {
962                 /* Take the lesser of the number of samples we need and what we have */
963                 pass = len;
964                 if (pass > dsp->gsamp_size - dsp->gsamps) {
965                         pass = dsp->gsamp_size - dsp->gsamps;
966                 }
967                 for (x = 0; x < pass; x++) {
968                         for (y = 0; y < dsp->freqcount; y++) {
969                                 goertzel_sample(&dsp->freqs[y], s[x]);
970                         }
971                         dsp->genergy += s[x] * s[x];
972                 }
973                 s += pass;
974                 dsp->gsamps += pass;
975                 len -= pass;
976                 if (dsp->gsamps == dsp->gsamp_size) {
977                         float hz[7];
978                         for (y = 0; y < 7; y++) {
979                                 hz[y] = goertzel_result(&dsp->freqs[y]);
980                         }
981                         switch (dsp->progmode) {
982                         case PROG_MODE_NA:
983                                 if (pair_there(hz[HZ_480], hz[HZ_620], hz[HZ_350], hz[HZ_440], dsp->genergy)) {
984                                         newstate = DSP_TONE_STATE_BUSY;
985                                 } else if (pair_there(hz[HZ_440], hz[HZ_480], hz[HZ_350], hz[HZ_620], dsp->genergy)) {
986                                         newstate = DSP_TONE_STATE_RINGING;
987                                 } else if (pair_there(hz[HZ_350], hz[HZ_440], hz[HZ_480], hz[HZ_620], dsp->genergy)) {
988                                         newstate = DSP_TONE_STATE_DIALTONE;
989                                 } else if (hz[HZ_950] > TONE_MIN_THRESH * TONE_THRESH) {
990                                         newstate = DSP_TONE_STATE_SPECIAL1;
991                                 } else if (hz[HZ_1400] > TONE_MIN_THRESH * TONE_THRESH) {
992                                         if (dsp->tstate == DSP_TONE_STATE_SPECIAL1)
993                                                 newstate = DSP_TONE_STATE_SPECIAL2;
994                                 } else if (hz[HZ_1800] > TONE_MIN_THRESH * TONE_THRESH) {
995                                         if (dsp->tstate == DSP_TONE_STATE_SPECIAL2) {
996                                                 newstate = DSP_TONE_STATE_SPECIAL3;
997                                         }
998                                 } else if (dsp->genergy > TONE_MIN_THRESH * TONE_THRESH) {
999                                         newstate = DSP_TONE_STATE_TALKING;
1000                                 } else {
1001                                         newstate = DSP_TONE_STATE_SILENCE;
1002                                 }
1003                                 break;
1004                         case PROG_MODE_CR:
1005                                 if (hz[HZ_425] > TONE_MIN_THRESH * TONE_THRESH) {
1006                                         newstate = DSP_TONE_STATE_RINGING;
1007                                 } else if (dsp->genergy > TONE_MIN_THRESH * TONE_THRESH) {
1008                                         newstate = DSP_TONE_STATE_TALKING;
1009                                 } else {
1010                                         newstate = DSP_TONE_STATE_SILENCE;
1011                                 }
1012                                 break;
1013                         case PROG_MODE_UK:
1014                                 if (hz[HZ_400UK] > TONE_MIN_THRESH * TONE_THRESH) {
1015                                         newstate = DSP_TONE_STATE_HUNGUP;
1016                                 } else if (pair_there(hz[HZ_350UK], hz[HZ_440UK], hz[HZ_400UK], hz[HZ_400UK], dsp->genergy)) {
1017                                         newstate = DSP_TONE_STATE_DIALTONE;
1018                                 }
1019                                 break;
1020                         default:
1021                                 ast_log(LOG_WARNING, "Can't process in unknown prog mode '%d'\n", dsp->progmode);
1022                         }
1023                         if (newstate == dsp->tstate) {
1024                                 dsp->tcount++;
1025                                 if (dsp->ringtimeout) {
1026                                         dsp->ringtimeout++;
1027                                 }
1028                                 switch (dsp->tstate) {
1029                                         case DSP_TONE_STATE_RINGING:
1030                                                 if ((dsp->features & DSP_PROGRESS_RINGING) &&
1031                                                     (dsp->tcount==THRESH_RING)) {
1032                                                         res = AST_CONTROL_RINGING;
1033                                                         dsp->ringtimeout= 1;
1034                                                 }
1035                                                 break;
1036                                         case DSP_TONE_STATE_BUSY:
1037                                                 if ((dsp->features & DSP_PROGRESS_BUSY) &&
1038                                                     (dsp->tcount==THRESH_BUSY)) {
1039                                                         res = AST_CONTROL_BUSY;
1040                                                         dsp->features &= ~DSP_FEATURE_CALL_PROGRESS;
1041                                                 }
1042                                                 break;
1043                                         case DSP_TONE_STATE_TALKING:
1044                                                 if ((dsp->features & DSP_PROGRESS_TALK) &&
1045                                                     (dsp->tcount==THRESH_TALK)) {
1046                                                         res = AST_CONTROL_ANSWER;
1047                                                         dsp->features &= ~DSP_FEATURE_CALL_PROGRESS;
1048                                                 }
1049                                                 break;
1050                                         case DSP_TONE_STATE_SPECIAL3:
1051                                                 if ((dsp->features & DSP_PROGRESS_CONGESTION) &&
1052                                                     (dsp->tcount==THRESH_CONGESTION)) {
1053                                                         res = AST_CONTROL_CONGESTION;
1054                                                         dsp->features &= ~DSP_FEATURE_CALL_PROGRESS;
1055                                                 }
1056                                                 break;
1057                                         case DSP_TONE_STATE_HUNGUP:
1058                                                 if ((dsp->features & DSP_FEATURE_CALL_PROGRESS) &&
1059                                                     (dsp->tcount==THRESH_HANGUP)) {
1060                                                         res = AST_CONTROL_HANGUP;
1061                                                         dsp->features &= ~DSP_FEATURE_CALL_PROGRESS;
1062                                                 }
1063                                                 break;
1064                                 }
1065                                 if (dsp->ringtimeout==THRESH_RING2ANSWER) {
1066                                         ast_debug(1, "Consider call as answered because of timeout after last ring\n");
1067                                         res = AST_CONTROL_ANSWER;
1068                                         dsp->features &= ~DSP_FEATURE_CALL_PROGRESS;
1069                                 }
1070                         } else {
1071                                 ast_debug(5, "Stop state %d with duration %d\n", dsp->tstate, dsp->tcount);
1072                                 ast_debug(5, "Start state %d\n", newstate);
1073                                 dsp->tstate = newstate;
1074                                 dsp->tcount = 1;
1075                         }
1076                         
1077                         /* Reset goertzel */                                            
1078                         for (x = 0; x < 7; x++) {
1079                                 dsp->freqs[x].v2 = dsp->freqs[x].v3 = 0.0;
1080                         }
1081                         dsp->gsamps = 0;
1082                         dsp->genergy = 0.0;
1083                 }
1084         }
1085
1086         return res;
1087 }
1088
1089 int ast_dsp_call_progress(struct ast_dsp *dsp, struct ast_frame *inf)
1090 {
1091         if (inf->frametype != AST_FRAME_VOICE) {
1092                 ast_log(LOG_WARNING, "Can't check call progress of non-voice frames\n");
1093                 return 0;
1094         }
1095         if (inf->subclass != AST_FORMAT_SLINEAR) {
1096                 ast_log(LOG_WARNING, "Can only check call progress in signed-linear frames\n");
1097                 return 0;
1098         }
1099         return __ast_dsp_call_progress(dsp, inf->data.ptr, inf->datalen / 2);
1100 }
1101
1102 static int __ast_dsp_silence_noise(struct ast_dsp *dsp, short *s, int len, int *totalsilence, int *totalnoise)
1103 {
1104         int accum;
1105         int x;
1106         int res = 0;
1107
1108         if (!len) {
1109                 return 0;
1110         }
1111         accum = 0;
1112         for (x = 0; x < len; x++) {
1113                 accum += abs(s[x]);
1114         }
1115         accum /= len;
1116         if (accum < dsp->threshold) {
1117                 /* Silent */
1118                 dsp->totalsilence += len / 8;
1119                 if (dsp->totalnoise) {
1120                         /* Move and save history */
1121                         memmove(dsp->historicnoise + DSP_HISTORY - dsp->busycount, dsp->historicnoise + DSP_HISTORY - dsp->busycount + 1, dsp->busycount * sizeof(dsp->historicnoise[0]));
1122                         dsp->historicnoise[DSP_HISTORY - 1] = dsp->totalnoise;
1123 /* we don't want to check for busydetect that frequently */
1124 #if 0
1125                         dsp->busymaybe = 1;
1126 #endif
1127                 }
1128                 dsp->totalnoise = 0;
1129                 res = 1;
1130         } else {
1131                 /* Not silent */
1132                 dsp->totalnoise += len / 8;
1133                 if (dsp->totalsilence) {
1134                         int silence1 = dsp->historicsilence[DSP_HISTORY - 1];
1135                         int silence2 = dsp->historicsilence[DSP_HISTORY - 2];
1136                         /* Move and save history */
1137                         memmove(dsp->historicsilence + DSP_HISTORY - dsp->busycount, dsp->historicsilence + DSP_HISTORY - dsp->busycount + 1, dsp->busycount * sizeof(dsp->historicsilence[0]));
1138                         dsp->historicsilence[DSP_HISTORY - 1] = dsp->totalsilence;
1139                         /* check if the previous sample differs only by BUSY_PERCENT from the one before it */
1140                         if (silence1 < silence2) {
1141                                 if (silence1 + silence1 * BUSY_PERCENT / 100 >= silence2) {
1142                                         dsp->busymaybe = 1;
1143                                 } else {
1144                                         dsp->busymaybe = 0;
1145                                 }
1146                         } else {
1147                                 if (silence1 - silence1 * BUSY_PERCENT / 100 <= silence2) {
1148                                         dsp->busymaybe = 1;
1149                                 } else {
1150                                         dsp->busymaybe = 0;
1151                                 }
1152                         }
1153                 }
1154                 dsp->totalsilence = 0;
1155         }
1156         if (totalsilence) {
1157                 *totalsilence = dsp->totalsilence;
1158         }
1159         if (totalnoise) {
1160                 *totalnoise = dsp->totalnoise;
1161         }
1162         return res;
1163 }
1164
1165 int ast_dsp_busydetect(struct ast_dsp *dsp)
1166 {
1167         int res = 0, x;
1168 #ifndef BUSYDETECT_TONEONLY
1169         int avgsilence = 0, hitsilence = 0;
1170 #endif
1171         int avgtone = 0, hittone = 0;
1172         if (!dsp->busymaybe) {
1173                 return res;
1174         }
1175         for (x = DSP_HISTORY - dsp->busycount; x < DSP_HISTORY; x++) {
1176 #ifndef BUSYDETECT_TONEONLY
1177                 avgsilence += dsp->historicsilence[x];
1178 #endif
1179                 avgtone += dsp->historicnoise[x];
1180         }
1181 #ifndef BUSYDETECT_TONEONLY
1182         avgsilence /= dsp->busycount;
1183 #endif
1184         avgtone /= dsp->busycount;
1185         for (x = DSP_HISTORY - dsp->busycount; x < DSP_HISTORY; x++) {
1186 #ifndef BUSYDETECT_TONEONLY
1187                 if (avgsilence > dsp->historicsilence[x]) {
1188                         if (avgsilence - (avgsilence * BUSY_PERCENT / 100) <= dsp->historicsilence[x]) {
1189                                 hitsilence++;
1190                         }
1191                 } else {
1192                         if (avgsilence + (avgsilence * BUSY_PERCENT / 100) >= dsp->historicsilence[x]) {
1193                                 hitsilence++;
1194                         }
1195                 }
1196 #endif
1197                 if (avgtone > dsp->historicnoise[x]) {
1198                         if (avgtone - (avgtone * BUSY_PERCENT / 100) <= dsp->historicnoise[x]) {
1199                                 hittone++;
1200                         }
1201                 } else {
1202                         if (avgtone + (avgtone * BUSY_PERCENT / 100) >= dsp->historicnoise[x]) {
1203                                 hittone++;
1204                         }
1205                 }
1206         }
1207 #ifndef BUSYDETECT_TONEONLY
1208         if ((hittone >= dsp->busycount - 1) && (hitsilence >= dsp->busycount - 1) && 
1209             (avgtone >= BUSY_MIN && avgtone <= BUSY_MAX) && 
1210             (avgsilence >= BUSY_MIN && avgsilence <= BUSY_MAX)) {
1211 #else
1212         if ((hittone >= dsp->busycount - 1) && (avgtone >= BUSY_MIN && avgtone <= BUSY_MAX)) {
1213 #endif
1214 #ifdef BUSYDETECT_COMPARE_TONE_AND_SILENCE
1215                 if (avgtone > avgsilence) {
1216                         if (avgtone - avgtone*BUSY_PERCENT/100 <= avgsilence) {
1217                                 res = 1;
1218                         }
1219                 } else {
1220                         if (avgtone + avgtone*BUSY_PERCENT/100 >= avgsilence) {
1221                                 res = 1;
1222                         }
1223                 }
1224 #else
1225                 res = 1;
1226 #endif
1227         }
1228         /* If we know the expected busy tone length, check we are in the range */
1229         if (res && (dsp->busy_tonelength > 0)) {
1230                 if (abs(avgtone - dsp->busy_tonelength) > (dsp->busy_tonelength*BUSY_PAT_PERCENT/100)) {
1231 #ifdef BUSYDETECT_DEBUG
1232                         ast_debug(5, "busy detector: avgtone of %d not close enough to desired %d\n",
1233                                 avgtone, dsp->busy_tonelength);
1234 #endif
1235                         res = 0;
1236                 }
1237         }
1238 #ifndef BUSYDETECT_TONEONLY
1239         /* If we know the expected busy tone silent-period length, check we are in the range */
1240         if (res && (dsp->busy_quietlength > 0)) {
1241                 if (abs(avgsilence - dsp->busy_quietlength) > (dsp->busy_quietlength*BUSY_PAT_PERCENT/100)) {
1242 #ifdef BUSYDETECT_DEBUG
1243                 ast_debug(5, "busy detector: avgsilence of %d not close enough to desired %d\n",
1244                         avgsilence, dsp->busy_quietlength);
1245 #endif
1246                         res = 0;
1247                 }
1248         }
1249 #endif
1250 #if !defined(BUSYDETECT_TONEONLY) && defined(BUSYDETECT_DEBUG)
1251         if (res) {
1252                 ast_debug(5, "ast_dsp_busydetect detected busy, avgtone: %d, avgsilence %d\n", avgtone, avgsilence);
1253         } else {
1254                 ast_debug(5, "busy detector: FAILED with avgtone: %d, avgsilence %d\n", avgtone, avgsilence);
1255         }
1256 #endif
1257         return res;
1258 }
1259
1260 int ast_dsp_silence(struct ast_dsp *dsp, struct ast_frame *f, int *totalsilence)
1261 {
1262         short *s;
1263         int len;
1264         
1265         if (f->frametype != AST_FRAME_VOICE) {
1266                 ast_log(LOG_WARNING, "Can't calculate silence on a non-voice frame\n");
1267                 return 0;
1268         }
1269         if (f->subclass != AST_FORMAT_SLINEAR) {
1270                 ast_log(LOG_WARNING, "Can only calculate silence on signed-linear frames :(\n");
1271                 return 0;
1272         }
1273         s = f->data.ptr;
1274         len = f->datalen/2;
1275         return __ast_dsp_silence_noise(dsp, s, len, totalsilence, NULL);
1276 }
1277
1278 int ast_dsp_noise(struct ast_dsp *dsp, struct ast_frame *f, int *totalnoise)
1279 {
1280        short *s;
1281        int len;
1282
1283        if (f->frametype != AST_FRAME_VOICE) {
1284                ast_log(LOG_WARNING, "Can't calculate noise on a non-voice frame\n");
1285                return 0;
1286        }
1287        if (f->subclass != AST_FORMAT_SLINEAR) {
1288                ast_log(LOG_WARNING, "Can only calculate noise on signed-linear frames :(\n");
1289                return 0;
1290        }
1291        s = f->data.ptr;
1292        len = f->datalen/2;
1293        return __ast_dsp_silence_noise(dsp, s, len, NULL, totalnoise);
1294 }
1295
1296
1297 struct ast_frame *ast_dsp_process(struct ast_channel *chan, struct ast_dsp *dsp, struct ast_frame *af)
1298 {
1299         int silence;
1300         int res;
1301         int digit = 0, fax_digit = 0;
1302         int x;
1303         short *shortdata;
1304         unsigned char *odata;
1305         int len;
1306         struct ast_frame *outf = NULL;
1307
1308         if (!af) {
1309                 return NULL;
1310         }
1311         if (af->frametype != AST_FRAME_VOICE) {
1312                 return af;
1313         }
1314
1315         odata = af->data.ptr;
1316         len = af->datalen;
1317         /* Make sure we have short data */
1318         switch (af->subclass) {
1319         case AST_FORMAT_SLINEAR:
1320                 shortdata = af->data.ptr;
1321                 len = af->datalen / 2;
1322                 break;
1323         case AST_FORMAT_ULAW:
1324                 shortdata = alloca(af->datalen * 2);
1325                 for (x = 0;x < len; x++) {
1326                         shortdata[x] = AST_MULAW(odata[x]);
1327                 }
1328                 break;
1329         case AST_FORMAT_ALAW:
1330                 shortdata = alloca(af->datalen * 2);
1331                 for (x = 0; x < len; x++) {
1332                         shortdata[x] = AST_ALAW(odata[x]);
1333                 }
1334                 break;
1335         default:
1336                 ast_log(LOG_WARNING, "Inband DTMF is not supported on codec %s. Use RFC2833\n", ast_getformatname(af->subclass));
1337                 return af;
1338         }
1339
1340         /* Initially we do not want to mute anything */
1341         dsp->mute_fragments = 0;
1342
1343         /* Need to run the silence detection stuff for silence suppression and busy detection */
1344         if ((dsp->features & DSP_FEATURE_SILENCE_SUPPRESS) || (dsp->features & DSP_FEATURE_BUSY_DETECT)) {
1345                 res = __ast_dsp_silence_noise(dsp, shortdata, len, &silence, NULL);
1346         }
1347
1348         if ((dsp->features & DSP_FEATURE_SILENCE_SUPPRESS) && silence) {
1349                 memset(&dsp->f, 0, sizeof(dsp->f));
1350                 dsp->f.frametype = AST_FRAME_NULL;
1351                 ast_frfree(af);
1352                 return ast_frisolate(&dsp->f);
1353         }
1354         if ((dsp->features & DSP_FEATURE_BUSY_DETECT) && ast_dsp_busydetect(dsp)) {
1355                 chan->_softhangup |= AST_SOFTHANGUP_DEV;
1356                 memset(&dsp->f, 0, sizeof(dsp->f));
1357                 dsp->f.frametype = AST_FRAME_CONTROL;
1358                 dsp->f.subclass = AST_CONTROL_BUSY;
1359                 ast_frfree(af);
1360                 ast_debug(1, "Requesting Hangup because the busy tone was detected on channel %s\n", chan->name);
1361                 return ast_frisolate(&dsp->f);
1362         }
1363
1364         if ((dsp->features & DSP_FEATURE_FAX_DETECT)) {
1365                 if ((dsp->faxmode & DSP_FAXMODE_DETECT_CNG) && tone_detect(dsp, &dsp->cng_tone_state, shortdata, len)) {
1366                         fax_digit = 'f';
1367                 }
1368
1369                 if ((dsp->faxmode & DSP_FAXMODE_DETECT_CED) && tone_detect(dsp, &dsp->ced_tone_state, shortdata, len)) {
1370                         fax_digit = 'e';
1371                 }
1372         }
1373
1374         if ((dsp->features & DSP_FEATURE_DIGIT_DETECT)) {
1375                 if ((dsp->digitmode & DSP_DIGITMODE_MF))
1376                         digit = mf_detect(dsp, &dsp->digit_state, shortdata, len, (dsp->digitmode & DSP_DIGITMODE_NOQUELCH) == 0, (dsp->digitmode & DSP_DIGITMODE_RELAXDTMF));
1377                 else
1378                         digit = dtmf_detect(dsp, &dsp->digit_state, shortdata, len, (dsp->digitmode & DSP_DIGITMODE_NOQUELCH) == 0, (dsp->digitmode & DSP_DIGITMODE_RELAXDTMF));
1379
1380                 if (dsp->digit_state.current_digits) {
1381                         int event = 0;
1382                         char event_digit = 0;
1383
1384                         if (!dsp->dtmf_began) {
1385                                 /* We have not reported DTMF_BEGIN for anything yet */
1386
1387                                 event = AST_FRAME_DTMF_BEGIN;
1388                                 event_digit = dsp->digit_state.digits[0];
1389                                 dsp->dtmf_began = 1;
1390
1391                         } else if (dsp->digit_state.current_digits > 1 || digit != dsp->digit_state.digits[0]) {
1392                                 /* Digit changed. This means digit we have reported with DTMF_BEGIN ended */
1393         
1394                                 event = AST_FRAME_DTMF_END;
1395                                 event_digit = dsp->digit_state.digits[0];
1396                                 memmove(dsp->digit_state.digits, dsp->digit_state.digits + 1, dsp->digit_state.current_digits);
1397                                 dsp->digit_state.current_digits--;
1398                                 dsp->dtmf_began = 0;
1399                         }
1400
1401                         if (event) {
1402                                 memset(&dsp->f, 0, sizeof(dsp->f));
1403                                 dsp->f.frametype = event;
1404                                 dsp->f.subclass = event_digit;
1405                                 outf = &dsp->f;
1406                                 goto done;
1407                         }
1408                 }
1409         }
1410
1411         if (fax_digit) {
1412                 /* Fax was detected - digit is either 'f' or 'e' */
1413
1414                 memset(&dsp->f, 0, sizeof(dsp->f));
1415                 dsp->f.frametype = AST_FRAME_DTMF;
1416                 dsp->f.subclass = fax_digit;
1417                 outf = &dsp->f;
1418                 goto done;
1419         }
1420
1421         if ((dsp->features & DSP_FEATURE_CALL_PROGRESS)) {
1422                 res = __ast_dsp_call_progress(dsp, shortdata, len);
1423                 if (res) {
1424                         switch (res) {
1425                         case AST_CONTROL_ANSWER:
1426                         case AST_CONTROL_BUSY:
1427                         case AST_CONTROL_RINGING:
1428                         case AST_CONTROL_CONGESTION:
1429                         case AST_CONTROL_HANGUP:
1430                                 memset(&dsp->f, 0, sizeof(dsp->f));
1431                                 dsp->f.frametype = AST_FRAME_CONTROL;
1432                                 dsp->f.subclass = res;
1433                                 dsp->f.src = "dsp_progress";
1434                                 if (chan) 
1435                                         ast_queue_frame(chan, &dsp->f);
1436                                 break;
1437                         default:
1438                                 ast_log(LOG_WARNING, "Don't know how to represent call progress message %d\n", res);
1439                         }
1440                 }
1441         } else if ((dsp->features & DSP_FEATURE_WAITDIALTONE)) {
1442                 res = __ast_dsp_call_progress(dsp, shortdata, len);
1443         }
1444
1445 done:
1446         /* Mute fragment of the frame */
1447         for (x = 0; x < dsp->mute_fragments; x++) {
1448                 memset(shortdata + dsp->mute_data[x].start, 0, sizeof(int16_t) * (dsp->mute_data[x].end - dsp->mute_data[x].start));
1449         }
1450
1451         switch (af->subclass) {
1452         case AST_FORMAT_SLINEAR:
1453                 break;
1454         case AST_FORMAT_ULAW:
1455                 for (x = 0; x < len; x++) {
1456                         odata[x] = AST_LIN2MU((unsigned short) shortdata[x]);
1457                 }
1458                 break;
1459         case AST_FORMAT_ALAW:
1460                 for (x = 0; x < len; x++) {
1461                         odata[x] = AST_LIN2A((unsigned short) shortdata[x]);
1462                 }
1463                 break;
1464         }
1465
1466         if (outf) {
1467                 if (chan) {
1468                         ast_queue_frame(chan, af);
1469                 }
1470                 ast_frfree(af);
1471                 return ast_frisolate(outf);
1472         } else {
1473                 return af;
1474         }
1475 }
1476
1477 static void ast_dsp_prog_reset(struct ast_dsp *dsp)
1478 {
1479         int max = 0;
1480         int x;
1481         
1482         dsp->gsamp_size = modes[dsp->progmode].size;
1483         dsp->gsamps = 0;
1484         for (x = 0; x < ARRAY_LEN(modes[dsp->progmode].freqs); x++) {
1485                 if (modes[dsp->progmode].freqs[x]) {
1486                         goertzel_init(&dsp->freqs[x], (float)modes[dsp->progmode].freqs[x], dsp->gsamp_size);
1487                         max = x + 1;
1488                 }
1489         }
1490         dsp->freqcount = max;
1491         dsp->ringtimeout= 0;
1492 }
1493
1494 struct ast_dsp *ast_dsp_new(void)
1495 {
1496         struct ast_dsp *dsp;
1497         
1498         if ((dsp = ast_calloc(1, sizeof(*dsp)))) {              
1499                 dsp->threshold = DEFAULT_THRESHOLD;
1500                 dsp->features = DSP_FEATURE_SILENCE_SUPPRESS;
1501                 dsp->busycount = DSP_HISTORY;
1502                 dsp->digitmode = DSP_DIGITMODE_DTMF;
1503                 dsp->faxmode = DSP_FAXMODE_DETECT_CNG;
1504                 /* Initialize digit detector */
1505                 ast_digit_detect_init(&dsp->digit_state, dsp->digitmode & DSP_DIGITMODE_MF);
1506                 /* Initialize initial DSP progress detect parameters */
1507                 ast_dsp_prog_reset(dsp);
1508                 /* Initialize fax detector */
1509                 ast_fax_detect_init(dsp);
1510         }
1511         return dsp;
1512 }
1513
1514 void ast_dsp_set_features(struct ast_dsp *dsp, int features)
1515 {
1516         dsp->features = features;
1517 }
1518
1519 void ast_dsp_free(struct ast_dsp *dsp)
1520 {
1521         ast_free(dsp);
1522 }
1523
1524 void ast_dsp_set_threshold(struct ast_dsp *dsp, int threshold)
1525 {
1526         dsp->threshold = threshold;
1527 }
1528
1529 void ast_dsp_set_busy_count(struct ast_dsp *dsp, int cadences)
1530 {
1531         if (cadences < 4) {
1532                 cadences = 4;
1533         }
1534         if (cadences > DSP_HISTORY) {
1535                 cadences = DSP_HISTORY;
1536         }
1537         dsp->busycount = cadences;
1538 }
1539
1540 void ast_dsp_set_busy_pattern(struct ast_dsp *dsp, int tonelength, int quietlength)
1541 {
1542         dsp->busy_tonelength = tonelength;
1543         dsp->busy_quietlength = quietlength;
1544         ast_debug(1, "dsp busy pattern set to %d,%d\n", tonelength, quietlength);
1545 }
1546
1547 void ast_dsp_digitreset(struct ast_dsp *dsp)
1548 {
1549         int i;
1550         
1551         dsp->dtmf_began = 0;
1552         if (dsp->digitmode & DSP_DIGITMODE_MF) {
1553                 mf_detect_state_t *s = &dsp->digit_state.td.mf;
1554                 /* Reinitialise the detector for the next block */
1555                 for (i = 0;  i < 6;  i++) {
1556                         goertzel_reset(&s->tone_out[i]);
1557                 }
1558                 s->hits[4] = s->hits[3] = s->hits[2] = s->hits[1] = s->hits[0] = s->current_hit = 0;
1559                 s->current_sample = 0;
1560         } else {
1561                 dtmf_detect_state_t *s = &dsp->digit_state.td.dtmf;
1562                 /* Reinitialise the detector for the next block */
1563                 for (i = 0;  i < 4;  i++) {
1564                         goertzel_reset(&s->row_out[i]);
1565                         goertzel_reset(&s->col_out[i]);
1566                 }
1567                 s->lasthit = s->current_hit = 0;
1568                 s->energy = 0.0;
1569                 s->current_sample = 0;
1570                 s->hits = 0;
1571                 s->misses = 0;
1572         }
1573
1574         dsp->digit_state.digits[0] = '\0';
1575         dsp->digit_state.current_digits = 0;
1576 }
1577
1578 void ast_dsp_reset(struct ast_dsp *dsp)
1579 {
1580         int x;
1581         
1582         dsp->totalsilence = 0;
1583         dsp->gsamps = 0;
1584         for (x = 0; x < 4; x++) {
1585                 dsp->freqs[x].v2 = dsp->freqs[x].v3 = 0.0;
1586         }
1587         memset(dsp->historicsilence, 0, sizeof(dsp->historicsilence));
1588         memset(dsp->historicnoise, 0, sizeof(dsp->historicnoise));      
1589         dsp->ringtimeout= 0;
1590 }
1591
1592 int ast_dsp_set_digitmode(struct ast_dsp *dsp, int digitmode)
1593 {
1594         int new;
1595         int old;
1596         
1597         old = dsp->digitmode & (DSP_DIGITMODE_DTMF | DSP_DIGITMODE_MF | DSP_DIGITMODE_MUTECONF | DSP_DIGITMODE_MUTEMAX);
1598         new = digitmode & (DSP_DIGITMODE_DTMF | DSP_DIGITMODE_MF | DSP_DIGITMODE_MUTECONF | DSP_DIGITMODE_MUTEMAX);
1599         if (old != new) {
1600                 /* Must initialize structures if switching from MF to DTMF or vice-versa */
1601                 ast_digit_detect_init(&dsp->digit_state, new & DSP_DIGITMODE_MF);
1602         }
1603         dsp->digitmode = digitmode;
1604         return 0;
1605 }
1606
1607 int ast_dsp_set_faxmode(struct ast_dsp *dsp, int faxmode)
1608 {
1609         if (dsp->faxmode != faxmode) {
1610                 ast_fax_detect_init(dsp);
1611         }
1612         dsp->faxmode = faxmode;
1613         return 0;
1614 }
1615
1616 int ast_dsp_set_call_progress_zone(struct ast_dsp *dsp, char *zone)
1617 {
1618         int x;
1619         
1620         for (x = 0; x < ARRAY_LEN(aliases); x++) {
1621                 if (!strcasecmp(aliases[x].name, zone)) {
1622                         dsp->progmode = aliases[x].mode;
1623                         ast_dsp_prog_reset(dsp);
1624                         return 0;
1625                 }
1626         }
1627         return -1;
1628 }
1629
1630 int ast_dsp_was_muted(struct ast_dsp *dsp)
1631 {
1632         return (dsp->mute_fragments > 0);
1633 }
1634
1635 int ast_dsp_get_tstate(struct ast_dsp *dsp) 
1636 {
1637         return dsp->tstate;
1638 }
1639
1640 int ast_dsp_get_tcount(struct ast_dsp *dsp) 
1641 {
1642         return dsp->tcount;
1643 }
1644
1645 static int _dsp_init(int reload)
1646 {
1647         struct ast_flags config_flags = { reload ? CONFIG_FLAG_FILEUNCHANGED : 0 };
1648         struct ast_config *cfg;
1649
1650         cfg = ast_config_load2(CONFIG_FILE_NAME, "dsp", config_flags);
1651         if (cfg == CONFIG_STATUS_FILEMISSING || cfg == CONFIG_STATUS_FILEUNCHANGED || cfg == CONFIG_STATUS_FILEINVALID) {
1652                 return 0;
1653         }
1654
1655         if (cfg && cfg != CONFIG_STATUS_FILEUNCHANGED) {
1656                 const char *value;
1657
1658                 value = ast_variable_retrieve(cfg, "default", "silencethreshold");
1659                 if (value && sscanf(value, "%30d", &thresholds[THRESHOLD_SILENCE]) != 1) {
1660                         ast_log(LOG_WARNING, "%s: '%s' is not a valid silencethreshold value\n", CONFIG_FILE_NAME, value);
1661                         thresholds[THRESHOLD_SILENCE] = 256;
1662                 } else if (!value) {
1663                         thresholds[THRESHOLD_SILENCE] = 256;
1664                 }
1665
1666                 ast_config_destroy(cfg);
1667         }
1668         return 0;
1669 }
1670
1671 int ast_dsp_get_threshold_from_settings(enum threshold which)
1672 {
1673         return thresholds[which];
1674 }
1675
1676 int ast_dsp_init(void)
1677 {
1678         return _dsp_init(0);
1679 }
1680
1681 int ast_dsp_reload(void)
1682 {
1683         return _dsp_init(1);
1684 }
1685