Merge "res_calendar: Specialized calendars depend on symbols of general calendar."
[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 /*! \li \ref dsp.c uses the configuration file \ref dsp.conf
31  * \addtogroup configuration_file Configuration Files
32  */
33
34 /*!
35  * \page dsp.conf dsp.conf
36  * \verbinclude dsp.conf.sample
37  */
38
39 /* Some routines from tone_detect.c by Steven Underwood as published under the zapata library */
40 /*
41         tone_detect.c - General telephony tone detection, and specific
42                                         detection of DTMF.
43
44         Copyright (C) 2001  Steve Underwood <steveu@coppice.org>
45
46         Despite my general liking of the GPL, I place this code in the
47         public domain for the benefit of all mankind - even the slimy
48         ones who might try to proprietize my work and use it to my
49         detriment.
50 */
51
52 /*** MODULEINFO
53         <support_level>core</support_level>
54  ***/
55
56 #include "asterisk.h"
57
58 #include <math.h>
59
60 #include "asterisk/frame.h"
61 #include "asterisk/format_cache.h"
62 #include "asterisk/channel.h"
63 #include "asterisk/dsp.h"
64 #include "asterisk/ulaw.h"
65 #include "asterisk/alaw.h"
66 #include "asterisk/utils.h"
67 #include "asterisk/options.h"
68 #include "asterisk/config.h"
69 #include "asterisk/test.h"
70
71 /*! Number of goertzels for progress detect */
72 enum gsamp_size {
73         GSAMP_SIZE_NA = 183,                    /*!< North America - 350, 440, 480, 620, 950, 1400, 1800 Hz */
74         GSAMP_SIZE_CR = 188,                    /*!< Costa Rica, Brazil - Only care about 425 Hz */
75         GSAMP_SIZE_UK = 160                     /*!< UK disconnect goertzel feed - should trigger 400hz */
76 };
77
78 enum prog_mode {
79         PROG_MODE_NA = 0,
80         PROG_MODE_CR,
81         PROG_MODE_UK
82 };
83
84 enum freq_index {
85         /*! For US modes { */
86         HZ_350 = 0,
87         HZ_440,
88         HZ_480,
89         HZ_620,
90         HZ_950,
91         HZ_1400,
92         HZ_1800, /*!< } */
93
94         /*! For CR/BR modes */
95         HZ_425 = 0,
96
97         /*! For UK mode */
98         HZ_350UK = 0,
99         HZ_400UK,
100         HZ_440UK
101 };
102
103 static struct progalias {
104         char *name;
105         enum prog_mode mode;
106 } aliases[] = {
107         { "us", PROG_MODE_NA },
108         { "ca", PROG_MODE_NA },
109         { "cr", PROG_MODE_CR },
110         { "br", PROG_MODE_CR },
111         { "uk", PROG_MODE_UK },
112 };
113
114 #define FREQ_ARRAY_SIZE 7
115
116 static struct progress {
117         enum gsamp_size size;
118         int freqs[FREQ_ARRAY_SIZE];
119 } modes[] = {
120         { GSAMP_SIZE_NA, { 350, 440, 480, 620, 950, 1400, 1800 } },     /*!< North America */
121         { GSAMP_SIZE_CR, { 425 } },                                     /*!< Costa Rica, Brazil */
122         { GSAMP_SIZE_UK, { 350, 400, 440 } },                           /*!< UK */
123 };
124
125 /*!
126  * \brief Default minimum average magnitude threshold to determine talking/noise by the DSP.
127  *
128  * \details
129  * The magnitude calculated for this threshold is determined by
130  * averaging the absolute value of all samples within a frame.
131  *
132  * This value is the threshold for which a frame's average magnitude
133  * is determined to either be silence (below the threshold) or
134  * noise/talking (at or above the threshold).  Please note that while
135  * the default threshold is an even exponent of 2, there is no
136  * requirement that it be so.  The threshold will work for any value
137  * between 1 and 2^15.
138  */
139 #define DEFAULT_THRESHOLD       512
140
141 enum busy_detect {
142         BUSY_PERCENT = 10,      /*!< The percentage difference between the two last silence periods */
143         BUSY_PAT_PERCENT = 7,   /*!< The percentage difference between measured and actual pattern */
144         BUSY_THRESHOLD = 100,   /*!< Max number of ms difference between max and min times in busy */
145         BUSY_MIN = 75,          /*!< Busy must be at least 80 ms in half-cadence */
146         BUSY_MAX = 3100         /*!< Busy can't be longer than 3100 ms in half-cadence */
147 };
148
149 /*! Remember last 15 units */
150 #define DSP_HISTORY             15
151
152 #define TONE_THRESH             10.0    /*!< How much louder the tone should be than channel energy */
153 #define TONE_MIN_THRESH         1e8     /*!< How much tone there should be at least to attempt */
154
155 /*! All THRESH_XXX values are in GSAMP_SIZE chunks (us = 22ms) */
156 enum gsamp_thresh {
157         THRESH_RING = 8,                /*!< Need at least 150ms ring to accept */
158         THRESH_TALK = 2,                /*!< Talk detection does not work continuously */
159         THRESH_BUSY = 4,                /*!< Need at least 80ms to accept */
160         THRESH_CONGESTION = 4,          /*!< Need at least 80ms to accept */
161         THRESH_HANGUP = 60,             /*!< Need at least 1300ms to accept hangup */
162         THRESH_RING2ANSWER = 300        /*!< Timeout from start of ring to answer (about 6600 ms) */
163 };
164
165 #define MAX_DTMF_DIGITS         128
166
167 /* Basic DTMF (AT&T) specs:
168  *
169  * Minimum tone on = 40ms
170  * Minimum tone off = 50ms
171  * Maximum digit rate = 10 per second
172  * Normal twist <= 8dB accepted
173  * Reverse twist <= 4dB accepted
174  * S/N >= 15dB will detect OK
175  * Attenuation <= 26dB will detect OK
176  * Frequency tolerance +- 1.5% will detect, +-3.5% will reject
177  */
178
179 #define DTMF_THRESHOLD          8.0e7
180 #define TONE_THRESHOLD          7.8e7
181
182 #define DEF_DTMF_NORMAL_TWIST           6.31     /* 8.0dB */
183 #define DEF_RELAX_DTMF_NORMAL_TWIST     6.31     /* 8.0dB */
184
185 #ifdef  RADIO_RELAX
186 #define DEF_DTMF_REVERSE_TWIST          2.51     /* 4.01dB */
187 #define DEF_RELAX_DTMF_REVERSE_TWIST    6.61     /* 8.2dB */
188 #else
189 #define DEF_DTMF_REVERSE_TWIST          2.51     /* 4.01dB */
190 #define DEF_RELAX_DTMF_REVERSE_TWIST    3.98     /* 6.0dB */
191 #endif
192
193 #define DTMF_RELATIVE_PEAK_ROW  6.3     /* 8dB */
194 #define DTMF_RELATIVE_PEAK_COL  6.3     /* 8dB */
195 #define DTMF_TO_TOTAL_ENERGY    42.0
196
197 #define BELL_MF_THRESHOLD       1.6e9
198 #define BELL_MF_TWIST           4.0     /* 6dB */
199 #define BELL_MF_RELATIVE_PEAK   12.6    /* 11dB */
200
201 #if defined(BUSYDETECT_TONEONLY) && defined(BUSYDETECT_COMPARE_TONE_AND_SILENCE)
202 #error You cant use BUSYDETECT_TONEONLY together with BUSYDETECT_COMPARE_TONE_AND_SILENCE
203 #endif
204
205 /* The CNG signal consists of the transmission of 1100 Hz for 1/2 second,
206  * followed by a 3 second silent (2100 Hz OFF) period.
207  */
208 #define FAX_TONE_CNG_FREQ       1100
209 #define FAX_TONE_CNG_DURATION   500     /* ms */
210 #define FAX_TONE_CNG_DB         16
211
212 /* This signal may be sent by the Terminating FAX machine anywhere between
213  * 1.8 to 2.5 seconds AFTER answering the call.  The CED signal consists
214  * of a 2100 Hz tone that is from 2.6 to 4 seconds in duration.
215 */
216 #define FAX_TONE_CED_FREQ       2100
217 #define FAX_TONE_CED_DURATION   2600    /* ms */
218 #define FAX_TONE_CED_DB         16
219
220 #define DEFAULT_SAMPLE_RATE             8000
221
222 /* MF goertzel size */
223 #define MF_GSIZE                120
224
225 /* DTMF goertzel size */
226 #define DTMF_GSIZE              102
227
228 /* How many successive hits needed to consider begin of a digit
229  * IE. Override with dtmf_hits_to_begin=4 in dsp.conf
230  */
231 #define DEF_DTMF_HITS_TO_BEGIN  2
232
233 /* How many successive misses needed to consider end of a digit
234  * IE. Override with dtmf_misses_to_end=4 in dsp.conf
235  */
236 #define DEF_DTMF_MISSES_TO_END  3
237
238 /*!
239  * \brief The default silence threshold we will use if an alternate
240  * configured value is not present or is invalid.
241  */
242 static const int DEFAULT_SILENCE_THRESHOLD = 256;
243
244 #define CONFIG_FILE_NAME "dsp.conf"
245
246 typedef struct {
247         /*! The previous previous sample calculation (No binary point just plain int) */
248         int v2;
249         /*! The previous sample calculation (No binary point just plain int) */
250         int v3;
251         /*! v2 and v3 power of two exponent to keep value in int range */
252         int chunky;
253         /*! 15 bit fixed point goertzel coefficient = 2 * cos(2 * pi * freq / sample_rate) */
254         int fac;
255 } goertzel_state_t;
256
257 typedef struct {
258         int value;
259         int power;
260 } goertzel_result_t;
261
262 typedef struct
263 {
264         int freq;
265         int block_size;
266         int squelch;            /* Remove (squelch) tone */
267         goertzel_state_t tone;
268         float energy;           /* Accumulated energy of the current block */
269         int samples_pending;    /* Samples remain to complete the current block */
270         int mute_samples;       /* How many additional samples needs to be muted to suppress already detected tone */
271
272         int hits_required;      /* How many successive blocks with tone we are looking for */
273         float threshold;        /* Energy of the tone relative to energy from all other signals to consider a hit */
274
275         int hit_count;          /* How many successive blocks we consider tone present */
276         int last_hit;           /* Indicates if the last processed block was a hit */
277
278 } tone_detect_state_t;
279
280 typedef struct
281 {
282         goertzel_state_t row_out[4];
283         goertzel_state_t col_out[4];
284         int hits;                       /* How many successive hits we have seen already */
285         int misses;                     /* How many successive misses we have seen already */
286         int lasthit;
287         int current_hit;
288         float energy;
289         int current_sample;
290         int mute_samples;
291 } dtmf_detect_state_t;
292
293 typedef struct
294 {
295         goertzel_state_t tone_out[6];
296         int current_hit;
297         int hits[5];
298         int current_sample;
299         int mute_samples;
300 } mf_detect_state_t;
301
302 typedef struct
303 {
304         char digits[MAX_DTMF_DIGITS + 1];
305         int digitlen[MAX_DTMF_DIGITS + 1];
306         int current_digits;
307         int detected_digits;
308         int lost_digits;
309
310         union {
311                 dtmf_detect_state_t dtmf;
312                 mf_detect_state_t mf;
313         } td;
314 } digit_detect_state_t;
315
316 static const float dtmf_row[] = {
317         697.0,  770.0,  852.0,  941.0
318 };
319 static const float dtmf_col[] = {
320         1209.0, 1336.0, 1477.0, 1633.0
321 };
322 static const float mf_tones[] = {
323         700.0, 900.0, 1100.0, 1300.0, 1500.0, 1700.0
324 };
325 static const char dtmf_positions[] = "123A" "456B" "789C" "*0#D";
326 static const char bell_mf_positions[] = "1247C-358A--69*---0B----#";
327 static int thresholds[THRESHOLD_MAX];
328 static float dtmf_normal_twist;         /* AT&T = 8dB */
329 static float dtmf_reverse_twist;        /* AT&T = 4dB */
330 static float relax_dtmf_normal_twist;   /* AT&T = 8dB */
331 static float relax_dtmf_reverse_twist;  /* AT&T = 6dB */
332 static int dtmf_hits_to_begin;          /* How many successive hits needed to consider begin of a digit */
333 static int dtmf_misses_to_end;          /* How many successive misses needed to consider end of a digit */
334
335 static inline void goertzel_sample(goertzel_state_t *s, short sample)
336 {
337         int v1;
338
339         /*
340          * Shift previous values so
341          * v1 is previous previous value
342          * v2 is previous value
343          * until the new v3 is calculated.
344          */
345         v1 = s->v2;
346         s->v2 = s->v3;
347
348         /* Discard the binary fraction introduced by s->fac */
349         s->v3 = (s->fac * s->v2) >> 15;
350         /* Scale sample to match previous values */
351         s->v3 = s->v3 - v1 + (sample >> s->chunky);
352
353         if (abs(s->v3) > (1 << 15)) {
354                 /* The result is now too large so increase the chunky power. */
355                 s->chunky++;
356                 s->v3 = s->v3 >> 1;
357                 s->v2 = s->v2 >> 1;
358         }
359 }
360
361 static inline float goertzel_result(goertzel_state_t *s)
362 {
363         goertzel_result_t r;
364
365         r.value = (s->v3 * s->v3) + (s->v2 * s->v2);
366         r.value -= ((s->v2 * s->v3) >> 15) * s->fac;
367         /*
368          * We have to double the exponent because we multiplied the
369          * previous sample calculation values together.
370          */
371         r.power = s->chunky * 2;
372         return (float)r.value * (float)(1 << r.power);
373 }
374
375 static inline void goertzel_init(goertzel_state_t *s, float freq, unsigned int sample_rate)
376 {
377         s->v2 = s->v3 = s->chunky = 0;
378         s->fac = (int)(32768.0 * 2.0 * cos(2.0 * M_PI * freq / sample_rate));
379 }
380
381 static inline void goertzel_reset(goertzel_state_t *s)
382 {
383         s->v2 = s->v3 = s->chunky = 0;
384 }
385
386 typedef struct {
387         int start;
388         int end;
389 } fragment_t;
390
391 /* Note on tone suppression (squelching). Individual detectors (DTMF/MF/generic tone)
392  * report fragments of the frame in which detected tone resides and which needs
393  * to be "muted" in order to suppress the tone. To mark fragment for muting,
394  * detectors call mute_fragment passing fragment_t there. Multiple fragments
395  * can be marked and ast_dsp_process later will mute all of them.
396  *
397  * Note: When tone starts in the middle of a Goertzel block, it won't be properly
398  * detected in that block, only in the next. If we only mute the next block
399  * where tone is actually detected, the user will still hear beginning
400  * of the tone in preceeding block. This is why we usually want to mute some amount
401  * of samples preceeding and following the block where tone was detected.
402 */
403
404 struct ast_dsp {
405         struct ast_frame f;
406         int threshold;
407         /*! Accumulated total silence in ms since last talking/noise. */
408         int totalsilence;
409         /*! Accumulated total talking/noise in ms since last silence. */
410         int totalnoise;
411         int features;
412         int ringtimeout;
413         int busymaybe;
414         int busycount;
415         struct ast_dsp_busy_pattern busy_cadence;
416         int historicnoise[DSP_HISTORY];
417         int historicsilence[DSP_HISTORY];
418         goertzel_state_t freqs[FREQ_ARRAY_SIZE];
419         int freqcount;
420         int gsamps;
421         enum gsamp_size gsamp_size;
422         enum prog_mode progmode;
423         int tstate;
424         int tcount;
425         int digitmode;
426         int faxmode;
427         int dtmf_began;
428         int display_inband_dtmf_warning;
429         float genergy;
430         int mute_fragments;
431         unsigned int sample_rate;
432         fragment_t mute_data[5];
433         digit_detect_state_t digit_state;
434         tone_detect_state_t cng_tone_state;
435         tone_detect_state_t ced_tone_state;
436 };
437
438 static void mute_fragment(struct ast_dsp *dsp, fragment_t *fragment)
439 {
440         if (dsp->mute_fragments >= ARRAY_LEN(dsp->mute_data)) {
441                 ast_log(LOG_ERROR, "Too many fragments to mute. Ignoring\n");
442                 return;
443         }
444
445         dsp->mute_data[dsp->mute_fragments++] = *fragment;
446 }
447
448 static void ast_tone_detect_init(tone_detect_state_t *s, int freq, int duration, int amp, unsigned int sample_rate)
449 {
450         int duration_samples;
451         float x;
452         int periods_in_block;
453
454         s->freq = freq;
455
456         /* Desired tone duration in samples */
457         duration_samples = duration * sample_rate / 1000;
458         /* We want to allow 10% deviation of tone duration */
459         duration_samples = duration_samples * 9 / 10;
460
461         /* If we want to remove tone, it is important to have block size not
462            to exceed frame size. Otherwise by the moment tone is detected it is too late
463            to squelch it from previous frames. Block size is 20ms at the given sample rate.*/
464         s->block_size = (20 * sample_rate) / 1000;
465
466         periods_in_block = s->block_size * freq / sample_rate;
467
468         /* Make sure we will have at least 5 periods at target frequency for analisys.
469            This may make block larger than expected packet and will make squelching impossible
470            but at least we will be detecting the tone */
471         if (periods_in_block < 5) {
472                 periods_in_block = 5;
473         }
474
475         /* Now calculate final block size. It will contain integer number of periods */
476         s->block_size = periods_in_block * sample_rate / freq;
477
478         /* tone_detect is currently only used to detect fax tones and we
479            do not need squelching the fax tones */
480         s->squelch = 0;
481
482         /* Account for the first and the last block to be incomplete
483            and thus no tone will be detected in them */
484         s->hits_required = (duration_samples - (s->block_size - 1)) / s->block_size;
485
486         goertzel_init(&s->tone, freq, sample_rate);
487
488         s->samples_pending = s->block_size;
489         s->hit_count = 0;
490         s->last_hit = 0;
491         s->energy = 0.0;
492
493         /* We want tone energy to be amp decibels above the rest of the signal (the noise).
494            According to Parseval's theorem the energy computed in time domain equals to energy
495            computed in frequency domain. So subtracting energy in the frequency domain (Goertzel result)
496            from the energy in the time domain we will get energy of the remaining signal (without the tone
497            we are detecting). We will be checking that
498                 10*log(Ew / (Et - Ew)) > amp
499            Calculate threshold so that we will be actually checking
500                 Ew > Et * threshold
501         */
502
503         x = pow(10.0, amp / 10.0);
504         s->threshold = x / (x + 1);
505
506         ast_debug(1, "Setup tone %d Hz, %d ms, block_size=%d, hits_required=%d\n", freq, duration, s->block_size, s->hits_required);
507 }
508
509 static void ast_fax_detect_init(struct ast_dsp *s)
510 {
511         ast_tone_detect_init(&s->cng_tone_state, FAX_TONE_CNG_FREQ, FAX_TONE_CNG_DURATION, FAX_TONE_CNG_DB, s->sample_rate);
512         ast_tone_detect_init(&s->ced_tone_state, FAX_TONE_CED_FREQ, FAX_TONE_CED_DURATION, FAX_TONE_CED_DB, s->sample_rate);
513         if (s->faxmode & DSP_FAXMODE_DETECT_SQUELCH) {
514                 s->cng_tone_state.squelch = 1;
515                 s->ced_tone_state.squelch = 1;
516         }
517
518 }
519
520 static void ast_dtmf_detect_init(dtmf_detect_state_t *s, unsigned int sample_rate)
521 {
522         int i;
523
524         for (i = 0; i < 4; i++) {
525                 goertzel_init(&s->row_out[i], dtmf_row[i], sample_rate);
526                 goertzel_init(&s->col_out[i], dtmf_col[i], sample_rate);
527         }
528         s->lasthit = 0;
529         s->current_hit = 0;
530         s->energy = 0.0;
531         s->current_sample = 0;
532         s->hits = 0;
533         s->misses = 0;
534 }
535
536 static void ast_mf_detect_init(mf_detect_state_t *s, unsigned int sample_rate)
537 {
538         int i;
539
540         for (i = 0; i < 6; i++) {
541                 goertzel_init(&s->tone_out[i], mf_tones[i], sample_rate);
542         }
543         s->hits[0] = s->hits[1] = s->hits[2] = s->hits[3] = s->hits[4] = 0;
544         s->current_sample = 0;
545         s->current_hit = 0;
546 }
547
548 static void ast_digit_detect_init(digit_detect_state_t *s, int mf, unsigned int sample_rate)
549 {
550         s->current_digits = 0;
551         s->detected_digits = 0;
552         s->lost_digits = 0;
553         s->digits[0] = '\0';
554
555         if (mf) {
556                 ast_mf_detect_init(&s->td.mf, sample_rate);
557         } else {
558                 ast_dtmf_detect_init(&s->td.dtmf, sample_rate);
559         }
560 }
561
562 static int tone_detect(struct ast_dsp *dsp, tone_detect_state_t *s, int16_t *amp, int samples)
563 {
564         float tone_energy;
565         int i;
566         int hit = 0;
567         int limit;
568         int res = 0;
569         int16_t *ptr;
570         short samp;
571         int start, end;
572         fragment_t mute = {0, 0};
573
574         if (s->squelch && s->mute_samples > 0) {
575                 mute.end = (s->mute_samples < samples) ? s->mute_samples : samples;
576                 s->mute_samples -= mute.end;
577         }
578
579         for (start = 0; start < samples; start = end) {
580                 /* Process in blocks. */
581                 limit = samples - start;
582                 if (limit > s->samples_pending) {
583                         limit = s->samples_pending;
584                 }
585                 end = start + limit;
586
587                 for (i = limit, ptr = amp ; i > 0; i--, ptr++) {
588                         samp = *ptr;
589                         /* signed 32 bit int should be enough to square any possible signed 16 bit value */
590                         s->energy += (int32_t) samp * (int32_t) samp;
591
592                         goertzel_sample(&s->tone, samp);
593                 }
594
595                 s->samples_pending -= limit;
596
597                 if (s->samples_pending) {
598                         /* Finished incomplete (last) block */
599                         break;
600                 }
601
602                 tone_energy = goertzel_result(&s->tone);
603
604                 /* Scale to make comparable */
605                 tone_energy *= 2.0;
606                 s->energy *= s->block_size;
607
608                 ast_debug(10, "%d Hz tone %2d Ew=%.4E, Et=%.4E, s/n=%10.2f\n", s->freq, s->hit_count, tone_energy, s->energy, tone_energy / (s->energy - tone_energy));
609                 hit = 0;
610                 if (TONE_THRESHOLD <= tone_energy
611                         && tone_energy > s->energy * s->threshold) {
612                         ast_debug(10, "%d Hz tone Hit! %2d Ew=%.4E, Et=%.4E, s/n=%10.2f\n", s->freq, s->hit_count, tone_energy, s->energy, tone_energy / (s->energy - tone_energy));
613                         hit = 1;
614                 }
615
616                 if (s->hit_count) {
617                         s->hit_count++;
618                 }
619
620                 if (hit == s->last_hit) {
621                         if (!hit) {
622                                 /* Two successive misses. Tone ended */
623                                 s->hit_count = 0;
624                         } else if (!s->hit_count) {
625                                 s->hit_count++;
626                         }
627
628                 }
629
630                 if (s->hit_count == s->hits_required) {
631                         ast_debug(1, "%d Hz tone detected\n", s->freq);
632                         res = 1;
633                 }
634
635                 s->last_hit = hit;
636
637                 /* If we had a hit in this block, include it into mute fragment */
638                 if (s->squelch && hit) {
639                         if (mute.end < start - s->block_size) {
640                                 /* There is a gap between fragments */
641                                 mute_fragment(dsp, &mute);
642                                 mute.start = (start > s->block_size) ? (start - s->block_size) : 0;
643                         }
644                         mute.end = end + s->block_size;
645                 }
646
647                 /* Reinitialise the detector for the next block */
648                 /* Reset for the next block */
649                 goertzel_reset(&s->tone);
650
651                 /* Advance to the next block */
652                 s->energy = 0.0;
653                 s->samples_pending = s->block_size;
654
655                 amp += limit;
656         }
657
658         if (s->squelch && mute.end) {
659                 if (mute.end > samples) {
660                         s->mute_samples = mute.end - samples;
661                         mute.end = samples;
662                 }
663                 mute_fragment(dsp, &mute);
664         }
665
666         return res;
667 }
668
669 static void store_digit(digit_detect_state_t *s, char digit)
670 {
671         s->detected_digits++;
672         if (s->current_digits < MAX_DTMF_DIGITS) {
673                 s->digitlen[s->current_digits] = 0;
674                 s->digits[s->current_digits++] = digit;
675                 s->digits[s->current_digits] = '\0';
676         } else {
677                 ast_log(LOG_WARNING, "Digit lost due to full buffer\n");
678                 s->lost_digits++;
679         }
680 }
681
682 static int dtmf_detect(struct ast_dsp *dsp, digit_detect_state_t *s, int16_t amp[], int samples, int squelch, int relax)
683 {
684         float row_energy[4];
685         float col_energy[4];
686         int i;
687         int j;
688         int sample;
689         short samp;
690         int best_row;
691         int best_col;
692         int hit;
693         int limit;
694         fragment_t mute = {0, 0};
695
696         if (squelch && s->td.dtmf.mute_samples > 0) {
697                 mute.end = (s->td.dtmf.mute_samples < samples) ? s->td.dtmf.mute_samples : samples;
698                 s->td.dtmf.mute_samples -= mute.end;
699         }
700
701         hit = 0;
702         for (sample = 0; sample < samples; sample = limit) {
703                 /* DTMF_GSIZE is optimised to meet the DTMF specs. */
704                 if ((samples - sample) >= (DTMF_GSIZE - s->td.dtmf.current_sample)) {
705                         limit = sample + (DTMF_GSIZE - s->td.dtmf.current_sample);
706                 } else {
707                         limit = samples;
708                 }
709                 /* The following unrolled loop takes only 35% (rough estimate) of the
710                    time of a rolled loop on the machine on which it was developed */
711                 for (j = sample; j < limit; j++) {
712                         samp = amp[j];
713                         s->td.dtmf.energy += (int32_t) samp * (int32_t) samp;
714                         /* With GCC 2.95, the following unrolled code seems to take about 35%
715                            (rough estimate) as long as a neat little 0-3 loop */
716                         goertzel_sample(s->td.dtmf.row_out, samp);
717                         goertzel_sample(s->td.dtmf.col_out, samp);
718                         goertzel_sample(s->td.dtmf.row_out + 1, samp);
719                         goertzel_sample(s->td.dtmf.col_out + 1, samp);
720                         goertzel_sample(s->td.dtmf.row_out + 2, samp);
721                         goertzel_sample(s->td.dtmf.col_out + 2, samp);
722                         goertzel_sample(s->td.dtmf.row_out + 3, samp);
723                         goertzel_sample(s->td.dtmf.col_out + 3, samp);
724                 }
725                 s->td.dtmf.current_sample += (limit - sample);
726                 if (s->td.dtmf.current_sample < DTMF_GSIZE) {
727                         continue;
728                 }
729                 /* We are at the end of a DTMF detection block */
730                 /* Find the peak row and the peak column */
731                 row_energy[0] = goertzel_result(&s->td.dtmf.row_out[0]);
732                 col_energy[0] = goertzel_result(&s->td.dtmf.col_out[0]);
733
734                 for (best_row = best_col = 0, i = 1; i < 4; i++) {
735                         row_energy[i] = goertzel_result(&s->td.dtmf.row_out[i]);
736                         if (row_energy[i] > row_energy[best_row]) {
737                                 best_row = i;
738                         }
739                         col_energy[i] = goertzel_result(&s->td.dtmf.col_out[i]);
740                         if (col_energy[i] > col_energy[best_col]) {
741                                 best_col = i;
742                         }
743                 }
744                 ast_debug(10, "DTMF best '%c' Erow=%.4E Ecol=%.4E Erc=%.4E Et=%.4E\n",
745                         dtmf_positions[(best_row << 2) + best_col],
746                         row_energy[best_row], col_energy[best_col],
747                         row_energy[best_row] + col_energy[best_col], s->td.dtmf.energy);
748                 hit = 0;
749                 /* Basic signal level test and the twist test */
750                 if (row_energy[best_row] >= DTMF_THRESHOLD &&
751                     col_energy[best_col] >= DTMF_THRESHOLD &&
752                     col_energy[best_col] < row_energy[best_row] * (relax ? relax_dtmf_reverse_twist : dtmf_reverse_twist) &&
753                     row_energy[best_row] < col_energy[best_col] * (relax ? relax_dtmf_normal_twist : dtmf_normal_twist)) {
754                         /* Relative peak test */
755                         for (i = 0; i < 4; i++) {
756                                 if ((i != best_col &&
757                                     col_energy[i] * DTMF_RELATIVE_PEAK_COL > col_energy[best_col]) ||
758                                     (i != best_row
759                                      && row_energy[i] * DTMF_RELATIVE_PEAK_ROW > row_energy[best_row])) {
760                                         break;
761                                 }
762                         }
763                         /* ... and fraction of total energy test */
764                         if (i >= 4 &&
765                             (row_energy[best_row] + col_energy[best_col]) > DTMF_TO_TOTAL_ENERGY * s->td.dtmf.energy) {
766                                 /* Got a hit */
767                                 hit = dtmf_positions[(best_row << 2) + best_col];
768                                 ast_debug(10, "DTMF hit '%c'\n", hit);
769                         }
770                 }
771
772 /*
773  * Adapted from ETSI ES 201 235-3 V1.3.1 (2006-03)
774  * (40ms reference is tunable with hits_to_begin and misses_to_end)
775  * each hit/miss is 12.75ms with DTMF_GSIZE at 102
776  *
777  * Character recognition: When not DRC *(1) and then
778  *      Shall exist VSC > 40 ms (hits_to_begin)
779  *      May exist 20 ms <= VSC <= 40 ms
780  *      Shall not exist VSC < 20 ms
781  *
782  * Character recognition: When DRC and then
783  *      Shall cease Not VSC > 40 ms (misses_to_end)
784  *      May cease 20 ms >= Not VSC >= 40 ms
785  *      Shall not cease Not VSC < 20 ms
786  *
787  * *(1) or optionally a different digit recognition condition
788  *
789  * Legend: VSC The continuous existence of a valid signal condition.
790  *      Not VSC The continuous non-existence of valid signal condition.
791  *      DRC The existence of digit recognition condition.
792  *      Not DRC The non-existence of digit recognition condition.
793  */
794
795 /*
796  * Example: hits_to_begin=2 misses_to_end=3
797  * -------A last_hit=A hits=0&1
798  * ------AA hits=2 current_hit=A misses=0       BEGIN A
799  * -----AA- misses=1 last_hit=' ' hits=0
800  * ----AA-- misses=2
801  * ---AA--- misses=3 current_hit=' '            END A
802  * --AA---B last_hit=B hits=0&1
803  * -AA---BC last_hit=C hits=0&1
804  * AA---BCC hits=2 current_hit=C misses=0       BEGIN C
805  * A---BCC- misses=1 last_hit=' ' hits=0
806  * ---BCC-C misses=0 last_hit=C hits=0&1
807  * --BCC-CC misses=0
808  *
809  * Example: hits_to_begin=3 misses_to_end=2
810  * -------A last_hit=A hits=0&1
811  * ------AA hits=2
812  * -----AAA hits=3 current_hit=A misses=0       BEGIN A
813  * ----AAAB misses=1 last_hit=B hits=0&1
814  * ---AAABB misses=2 current_hit=' ' hits=2     END A
815  * --AAABBB hits=3 current_hit=B misses=0       BEGIN B
816  * -AAABBBB misses=0
817  *
818  * Example: hits_to_begin=2 misses_to_end=2
819  * -------A last_hit=A hits=0&1
820  * ------AA hits=2 current_hit=A misses=0       BEGIN A
821  * -----AAB misses=1 hits=0&1
822  * ----AABB misses=2 current_hit=' ' hits=2 current_hit=B misses=0 BEGIN B
823  * ---AABBB misses=0
824  */
825
826                 if (s->td.dtmf.current_hit) {
827                         /* We are in the middle of a digit already */
828                         if (hit != s->td.dtmf.current_hit) {
829                                 s->td.dtmf.misses++;
830                                 if (s->td.dtmf.misses == dtmf_misses_to_end) {
831                                         /* There were enough misses to consider digit ended */
832                                         s->td.dtmf.current_hit = 0;
833                                 }
834                         } else {
835                                 s->td.dtmf.misses = 0;
836                                 /* Current hit was same as last, so increment digit duration (of last digit) */
837                                 s->digitlen[s->current_digits - 1] += DTMF_GSIZE;
838                         }
839                 }
840
841                 /* Look for a start of a new digit no matter if we are already in the middle of some
842                    digit or not. This is because hits_to_begin may be smaller than misses_to_end
843                    and we may find begin of new digit before we consider last one ended. */
844
845                 if (hit != s->td.dtmf.lasthit) {
846                         s->td.dtmf.lasthit = hit;
847                         s->td.dtmf.hits = 0;
848                 }
849                 if (hit && hit != s->td.dtmf.current_hit) {
850                         s->td.dtmf.hits++;
851                         if (s->td.dtmf.hits == dtmf_hits_to_begin) {
852                                 store_digit(s, hit);
853                                 s->digitlen[s->current_digits - 1] = dtmf_hits_to_begin * DTMF_GSIZE;
854                                 s->td.dtmf.current_hit = hit;
855                                 s->td.dtmf.misses = 0;
856                         }
857                 }
858
859                 /* If we had a hit in this block, include it into mute fragment */
860                 if (squelch && hit) {
861                         if (mute.end < sample - DTMF_GSIZE) {
862                                 /* There is a gap between fragments */
863                                 mute_fragment(dsp, &mute);
864                                 mute.start = (sample > DTMF_GSIZE) ? (sample - DTMF_GSIZE) : 0;
865                         }
866                         mute.end = limit + DTMF_GSIZE;
867                 }
868
869                 /* Reinitialise the detector for the next block */
870                 for (i = 0; i < 4; i++) {
871                         goertzel_reset(&s->td.dtmf.row_out[i]);
872                         goertzel_reset(&s->td.dtmf.col_out[i]);
873                 }
874                 s->td.dtmf.energy = 0.0;
875                 s->td.dtmf.current_sample = 0;
876         }
877
878         if (squelch && mute.end) {
879                 if (mute.end > samples) {
880                         s->td.dtmf.mute_samples = mute.end - samples;
881                         mute.end = samples;
882                 }
883                 mute_fragment(dsp, &mute);
884         }
885
886         return (s->td.dtmf.current_hit);        /* return the debounced hit */
887 }
888
889 static int mf_detect(struct ast_dsp *dsp, digit_detect_state_t *s, int16_t amp[],
890                 int samples, int squelch, int relax)
891 {
892         float energy[6];
893         int best;
894         int second_best;
895         int i;
896         int j;
897         int sample;
898         short samp;
899         int hit;
900         int limit;
901         fragment_t mute = {0, 0};
902
903         if (squelch && s->td.mf.mute_samples > 0) {
904                 mute.end = (s->td.mf.mute_samples < samples) ? s->td.mf.mute_samples : samples;
905                 s->td.mf.mute_samples -= mute.end;
906         }
907
908         hit = 0;
909         for (sample = 0; sample < samples; sample = limit) {
910                 /* 80 is optimised to meet the MF specs. */
911                 /* XXX So then why is MF_GSIZE defined as 120? */
912                 if ((samples - sample) >= (MF_GSIZE - s->td.mf.current_sample)) {
913                         limit = sample + (MF_GSIZE - s->td.mf.current_sample);
914                 } else {
915                         limit = samples;
916                 }
917                 /* The following unrolled loop takes only 35% (rough estimate) of the
918                    time of a rolled loop on the machine on which it was developed */
919                 for (j = sample; j < limit; j++) {
920                         /* With GCC 2.95, the following unrolled code seems to take about 35%
921                            (rough estimate) as long as a neat little 0-3 loop */
922                         samp = amp[j];
923                         goertzel_sample(s->td.mf.tone_out, samp);
924                         goertzel_sample(s->td.mf.tone_out + 1, samp);
925                         goertzel_sample(s->td.mf.tone_out + 2, samp);
926                         goertzel_sample(s->td.mf.tone_out + 3, samp);
927                         goertzel_sample(s->td.mf.tone_out + 4, samp);
928                         goertzel_sample(s->td.mf.tone_out + 5, samp);
929                 }
930                 s->td.mf.current_sample += (limit - sample);
931                 if (s->td.mf.current_sample < MF_GSIZE) {
932                         continue;
933                 }
934                 /* We're at the end of an MF detection block.  */
935                 /* Find the two highest energies. The spec says to look for
936                    two tones and two tones only. Taking this literally -ie
937                    only two tones pass the minimum threshold - doesn't work
938                    well. The sinc function mess, due to rectangular windowing
939                    ensure that! Find the two highest energies and ensure they
940                    are considerably stronger than any of the others. */
941                 energy[0] = goertzel_result(&s->td.mf.tone_out[0]);
942                 energy[1] = goertzel_result(&s->td.mf.tone_out[1]);
943                 if (energy[0] > energy[1]) {
944                         best = 0;
945                         second_best = 1;
946                 } else {
947                         best = 1;
948                         second_best = 0;
949                 }
950                 /*endif*/
951                 for (i = 2; i < 6; i++) {
952                         energy[i] = goertzel_result(&s->td.mf.tone_out[i]);
953                         if (energy[i] >= energy[best]) {
954                                 second_best = best;
955                                 best = i;
956                         } else if (energy[i] >= energy[second_best]) {
957                                 second_best = i;
958                         }
959                 }
960                 /* Basic signal level and twist tests */
961                 hit = 0;
962                 if (energy[best] >= BELL_MF_THRESHOLD && energy[second_best] >= BELL_MF_THRESHOLD
963                     && energy[best] < energy[second_best]*BELL_MF_TWIST
964                     && energy[best] * BELL_MF_TWIST > energy[second_best]) {
965                         /* Relative peak test */
966                         hit = -1;
967                         for (i = 0; i < 6; i++) {
968                                 if (i != best && i != second_best) {
969                                         if (energy[i]*BELL_MF_RELATIVE_PEAK >= energy[second_best]) {
970                                                 /* The best two are not clearly the best */
971                                                 hit = 0;
972                                                 break;
973                                         }
974                                 }
975                         }
976                 }
977                 if (hit) {
978                         /* Get the values into ascending order */
979                         if (second_best < best) {
980                                 i = best;
981                                 best = second_best;
982                                 second_best = i;
983                         }
984                         best = best * 5 + second_best - 1;
985                         hit = bell_mf_positions[best];
986                         /* Look for two successive similar results */
987                         /* The logic in the next test is:
988                            For KP we need 4 successive identical clean detects, with
989                            two blocks of something different preceeding it. For anything
990                            else we need two successive identical clean detects, with
991                            two blocks of something different preceeding it. */
992                         if (hit == s->td.mf.hits[4] && hit == s->td.mf.hits[3] &&
993                            ((hit != '*' && hit != s->td.mf.hits[2] && hit != s->td.mf.hits[1])||
994                             (hit == '*' && hit == s->td.mf.hits[2] && hit != s->td.mf.hits[1] &&
995                             hit != s->td.mf.hits[0]))) {
996                                 store_digit(s, hit);
997                         }
998                 }
999
1000
1001                 if (hit != s->td.mf.hits[4] && hit != s->td.mf.hits[3]) {
1002                         /* Two successive block without a hit terminate current digit */
1003                         s->td.mf.current_hit = 0;
1004                 }
1005
1006                 s->td.mf.hits[0] = s->td.mf.hits[1];
1007                 s->td.mf.hits[1] = s->td.mf.hits[2];
1008                 s->td.mf.hits[2] = s->td.mf.hits[3];
1009                 s->td.mf.hits[3] = s->td.mf.hits[4];
1010                 s->td.mf.hits[4] = hit;
1011
1012                 /* If we had a hit in this block, include it into mute fragment */
1013                 if (squelch && hit) {
1014                         if (mute.end < sample - MF_GSIZE) {
1015                                 /* There is a gap between fragments */
1016                                 mute_fragment(dsp, &mute);
1017                                 mute.start = (sample > MF_GSIZE) ? (sample - MF_GSIZE) : 0;
1018                         }
1019                         mute.end = limit + MF_GSIZE;
1020                 }
1021
1022                 /* Reinitialise the detector for the next block */
1023                 for (i = 0; i < 6; i++) {
1024                         goertzel_reset(&s->td.mf.tone_out[i]);
1025                 }
1026                 s->td.mf.current_sample = 0;
1027         }
1028
1029         if (squelch && mute.end) {
1030                 if (mute.end > samples) {
1031                         s->td.mf.mute_samples = mute.end - samples;
1032                         mute.end = samples;
1033                 }
1034                 mute_fragment(dsp, &mute);
1035         }
1036
1037         return (s->td.mf.current_hit); /* return the debounced hit */
1038 }
1039
1040 static inline int pair_there(float p1, float p2, float i1, float i2, float e)
1041 {
1042         /* See if p1 and p2 are there, relative to i1 and i2 and total energy */
1043         /* Make sure absolute levels are high enough */
1044         if ((p1 < TONE_MIN_THRESH) || (p2 < TONE_MIN_THRESH)) {
1045                 return 0;
1046         }
1047         /* Amplify ignored stuff */
1048         i2 *= TONE_THRESH;
1049         i1 *= TONE_THRESH;
1050         e *= TONE_THRESH;
1051         /* Check first tone */
1052         if ((p1 < i1) || (p1 < i2) || (p1 < e)) {
1053                 return 0;
1054         }
1055         /* And second */
1056         if ((p2 < i1) || (p2 < i2) || (p2 < e)) {
1057                 return 0;
1058         }
1059         /* Guess it's there... */
1060         return 1;
1061 }
1062
1063 static int __ast_dsp_call_progress(struct ast_dsp *dsp, short *s, int len)
1064 {
1065         short samp;
1066         int x;
1067         int y;
1068         int pass;
1069         int newstate = DSP_TONE_STATE_SILENCE;
1070         int res = 0;
1071         int freqcount = dsp->freqcount > FREQ_ARRAY_SIZE ? FREQ_ARRAY_SIZE : dsp->freqcount;
1072
1073         while (len) {
1074                 /* Take the lesser of the number of samples we need and what we have */
1075                 pass = len;
1076                 if (pass > dsp->gsamp_size - dsp->gsamps) {
1077                         pass = dsp->gsamp_size - dsp->gsamps;
1078                 }
1079                 for (x = 0; x < pass; x++) {
1080                         samp = s[x];
1081                         dsp->genergy += (int32_t) samp * (int32_t) samp;
1082                         for (y = 0; y < freqcount; y++) {
1083                                 goertzel_sample(&dsp->freqs[y], samp);
1084                         }
1085                 }
1086                 s += pass;
1087                 dsp->gsamps += pass;
1088                 len -= pass;
1089                 if (dsp->gsamps == dsp->gsamp_size) {
1090                         float hz[FREQ_ARRAY_SIZE];
1091                         for (y = 0; y < FREQ_ARRAY_SIZE; y++) {
1092                                 hz[y] = goertzel_result(&dsp->freqs[y]);
1093                         }
1094                         switch (dsp->progmode) {
1095                         case PROG_MODE_NA:
1096                                 if (pair_there(hz[HZ_480], hz[HZ_620], hz[HZ_350], hz[HZ_440], dsp->genergy)) {
1097                                         newstate = DSP_TONE_STATE_BUSY;
1098                                 } else if (pair_there(hz[HZ_440], hz[HZ_480], hz[HZ_350], hz[HZ_620], dsp->genergy)) {
1099                                         newstate = DSP_TONE_STATE_RINGING;
1100                                 } else if (pair_there(hz[HZ_350], hz[HZ_440], hz[HZ_480], hz[HZ_620], dsp->genergy)) {
1101                                         newstate = DSP_TONE_STATE_DIALTONE;
1102                                 } else if (hz[HZ_950] > TONE_MIN_THRESH * TONE_THRESH) {
1103                                         newstate = DSP_TONE_STATE_SPECIAL1;
1104                                 } else if (hz[HZ_1400] > TONE_MIN_THRESH * TONE_THRESH) {
1105                                         /* End of SPECIAL1 or middle of SPECIAL2 */
1106                                         if (dsp->tstate == DSP_TONE_STATE_SPECIAL1 || dsp->tstate == DSP_TONE_STATE_SPECIAL2) {
1107                                                 newstate = DSP_TONE_STATE_SPECIAL2;
1108                                         }
1109                                 } else if (hz[HZ_1800] > TONE_MIN_THRESH * TONE_THRESH) {
1110                                         /* End of SPECIAL2 or middle of SPECIAL3 */
1111                                         if (dsp->tstate == DSP_TONE_STATE_SPECIAL2 || dsp->tstate == DSP_TONE_STATE_SPECIAL3) {
1112                                                 newstate = DSP_TONE_STATE_SPECIAL3;
1113                                         }
1114                                 } else if (dsp->genergy > TONE_MIN_THRESH * TONE_THRESH) {
1115                                         newstate = DSP_TONE_STATE_TALKING;
1116                                 } else {
1117                                         newstate = DSP_TONE_STATE_SILENCE;
1118                                 }
1119                                 break;
1120                         case PROG_MODE_CR:
1121                                 if (hz[HZ_425] > TONE_MIN_THRESH * TONE_THRESH) {
1122                                         newstate = DSP_TONE_STATE_RINGING;
1123                                 } else if (dsp->genergy > TONE_MIN_THRESH * TONE_THRESH) {
1124                                         newstate = DSP_TONE_STATE_TALKING;
1125                                 } else {
1126                                         newstate = DSP_TONE_STATE_SILENCE;
1127                                 }
1128                                 break;
1129                         case PROG_MODE_UK:
1130                                 if (hz[HZ_400UK] > TONE_MIN_THRESH * TONE_THRESH) {
1131                                         newstate = DSP_TONE_STATE_HUNGUP;
1132                                 } else if (pair_there(hz[HZ_350UK], hz[HZ_440UK], hz[HZ_400UK], hz[HZ_400UK], dsp->genergy)) {
1133                                         newstate = DSP_TONE_STATE_DIALTONE;
1134                                 }
1135                                 break;
1136                         default:
1137                                 ast_log(LOG_WARNING, "Can't process in unknown prog mode '%u'\n", dsp->progmode);
1138                         }
1139                         if (newstate == dsp->tstate) {
1140                                 dsp->tcount++;
1141                                 if (dsp->ringtimeout) {
1142                                         dsp->ringtimeout++;
1143                                 }
1144                                 switch (dsp->tstate) {
1145                                 case DSP_TONE_STATE_RINGING:
1146                                         if ((dsp->features & DSP_PROGRESS_RINGING) &&
1147                                             (dsp->tcount == THRESH_RING)) {
1148                                                 res = AST_CONTROL_RINGING;
1149                                                 dsp->ringtimeout = 1;
1150                                         }
1151                                         break;
1152                                 case DSP_TONE_STATE_BUSY:
1153                                         if ((dsp->features & DSP_PROGRESS_BUSY) &&
1154                                             (dsp->tcount == THRESH_BUSY)) {
1155                                                 res = AST_CONTROL_BUSY;
1156                                                 dsp->features &= ~DSP_FEATURE_CALL_PROGRESS;
1157                                         }
1158                                         break;
1159                                 case DSP_TONE_STATE_TALKING:
1160                                         if ((dsp->features & DSP_PROGRESS_TALK) &&
1161                                             (dsp->tcount == THRESH_TALK)) {
1162                                                 res = AST_CONTROL_ANSWER;
1163                                                 dsp->features &= ~DSP_FEATURE_CALL_PROGRESS;
1164                                         }
1165                                         break;
1166                                 case DSP_TONE_STATE_SPECIAL3:
1167                                         if ((dsp->features & DSP_PROGRESS_CONGESTION) &&
1168                                             (dsp->tcount == THRESH_CONGESTION)) {
1169                                                 res = AST_CONTROL_CONGESTION;
1170                                                 dsp->features &= ~DSP_FEATURE_CALL_PROGRESS;
1171                                         }
1172                                         break;
1173                                 case DSP_TONE_STATE_HUNGUP:
1174                                         if ((dsp->features & DSP_FEATURE_CALL_PROGRESS) &&
1175                                             (dsp->tcount == THRESH_HANGUP)) {
1176                                                 res = AST_CONTROL_HANGUP;
1177                                                 dsp->features &= ~DSP_FEATURE_CALL_PROGRESS;
1178                                         }
1179                                         break;
1180                                 }
1181                                 if (dsp->ringtimeout == THRESH_RING2ANSWER) {
1182                                         ast_debug(1, "Consider call as answered because of timeout after last ring\n");
1183                                         res = AST_CONTROL_ANSWER;
1184                                         dsp->features &= ~DSP_FEATURE_CALL_PROGRESS;
1185                                 }
1186                         } else {
1187                                 ast_debug(5, "Stop state %d with duration %d\n", dsp->tstate, dsp->tcount);
1188                                 ast_debug(5, "Start state %d\n", newstate);
1189                                 dsp->tstate = newstate;
1190                                 dsp->tcount = 1;
1191                         }
1192
1193                         /* Reset goertzel */
1194                         for (x = 0; x < 7; x++) {
1195                                 dsp->freqs[x].v2 = dsp->freqs[x].v3 = 0.0;
1196                         }
1197                         dsp->gsamps = 0;
1198                         dsp->genergy = 0.0;
1199                 }
1200         }
1201
1202         return res;
1203 }
1204
1205 int ast_dsp_call_progress(struct ast_dsp *dsp, struct ast_frame *inf)
1206 {
1207         if (inf->frametype != AST_FRAME_VOICE) {
1208                 ast_log(LOG_WARNING, "Can't check call progress of non-voice frames\n");
1209                 return 0;
1210         }
1211         if (!ast_format_cache_is_slinear(inf->subclass.format)) {
1212                 ast_log(LOG_WARNING, "Can only check call progress in signed-linear frames\n");
1213                 return 0;
1214         }
1215         return __ast_dsp_call_progress(dsp, inf->data.ptr, inf->datalen / 2);
1216 }
1217
1218 static int __ast_dsp_silence_noise(struct ast_dsp *dsp, short *s, int len, int *totalsilence, int *totalnoise, int *frames_energy)
1219 {
1220         int accum;
1221         int x;
1222         int res = 0;
1223
1224         if (!len) {
1225                 return 0;
1226         }
1227         accum = 0;
1228         for (x = 0; x < len; x++) {
1229                 accum += abs(s[x]);
1230         }
1231         accum /= len;
1232         if (accum < dsp->threshold) {
1233                 /* Silent */
1234                 dsp->totalsilence += len / (dsp->sample_rate / 1000);
1235                 if (dsp->totalnoise) {
1236                         /* Move and save history */
1237                         memmove(dsp->historicnoise + DSP_HISTORY - dsp->busycount, dsp->historicnoise + DSP_HISTORY - dsp->busycount + 1, dsp->busycount * sizeof(dsp->historicnoise[0]));
1238                         dsp->historicnoise[DSP_HISTORY - 1] = dsp->totalnoise;
1239 /* we don't want to check for busydetect that frequently */
1240 #if 0
1241                         dsp->busymaybe = 1;
1242 #endif
1243                 }
1244                 dsp->totalnoise = 0;
1245                 res = 1;
1246         } else {
1247                 /* Not silent */
1248                 dsp->totalnoise += len / (dsp->sample_rate / 1000);
1249                 if (dsp->totalsilence) {
1250                         int silence1 = dsp->historicsilence[DSP_HISTORY - 1];
1251                         int silence2 = dsp->historicsilence[DSP_HISTORY - 2];
1252                         /* Move and save history */
1253                         memmove(dsp->historicsilence + DSP_HISTORY - dsp->busycount, dsp->historicsilence + DSP_HISTORY - dsp->busycount + 1, dsp->busycount * sizeof(dsp->historicsilence[0]));
1254                         dsp->historicsilence[DSP_HISTORY - 1] = dsp->totalsilence;
1255                         /* check if the previous sample differs only by BUSY_PERCENT from the one before it */
1256                         if (silence1 < silence2) {
1257                                 if (silence1 + silence1 * BUSY_PERCENT / 100 >= silence2) {
1258                                         dsp->busymaybe = 1;
1259                                 } else {
1260                                         dsp->busymaybe = 0;
1261                                 }
1262                         } else {
1263                                 if (silence1 - silence1 * BUSY_PERCENT / 100 <= silence2) {
1264                                         dsp->busymaybe = 1;
1265                                 } else {
1266                                         dsp->busymaybe = 0;
1267                                 }
1268                         }
1269                 }
1270                 dsp->totalsilence = 0;
1271         }
1272         if (totalsilence) {
1273                 *totalsilence = dsp->totalsilence;
1274         }
1275         if (totalnoise) {
1276                 *totalnoise = dsp->totalnoise;
1277         }
1278         if (frames_energy) {
1279                 *frames_energy = accum;
1280         }
1281         return res;
1282 }
1283
1284 int ast_dsp_busydetect(struct ast_dsp *dsp)
1285 {
1286         int res = 0, x;
1287 #ifndef BUSYDETECT_TONEONLY
1288         int avgsilence = 0, hitsilence = 0;
1289 #endif
1290         int avgtone = 0, hittone = 0;
1291
1292         /* if we have a 4 length pattern, the way busymaybe is set doesn't help us. */
1293         if (dsp->busy_cadence.length != 4) {
1294                 if (!dsp->busymaybe) {
1295                         return res;
1296                 }
1297         }
1298
1299         for (x = DSP_HISTORY - dsp->busycount; x < DSP_HISTORY; x++) {
1300 #ifndef BUSYDETECT_TONEONLY
1301                 avgsilence += dsp->historicsilence[x];
1302 #endif
1303                 avgtone += dsp->historicnoise[x];
1304         }
1305 #ifndef BUSYDETECT_TONEONLY
1306         avgsilence /= dsp->busycount;
1307 #endif
1308         avgtone /= dsp->busycount;
1309         for (x = DSP_HISTORY - dsp->busycount; x < DSP_HISTORY; x++) {
1310 #ifndef BUSYDETECT_TONEONLY
1311                 if (avgsilence > dsp->historicsilence[x]) {
1312                         if (avgsilence - (avgsilence * BUSY_PERCENT / 100) <= dsp->historicsilence[x]) {
1313                                 hitsilence++;
1314                         }
1315                 } else {
1316                         if (avgsilence + (avgsilence * BUSY_PERCENT / 100) >= dsp->historicsilence[x]) {
1317                                 hitsilence++;
1318                         }
1319                 }
1320 #endif
1321                 if (avgtone > dsp->historicnoise[x]) {
1322                         if (avgtone - (avgtone * BUSY_PERCENT / 100) <= dsp->historicnoise[x]) {
1323                                 hittone++;
1324                         }
1325                 } else {
1326                         if (avgtone + (avgtone * BUSY_PERCENT / 100) >= dsp->historicnoise[x]) {
1327                                 hittone++;
1328                         }
1329                 }
1330         }
1331 #ifndef BUSYDETECT_TONEONLY
1332         if ((hittone >= dsp->busycount - 1) && (hitsilence >= dsp->busycount - 1) &&
1333             (avgtone >= BUSY_MIN && avgtone <= BUSY_MAX) &&
1334             (avgsilence >= BUSY_MIN && avgsilence <= BUSY_MAX)) {
1335 #else
1336         if ((hittone >= dsp->busycount - 1) && (avgtone >= BUSY_MIN && avgtone <= BUSY_MAX)) {
1337 #endif
1338 #ifdef BUSYDETECT_COMPARE_TONE_AND_SILENCE
1339                 if (avgtone > avgsilence) {
1340                         if (avgtone - avgtone*BUSY_PERCENT/100 <= avgsilence) {
1341                                 res = 1;
1342                         }
1343                 } else {
1344                         if (avgtone + avgtone*BUSY_PERCENT/100 >= avgsilence) {
1345                                 res = 1;
1346                         }
1347                 }
1348 #else
1349                 res = 1;
1350 #endif
1351         }
1352
1353         /* If we have a 4-length pattern, we can go ahead and just check it in a different way. */
1354         if (dsp->busy_cadence.length == 4) {
1355                 int x;
1356                 int errors = 0;
1357                 int errors_max = ((4 * dsp->busycount) / 100.0) * BUSY_PAT_PERCENT;
1358
1359                 for (x = DSP_HISTORY - (dsp->busycount); x < DSP_HISTORY; x += 2) {
1360                         int temp_error;
1361                         temp_error = abs(dsp->historicnoise[x] - dsp->busy_cadence.pattern[0]);
1362                         if ((temp_error * 100) / dsp->busy_cadence.pattern[0] > BUSY_PERCENT) {
1363                                 errors++;
1364                         }
1365
1366                         temp_error = abs(dsp->historicnoise[x + 1] - dsp->busy_cadence.pattern[2]);
1367                         if ((temp_error * 100) / dsp->busy_cadence.pattern[2] > BUSY_PERCENT) {
1368                                 errors++;
1369                         }
1370
1371                         temp_error = abs(dsp->historicsilence[x] - dsp->busy_cadence.pattern[1]);
1372                         if ((temp_error * 100) / dsp->busy_cadence.pattern[1] > BUSY_PERCENT) {
1373                                 errors++;
1374                         }
1375
1376                         temp_error = abs(dsp->historicsilence[x + 1] - dsp->busy_cadence.pattern[3]);
1377                         if ((temp_error * 100) / dsp->busy_cadence.pattern[3] > BUSY_PERCENT) {
1378                                 errors++;
1379                         }
1380                 }
1381
1382                 ast_debug(5, "errors = %d  max = %d\n", errors, errors_max);
1383
1384                 if (errors <= errors_max) {
1385                         return 1;
1386                 }
1387         }
1388
1389         /* If we know the expected busy tone length, check we are in the range */
1390         if (res && (dsp->busy_cadence.pattern[0] > 0)) {
1391                 if (abs(avgtone - dsp->busy_cadence.pattern[0]) > MAX(dsp->busy_cadence.pattern[0]*BUSY_PAT_PERCENT/100, 20)) {
1392 #ifdef BUSYDETECT_DEBUG
1393                         ast_debug(5, "busy detector: avgtone of %d not close enough to desired %d\n",
1394                                 avgtone, dsp->busy_cadence.pattern[0]);
1395 #endif
1396                         res = 0;
1397                 }
1398         }
1399 #ifndef BUSYDETECT_TONEONLY
1400         /* If we know the expected busy tone silent-period length, check we are in the range */
1401         if (res && (dsp->busy_cadence.pattern[1] > 0)) {
1402                 if (abs(avgsilence - dsp->busy_cadence.pattern[1]) > MAX(dsp->busy_cadence.pattern[1]*BUSY_PAT_PERCENT/100, 20)) {
1403 #ifdef BUSYDETECT_DEBUG
1404                 ast_debug(5, "busy detector: avgsilence of %d not close enough to desired %d\n",
1405                         avgsilence, dsp->busy_cadence.pattern[1]);
1406 #endif
1407                         res = 0;
1408                 }
1409         }
1410 #endif
1411 #if !defined(BUSYDETECT_TONEONLY) && defined(BUSYDETECT_DEBUG)
1412         if (res) {
1413                 ast_debug(5, "ast_dsp_busydetect detected busy, avgtone: %d, avgsilence %d\n", avgtone, avgsilence);
1414         } else {
1415                 ast_debug(5, "busy detector: FAILED with avgtone: %d, avgsilence %d\n", avgtone, avgsilence);
1416         }
1417 #endif
1418         return res;
1419 }
1420
1421 static int ast_dsp_silence_noise_with_energy(struct ast_dsp *dsp, struct ast_frame *f, int *total, int *frames_energy, int noise)
1422 {
1423         short *s;
1424         int len;
1425         int x;
1426         unsigned char *odata;
1427
1428         if (!f) {
1429                 return 0;
1430         }
1431
1432         if (f->frametype != AST_FRAME_VOICE) {
1433                 ast_log(LOG_WARNING, "Can't calculate silence on a non-voice frame\n");
1434                 return 0;
1435         }
1436
1437         if (ast_format_cache_is_slinear(f->subclass.format)) {
1438                 s = f->data.ptr;
1439                 len = f->datalen/2;
1440         } else {
1441                 odata = f->data.ptr;
1442                 len = f->datalen;
1443                 if (ast_format_cmp(f->subclass.format, ast_format_ulaw)) {
1444                         s = ast_alloca(len * 2);
1445                         for (x = 0; x < len; x++) {
1446                                 s[x] = AST_MULAW(odata[x]);
1447                         }
1448                 } else if (ast_format_cmp(f->subclass.format, ast_format_alaw)) {
1449                         s = ast_alloca(len * 2);
1450                         for (x = 0; x < len; x++) {
1451                                 s[x] = AST_ALAW(odata[x]);
1452                         }
1453                 } else {
1454                         ast_log(LOG_WARNING, "Can only calculate silence on signed-linear, alaw or ulaw frames :(\n");
1455                         return 0;
1456                 }
1457         }
1458
1459         if (noise) {
1460                 return __ast_dsp_silence_noise(dsp, s, len, NULL, total, frames_energy);
1461         } else {
1462                 return __ast_dsp_silence_noise(dsp, s, len, total, NULL, frames_energy);
1463         }
1464 }
1465
1466 int ast_dsp_silence_with_energy(struct ast_dsp *dsp, struct ast_frame *f, int *totalsilence, int *frames_energy)
1467 {
1468         return ast_dsp_silence_noise_with_energy(dsp, f, totalsilence, frames_energy, 0);
1469 }
1470
1471 int ast_dsp_silence(struct ast_dsp *dsp, struct ast_frame *f, int *totalsilence)
1472 {
1473         return ast_dsp_silence_noise_with_energy(dsp, f, totalsilence, NULL, 0);
1474 }
1475
1476 int ast_dsp_noise(struct ast_dsp *dsp, struct ast_frame *f, int *totalnoise)
1477 {
1478         return ast_dsp_silence_noise_with_energy(dsp, f, totalnoise, NULL, 1);
1479 }
1480
1481
1482 struct ast_frame *ast_dsp_process(struct ast_channel *chan, struct ast_dsp *dsp, struct ast_frame *af)
1483 {
1484         int silence;
1485         int res;
1486         int digit = 0, fax_digit = 0;
1487         int x;
1488         short *shortdata;
1489         unsigned char *odata;
1490         int len;
1491         struct ast_frame *outf = NULL;
1492
1493         if (!af) {
1494                 return NULL;
1495         }
1496         if (af->frametype != AST_FRAME_VOICE) {
1497                 return af;
1498         }
1499
1500         odata = af->data.ptr;
1501         len = af->datalen;
1502         /* Make sure we have short data */
1503         if (ast_format_cache_is_slinear(af->subclass.format)) {
1504                 shortdata = af->data.ptr;
1505                 len = af->datalen / 2;
1506         } else if (ast_format_cmp(af->subclass.format, ast_format_ulaw) == AST_FORMAT_CMP_EQUAL) {
1507                 shortdata = ast_alloca(af->datalen * 2);
1508                 for (x = 0; x < len; x++) {
1509                         shortdata[x] = AST_MULAW(odata[x]);
1510                 }
1511         } else if (ast_format_cmp(af->subclass.format, ast_format_alaw) == AST_FORMAT_CMP_EQUAL) {
1512                 shortdata = ast_alloca(af->datalen * 2);
1513                 for (x = 0; x < len; x++) {
1514                         shortdata[x] = AST_ALAW(odata[x]);
1515                 }
1516         } else {
1517                 /*Display warning only once. Otherwise you would get hundreds of warnings every second */
1518                 if (dsp->display_inband_dtmf_warning) {
1519                         ast_log(LOG_WARNING, "Inband DTMF is not supported on codec %s. Use RFC2833\n", ast_format_get_name(af->subclass.format));
1520                 }
1521                 dsp->display_inband_dtmf_warning = 0;
1522                 return af;
1523         }
1524
1525         /* Initially we do not want to mute anything */
1526         dsp->mute_fragments = 0;
1527
1528         /* Need to run the silence detection stuff for silence suppression and busy detection */
1529         if ((dsp->features & DSP_FEATURE_SILENCE_SUPPRESS) || (dsp->features & DSP_FEATURE_BUSY_DETECT)) {
1530                 res = __ast_dsp_silence_noise(dsp, shortdata, len, &silence, NULL, NULL);
1531         }
1532
1533         if ((dsp->features & DSP_FEATURE_SILENCE_SUPPRESS) && silence) {
1534                 memset(&dsp->f, 0, sizeof(dsp->f));
1535                 dsp->f.frametype = AST_FRAME_NULL;
1536                 ast_frfree(af);
1537                 return ast_frisolate(&dsp->f);
1538         }
1539         if ((dsp->features & DSP_FEATURE_BUSY_DETECT) && ast_dsp_busydetect(dsp)) {
1540                 ast_channel_softhangup_internal_flag_add(chan, AST_SOFTHANGUP_DEV);
1541                 memset(&dsp->f, 0, sizeof(dsp->f));
1542                 dsp->f.frametype = AST_FRAME_CONTROL;
1543                 dsp->f.subclass.integer = AST_CONTROL_BUSY;
1544                 ast_frfree(af);
1545                 ast_debug(1, "Requesting Hangup because the busy tone was detected on channel %s\n", ast_channel_name(chan));
1546                 return ast_frisolate(&dsp->f);
1547         }
1548
1549         if ((dsp->features & DSP_FEATURE_FAX_DETECT)) {
1550                 if ((dsp->faxmode & DSP_FAXMODE_DETECT_CNG) && tone_detect(dsp, &dsp->cng_tone_state, shortdata, len)) {
1551                         fax_digit = 'f';
1552                 }
1553
1554                 if ((dsp->faxmode & DSP_FAXMODE_DETECT_CED) && tone_detect(dsp, &dsp->ced_tone_state, shortdata, len)) {
1555                         fax_digit = 'e';
1556                 }
1557         }
1558
1559         if (dsp->features & (DSP_FEATURE_DIGIT_DETECT | DSP_FEATURE_BUSY_DETECT)) {
1560                 if (dsp->digitmode & DSP_DIGITMODE_MF) {
1561                         digit = mf_detect(dsp, &dsp->digit_state, shortdata, len, (dsp->digitmode & DSP_DIGITMODE_NOQUELCH) == 0, (dsp->digitmode & DSP_DIGITMODE_RELAXDTMF));
1562                 } else {
1563                         digit = dtmf_detect(dsp, &dsp->digit_state, shortdata, len, (dsp->digitmode & DSP_DIGITMODE_NOQUELCH) == 0, (dsp->digitmode & DSP_DIGITMODE_RELAXDTMF));
1564                 }
1565
1566                 if (dsp->digit_state.current_digits) {
1567                         int event = 0, event_len = 0;
1568                         char event_digit = 0;
1569
1570                         if (!dsp->dtmf_began) {
1571                                 /* We have not reported DTMF_BEGIN for anything yet */
1572
1573                                 if (dsp->features & DSP_FEATURE_DIGIT_DETECT) {
1574                                         event = AST_FRAME_DTMF_BEGIN;
1575                                         event_digit = dsp->digit_state.digits[0];
1576                                 }
1577                                 dsp->dtmf_began = 1;
1578
1579                         } else if (dsp->digit_state.current_digits > 1 || digit != dsp->digit_state.digits[0]) {
1580                                 /* Digit changed. This means digit we have reported with DTMF_BEGIN ended */
1581                                 if (dsp->features & DSP_FEATURE_DIGIT_DETECT) {
1582                                         event = AST_FRAME_DTMF_END;
1583                                         event_digit = dsp->digit_state.digits[0];
1584                                         event_len = dsp->digit_state.digitlen[0] * 1000 / dsp->sample_rate;
1585                                 }
1586                                 memmove(&dsp->digit_state.digits[0], &dsp->digit_state.digits[1], dsp->digit_state.current_digits);
1587                                 memmove(&dsp->digit_state.digitlen[0], &dsp->digit_state.digitlen[1], dsp->digit_state.current_digits * sizeof(dsp->digit_state.digitlen[0]));
1588                                 dsp->digit_state.current_digits--;
1589                                 dsp->dtmf_began = 0;
1590
1591                                 if (dsp->features & DSP_FEATURE_BUSY_DETECT) {
1592                                         /* Reset Busy Detector as we have some confirmed activity */
1593                                         memset(dsp->historicsilence, 0, sizeof(dsp->historicsilence));
1594                                         memset(dsp->historicnoise, 0, sizeof(dsp->historicnoise));
1595                                         ast_debug(1, "DTMF Detected - Reset busydetector\n");
1596                                 }
1597                         }
1598
1599                         if (event) {
1600                                 memset(&dsp->f, 0, sizeof(dsp->f));
1601                                 dsp->f.frametype = event;
1602                                 dsp->f.subclass.integer = event_digit;
1603                                 dsp->f.len = event_len;
1604                                 outf = &dsp->f;
1605                                 goto done;
1606                         }
1607                 }
1608         }
1609
1610         if (fax_digit) {
1611                 /* Fax was detected - digit is either 'f' or 'e' */
1612
1613                 memset(&dsp->f, 0, sizeof(dsp->f));
1614                 dsp->f.frametype = AST_FRAME_DTMF;
1615                 dsp->f.subclass.integer = fax_digit;
1616                 outf = &dsp->f;
1617                 goto done;
1618         }
1619
1620         if ((dsp->features & DSP_FEATURE_CALL_PROGRESS)) {
1621                 res = __ast_dsp_call_progress(dsp, shortdata, len);
1622                 if (res) {
1623                         switch (res) {
1624                         case AST_CONTROL_ANSWER:
1625                         case AST_CONTROL_BUSY:
1626                         case AST_CONTROL_RINGING:
1627                         case AST_CONTROL_CONGESTION:
1628                         case AST_CONTROL_HANGUP:
1629                                 memset(&dsp->f, 0, sizeof(dsp->f));
1630                                 dsp->f.frametype = AST_FRAME_CONTROL;
1631                                 dsp->f.subclass.integer = res;
1632                                 dsp->f.src = "dsp_progress";
1633                                 if (chan) {
1634                                         ast_queue_frame(chan, &dsp->f);
1635                                 }
1636                                 break;
1637                         default:
1638                                 ast_log(LOG_WARNING, "Don't know how to represent call progress message %d\n", res);
1639                         }
1640                 }
1641         } else if ((dsp->features & DSP_FEATURE_WAITDIALTONE)) {
1642                 res = __ast_dsp_call_progress(dsp, shortdata, len);
1643         }
1644
1645 done:
1646         /* Mute fragment of the frame */
1647         for (x = 0; x < dsp->mute_fragments; x++) {
1648                 memset(shortdata + dsp->mute_data[x].start, 0, sizeof(int16_t) * (dsp->mute_data[x].end - dsp->mute_data[x].start));
1649         }
1650
1651         if (ast_format_cmp(af->subclass.format, ast_format_ulaw) == AST_FORMAT_CMP_EQUAL) {
1652                 for (x = 0; x < len; x++) {
1653                         odata[x] = AST_LIN2MU((unsigned short) shortdata[x]);
1654                 }
1655         } else if (ast_format_cmp(af->subclass.format, ast_format_alaw) == AST_FORMAT_CMP_EQUAL) {
1656                 for (x = 0; x < len; x++) {
1657                         odata[x] = AST_LIN2A((unsigned short) shortdata[x]);
1658                 }
1659         }
1660
1661         if (outf) {
1662                 if (chan) {
1663                         ast_queue_frame(chan, af);
1664                 }
1665                 ast_frfree(af);
1666                 return ast_frisolate(outf);
1667         } else {
1668                 return af;
1669         }
1670 }
1671
1672 static void ast_dsp_prog_reset(struct ast_dsp *dsp)
1673 {
1674         int max = 0;
1675         int x;
1676
1677         dsp->gsamp_size = modes[dsp->progmode].size;
1678         dsp->gsamps = 0;
1679         for (x = 0; x < FREQ_ARRAY_SIZE; x++) {
1680                 if (modes[dsp->progmode].freqs[x]) {
1681                         goertzel_init(&dsp->freqs[x], (float)modes[dsp->progmode].freqs[x], dsp->sample_rate);
1682                         max = x + 1;
1683                 }
1684         }
1685         dsp->freqcount = max;
1686         dsp->ringtimeout = 0;
1687 }
1688
1689 unsigned int ast_dsp_get_sample_rate(const struct ast_dsp *dsp)
1690 {
1691         return dsp->sample_rate;
1692 }
1693
1694 static struct ast_dsp *__ast_dsp_new(unsigned int sample_rate)
1695 {
1696         struct ast_dsp *dsp;
1697
1698         if ((dsp = ast_calloc(1, sizeof(*dsp)))) {
1699                 dsp->threshold = DEFAULT_THRESHOLD;
1700                 dsp->features = DSP_FEATURE_SILENCE_SUPPRESS;
1701                 dsp->busycount = DSP_HISTORY;
1702                 dsp->digitmode = DSP_DIGITMODE_DTMF;
1703                 dsp->faxmode = DSP_FAXMODE_DETECT_CNG;
1704                 dsp->sample_rate = sample_rate;
1705                 dsp->freqcount = 0;
1706                 /* Initialize digit detector */
1707                 ast_digit_detect_init(&dsp->digit_state, dsp->digitmode & DSP_DIGITMODE_MF, dsp->sample_rate);
1708                 dsp->display_inband_dtmf_warning = 1;
1709                 /* Initialize initial DSP progress detect parameters */
1710                 ast_dsp_prog_reset(dsp);
1711                 /* Initialize fax detector */
1712                 ast_fax_detect_init(dsp);
1713         }
1714         return dsp;
1715 }
1716
1717 struct ast_dsp *ast_dsp_new(void)
1718 {
1719         return __ast_dsp_new(DEFAULT_SAMPLE_RATE);
1720 }
1721
1722 struct ast_dsp *ast_dsp_new_with_rate(unsigned int sample_rate)
1723 {
1724         return __ast_dsp_new(sample_rate);
1725 }
1726
1727 void ast_dsp_set_features(struct ast_dsp *dsp, int features)
1728 {
1729         dsp->features = features;
1730         if (!(features & DSP_FEATURE_DIGIT_DETECT)) {
1731                 dsp->display_inband_dtmf_warning = 0;
1732         }
1733 }
1734
1735
1736 int ast_dsp_get_features(struct ast_dsp *dsp)
1737 {
1738         return (dsp->features);
1739 }
1740
1741
1742 void ast_dsp_free(struct ast_dsp *dsp)
1743 {
1744         ast_free(dsp);
1745 }
1746
1747 void ast_dsp_set_threshold(struct ast_dsp *dsp, int threshold)
1748 {
1749         dsp->threshold = threshold;
1750 }
1751
1752 void ast_dsp_set_busy_count(struct ast_dsp *dsp, int cadences)
1753 {
1754         if (cadences < 4) {
1755                 cadences = 4;
1756         }
1757         if (cadences > DSP_HISTORY) {
1758                 cadences = DSP_HISTORY;
1759         }
1760         dsp->busycount = cadences;
1761 }
1762
1763 void ast_dsp_set_busy_pattern(struct ast_dsp *dsp, const struct ast_dsp_busy_pattern *cadence)
1764 {
1765         dsp->busy_cadence = *cadence;
1766         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);
1767 }
1768
1769 void ast_dsp_digitreset(struct ast_dsp *dsp)
1770 {
1771         int i;
1772
1773         dsp->dtmf_began = 0;
1774         if (dsp->digitmode & DSP_DIGITMODE_MF) {
1775                 mf_detect_state_t *s = &dsp->digit_state.td.mf;
1776                 /* Reinitialise the detector for the next block */
1777                 for (i = 0; i < 6; i++) {
1778                         goertzel_reset(&s->tone_out[i]);
1779                 }
1780                 s->hits[4] = s->hits[3] = s->hits[2] = s->hits[1] = s->hits[0] = 0;
1781                 s->current_hit = 0;
1782                 s->current_sample = 0;
1783         } else {
1784                 dtmf_detect_state_t *s = &dsp->digit_state.td.dtmf;
1785                 /* Reinitialise the detector for the next block */
1786                 for (i = 0; i < 4; i++) {
1787                         goertzel_reset(&s->row_out[i]);
1788                         goertzel_reset(&s->col_out[i]);
1789                 }
1790                 s->lasthit = 0;
1791                 s->current_hit = 0;
1792                 s->energy = 0.0;
1793                 s->current_sample = 0;
1794                 s->hits = 0;
1795                 s->misses = 0;
1796         }
1797
1798         dsp->digit_state.digits[0] = '\0';
1799         dsp->digit_state.current_digits = 0;
1800 }
1801
1802 void ast_dsp_reset(struct ast_dsp *dsp)
1803 {
1804         int x;
1805
1806         dsp->totalsilence = 0;
1807         dsp->gsamps = 0;
1808         for (x = 0; x < 4; x++) {
1809                 dsp->freqs[x].v2 = dsp->freqs[x].v3 = 0.0;
1810         }
1811         memset(dsp->historicsilence, 0, sizeof(dsp->historicsilence));
1812         memset(dsp->historicnoise, 0, sizeof(dsp->historicnoise));
1813         dsp->ringtimeout = 0;
1814 }
1815
1816 int ast_dsp_set_digitmode(struct ast_dsp *dsp, int digitmode)
1817 {
1818         int new;
1819         int old;
1820
1821         old = dsp->digitmode & (DSP_DIGITMODE_DTMF | DSP_DIGITMODE_MF | DSP_DIGITMODE_MUTECONF | DSP_DIGITMODE_MUTEMAX);
1822         new = digitmode & (DSP_DIGITMODE_DTMF | DSP_DIGITMODE_MF | DSP_DIGITMODE_MUTECONF | DSP_DIGITMODE_MUTEMAX);
1823         if (old != new) {
1824                 /* Must initialize structures if switching from MF to DTMF or vice-versa */
1825                 ast_digit_detect_init(&dsp->digit_state, new & DSP_DIGITMODE_MF, dsp->sample_rate);
1826         }
1827         dsp->digitmode = digitmode;
1828         return 0;
1829 }
1830
1831 int ast_dsp_set_faxmode(struct ast_dsp *dsp, int faxmode)
1832 {
1833         if (dsp->faxmode != faxmode) {
1834                 dsp->faxmode = faxmode;
1835                 ast_fax_detect_init(dsp);
1836         }
1837         return 0;
1838 }
1839
1840 int ast_dsp_set_call_progress_zone(struct ast_dsp *dsp, char *zone)
1841 {
1842         int x;
1843
1844         for (x = 0; x < ARRAY_LEN(aliases); x++) {
1845                 if (!strcasecmp(aliases[x].name, zone)) {
1846                         dsp->progmode = aliases[x].mode;
1847                         ast_dsp_prog_reset(dsp);
1848                         return 0;
1849                 }
1850         }
1851         return -1;
1852 }
1853
1854 int ast_dsp_was_muted(struct ast_dsp *dsp)
1855 {
1856         return (dsp->mute_fragments > 0);
1857 }
1858
1859 int ast_dsp_get_tstate(struct ast_dsp *dsp)
1860 {
1861         return dsp->tstate;
1862 }
1863
1864 int ast_dsp_get_tcount(struct ast_dsp *dsp)
1865 {
1866         return dsp->tcount;
1867 }
1868
1869 static int _dsp_init(int reload)
1870 {
1871         struct ast_config *cfg;
1872         struct ast_variable *v;
1873         struct ast_flags config_flags = { reload ? CONFIG_FLAG_FILEUNCHANGED : 0 };
1874         int cfg_threshold;
1875         float cfg_twist;
1876
1877         if ((cfg = ast_config_load2(CONFIG_FILE_NAME, "dsp", config_flags)) == CONFIG_STATUS_FILEUNCHANGED) {
1878                 return 0;
1879         }
1880
1881         thresholds[THRESHOLD_SILENCE] = DEFAULT_SILENCE_THRESHOLD;
1882         dtmf_normal_twist = DEF_DTMF_NORMAL_TWIST;
1883         dtmf_reverse_twist = DEF_DTMF_REVERSE_TWIST;
1884         relax_dtmf_normal_twist = DEF_RELAX_DTMF_NORMAL_TWIST;
1885         relax_dtmf_reverse_twist = DEF_RELAX_DTMF_REVERSE_TWIST;
1886         dtmf_hits_to_begin = DEF_DTMF_HITS_TO_BEGIN;
1887         dtmf_misses_to_end = DEF_DTMF_MISSES_TO_END;
1888
1889         if (cfg == CONFIG_STATUS_FILEMISSING || cfg == CONFIG_STATUS_FILEINVALID) {
1890                 return 0;
1891         }
1892
1893         for (v = ast_variable_browse(cfg, "default"); v; v = v->next) {
1894                 if (!strcasecmp(v->name, "silencethreshold")) {
1895                         if (sscanf(v->value, "%30d", &cfg_threshold) < 1) {
1896                                 ast_log(LOG_WARNING, "Unable to convert '%s' to a numeric value.\n", v->value);
1897                         } else if (cfg_threshold < 0) {
1898                                 ast_log(LOG_WARNING, "Invalid silence threshold '%d' specified, using default\n", cfg_threshold);
1899                         } else {
1900                                 thresholds[THRESHOLD_SILENCE] = cfg_threshold;
1901                         }
1902                 } else if (!strcasecmp(v->name, "dtmf_normal_twist")) {
1903                         if (sscanf(v->value, "%30f", &cfg_twist) < 1) {
1904                                 ast_log(LOG_WARNING, "Unable to convert '%s' to a numeric value.\n", v->value);
1905                         } else if ((cfg_twist < 2.0) || (cfg_twist > 100.0)) {          /* < 3.0dB or > 20dB */
1906                                 ast_log(LOG_WARNING, "Invalid dtmf_normal_twist value '%.2f' specified, using default of %.2f\n", cfg_twist, dtmf_normal_twist);
1907                         } else {
1908                                 dtmf_normal_twist = cfg_twist;
1909                         }
1910                 } else if (!strcasecmp(v->name, "dtmf_reverse_twist")) {
1911                         if (sscanf(v->value, "%30f", &cfg_twist) < 1) {
1912                                 ast_log(LOG_WARNING, "Unable to convert '%s' to a numeric value.\n", v->value);
1913                         } else if ((cfg_twist < 2.0) || (cfg_twist > 100.0)) {          /* < 3.0dB or > 20dB */
1914                                 ast_log(LOG_WARNING, "Invalid dtmf_reverse_twist value '%.2f' specified, using default of %.2f\n", cfg_twist, dtmf_reverse_twist);
1915                         } else {
1916                                 dtmf_reverse_twist = cfg_twist;
1917                         }
1918                 } else if (!strcasecmp(v->name, "relax_dtmf_normal_twist")) {
1919                         if (sscanf(v->value, "%30f", &cfg_twist) < 1) {
1920                                 ast_log(LOG_WARNING, "Unable to convert '%s' to a numeric value.\n", v->value);
1921                         } else if ((cfg_twist < 2.0) || (cfg_twist > 100.0)) {          /* < 3.0dB or > 20dB */
1922                                 ast_log(LOG_WARNING, "Invalid relax_dtmf_normal_twist value '%.2f' specified, using default of %.2f\n", cfg_twist, relax_dtmf_normal_twist);
1923                         } else {
1924                                 relax_dtmf_normal_twist = cfg_twist;
1925                         }
1926                 } else if (!strcasecmp(v->name, "relax_dtmf_reverse_twist")) {
1927                         if (sscanf(v->value, "%30f", &cfg_twist) < 1) {
1928                                 ast_log(LOG_WARNING, "Unable to convert '%s' to a numeric value.\n", v->value);
1929                         } else if ((cfg_twist < 2.0) || (cfg_twist > 100.0)) {          /* < 3.0dB or > 20dB */
1930                                 ast_log(LOG_WARNING, "Invalid relax_dtmf_reverse_twist value '%.2f' specified, using default of %.2f\n", cfg_twist, relax_dtmf_reverse_twist);
1931                         } else {
1932                                 relax_dtmf_reverse_twist = cfg_twist;
1933                         }
1934                 } else if (!strcasecmp(v->name, "dtmf_hits_to_begin")) {
1935                         if (sscanf(v->value, "%30d", &cfg_threshold) < 1) {
1936                                 ast_log(LOG_WARNING, "Unable to convert '%s' to a numeric value.\n", v->value);
1937                         } else if (cfg_threshold < 1) {         /* must be 1 or greater */
1938                                 ast_log(LOG_WARNING, "Invalid dtmf_hits_to_begin value '%d' specified, using default of %d\n", cfg_threshold, dtmf_hits_to_begin);
1939                         } else {
1940                                 dtmf_hits_to_begin = cfg_threshold;
1941                         }
1942                 } else if (!strcasecmp(v->name, "dtmf_misses_to_end")) {
1943                         if (sscanf(v->value, "%30d", &cfg_threshold) < 1) {
1944                                 ast_log(LOG_WARNING, "Unable to convert '%s' to a numeric value.\n", v->value);
1945                         } else if (cfg_threshold < 1) {         /* must be 1 or greater */
1946                                 ast_log(LOG_WARNING, "Invalid dtmf_misses_to_end value '%d' specified, using default of %d\n", cfg_threshold, dtmf_misses_to_end);
1947                         } else {
1948                                 dtmf_misses_to_end = cfg_threshold;
1949                         }
1950                 }
1951         }
1952         ast_config_destroy(cfg);
1953
1954         return 0;
1955 }
1956
1957 int ast_dsp_get_threshold_from_settings(enum threshold which)
1958 {
1959         return thresholds[which];
1960 }
1961
1962 #ifdef TEST_FRAMEWORK
1963 static void test_tone_sample_gen(short *slin_buf, int samples, int rate, int freq, short amplitude)
1964 {
1965         int idx;
1966         double sample_step = 2.0 * M_PI * freq / rate;/* radians per step */
1967
1968         for (idx = 0; idx < samples; ++idx) {
1969                 slin_buf[idx] = amplitude * sin(sample_step * idx);
1970         }
1971 }
1972 #endif
1973
1974 #ifdef TEST_FRAMEWORK
1975 static void test_tone_sample_gen_add(short *slin_buf, int samples, int rate, int freq, short amplitude)
1976 {
1977         int idx;
1978         double sample_step = 2.0 * M_PI * freq / rate;/* radians per step */
1979
1980         for (idx = 0; idx < samples; ++idx) {
1981                 slin_buf[idx] += amplitude * sin(sample_step * idx);
1982         }
1983 }
1984 #endif
1985
1986 #ifdef TEST_FRAMEWORK
1987 static void test_dual_sample_gen(short *slin_buf, int samples, int rate, int f1, short a1, int f2, short a2)
1988 {
1989         test_tone_sample_gen(slin_buf, samples, rate, f1, a1);
1990         test_tone_sample_gen_add(slin_buf, samples, rate, f2, a2);
1991 }
1992 #endif
1993
1994 #ifdef TEST_FRAMEWORK
1995 #define TONE_AMPLITUDE_MAX      0x7fff  /* Max signed linear amplitude */
1996 #define TONE_AMPLITUDE_MIN      80              /* Min signed linear amplitude detectable */
1997
1998 static int test_tone_amplitude_sweep(struct ast_test *test, struct ast_dsp *dsp, tone_detect_state_t *tone_state)
1999 {
2000         short slin_buf[tone_state->block_size];
2001         int result;
2002         int idx;
2003         struct {
2004                 short amp_val;
2005                 int detect;
2006         } amp_tests[] = {
2007                 { .amp_val = TONE_AMPLITUDE_MAX,        .detect = 1, },
2008                 { .amp_val = 10000,                                     .detect = 1, },
2009                 { .amp_val = 1000,                                      .detect = 1, },
2010                 { .amp_val = 100,                                       .detect = 1, },
2011                 { .amp_val = TONE_AMPLITUDE_MIN,        .detect = 1, },
2012                 { .amp_val = 75,                                        .detect = 0, },
2013                 { .amp_val = 10,                                        .detect = 0, },
2014                 { .amp_val = 1,                                         .detect = 0, },
2015         };
2016
2017         result = 0;
2018
2019         for (idx = 0; idx < ARRAY_LEN(amp_tests); ++idx) {
2020                 int detected;
2021                 int duration;
2022
2023                 ast_debug(1, "Test %d Hz at amplitude %d\n",
2024                         tone_state->freq, amp_tests[idx].amp_val);
2025                 test_tone_sample_gen(slin_buf, tone_state->block_size, DEFAULT_SAMPLE_RATE,
2026                         tone_state->freq, amp_tests[idx].amp_val);
2027
2028                 detected = 0;
2029                 for (duration = 0; !detected && duration < tone_state->hits_required + 3; ++duration) {
2030                         detected = tone_detect(dsp, tone_state, slin_buf, tone_state->block_size) ? 1 : 0;
2031                 }
2032                 if (amp_tests[idx].detect != detected) {
2033                         /*
2034                          * Both messages are needed.  ast_debug for when figuring out
2035                          * what went wrong and the test update for normal output before
2036                          * you start debugging.  The different logging methods are not
2037                          * synchronized.
2038                          */
2039                         ast_debug(1,
2040                                 "Test %d Hz at amplitude %d failed.  Detected: %s\n",
2041                                 tone_state->freq, amp_tests[idx].amp_val,
2042                                 detected ? "yes" : "no");
2043                         ast_test_status_update(test,
2044                                 "Test %d Hz at amplitude %d failed.  Detected: %s\n",
2045                                 tone_state->freq, amp_tests[idx].amp_val,
2046                                 detected ? "yes" : "no");
2047                         result = -1;
2048                 }
2049                 tone_state->hit_count = 0;
2050         }
2051
2052         return result;
2053 }
2054 #endif
2055
2056 #ifdef TEST_FRAMEWORK
2057 static int test_dtmf_amplitude_sweep(struct ast_test *test, struct ast_dsp *dsp, int digit_index)
2058 {
2059         short slin_buf[DTMF_GSIZE];
2060         int result;
2061         int row;
2062         int column;
2063         int idx;
2064         struct {
2065                 short amp_val;
2066                 int digit;
2067         } amp_tests[] = {
2068                 /*
2069                  * XXX Since there is no current DTMF level detection issue.  This test
2070                  * just checks the current detection levels.
2071                  */
2072                 { .amp_val = TONE_AMPLITUDE_MAX/2,      .digit = dtmf_positions[digit_index], },
2073                 { .amp_val = 10000,                                     .digit = dtmf_positions[digit_index], },
2074                 { .amp_val = 1000,                                      .digit = dtmf_positions[digit_index], },
2075                 { .amp_val = 500,                                       .digit = dtmf_positions[digit_index], },
2076                 { .amp_val = 250,                                       .digit = dtmf_positions[digit_index], },
2077                 { .amp_val = 200,                                       .digit = dtmf_positions[digit_index], },
2078                 { .amp_val = 180,                                       .digit = dtmf_positions[digit_index], },
2079                 /* Various digits detect and not detect in this range */
2080                 { .amp_val = 170,                                       .digit = 0, },
2081                 { .amp_val = 100,                                       .digit = 0, },
2082                 /*
2083                  * Amplitudes below TONE_AMPLITUDE_MIN start having questionable detection
2084                  * over quantization and background noise.
2085                  */
2086                 { .amp_val = TONE_AMPLITUDE_MIN,        .digit = 0, },
2087                 { .amp_val = 75,                                        .digit = 0, },
2088                 { .amp_val = 10,                                        .digit = 0, },
2089                 { .amp_val = 1,                                         .digit = 0, },
2090         };
2091
2092         row = (digit_index >> 2) & 0x03;
2093         column = digit_index & 0x03;
2094
2095         result = 0;
2096
2097         for (idx = 0; idx < ARRAY_LEN(amp_tests); ++idx) {
2098                 int digit;
2099                 int duration;
2100
2101                 ast_debug(1, "Test '%c' at amplitude %d\n",
2102                         dtmf_positions[digit_index], amp_tests[idx].amp_val);
2103                 test_dual_sample_gen(slin_buf, ARRAY_LEN(slin_buf), DEFAULT_SAMPLE_RATE,
2104                         (int) dtmf_row[row], amp_tests[idx].amp_val,
2105                         (int) dtmf_col[column], amp_tests[idx].amp_val);
2106
2107                 digit = 0;
2108                 for (duration = 0; !digit && duration < 3; ++duration) {
2109                         digit = dtmf_detect(dsp, &dsp->digit_state, slin_buf, ARRAY_LEN(slin_buf),
2110                                 0, 0);
2111                 }
2112                 if (amp_tests[idx].digit != digit) {
2113                         /*
2114                          * Both messages are needed.  ast_debug for when figuring out
2115                          * what went wrong and the test update for normal output before
2116                          * you start debugging.  The different logging methods are not
2117                          * synchronized.
2118                          */
2119                         ast_debug(1,
2120                                 "Test '%c' at amplitude %d failed.  Detected Digit: '%c'\n",
2121                                 dtmf_positions[digit_index], amp_tests[idx].amp_val,
2122                                 digit ?: ' ');
2123                         ast_test_status_update(test,
2124                                 "Test '%c' at amplitude %d failed.  Detected Digit: '%c'\n",
2125                                 dtmf_positions[digit_index], amp_tests[idx].amp_val,
2126                                 digit ?: ' ');
2127                         result = -1;
2128                 }
2129                 ast_dsp_digitreset(dsp);
2130         }
2131
2132         return result;
2133 }
2134 #endif
2135
2136 #ifdef TEST_FRAMEWORK
2137 static int test_dtmf_twist_sweep(struct ast_test *test, struct ast_dsp *dsp, int digit_index)
2138 {
2139         short slin_buf[DTMF_GSIZE];
2140         int result;
2141         int row;
2142         int column;
2143         int idx;
2144         struct {
2145                 short amp_row;
2146                 short amp_col;
2147                 int digit;
2148         } twist_tests[] = {
2149                 /*
2150                  * XXX Since there is no current DTMF twist detection issue.  This test
2151                  * just checks the current detection levels.
2152                  *
2153                  * Normal twist has the column higher than the row amplitude.
2154                  * Reverse twist is the other way.
2155                  */
2156                 { .amp_row = 1000 + 1800, .amp_col = 1000 +    0, .digit = 0, },
2157                 { .amp_row = 1000 + 1700, .amp_col = 1000 +    0, .digit = 0, },
2158                 /* Various digits detect and not detect in this range */
2159                 { .amp_row = 1000 + 1400, .amp_col = 1000 +    0, .digit = dtmf_positions[digit_index], },
2160                 { .amp_row = 1000 + 1300, .amp_col = 1000 +    0, .digit = dtmf_positions[digit_index], },
2161                 { .amp_row = 1000 + 1200, .amp_col = 1000 +    0, .digit = dtmf_positions[digit_index], },
2162                 { .amp_row = 1000 + 1100, .amp_col = 1000 +    0, .digit = dtmf_positions[digit_index], },
2163                 { .amp_row = 1000 + 1000, .amp_col = 1000 +    0, .digit = dtmf_positions[digit_index], },
2164                 { .amp_row = 1000 +  100, .amp_col = 1000 +    0, .digit = dtmf_positions[digit_index], },
2165                 { .amp_row = 1000 +    0, .amp_col = 1000 +  100, .digit = dtmf_positions[digit_index], },
2166                 { .amp_row = 1000 +    0, .amp_col = 1000 +  200, .digit = dtmf_positions[digit_index], },
2167                 { .amp_row = 1000 +    0, .amp_col = 1000 +  300, .digit = dtmf_positions[digit_index], },
2168                 { .amp_row = 1000 +    0, .amp_col = 1000 +  400, .digit = dtmf_positions[digit_index], },
2169                 { .amp_row = 1000 +    0, .amp_col = 1000 +  500, .digit = dtmf_positions[digit_index], },
2170                 { .amp_row = 1000 +    0, .amp_col = 1000 +  550, .digit = dtmf_positions[digit_index], },
2171                 /* Various digits detect and not detect in this range */
2172                 { .amp_row = 1000 +    0, .amp_col = 1000 +  650, .digit = 0, },
2173                 { .amp_row = 1000 +    0, .amp_col = 1000 +  700, .digit = 0, },
2174                 { .amp_row = 1000 +    0, .amp_col = 1000 +  800, .digit = 0, },
2175         };
2176         float save_normal_twist;
2177         float save_reverse_twist;
2178
2179         save_normal_twist = dtmf_normal_twist;
2180         save_reverse_twist = dtmf_reverse_twist;
2181         dtmf_normal_twist = DEF_DTMF_NORMAL_TWIST;
2182         dtmf_reverse_twist = DEF_DTMF_REVERSE_TWIST;
2183
2184         row = (digit_index >> 2) & 0x03;
2185         column = digit_index & 0x03;
2186
2187         result = 0;
2188
2189         for (idx = 0; idx < ARRAY_LEN(twist_tests); ++idx) {
2190                 int digit;
2191                 int duration;
2192
2193                 ast_debug(1, "Test '%c' twist row %d col %d amplitudes\n",
2194                         dtmf_positions[digit_index],
2195                         twist_tests[idx].amp_row, twist_tests[idx].amp_col);
2196                 test_dual_sample_gen(slin_buf, ARRAY_LEN(slin_buf), DEFAULT_SAMPLE_RATE,
2197                         (int) dtmf_row[row], twist_tests[idx].amp_row,
2198                         (int) dtmf_col[column], twist_tests[idx].amp_col);
2199
2200                 digit = 0;
2201                 for (duration = 0; !digit && duration < 3; ++duration) {
2202                         digit = dtmf_detect(dsp, &dsp->digit_state, slin_buf, ARRAY_LEN(slin_buf),
2203                                 0, 0);
2204                 }
2205                 if (twist_tests[idx].digit != digit) {
2206                         /*
2207                          * Both messages are needed.  ast_debug for when figuring out
2208                          * what went wrong and the test update for normal output before
2209                          * you start debugging.  The different logging methods are not
2210                          * synchronized.
2211                          */
2212                         ast_debug(1,
2213                                 "Test '%c' twist row %d col %d amplitudes failed.  Detected Digit: '%c'\n",
2214                                 dtmf_positions[digit_index],
2215                                 twist_tests[idx].amp_row, twist_tests[idx].amp_col,
2216                                 digit ?: ' ');
2217                         ast_test_status_update(test,
2218                                 "Test '%c' twist row %d col %d amplitudes failed.  Detected Digit: '%c'\n",
2219                                 dtmf_positions[digit_index],
2220                                 twist_tests[idx].amp_row, twist_tests[idx].amp_col,
2221                                 digit ?: ' ');
2222                         result = -1;
2223                 }
2224                 ast_dsp_digitreset(dsp);
2225         }
2226
2227         dtmf_normal_twist = save_normal_twist;
2228         dtmf_reverse_twist = save_reverse_twist;
2229
2230         return result;
2231 }
2232 #endif
2233
2234 #ifdef TEST_FRAMEWORK
2235 static int test_tone_freq_sweep(struct ast_test *test, struct ast_dsp *dsp, tone_detect_state_t *tone_state, short amplitude)
2236 {
2237         short slin_buf[tone_state->block_size];
2238         int result;
2239         int freq;
2240         int lower_freq;
2241         int upper_freq;
2242
2243         /* Calculate detection frequency range */
2244         lower_freq = tone_state->freq - 4;
2245         upper_freq = tone_state->freq + 4;
2246
2247         result = 0;
2248
2249         /* Sweep frequencies loop. */
2250         for (freq = 100; freq <= 3500; freq += 1) {
2251                 int detected;
2252                 int duration;
2253                 int expect_detection;
2254
2255                 if (freq == tone_state->freq) {
2256                         /* This case is done by the amplitude sweep. */
2257                         continue;
2258                 }
2259
2260                 expect_detection = (lower_freq <= freq && freq <= upper_freq) ? 1 : 0;
2261
2262                 ast_debug(1, "Test %d Hz detection given %d Hz tone at amplitude %d.  Range:%d-%d Expect detect: %s\n",
2263                         tone_state->freq, freq, amplitude, lower_freq, upper_freq,
2264                         expect_detection ? "yes" : "no");
2265                 test_tone_sample_gen(slin_buf, tone_state->block_size, DEFAULT_SAMPLE_RATE, freq,
2266                         amplitude);
2267
2268                 detected = 0;
2269                 for (duration = 0; !detected && duration < tone_state->hits_required + 3; ++duration) {
2270                         detected = tone_detect(dsp, tone_state, slin_buf, tone_state->block_size) ? 1 : 0;
2271                 }
2272                 if (expect_detection != detected) {
2273                         /*
2274                          * Both messages are needed.  ast_debug for when figuring out
2275                          * what went wrong and the test update for normal output before
2276                          * you start debugging.  The different logging methods are not
2277                          * synchronized.
2278                          */
2279                         ast_debug(1,
2280                                 "Test %d Hz detection given %d Hz tone at amplitude %d failed.  Range:%d-%d Detected: %s\n",
2281                                 tone_state->freq, freq, amplitude, lower_freq, upper_freq,
2282                                 detected ? "yes" : "no");
2283                         ast_test_status_update(test,
2284                                 "Test %d Hz detection given %d Hz tone at amplitude %d failed.  Range:%d-%d Detected: %s\n",
2285                                 tone_state->freq, freq, amplitude, lower_freq, upper_freq,
2286                                 detected ? "yes" : "no");
2287                         result = -1;
2288                 }
2289                 tone_state->hit_count = 0;
2290         }
2291
2292         return result;
2293 }
2294 #endif
2295
2296 #ifdef TEST_FRAMEWORK
2297 AST_TEST_DEFINE(test_dsp_fax_detect)
2298 {
2299         struct ast_dsp *dsp;
2300         enum ast_test_result_state result;
2301
2302         switch (cmd) {
2303         case TEST_INIT:
2304                 info->name = "fax";
2305                 info->category = "/main/dsp/";
2306                 info->summary = "DSP fax tone detect unit test";
2307                 info->description =
2308                         "Tests fax tone detection code.";
2309                 return AST_TEST_NOT_RUN;
2310         case TEST_EXECUTE:
2311                 break;
2312         }
2313
2314         dsp = ast_dsp_new();
2315         if (!dsp) {
2316                 return AST_TEST_FAIL;
2317         }
2318
2319         result = AST_TEST_PASS;
2320
2321         /* Test CNG tone amplitude detection */
2322         if (test_tone_amplitude_sweep(test, dsp, &dsp->cng_tone_state)) {
2323                 result = AST_TEST_FAIL;
2324         }
2325
2326         /* Test CED tone amplitude detection */
2327         if (test_tone_amplitude_sweep(test, dsp, &dsp->ced_tone_state)) {
2328                 result = AST_TEST_FAIL;
2329         }
2330
2331         /* Test CNG tone frequency detection */
2332         if (test_tone_freq_sweep(test, dsp, &dsp->cng_tone_state, TONE_AMPLITUDE_MAX)) {
2333                 result = AST_TEST_FAIL;
2334         }
2335         if (test_tone_freq_sweep(test, dsp, &dsp->cng_tone_state, TONE_AMPLITUDE_MIN)) {
2336                 result = AST_TEST_FAIL;
2337         }
2338
2339         /* Test CED tone frequency detection */
2340         if (test_tone_freq_sweep(test, dsp, &dsp->ced_tone_state, TONE_AMPLITUDE_MAX)) {
2341                 result = AST_TEST_FAIL;
2342         }
2343         if (test_tone_freq_sweep(test, dsp, &dsp->ced_tone_state, TONE_AMPLITUDE_MIN)) {
2344                 result = AST_TEST_FAIL;
2345         }
2346
2347         ast_dsp_free(dsp);
2348         return result;
2349 }
2350 #endif
2351
2352 #ifdef TEST_FRAMEWORK
2353 AST_TEST_DEFINE(test_dsp_dtmf_detect)
2354 {
2355         int idx;
2356         struct ast_dsp *dsp;
2357         enum ast_test_result_state result;
2358
2359         switch (cmd) {
2360         case TEST_INIT:
2361                 info->name = "dtmf";
2362                 info->category = "/main/dsp/";
2363                 info->summary = "DSP DTMF detect unit test";
2364                 info->description =
2365                         "Tests DTMF detection code.";
2366                 return AST_TEST_NOT_RUN;
2367         case TEST_EXECUTE:
2368                 break;
2369         }
2370
2371         dsp = ast_dsp_new();
2372         if (!dsp) {
2373                 return AST_TEST_FAIL;
2374         }
2375
2376         result = AST_TEST_PASS;
2377
2378         for (idx = 0; dtmf_positions[idx]; ++idx) {
2379                 if (test_dtmf_amplitude_sweep(test, dsp, idx)) {
2380                         result = AST_TEST_FAIL;
2381                 }
2382         }
2383
2384         for (idx = 0; dtmf_positions[idx]; ++idx) {
2385                 if (test_dtmf_twist_sweep(test, dsp, idx)) {
2386                         result = AST_TEST_FAIL;
2387                 }
2388         }
2389
2390         ast_dsp_free(dsp);
2391         return result;
2392 }
2393 #endif
2394
2395 #ifdef TEST_FRAMEWORK
2396 static void test_dsp_shutdown(void)
2397 {
2398         AST_TEST_UNREGISTER(test_dsp_fax_detect);
2399         AST_TEST_UNREGISTER(test_dsp_dtmf_detect);
2400 }
2401 #endif
2402
2403 int ast_dsp_init(void)
2404 {
2405         int res = _dsp_init(0);
2406
2407 #ifdef TEST_FRAMEWORK
2408         if (!res) {
2409                 AST_TEST_REGISTER(test_dsp_fax_detect);
2410                 AST_TEST_REGISTER(test_dsp_dtmf_detect);
2411
2412                 ast_register_cleanup(test_dsp_shutdown);
2413         }
2414 #endif
2415         return res;
2416 }
2417
2418 int ast_dsp_reload(void)
2419 {
2420         return _dsp_init(1);
2421 }