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