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