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