Merge "res_calendar: Specialized calendars depend on symbols of general calendar."
[asterisk/asterisk.git] / main / dsp.c
index c0f4746..8b39fe5 100644 (file)
  * \author Steve Underwood <steveu@coppice.org>
  */
 
+/*! \li \ref dsp.c uses the configuration file \ref dsp.conf
+ * \addtogroup configuration_file Configuration Files
+ */
+
+/*!
+ * \page dsp.conf dsp.conf
+ * \verbinclude dsp.conf.sample
+ */
+
 /* Some routines from tone_detect.c by Steven Underwood as published under the zapata library */
 /*
        tone_detect.c - General telephony tone detection, and specific
        detriment.
 */
 
-#include "asterisk.h"
+/*** MODULEINFO
+       <support_level>core</support_level>
+ ***/
 
-ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
+#include "asterisk.h"
 
 #include <math.h>
 
 #include "asterisk/frame.h"
+#include "asterisk/format_cache.h"
 #include "asterisk/channel.h"
 #include "asterisk/dsp.h"
 #include "asterisk/ulaw.h"
@@ -54,12 +66,13 @@ ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
 #include "asterisk/utils.h"
 #include "asterisk/options.h"
 #include "asterisk/config.h"
+#include "asterisk/test.h"
 
 /*! Number of goertzels for progress detect */
 enum gsamp_size {
        GSAMP_SIZE_NA = 183,                    /*!< North America - 350, 440, 480, 620, 950, 1400, 1800 Hz */
        GSAMP_SIZE_CR = 188,                    /*!< Costa Rica, Brazil - Only care about 425 Hz */
-       GSAMP_SIZE_UK = 160                     /*!< UK disconnect goertzel feed - should trigger 400hz */
+       GSAMP_SIZE_UK = 160                     /*!< UK disconnect goertzel feed - should trigger 400hz */
 };
 
 enum prog_mode {
@@ -68,7 +81,7 @@ enum prog_mode {
        PROG_MODE_UK
 };
 
-enum freq_index { 
+enum freq_index {
        /*! For US modes { */
        HZ_350 = 0,
        HZ_440,
@@ -82,7 +95,9 @@ enum freq_index {
        HZ_425 = 0,
 
        /*! For UK mode */
-       HZ_400 = 0
+       HZ_350UK = 0,
+       HZ_400UK,
+       HZ_440UK
 };
 
 static struct progalias {
@@ -96,44 +111,60 @@ static struct progalias {
        { "uk", PROG_MODE_UK },
 };
 
+#define FREQ_ARRAY_SIZE 7
+
 static struct progress {
        enum gsamp_size size;
-       int freqs[7];
+       int freqs[FREQ_ARRAY_SIZE];
 } modes[] = {
        { GSAMP_SIZE_NA, { 350, 440, 480, 620, 950, 1400, 1800 } },     /*!< North America */
-       { GSAMP_SIZE_CR, { 425 } },                                     /*!< Costa Rica, Brazil */
-       { GSAMP_SIZE_UK, { 400 } },                                     /*!< UK */
+       { GSAMP_SIZE_CR, { 425 } },                                     /*!< Costa Rica, Brazil */
+       { GSAMP_SIZE_UK, { 350, 400, 440 } },                           /*!< UK */
 };
 
+/*!
+ * \brief Default minimum average magnitude threshold to determine talking/noise by the DSP.
+ *
+ * \details
+ * The magnitude calculated for this threshold is determined by
+ * averaging the absolute value of all samples within a frame.
+ *
+ * This value is the threshold for which a frame's average magnitude
+ * is determined to either be silence (below the threshold) or
+ * noise/talking (at or above the threshold).  Please note that while
+ * the default threshold is an even exponent of 2, there is no
+ * requirement that it be so.  The threshold will work for any value
+ * between 1 and 2^15.
+ */
 #define DEFAULT_THRESHOLD      512
 
 enum busy_detect {
-       BUSY_PERCENT = 10,      /*!< The percentage difference between the two last silence periods */
+       BUSY_PERCENT = 10,      /*!< The percentage difference between the two last silence periods */
        BUSY_PAT_PERCENT = 7,   /*!< The percentage difference between measured and actual pattern */
        BUSY_THRESHOLD = 100,   /*!< Max number of ms difference between max and min times in busy */
-       BUSY_MIN = 75,          /*!< Busy must be at least 80 ms in half-cadence */
-       BUSY_MAX =3100          /*!< Busy can't be longer than 3100 ms in half-cadence */
+       BUSY_MIN = 75,          /*!< Busy must be at least 80 ms in half-cadence */
+       BUSY_MAX = 3100         /*!< Busy can't be longer than 3100 ms in half-cadence */
 };
 
 /*! Remember last 15 units */
-#define DSP_HISTORY            15
+#define DSP_HISTORY            15
 
 #define TONE_THRESH            10.0    /*!< How much louder the tone should be than channel energy */
-#define TONE_MIN_THRESH        1e8     /*!< How much tone there should be at least to attempt */
+#define TONE_MIN_THRESH                1e8     /*!< How much tone there should be at least to attempt */
 
 /*! All THRESH_XXX values are in GSAMP_SIZE chunks (us = 22ms) */
 enum gsamp_thresh {
-       THRESH_RING = 8,                /*!< Need at least 150ms ring to accept */
-       THRESH_TALK = 2,                /*!< Talk detection does not work continuously */
-       THRESH_BUSY = 4,                /*!< Need at least 80ms to accept */
-       THRESH_CONGESTION = 4,          /*!< Need at least 80ms to accept */
-       THRESH_HANGUP = 60,             /*!< Need at least 1300ms to accept hangup */
+       THRESH_RING = 8,                /*!< Need at least 150ms ring to accept */
+       THRESH_TALK = 2,                /*!< Talk detection does not work continuously */
+       THRESH_BUSY = 4,                /*!< Need at least 80ms to accept */
+       THRESH_CONGESTION = 4,          /*!< Need at least 80ms to accept */
+       THRESH_HANGUP = 60,             /*!< Need at least 1300ms to accept hangup */
        THRESH_RING2ANSWER = 300        /*!< Timeout from start of ring to answer (about 6600 ms) */
 };
 
 #define        MAX_DTMF_DIGITS         128
 
-/* Basic DTMF specs:
+/* Basic DTMF (AT&T) specs:
  *
  * Minimum tone on = 40ms
  * Minimum tone off = 50ms
@@ -146,18 +177,21 @@ enum gsamp_thresh {
  */
 
 #define DTMF_THRESHOLD         8.0e7
-#define FAX_THRESHOLD          8.0e7
-#define FAX_2ND_HARMONIC       2.0     /* 4dB */
-#define DTMF_NORMAL_TWIST      6.3     /* 8dB */
+#define TONE_THRESHOLD         7.8e7
+
+#define DEF_DTMF_NORMAL_TWIST          6.31     /* 8.0dB */
+#define DEF_RELAX_DTMF_NORMAL_TWIST    6.31     /* 8.0dB */
+
 #ifdef RADIO_RELAX
-#define DTMF_REVERSE_TWIST          (relax ? 6.5 : 2.5)     /* 4dB normal */
+#define DEF_DTMF_REVERSE_TWIST         2.51     /* 4.01dB */
+#define DEF_RELAX_DTMF_REVERSE_TWIST   6.61     /* 8.2dB */
 #else
-#define DTMF_REVERSE_TWIST          (relax ? 4.0 : 2.5)     /* 4dB normal */
+#define DEF_DTMF_REVERSE_TWIST         2.51     /* 4.01dB */
+#define DEF_RELAX_DTMF_REVERSE_TWIST   3.98     /* 6.0dB */
 #endif
+
 #define DTMF_RELATIVE_PEAK_ROW 6.3     /* 8dB */
 #define DTMF_RELATIVE_PEAK_COL 6.3     /* 8dB */
-#define DTMF_2ND_HARMONIC_ROW       (relax ? 1.7 : 2.5)     /* 4dB normal */
-#define DTMF_2ND_HARMONIC_COL  63.1    /* 18dB */
 #define DTMF_TO_TOTAL_ENERGY   42.0
 
 #define BELL_MF_THRESHOLD      1.6e9
@@ -172,7 +206,7 @@ enum gsamp_thresh {
  * followed by a 3 second silent (2100 Hz OFF) period.
  */
 #define FAX_TONE_CNG_FREQ      1100
-#define FAX_TONE_CNG_DURATION  500
+#define FAX_TONE_CNG_DURATION  500     /* ms */
 #define FAX_TONE_CNG_DB                16
 
 /* This signal may be sent by the Terminating FAX machine anywhere between
@@ -180,18 +214,10 @@ enum gsamp_thresh {
  * of a 2100 Hz tone that is from 2.6 to 4 seconds in duration.
 */
 #define FAX_TONE_CED_FREQ      2100
-#define FAX_TONE_CED_DURATION  2600
+#define FAX_TONE_CED_DURATION  2600    /* ms */
 #define FAX_TONE_CED_DB                16
 
-#define SAMPLE_RATE            8000
-
-/* How many samples a frame has.  This constant is used when calculating
- * Goertzel block size for tone_detect.  It is only important if we want to
- * remove (squelch) the tone. In this case it is important to have block
- * size not to exceed size of voice frame.  Otherwise by the moment the tone
- * is detected it is too late to squelch it from previous frames.
- */
-#define SAMPLES_IN_FRAME       160
+#define DEFAULT_SAMPLE_RATE            8000
 
 /* MF goertzel size */
 #define MF_GSIZE               120
@@ -199,19 +225,33 @@ enum gsamp_thresh {
 /* DTMF goertzel size */
 #define DTMF_GSIZE             102
 
-/* How many successive hits needed to consider begin of a digit */
-#define DTMF_HITS_TO_BEGIN     2
-/* How many successive misses needed to consider end of a digit */
-#define DTMF_MISSES_TO_END     3
+/* How many successive hits needed to consider begin of a digit
+ * IE. Override with dtmf_hits_to_begin=4 in dsp.conf
+ */
+#define DEF_DTMF_HITS_TO_BEGIN 2
+
+/* How many successive misses needed to consider end of a digit
+ * IE. Override with dtmf_misses_to_end=4 in dsp.conf
+ */
+#define DEF_DTMF_MISSES_TO_END 3
+
+/*!
+ * \brief The default silence threshold we will use if an alternate
+ * configured value is not present or is invalid.
+ */
+static const int DEFAULT_SILENCE_THRESHOLD = 256;
 
 #define CONFIG_FILE_NAME "dsp.conf"
 
 typedef struct {
+       /*! The previous previous sample calculation (No binary point just plain int) */
        int v2;
+       /*! The previous sample calculation (No binary point just plain int) */
        int v3;
+       /*! v2 and v3 power of two exponent to keep value in int range */
        int chunky;
+       /*! 15 bit fixed point goertzel coefficient = 2 * cos(2 * pi * freq / sample_rate) */
        int fac;
-       int samples;
 } goertzel_state_t;
 
 typedef struct {
@@ -241,8 +281,6 @@ typedef struct
 {
        goertzel_state_t row_out[4];
        goertzel_state_t col_out[4];
-       int hits_to_begin;              /* How many successive hits needed to consider begin of a digit */
-       int misses_to_end;              /* How many successive misses needed to consider end of a digit */
        int hits;                       /* How many successive hits we have seen already */
        int misses;                     /* How many successive misses we have seen already */
        int lasthit;
@@ -264,6 +302,7 @@ typedef struct
 typedef struct
 {
        char digits[MAX_DTMF_DIGITS + 1];
+       int digitlen[MAX_DTMF_DIGITS + 1];
        int current_digits;
        int detected_digits;
        int lost_digits;
@@ -274,71 +313,74 @@ typedef struct
        } td;
 } digit_detect_state_t;
 
-static float dtmf_row[] =
-{
+static const float dtmf_row[] = {
        697.0,  770.0,  852.0,  941.0
 };
-static float dtmf_col[] =
-{
+static const float dtmf_col[] = {
        1209.0, 1336.0, 1477.0, 1633.0
 };
-
-static float mf_tones[] =
-{
+static const float mf_tones[] = {
        700.0, 900.0, 1100.0, 1300.0, 1500.0, 1700.0
 };
-
-static char dtmf_positions[] = "123A" "456B" "789C" "*0#D";
-
-static char bell_mf_positions[] = "1247C-358A--69*---0B----#";
-
+static const char dtmf_positions[] = "123A" "456B" "789C" "*0#D";
+static const char bell_mf_positions[] = "1247C-358A--69*---0B----#";
 static int thresholds[THRESHOLD_MAX];
+static float dtmf_normal_twist;                /* AT&T = 8dB */
+static float dtmf_reverse_twist;       /* AT&T = 4dB */
+static float relax_dtmf_normal_twist;  /* AT&T = 8dB */
+static float relax_dtmf_reverse_twist; /* AT&T = 6dB */
+static int dtmf_hits_to_begin;         /* How many successive hits needed to consider begin of a digit */
+static int dtmf_misses_to_end;         /* How many successive misses needed to consider end of a digit */
 
 static inline void goertzel_sample(goertzel_state_t *s, short sample)
 {
        int v1;
-       
+
+       /*
+        * Shift previous values so
+        * v1 is previous previous value
+        * v2 is previous value
+        * until the new v3 is calculated.
+        */
        v1 = s->v2;
        s->v2 = s->v3;
-       
+
+       /* Discard the binary fraction introduced by s->fac */
        s->v3 = (s->fac * s->v2) >> 15;
+       /* Scale sample to match previous values */
        s->v3 = s->v3 - v1 + (sample >> s->chunky);
-       if (abs(s->v3) > 32768) {
+
+       if (abs(s->v3) > (1 << 15)) {
+               /* The result is now too large so increase the chunky power. */
                s->chunky++;
                s->v3 = s->v3 >> 1;
                s->v2 = s->v2 >> 1;
-               v1 = v1 >> 1;
        }
 }
 
-static inline void goertzel_update(goertzel_state_t *s, short *samps, int count)
-{
-       int i;
-       
-       for (i=0;i<count;i++) 
-               goertzel_sample(s, samps[i]);
-}
-
-
 static inline float goertzel_result(goertzel_state_t *s)
 {
        goertzel_result_t r;
+
        r.value = (s->v3 * s->v3) + (s->v2 * s->v2);
        r.value -= ((s->v2 * s->v3) >> 15) * s->fac;
+       /*
+        * We have to double the exponent because we multiplied the
+        * previous sample calculation values together.
+        */
        r.power = s->chunky * 2;
        return (float)r.value * (float)(1 << r.power);
 }
 
-static inline void goertzel_init(goertzel_state_t *s, float freq, int samples)
+static inline void goertzel_init(goertzel_state_t *s, float freq, unsigned int sample_rate)
 {
-       s->v2 = s->v3 = s->chunky = 0.0;
-       s->fac = (int)(32768.0 * 2.0 * cos(2.0 * M_PI * freq / SAMPLE_RATE));
-       s->samples = samples;
+       s->v2 = s->v3 = s->chunky = 0;
+       s->fac = (int)(32768.0 * 2.0 * cos(2.0 * M_PI * freq / sample_rate));
 }
 
 static inline void goertzel_reset(goertzel_state_t *s)
 {
-       s->v2 = s->v3 = s->chunky = 0.0;
+       s->v2 = s->v3 = s->chunky = 0;
 }
 
 typedef struct {
@@ -347,7 +389,7 @@ typedef struct {
 } fragment_t;
 
 /* Note on tone suppression (squelching). Individual detectors (DTMF/MF/generic tone)
- * report fragmens of the frame in which detected tone resides and which needs
+ * report fragments of the frame in which detected tone resides and which needs
  * to be "muted" in order to suppress the tone. To mark fragment for muting,
  * detectors call mute_fragment passing fragment_t there. Multiple fragments
  * can be marked and ast_dsp_process later will mute all of them.
@@ -362,17 +404,18 @@ typedef struct {
 struct ast_dsp {
        struct ast_frame f;
        int threshold;
+       /*! Accumulated total silence in ms since last talking/noise. */
        int totalsilence;
+       /*! Accumulated total talking/noise in ms since last silence. */
        int totalnoise;
        int features;
        int ringtimeout;
        int busymaybe;
        int busycount;
-       int busy_tonelength;
-       int busy_quietlength;
+       struct ast_dsp_busy_pattern busy_cadence;
        int historicnoise[DSP_HISTORY];
        int historicsilence[DSP_HISTORY];
-       goertzel_state_t freqs[7];
+       goertzel_state_t freqs[FREQ_ARRAY_SIZE];
        int freqcount;
        int gsamps;
        enum gsamp_size gsamp_size;
@@ -382,18 +425,19 @@ struct ast_dsp {
        int digitmode;
        int faxmode;
        int dtmf_began;
+       int display_inband_dtmf_warning;
        float genergy;
        int mute_fragments;
+       unsigned int sample_rate;
        fragment_t mute_data[5];
        digit_detect_state_t digit_state;
        tone_detect_state_t cng_tone_state;
        tone_detect_state_t ced_tone_state;
-       int destroy;
 };
 
 static void mute_fragment(struct ast_dsp *dsp, fragment_t *fragment)
 {
-       if (dsp->mute_fragments >= sizeof(dsp->mute_data) / sizeof(dsp->mute_data[0])) {
+       if (dsp->mute_fragments >= ARRAY_LEN(dsp->mute_data)) {
                ast_log(LOG_ERROR, "Too many fragments to mute. Ignoring\n");
                return;
        }
@@ -401,7 +445,7 @@ static void mute_fragment(struct ast_dsp *dsp, fragment_t *fragment)
        dsp->mute_data[dsp->mute_fragments++] = *fragment;
 }
 
-static void ast_tone_detect_init(tone_detect_state_t *s, int freq, int duration, int amp)
+static void ast_tone_detect_init(tone_detect_state_t *s, int freq, int duration, int amp, unsigned int sample_rate)
 {
        int duration_samples;
        float x;
@@ -410,35 +454,36 @@ static void ast_tone_detect_init(tone_detect_state_t *s, int freq, int duration,
        s->freq = freq;
 
        /* Desired tone duration in samples */
-       duration_samples = duration * SAMPLE_RATE / 1000;
+       duration_samples = duration * sample_rate / 1000;
        /* We want to allow 10% deviation of tone duration */
        duration_samples = duration_samples * 9 / 10;
 
        /* If we want to remove tone, it is important to have block size not
           to exceed frame size. Otherwise by the moment tone is detected it is too late
-          to squelch it from previous frames */
-       s->block_size = SAMPLES_IN_FRAME;
+          to squelch it from previous frames. Block size is 20ms at the given sample rate.*/
+       s->block_size = (20 * sample_rate) / 1000;
 
-       periods_in_block = s->block_size * freq / SAMPLE_RATE;
+       periods_in_block = s->block_size * freq / sample_rate;
 
        /* Make sure we will have at least 5 periods at target frequency for analisys.
           This may make block larger than expected packet and will make squelching impossible
           but at least we will be detecting the tone */
-       if (periods_in_block < 5)
+       if (periods_in_block < 5) {
                periods_in_block = 5;
+       }
 
        /* Now calculate final block size. It will contain integer number of periods */
-       s->block_size = periods_in_block * SAMPLE_RATE / freq;
+       s->block_size = periods_in_block * sample_rate / freq;
 
        /* tone_detect is currently only used to detect fax tones and we
-          do not need suqlching the fax tones */
+          do not need squelching the fax tones */
        s->squelch = 0;
 
        /* Account for the first and the last block to be incomplete
           and thus no tone will be detected in them */
        s->hits_required = (duration_samples - (s->block_size - 1)) / s->block_size;
 
-       goertzel_init(&s->tone, freq, s->block_size);
+       goertzel_init(&s->tone, freq, sample_rate);
 
        s->samples_pending = s->block_size;
        s->hit_count = 0;
@@ -463,51 +508,55 @@ static void ast_tone_detect_init(tone_detect_state_t *s, int freq, int duration,
 
 static void ast_fax_detect_init(struct ast_dsp *s)
 {
-       ast_tone_detect_init(&s->cng_tone_state, FAX_TONE_CNG_FREQ, FAX_TONE_CNG_DURATION, FAX_TONE_CNG_DB);
-       ast_tone_detect_init(&s->ced_tone_state, FAX_TONE_CED_FREQ, FAX_TONE_CED_DURATION, FAX_TONE_CED_DB);
+       ast_tone_detect_init(&s->cng_tone_state, FAX_TONE_CNG_FREQ, FAX_TONE_CNG_DURATION, FAX_TONE_CNG_DB, s->sample_rate);
+       ast_tone_detect_init(&s->ced_tone_state, FAX_TONE_CED_FREQ, FAX_TONE_CED_DURATION, FAX_TONE_CED_DB, s->sample_rate);
+       if (s->faxmode & DSP_FAXMODE_DETECT_SQUELCH) {
+               s->cng_tone_state.squelch = 1;
+               s->ced_tone_state.squelch = 1;
+       }
+
 }
 
-static void ast_dtmf_detect_init (dtmf_detect_state_t *s)
+static void ast_dtmf_detect_init(dtmf_detect_state_t *s, unsigned int sample_rate)
 {
        int i;
 
+       for (i = 0; i < 4; i++) {
+               goertzel_init(&s->row_out[i], dtmf_row[i], sample_rate);
+               goertzel_init(&s->col_out[i], dtmf_col[i], sample_rate);
+       }
        s->lasthit = 0;
        s->current_hit = 0;
-       for (i = 0;  i < 4;  i++) {
-               goertzel_init (&s->row_out[i], dtmf_row[i], DTMF_GSIZE);
-               goertzel_init (&s->col_out[i], dtmf_col[i], DTMF_GSIZE);
-               s->energy = 0.0;
-       }
+       s->energy = 0.0;
        s->current_sample = 0;
        s->hits = 0;
        s->misses = 0;
-
-       s->hits_to_begin = DTMF_HITS_TO_BEGIN;
-       s->misses_to_end = DTMF_MISSES_TO_END;
 }
 
-static void ast_mf_detect_init (mf_detect_state_t *s)
+static void ast_mf_detect_init(mf_detect_state_t *s, unsigned int sample_rate)
 {
        int i;
-       s->hits[0] = s->hits[1] = s->hits[2] = s->hits[3] = s->hits[4] = 0;
-       for (i = 0;  i < 6;  i++) {
-               goertzel_init (&s->tone_out[i], mf_tones[i], 160);
+
+       for (i = 0; i < 6; i++) {
+               goertzel_init(&s->tone_out[i], mf_tones[i], sample_rate);
        }
+       s->hits[0] = s->hits[1] = s->hits[2] = s->hits[3] = s->hits[4] = 0;
        s->current_sample = 0;
        s->current_hit = 0;
 }
 
-static void ast_digit_detect_init(digit_detect_state_t *s, int mf)
+static void ast_digit_detect_init(digit_detect_state_t *s, int mf, unsigned int sample_rate)
 {
        s->current_digits = 0;
        s->detected_digits = 0;
        s->lost_digits = 0;
        s->digits[0] = '\0';
 
-       if (mf)
-               ast_mf_detect_init(&s->td.mf);
-       else
-               ast_dtmf_detect_init(&s->td.dtmf);
+       if (mf) {
+               ast_mf_detect_init(&s->td.mf, sample_rate);
+       } else {
+               ast_dtmf_detect_init(&s->td.dtmf, sample_rate);
+       }
 }
 
 static int tone_detect(struct ast_dsp *dsp, tone_detect_state_t *s, int16_t *amp, int samples)
@@ -518,6 +567,7 @@ static int tone_detect(struct ast_dsp *dsp, tone_detect_state_t *s, int16_t *amp
        int limit;
        int res = 0;
        int16_t *ptr;
+       short samp;
        int start, end;
        fragment_t mute = {0, 0};
 
@@ -526,18 +576,20 @@ static int tone_detect(struct ast_dsp *dsp, tone_detect_state_t *s, int16_t *amp
                s->mute_samples -= mute.end;
        }
 
-       for (start = 0;  start < samples;  start = end) {
+       for (start = 0; start < samples; start = end) {
                /* Process in blocks. */
                limit = samples - start;
-               if (limit > s->samples_pending)
+               if (limit > s->samples_pending) {
                        limit = s->samples_pending;
+               }
                end = start + limit;
 
                for (i = limit, ptr = amp ; i > 0; i--, ptr++) {
-                       /* signed 32 bit int should be enough to suqare any possible signed 16 bit value */
-                       s->energy += (int32_t) *ptr * (int32_t) *ptr;
+                       samp = *ptr;
+                       /* signed 32 bit int should be enough to square any possible signed 16 bit value */
+                       s->energy += (int32_t) samp * (int32_t) samp;
 
-                       goertzel_sample(&s->tone, *ptr);
+                       goertzel_sample(&s->tone, samp);
                }
 
                s->samples_pending -= limit;
@@ -553,16 +605,17 @@ static int tone_detect(struct ast_dsp *dsp, tone_detect_state_t *s, int16_t *amp
                tone_energy *= 2.0;
                s->energy *= s->block_size;
 
-               ast_debug(10, "tone %d, Ew=%.2E, Et=%.2E, s/n=%10.2f\n", s->freq, tone_energy, s->energy, tone_energy / (s->energy - tone_energy));
+               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));
                hit = 0;
-               if (tone_energy > s->energy * s->threshold) {
-
-                       ast_debug(10, "Hit! count=%d\n", s->hit_count);
+               if (TONE_THRESHOLD <= tone_energy
+                       && tone_energy > s->energy * s->threshold) {
+                       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));
                        hit = 1;
                }
 
-               if (s->hit_count)
+               if (s->hit_count) {
                        s->hit_count++;
+               }
 
                if (hit == s->last_hit) {
                        if (!hit) {
@@ -575,7 +628,7 @@ static int tone_detect(struct ast_dsp *dsp, tone_detect_state_t *s, int16_t *amp
                }
 
                if (s->hit_count == s->hits_required) {
-                       ast_debug(1, "%d Hz done detected\n", s->freq);
+                       ast_debug(1, "%d Hz tone detected\n", s->freq);
                        res = 1;
                }
 
@@ -617,6 +670,7 @@ static void store_digit(digit_detect_state_t *s, char digit)
 {
        s->detected_digits++;
        if (s->current_digits < MAX_DTMF_DIGITS) {
+               s->digitlen[s->current_digits] = 0;
                s->digits[s->current_digits++] = digit;
                s->digits[s->current_digits] = '\0';
        } else {
@@ -629,10 +683,10 @@ static int dtmf_detect(struct ast_dsp *dsp, digit_detect_state_t *s, int16_t amp
 {
        float row_energy[4];
        float col_energy[4];
-       float famp;
        int i;
        int j;
        int sample;
+       short samp;
        int best_row;
        int best_col;
        int hit;
@@ -645,27 +699,28 @@ static int dtmf_detect(struct ast_dsp *dsp, digit_detect_state_t *s, int16_t amp
        }
 
        hit = 0;
-       for (sample = 0;  sample < samples;  sample = limit) {
+       for (sample = 0; sample < samples; sample = limit) {
                /* DTMF_GSIZE is optimised to meet the DTMF specs. */
-               if ((samples - sample) >= (DTMF_GSIZE - s->td.dtmf.current_sample))
+               if ((samples - sample) >= (DTMF_GSIZE - s->td.dtmf.current_sample)) {
                        limit = sample + (DTMF_GSIZE - s->td.dtmf.current_sample);
-               else
+               } else {
                        limit = samples;
-               /* The following unrolled loop takes only 35% (rough estimate) of the 
+               }
+               /* The following unrolled loop takes only 35% (rough estimate) of the
                   time of a rolled loop on the machine on which it was developed */
                for (j = sample; j < limit; j++) {
-                       famp = amp[j];
-                       s->td.dtmf.energy += famp*famp;
+                       samp = amp[j];
+                       s->td.dtmf.energy += (int32_t) samp * (int32_t) samp;
                        /* With GCC 2.95, the following unrolled code seems to take about 35%
                           (rough estimate) as long as a neat little 0-3 loop */
-                       goertzel_sample(s->td.dtmf.row_out, amp[j]);
-                       goertzel_sample(s->td.dtmf.col_out, amp[j]);
-                       goertzel_sample(s->td.dtmf.row_out + 1, amp[j]);
-                       goertzel_sample(s->td.dtmf.col_out + 1, amp[j]);
-                       goertzel_sample(s->td.dtmf.row_out + 2, amp[j]);
-                       goertzel_sample(s->td.dtmf.col_out + 2, amp[j]);
-                       goertzel_sample(s->td.dtmf.row_out + 3, amp[j]);
-                       goertzel_sample(s->td.dtmf.col_out + 3, amp[j]);
+                       goertzel_sample(s->td.dtmf.row_out, samp);
+                       goertzel_sample(s->td.dtmf.col_out, samp);
+                       goertzel_sample(s->td.dtmf.row_out + 1, samp);
+                       goertzel_sample(s->td.dtmf.col_out + 1, samp);
+                       goertzel_sample(s->td.dtmf.row_out + 2, samp);
+                       goertzel_sample(s->td.dtmf.col_out + 2, samp);
+                       goertzel_sample(s->td.dtmf.row_out + 3, samp);
+                       goertzel_sample(s->td.dtmf.col_out + 3, samp);
                }
                s->td.dtmf.current_sample += (limit - sample);
                if (s->td.dtmf.current_sample < DTMF_GSIZE) {
@@ -673,74 +728,134 @@ static int dtmf_detect(struct ast_dsp *dsp, digit_detect_state_t *s, int16_t amp
                }
                /* We are at the end of a DTMF detection block */
                /* Find the peak row and the peak column */
-               row_energy[0] = goertzel_result (&s->td.dtmf.row_out[0]);
-               col_energy[0] = goertzel_result (&s->td.dtmf.col_out[0]);
+               row_energy[0] = goertzel_result(&s->td.dtmf.row_out[0]);
+               col_energy[0] = goertzel_result(&s->td.dtmf.col_out[0]);
 
-               for (best_row = best_col = 0, i = 1;  i < 4;  i++) {
-                       row_energy[i] = goertzel_result (&s->td.dtmf.row_out[i]);
-                       if (row_energy[i] > row_energy[best_row])
+               for (best_row = best_col = 0, i = 1; i < 4; i++) {
+                       row_energy[i] = goertzel_result(&s->td.dtmf.row_out[i]);
+                       if (row_energy[i] > row_energy[best_row]) {
                                best_row = i;
-                       col_energy[i] = goertzel_result (&s->td.dtmf.col_out[i]);
-                       if (col_energy[i] > col_energy[best_col])
+                       }
+                       col_energy[i] = goertzel_result(&s->td.dtmf.col_out[i]);
+                       if (col_energy[i] > col_energy[best_col]) {
                                best_col = i;
+                       }
                }
+               ast_debug(10, "DTMF best '%c' Erow=%.4E Ecol=%.4E Erc=%.4E Et=%.4E\n",
+                       dtmf_positions[(best_row << 2) + best_col],
+                       row_energy[best_row], col_energy[best_col],
+                       row_energy[best_row] + col_energy[best_col], s->td.dtmf.energy);
                hit = 0;
                /* Basic signal level test and the twist test */
-               if (row_energy[best_row] >= DTMF_THRESHOLD && 
+               if (row_energy[best_row] >= DTMF_THRESHOLD &&
                    col_energy[best_col] >= DTMF_THRESHOLD &&
-                   col_energy[best_col] < row_energy[best_row]*DTMF_REVERSE_TWIST &&
-                   col_energy[best_col]*DTMF_NORMAL_TWIST > row_energy[best_row]) {
+                   col_energy[best_col] < row_energy[best_row] * (relax ? relax_dtmf_reverse_twist : dtmf_reverse_twist) &&
+                   row_energy[best_row] < col_energy[best_col] * (relax ? relax_dtmf_normal_twist : dtmf_normal_twist)) {
                        /* Relative peak test */
-                       for (i = 0;  i < 4;  i++) {
+                       for (i = 0; i < 4; i++) {
                                if ((i != best_col &&
-                                   col_energy[i]*DTMF_RELATIVE_PEAK_COL > col_energy[best_col]) ||
-                                   (i != best_row 
-                                    && row_energy[i]*DTMF_RELATIVE_PEAK_ROW > row_energy[best_row])) {
+                                   col_energy[i] * DTMF_RELATIVE_PEAK_COL > col_energy[best_col]) ||
+                                   (i != best_row
+                                    && row_energy[i] * DTMF_RELATIVE_PEAK_ROW > row_energy[best_row])) {
                                        break;
                                }
                        }
                        /* ... and fraction of total energy test */
                        if (i >= 4 &&
-                           (row_energy[best_row] + col_energy[best_col]) > DTMF_TO_TOTAL_ENERGY*s->td.dtmf.energy) {
+                           (row_energy[best_row] + col_energy[best_col]) > DTMF_TO_TOTAL_ENERGY * s->td.dtmf.energy) {
                                /* Got a hit */
                                hit = dtmf_positions[(best_row << 2) + best_col];
+                               ast_debug(10, "DTMF hit '%c'\n", hit);
                        }
-               } 
+               }
+
+/*
+ * Adapted from ETSI ES 201 235-3 V1.3.1 (2006-03)
+ * (40ms reference is tunable with hits_to_begin and misses_to_end)
+ * each hit/miss is 12.75ms with DTMF_GSIZE at 102
+ *
+ * Character recognition: When not DRC *(1) and then
+ *      Shall exist VSC > 40 ms (hits_to_begin)
+ *      May exist 20 ms <= VSC <= 40 ms
+ *      Shall not exist VSC < 20 ms
+ *
+ * Character recognition: When DRC and then
+ *      Shall cease Not VSC > 40 ms (misses_to_end)
+ *      May cease 20 ms >= Not VSC >= 40 ms
+ *      Shall not cease Not VSC < 20 ms
+ *
+ * *(1) or optionally a different digit recognition condition
+ *
+ * Legend: VSC The continuous existence of a valid signal condition.
+ *      Not VSC The continuous non-existence of valid signal condition.
+ *      DRC The existence of digit recognition condition.
+ *      Not DRC The non-existence of digit recognition condition.
+ */
+
+/*
+ * Example: hits_to_begin=2 misses_to_end=3
+ * -------A last_hit=A hits=0&1
+ * ------AA hits=2 current_hit=A misses=0       BEGIN A
+ * -----AA- misses=1 last_hit=' ' hits=0
+ * ----AA-- misses=2
+ * ---AA--- misses=3 current_hit=' '            END A
+ * --AA---B last_hit=B hits=0&1
+ * -AA---BC last_hit=C hits=0&1
+ * AA---BCC hits=2 current_hit=C misses=0       BEGIN C
+ * A---BCC- misses=1 last_hit=' ' hits=0
+ * ---BCC-C misses=0 last_hit=C hits=0&1
+ * --BCC-CC misses=0
+ *
+ * Example: hits_to_begin=3 misses_to_end=2
+ * -------A last_hit=A hits=0&1
+ * ------AA hits=2
+ * -----AAA hits=3 current_hit=A misses=0       BEGIN A
+ * ----AAAB misses=1 last_hit=B hits=0&1
+ * ---AAABB misses=2 current_hit=' ' hits=2     END A
+ * --AAABBB hits=3 current_hit=B misses=0       BEGIN B
+ * -AAABBBB misses=0
+ *
+ * Example: hits_to_begin=2 misses_to_end=2
+ * -------A last_hit=A hits=0&1
+ * ------AA hits=2 current_hit=A misses=0       BEGIN A
+ * -----AAB misses=1 hits=0&1
+ * ----AABB misses=2 current_hit=' ' hits=2 current_hit=B misses=0 BEGIN B
+ * ---AABBB misses=0
+ */
 
                if (s->td.dtmf.current_hit) {
                        /* We are in the middle of a digit already */
                        if (hit != s->td.dtmf.current_hit) {
                                s->td.dtmf.misses++;
-                               if (s->td.dtmf.misses == s->td.dtmf.misses_to_end) {
+                               if (s->td.dtmf.misses == dtmf_misses_to_end) {
                                        /* There were enough misses to consider digit ended */
                                        s->td.dtmf.current_hit = 0;
                                }
                        } else {
                                s->td.dtmf.misses = 0;
+                               /* Current hit was same as last, so increment digit duration (of last digit) */
+                               s->digitlen[s->current_digits - 1] += DTMF_GSIZE;
                        }
                }
 
                /* Look for a start of a new digit no matter if we are already in the middle of some
                   digit or not. This is because hits_to_begin may be smaller than misses_to_end
                   and we may find begin of new digit before we consider last one ended. */
-               if (hit) {
-                       if (hit == s->td.dtmf.lasthit) {
-                               s->td.dtmf.hits++;
-                       } else {
-                               s->td.dtmf.hits = 1;
-                       }
 
-                       if (s->td.dtmf.hits == s->td.dtmf.hits_to_begin && hit != s->td.dtmf.current_hit) {
+               if (hit != s->td.dtmf.lasthit) {
+                       s->td.dtmf.lasthit = hit;
+                       s->td.dtmf.hits = 0;
+               }
+               if (hit && hit != s->td.dtmf.current_hit) {
+                       s->td.dtmf.hits++;
+                       if (s->td.dtmf.hits == dtmf_hits_to_begin) {
                                store_digit(s, hit);
+                               s->digitlen[s->current_digits - 1] = dtmf_hits_to_begin * DTMF_GSIZE;
                                s->td.dtmf.current_hit = hit;
                                s->td.dtmf.misses = 0;
                        }
-               } else {
-                       s->td.dtmf.hits = 0;
                }
 
-               s->td.dtmf.lasthit = hit;
-
                /* If we had a hit in this block, include it into mute fragment */
                if (squelch && hit) {
                        if (mute.end < sample - DTMF_GSIZE) {
@@ -752,7 +867,7 @@ static int dtmf_detect(struct ast_dsp *dsp, digit_detect_state_t *s, int16_t amp
                }
 
                /* Reinitialise the detector for the next block */
-               for (i = 0;  i < 4;  i++) {
+               for (i = 0; i < 4; i++) {
                        goertzel_reset(&s->td.dtmf.row_out[i]);
                        goertzel_reset(&s->td.dtmf.col_out[i]);
                }
@@ -772,15 +887,15 @@ static int dtmf_detect(struct ast_dsp *dsp, digit_detect_state_t *s, int16_t amp
 }
 
 static int mf_detect(struct ast_dsp *dsp, digit_detect_state_t *s, int16_t amp[],
-                 int samples, int squelch, int relax)
+               int samples, int squelch, int relax)
 {
        float energy[6];
        int best;
        int second_best;
-       float famp;
        int i;
        int j;
        int sample;
+       short samp;
        int hit;
        int limit;
        fragment_t mute = {0, 0};
@@ -791,25 +906,26 @@ static int mf_detect(struct ast_dsp *dsp, digit_detect_state_t *s, int16_t amp[]
        }
 
        hit = 0;
-       for (sample = 0;  sample < samples;  sample = limit) {
+       for (sample = 0; sample < samples; sample = limit) {
                /* 80 is optimised to meet the MF specs. */
                /* XXX So then why is MF_GSIZE defined as 120? */
-               if ((samples - sample) >= (MF_GSIZE - s->td.mf.current_sample))
+               if ((samples - sample) >= (MF_GSIZE - s->td.mf.current_sample)) {
                        limit = sample + (MF_GSIZE - s->td.mf.current_sample);
-               else
+               } else {
                        limit = samples;
-               /* The following unrolled loop takes only 35% (rough estimate) of the 
+               }
+               /* The following unrolled loop takes only 35% (rough estimate) of the
                   time of a rolled loop on the machine on which it was developed */
-               for (j = sample;  j < limit;  j++) {
-                       famp = amp[j];
+               for (j = sample; j < limit; j++) {
                        /* With GCC 2.95, the following unrolled code seems to take about 35%
                           (rough estimate) as long as a neat little 0-3 loop */
-                       goertzel_sample(s->td.mf.tone_out, amp[j]);
-                       goertzel_sample(s->td.mf.tone_out + 1, amp[j]);
-                       goertzel_sample(s->td.mf.tone_out + 2, amp[j]);
-                       goertzel_sample(s->td.mf.tone_out + 3, amp[j]);
-                       goertzel_sample(s->td.mf.tone_out + 4, amp[j]);
-                       goertzel_sample(s->td.mf.tone_out + 5, amp[j]);
+                       samp = amp[j];
+                       goertzel_sample(s->td.mf.tone_out, samp);
+                       goertzel_sample(s->td.mf.tone_out + 1, samp);
+                       goertzel_sample(s->td.mf.tone_out + 2, samp);
+                       goertzel_sample(s->td.mf.tone_out + 3, samp);
+                       goertzel_sample(s->td.mf.tone_out + 4, samp);
+                       goertzel_sample(s->td.mf.tone_out + 5, samp);
                }
                s->td.mf.current_sample += (limit - sample);
                if (s->td.mf.current_sample < MF_GSIZE) {
@@ -832,7 +948,7 @@ static int mf_detect(struct ast_dsp *dsp, digit_detect_state_t *s, int16_t amp[]
                        second_best = 0;
                }
                /*endif*/
-               for (i=2;i<6;i++) {
+               for (i = 2; i < 6; i++) {
                        energy[i] = goertzel_result(&s->td.mf.tone_out[i]);
                        if (energy[i] >= energy[best]) {
                                second_best = best;
@@ -844,11 +960,11 @@ static int mf_detect(struct ast_dsp *dsp, digit_detect_state_t *s, int16_t amp[]
                /* Basic signal level and twist tests */
                hit = 0;
                if (energy[best] >= BELL_MF_THRESHOLD && energy[second_best] >= BELL_MF_THRESHOLD
-                   && energy[best] < energy[second_best]*BELL_MF_TWIST
-                   && energy[best]*BELL_MF_TWIST > energy[second_best]) {
+                   && energy[best] < energy[second_best]*BELL_MF_TWIST
+                   && energy[best] * BELL_MF_TWIST > energy[second_best]) {
                        /* Relative peak test */
                        hit = -1;
-                       for (i=0;i<6;i++) {
+                       for (i = 0; i < 6; i++) {
                                if (i != best && i != second_best) {
                                        if (energy[i]*BELL_MF_RELATIVE_PEAK >= energy[second_best]) {
                                                /* The best two are not clearly the best */
@@ -865,7 +981,7 @@ static int mf_detect(struct ast_dsp *dsp, digit_detect_state_t *s, int16_t amp[]
                                best = second_best;
                                second_best = i;
                        }
-                       best = best*5 + second_best - 1;
+                       best = best * 5 + second_best - 1;
                        hit = bell_mf_positions[best];
                        /* Look for two successive similar results */
                        /* The logic in the next test is:
@@ -875,7 +991,7 @@ static int mf_detect(struct ast_dsp *dsp, digit_detect_state_t *s, int16_t amp[]
                           two blocks of something different preceeding it. */
                        if (hit == s->td.mf.hits[4] && hit == s->td.mf.hits[3] &&
                           ((hit != '*' && hit != s->td.mf.hits[2] && hit != s->td.mf.hits[1])||
-                           (hit == '*' && hit == s->td.mf.hits[2] && hit != s->td.mf.hits[1] && 
+                           (hit == '*' && hit == s->td.mf.hits[2] && hit != s->td.mf.hits[1] &&
                            hit != s->td.mf.hits[0]))) {
                                store_digit(s, hit);
                        }
@@ -900,12 +1016,13 @@ static int mf_detect(struct ast_dsp *dsp, digit_detect_state_t *s, int16_t amp[]
                                mute_fragment(dsp, &mute);
                                mute.start = (sample > MF_GSIZE) ? (sample - MF_GSIZE) : 0;
                        }
-                       mute.end = limit + DTMF_GSIZE;
+                       mute.end = limit + MF_GSIZE;
                }
 
                /* Reinitialise the detector for the next block */
-               for (i = 0;  i < 6;  i++)
+               for (i = 0; i < 6; i++) {
                        goertzel_reset(&s->td.mf.tone_out[i]);
+               }
                s->td.mf.current_sample = 0;
        }
 
@@ -924,46 +1041,56 @@ static inline int pair_there(float p1, float p2, float i1, float i2, float e)
 {
        /* See if p1 and p2 are there, relative to i1 and i2 and total energy */
        /* Make sure absolute levels are high enough */
-       if ((p1 < TONE_MIN_THRESH) || (p2 < TONE_MIN_THRESH))
+       if ((p1 < TONE_MIN_THRESH) || (p2 < TONE_MIN_THRESH)) {
                return 0;
+       }
        /* Amplify ignored stuff */
        i2 *= TONE_THRESH;
        i1 *= TONE_THRESH;
        e *= TONE_THRESH;
        /* Check first tone */
-       if ((p1 < i1) || (p1 < i2) || (p1 < e))
+       if ((p1 < i1) || (p1 < i2) || (p1 < e)) {
                return 0;
+       }
        /* And second */
-       if ((p2 < i1) || (p2 < i2) || (p2 < e))
+       if ((p2 < i1) || (p2 < i2) || (p2 < e)) {
                return 0;
+       }
        /* Guess it's there... */
        return 1;
 }
 
 static int __ast_dsp_call_progress(struct ast_dsp *dsp, short *s, int len)
 {
+       short samp;
        int x;
        int y;
        int pass;
        int newstate = DSP_TONE_STATE_SILENCE;
        int res = 0;
+       int freqcount = dsp->freqcount > FREQ_ARRAY_SIZE ? FREQ_ARRAY_SIZE : dsp->freqcount;
+
        while (len) {
                /* Take the lesser of the number of samples we need and what we have */
                pass = len;
-               if (pass > dsp->gsamp_size - dsp->gsamps) 
+               if (pass > dsp->gsamp_size - dsp->gsamps) {
                        pass = dsp->gsamp_size - dsp->gsamps;
-               for (x=0;x<pass;x++) {
-                       for (y=0;y<dsp->freqcount;y++) 
-                               goertzel_sample(&dsp->freqs[y], s[x]);
-                       dsp->genergy += s[x] * s[x];
+               }
+               for (x = 0; x < pass; x++) {
+                       samp = s[x];
+                       dsp->genergy += (int32_t) samp * (int32_t) samp;
+                       for (y = 0; y < freqcount; y++) {
+                               goertzel_sample(&dsp->freqs[y], samp);
+                       }
                }
                s += pass;
                dsp->gsamps += pass;
                len -= pass;
                if (dsp->gsamps == dsp->gsamp_size) {
-                       float hz[7];
-                       for (y=0;y<7;y++)
+                       float hz[FREQ_ARRAY_SIZE];
+                       for (y = 0; y < FREQ_ARRAY_SIZE; y++) {
                                hz[y] = goertzel_result(&dsp->freqs[y]);
+                       }
                        switch (dsp->progmode) {
                        case PROG_MODE_NA:
                                if (pair_there(hz[HZ_480], hz[HZ_620], hz[HZ_350], hz[HZ_440], dsp->genergy)) {
@@ -975,74 +1102,83 @@ static int __ast_dsp_call_progress(struct ast_dsp *dsp, short *s, int len)
                                } else if (hz[HZ_950] > TONE_MIN_THRESH * TONE_THRESH) {
                                        newstate = DSP_TONE_STATE_SPECIAL1;
                                } else if (hz[HZ_1400] > TONE_MIN_THRESH * TONE_THRESH) {
-                                       if (dsp->tstate == DSP_TONE_STATE_SPECIAL1)
+                                       /* End of SPECIAL1 or middle of SPECIAL2 */
+                                       if (dsp->tstate == DSP_TONE_STATE_SPECIAL1 || dsp->tstate == DSP_TONE_STATE_SPECIAL2) {
                                                newstate = DSP_TONE_STATE_SPECIAL2;
+                                       }
                                } else if (hz[HZ_1800] > TONE_MIN_THRESH * TONE_THRESH) {
-                                       if (dsp->tstate == DSP_TONE_STATE_SPECIAL2)
+                                       /* End of SPECIAL2 or middle of SPECIAL3 */
+                                       if (dsp->tstate == DSP_TONE_STATE_SPECIAL2 || dsp->tstate == DSP_TONE_STATE_SPECIAL3) {
                                                newstate = DSP_TONE_STATE_SPECIAL3;
+                                       }
                                } else if (dsp->genergy > TONE_MIN_THRESH * TONE_THRESH) {
                                        newstate = DSP_TONE_STATE_TALKING;
-                               } else
+                               } else {
                                        newstate = DSP_TONE_STATE_SILENCE;
+                               }
                                break;
                        case PROG_MODE_CR:
                                if (hz[HZ_425] > TONE_MIN_THRESH * TONE_THRESH) {
                                        newstate = DSP_TONE_STATE_RINGING;
                                } else if (dsp->genergy > TONE_MIN_THRESH * TONE_THRESH) {
                                        newstate = DSP_TONE_STATE_TALKING;
-                               } else
+                               } else {
                                        newstate = DSP_TONE_STATE_SILENCE;
+                               }
                                break;
                        case PROG_MODE_UK:
-                               if (hz[HZ_400] > TONE_MIN_THRESH * TONE_THRESH) {
+                               if (hz[HZ_400UK] > TONE_MIN_THRESH * TONE_THRESH) {
                                        newstate = DSP_TONE_STATE_HUNGUP;
+                               } else if (pair_there(hz[HZ_350UK], hz[HZ_440UK], hz[HZ_400UK], hz[HZ_400UK], dsp->genergy)) {
+                                       newstate = DSP_TONE_STATE_DIALTONE;
                                }
                                break;
                        default:
-                               ast_log(LOG_WARNING, "Can't process in unknown prog mode '%d'\n", dsp->progmode);
+                               ast_log(LOG_WARNING, "Can't process in unknown prog mode '%u'\n", dsp->progmode);
                        }
                        if (newstate == dsp->tstate) {
                                dsp->tcount++;
-                               if (dsp->ringtimeout)
+                               if (dsp->ringtimeout) {
                                        dsp->ringtimeout++;
+                               }
                                switch (dsp->tstate) {
-                                       case DSP_TONE_STATE_RINGING:
-                                               if ((dsp->features & DSP_PROGRESS_RINGING) &&
-                                                   (dsp->tcount==THRESH_RING)) {
-                                                       res = AST_CONTROL_RINGING;
-                                                       dsp->ringtimeout= 1;
-                                               }
-                                               break;
-                                       case DSP_TONE_STATE_BUSY:
-                                               if ((dsp->features & DSP_PROGRESS_BUSY) &&
-                                                   (dsp->tcount==THRESH_BUSY)) {
-                                                       res = AST_CONTROL_BUSY;
-                                                       dsp->features &= ~DSP_FEATURE_CALL_PROGRESS;
-                                               }
-                                               break;
-                                       case DSP_TONE_STATE_TALKING:
-                                               if ((dsp->features & DSP_PROGRESS_TALK) &&
-                                                   (dsp->tcount==THRESH_TALK)) {
-                                                       res = AST_CONTROL_ANSWER;
-                                                       dsp->features &= ~DSP_FEATURE_CALL_PROGRESS;
-                                               }
-                                               break;
-                                       case DSP_TONE_STATE_SPECIAL3:
-                                               if ((dsp->features & DSP_PROGRESS_CONGESTION) &&
-                                                   (dsp->tcount==THRESH_CONGESTION)) {
-                                                       res = AST_CONTROL_CONGESTION;
-                                                       dsp->features &= ~DSP_FEATURE_CALL_PROGRESS;
-                                               }
-                                               break;
-                                       case DSP_TONE_STATE_HUNGUP:
-                                               if ((dsp->features & DSP_FEATURE_CALL_PROGRESS) &&
-                                                   (dsp->tcount==THRESH_HANGUP)) {
-                                                       res = AST_CONTROL_HANGUP;
-                                                       dsp->features &= ~DSP_FEATURE_CALL_PROGRESS;
-                                               }
-                                               break;
+                               case DSP_TONE_STATE_RINGING:
+                                       if ((dsp->features & DSP_PROGRESS_RINGING) &&
+                                           (dsp->tcount == THRESH_RING)) {
+                                               res = AST_CONTROL_RINGING;
+                                               dsp->ringtimeout = 1;
+                                       }
+                                       break;
+                               case DSP_TONE_STATE_BUSY:
+                                       if ((dsp->features & DSP_PROGRESS_BUSY) &&
+                                           (dsp->tcount == THRESH_BUSY)) {
+                                               res = AST_CONTROL_BUSY;
+                                               dsp->features &= ~DSP_FEATURE_CALL_PROGRESS;
+                                       }
+                                       break;
+                               case DSP_TONE_STATE_TALKING:
+                                       if ((dsp->features & DSP_PROGRESS_TALK) &&
+                                           (dsp->tcount == THRESH_TALK)) {
+                                               res = AST_CONTROL_ANSWER;
+                                               dsp->features &= ~DSP_FEATURE_CALL_PROGRESS;
+                                       }
+                                       break;
+                               case DSP_TONE_STATE_SPECIAL3:
+                                       if ((dsp->features & DSP_PROGRESS_CONGESTION) &&
+                                           (dsp->tcount == THRESH_CONGESTION)) {
+                                               res = AST_CONTROL_CONGESTION;
+                                               dsp->features &= ~DSP_FEATURE_CALL_PROGRESS;
+                                       }
+                                       break;
+                               case DSP_TONE_STATE_HUNGUP:
+                                       if ((dsp->features & DSP_FEATURE_CALL_PROGRESS) &&
+                                           (dsp->tcount == THRESH_HANGUP)) {
+                                               res = AST_CONTROL_HANGUP;
+                                               dsp->features &= ~DSP_FEATURE_CALL_PROGRESS;
+                                       }
+                                       break;
                                }
-                               if (dsp->ringtimeout==THRESH_RING2ANSWER) {
+                               if (dsp->ringtimeout == THRESH_RING2ANSWER) {
                                        ast_debug(1, "Consider call as answered because of timeout after last ring\n");
                                        res = AST_CONTROL_ANSWER;
                                        dsp->features &= ~DSP_FEATURE_CALL_PROGRESS;
@@ -1053,10 +1189,11 @@ static int __ast_dsp_call_progress(struct ast_dsp *dsp, short *s, int len)
                                dsp->tstate = newstate;
                                dsp->tcount = 1;
                        }
-                       
-                       /* Reset goertzel */                                            
-                       for (x=0;x<7;x++)
+
+                       /* Reset goertzel */
+                       for (x = 0; x < 7; x++) {
                                dsp->freqs[x].v2 = dsp->freqs[x].v3 = 0.0;
+                       }
                        dsp->gsamps = 0;
                        dsp->genergy = 0.0;
                }
@@ -1071,31 +1208,33 @@ int ast_dsp_call_progress(struct ast_dsp *dsp, struct ast_frame *inf)
                ast_log(LOG_WARNING, "Can't check call progress of non-voice frames\n");
                return 0;
        }
-       if (inf->subclass != AST_FORMAT_SLINEAR) {
+       if (!ast_format_cache_is_slinear(inf->subclass.format)) {
                ast_log(LOG_WARNING, "Can only check call progress in signed-linear frames\n");
                return 0;
        }
        return __ast_dsp_call_progress(dsp, inf->data.ptr, inf->datalen / 2);
 }
 
-static int __ast_dsp_silence_noise(struct ast_dsp *dsp, short *s, int len, int *totalsilence, int *totalnoise)
+static int __ast_dsp_silence_noise(struct ast_dsp *dsp, short *s, int len, int *totalsilence, int *totalnoise, int *frames_energy)
 {
        int accum;
        int x;
        int res = 0;
 
-       if (!len)
+       if (!len) {
                return 0;
+       }
        accum = 0;
-       for (x=0;x<len; x++) 
+       for (x = 0; x < len; x++) {
                accum += abs(s[x]);
+       }
        accum /= len;
        if (accum < dsp->threshold) {
                /* Silent */
-               dsp->totalsilence += len/8;
+               dsp->totalsilence += len / (dsp->sample_rate / 1000);
                if (dsp->totalnoise) {
                        /* Move and save history */
-                       memmove(dsp->historicnoise + DSP_HISTORY - dsp->busycount, dsp->historicnoise + DSP_HISTORY - dsp->busycount +1, dsp->busycount*sizeof(dsp->historicnoise[0]));
+                       memmove(dsp->historicnoise + DSP_HISTORY - dsp->busycount, dsp->historicnoise + DSP_HISTORY - dsp->busycount + 1, dsp->busycount * sizeof(dsp->historicnoise[0]));
                        dsp->historicnoise[DSP_HISTORY - 1] = dsp->totalnoise;
 /* we don't want to check for busydetect that frequently */
 #if 0
@@ -1106,32 +1245,39 @@ static int __ast_dsp_silence_noise(struct ast_dsp *dsp, short *s, int len, int *
                res = 1;
        } else {
                /* Not silent */
-               dsp->totalnoise += len/8;
+               dsp->totalnoise += len / (dsp->sample_rate / 1000);
                if (dsp->totalsilence) {
                        int silence1 = dsp->historicsilence[DSP_HISTORY - 1];
                        int silence2 = dsp->historicsilence[DSP_HISTORY - 2];
                        /* Move and save history */
-                       memmove(dsp->historicsilence + DSP_HISTORY - dsp->busycount, dsp->historicsilence + DSP_HISTORY - dsp->busycount + 1, dsp->busycount*sizeof(dsp->historicsilence[0]));
+                       memmove(dsp->historicsilence + DSP_HISTORY - dsp->busycount, dsp->historicsilence + DSP_HISTORY - dsp->busycount + 1, dsp->busycount * sizeof(dsp->historicsilence[0]));
                        dsp->historicsilence[DSP_HISTORY - 1] = dsp->totalsilence;
                        /* check if the previous sample differs only by BUSY_PERCENT from the one before it */
                        if (silence1 < silence2) {
-                               if (silence1 + silence1*BUSY_PERCENT/100 >= silence2)
+                               if (silence1 + silence1 * BUSY_PERCENT / 100 >= silence2) {
                                        dsp->busymaybe = 1;
-                               else 
+                               } else {
                                        dsp->busymaybe = 0;
+                               }
                        } else {
-                               if (silence1 - silence1*BUSY_PERCENT/100 <= silence2)
+                               if (silence1 - silence1 * BUSY_PERCENT / 100 <= silence2) {
                                        dsp->busymaybe = 1;
-                               else 
+                               } else {
                                        dsp->busymaybe = 0;
+                               }
                        }
                }
                dsp->totalsilence = 0;
        }
-       if (totalsilence)
+       if (totalsilence) {
                *totalsilence = dsp->totalsilence;
-       if (totalnoise)
+       }
+       if (totalnoise) {
                *totalnoise = dsp->totalnoise;
+       }
+       if (frames_energy) {
+               *frames_energy = accum;
+       }
        return res;
 }
 
@@ -1142,9 +1288,15 @@ int ast_dsp_busydetect(struct ast_dsp *dsp)
        int avgsilence = 0, hitsilence = 0;
 #endif
        int avgtone = 0, hittone = 0;
-       if (!dsp->busymaybe)
-               return res;
-       for (x=DSP_HISTORY - dsp->busycount;x<DSP_HISTORY;x++) {
+
+       /* if we have a 4 length pattern, the way busymaybe is set doesn't help us. */
+       if (dsp->busy_cadence.length != 4) {
+               if (!dsp->busymaybe) {
+                       return res;
+               }
+       }
+
+       for (x = DSP_HISTORY - dsp->busycount; x < DSP_HISTORY; x++) {
 #ifndef BUSYDETECT_TONEONLY
                avgsilence += dsp->historicsilence[x];
 #endif
@@ -1154,60 +1306,103 @@ int ast_dsp_busydetect(struct ast_dsp *dsp)
        avgsilence /= dsp->busycount;
 #endif
        avgtone /= dsp->busycount;
-       for (x=DSP_HISTORY - dsp->busycount;x<DSP_HISTORY;x++) {
+       for (x = DSP_HISTORY - dsp->busycount; x < DSP_HISTORY; x++) {
 #ifndef BUSYDETECT_TONEONLY
                if (avgsilence > dsp->historicsilence[x]) {
-                       if (avgsilence - (avgsilence*BUSY_PERCENT/100) <= dsp->historicsilence[x])
+                       if (avgsilence - (avgsilence * BUSY_PERCENT / 100) <= dsp->historicsilence[x]) {
                                hitsilence++;
+                       }
                } else {
-                       if (avgsilence + (avgsilence*BUSY_PERCENT/100) >= dsp->historicsilence[x])
+                       if (avgsilence + (avgsilence * BUSY_PERCENT / 100) >= dsp->historicsilence[x]) {
                                hitsilence++;
+                       }
                }
 #endif
                if (avgtone > dsp->historicnoise[x]) {
-                       if (avgtone - (avgtone*BUSY_PERCENT/100) <= dsp->historicnoise[x])
+                       if (avgtone - (avgtone * BUSY_PERCENT / 100) <= dsp->historicnoise[x]) {
                                hittone++;
+                       }
                } else {
-                       if (avgtone + (avgtone*BUSY_PERCENT/100) >= dsp->historicnoise[x])
+                       if (avgtone + (avgtone * BUSY_PERCENT / 100) >= dsp->historicnoise[x]) {
                                hittone++;
+                       }
                }
        }
 #ifndef BUSYDETECT_TONEONLY
-       if ((hittone >= dsp->busycount - 1) && (hitsilence >= dsp->busycount - 1) && 
-           (avgtone >= BUSY_MIN && avgtone <= BUSY_MAX) && 
+       if ((hittone >= dsp->busycount - 1) && (hitsilence >= dsp->busycount - 1) &&
+           (avgtone >= BUSY_MIN && avgtone <= BUSY_MAX) &&
            (avgsilence >= BUSY_MIN && avgsilence <= BUSY_MAX)) {
 #else
        if ((hittone >= dsp->busycount - 1) && (avgtone >= BUSY_MIN && avgtone <= BUSY_MAX)) {
 #endif
 #ifdef BUSYDETECT_COMPARE_TONE_AND_SILENCE
                if (avgtone > avgsilence) {
-                       if (avgtone - avgtone*BUSY_PERCENT/100 <= avgsilence)
+                       if (avgtone - avgtone*BUSY_PERCENT/100 <= avgsilence) {
                                res = 1;
+                       }
                } else {
-                       if (avgtone + avgtone*BUSY_PERCENT/100 >= avgsilence)
+                       if (avgtone + avgtone*BUSY_PERCENT/100 >= avgsilence) {
                                res = 1;
+                       }
                }
 #else
                res = 1;
 #endif
        }
+
+       /* If we have a 4-length pattern, we can go ahead and just check it in a different way. */
+       if (dsp->busy_cadence.length == 4) {
+               int x;
+               int errors = 0;
+               int errors_max = ((4 * dsp->busycount) / 100.0) * BUSY_PAT_PERCENT;
+
+               for (x = DSP_HISTORY - (dsp->busycount); x < DSP_HISTORY; x += 2) {
+                       int temp_error;
+                       temp_error = abs(dsp->historicnoise[x] - dsp->busy_cadence.pattern[0]);
+                       if ((temp_error * 100) / dsp->busy_cadence.pattern[0] > BUSY_PERCENT) {
+                               errors++;
+                       }
+
+                       temp_error = abs(dsp->historicnoise[x + 1] - dsp->busy_cadence.pattern[2]);
+                       if ((temp_error * 100) / dsp->busy_cadence.pattern[2] > BUSY_PERCENT) {
+                               errors++;
+                       }
+
+                       temp_error = abs(dsp->historicsilence[x] - dsp->busy_cadence.pattern[1]);
+                       if ((temp_error * 100) / dsp->busy_cadence.pattern[1] > BUSY_PERCENT) {
+                               errors++;
+                       }
+
+                       temp_error = abs(dsp->historicsilence[x + 1] - dsp->busy_cadence.pattern[3]);
+                       if ((temp_error * 100) / dsp->busy_cadence.pattern[3] > BUSY_PERCENT) {
+                               errors++;
+                       }
+               }
+
+               ast_debug(5, "errors = %d  max = %d\n", errors, errors_max);
+
+               if (errors <= errors_max) {
+                       return 1;
+               }
+       }
+
        /* If we know the expected busy tone length, check we are in the range */
-       if (res && (dsp->busy_tonelength > 0)) {
-               if (abs(avgtone - dsp->busy_tonelength) > (dsp->busy_tonelength*BUSY_PAT_PERCENT/100)) {
+       if (res && (dsp->busy_cadence.pattern[0] > 0)) {
+               if (abs(avgtone - dsp->busy_cadence.pattern[0]) > MAX(dsp->busy_cadence.pattern[0]*BUSY_PAT_PERCENT/100, 20)) {
 #ifdef BUSYDETECT_DEBUG
                        ast_debug(5, "busy detector: avgtone of %d not close enough to desired %d\n",
-                               avgtone, dsp->busy_tonelength);
+                               avgtone, dsp->busy_cadence.pattern[0]);
 #endif
                        res = 0;
                }
        }
 #ifndef BUSYDETECT_TONEONLY
        /* If we know the expected busy tone silent-period length, check we are in the range */
-       if (res && (dsp->busy_quietlength > 0)) {
-               if (abs(avgsilence - dsp->busy_quietlength) > (dsp->busy_quietlength*BUSY_PAT_PERCENT/100)) {
+       if (res && (dsp->busy_cadence.pattern[1] > 0)) {
+               if (abs(avgsilence - dsp->busy_cadence.pattern[1]) > MAX(dsp->busy_cadence.pattern[1]*BUSY_PAT_PERCENT/100, 20)) {
 #ifdef BUSYDETECT_DEBUG
                ast_debug(5, "busy detector: avgsilence of %d not close enough to desired %d\n",
-                       avgsilence, dsp->busy_quietlength);
+                       avgsilence, dsp->busy_cadence.pattern[1]);
 #endif
                        res = 0;
                }
@@ -1223,40 +1418,64 @@ int ast_dsp_busydetect(struct ast_dsp *dsp)
        return res;
 }
 
-int ast_dsp_silence(struct ast_dsp *dsp, struct ast_frame *f, int *totalsilence)
+static int ast_dsp_silence_noise_with_energy(struct ast_dsp *dsp, struct ast_frame *f, int *total, int *frames_energy, int noise)
 {
        short *s;
        int len;
-       
+       int x;
+       unsigned char *odata;
+
+       if (!f) {
+               return 0;
+       }
+
        if (f->frametype != AST_FRAME_VOICE) {
                ast_log(LOG_WARNING, "Can't calculate silence on a non-voice frame\n");
                return 0;
        }
-       if (f->subclass != AST_FORMAT_SLINEAR) {
-               ast_log(LOG_WARNING, "Can only calculate silence on signed-linear frames :(\n");
-               return 0;
+
+       if (ast_format_cache_is_slinear(f->subclass.format)) {
+               s = f->data.ptr;
+               len = f->datalen/2;
+       } else {
+               odata = f->data.ptr;
+               len = f->datalen;
+               if (ast_format_cmp(f->subclass.format, ast_format_ulaw)) {
+                       s = ast_alloca(len * 2);
+                       for (x = 0; x < len; x++) {
+                               s[x] = AST_MULAW(odata[x]);
+                       }
+               } else if (ast_format_cmp(f->subclass.format, ast_format_alaw)) {
+                       s = ast_alloca(len * 2);
+                       for (x = 0; x < len; x++) {
+                               s[x] = AST_ALAW(odata[x]);
+                       }
+               } else {
+                       ast_log(LOG_WARNING, "Can only calculate silence on signed-linear, alaw or ulaw frames :(\n");
+                       return 0;
+               }
+       }
+
+       if (noise) {
+               return __ast_dsp_silence_noise(dsp, s, len, NULL, total, frames_energy);
+       } else {
+               return __ast_dsp_silence_noise(dsp, s, len, total, NULL, frames_energy);
        }
-       s = f->data.ptr;
-       len = f->datalen/2;
-       return __ast_dsp_silence_noise(dsp, s, len, totalsilence, NULL);
+}
+
+int ast_dsp_silence_with_energy(struct ast_dsp *dsp, struct ast_frame *f, int *totalsilence, int *frames_energy)
+{
+       return ast_dsp_silence_noise_with_energy(dsp, f, totalsilence, frames_energy, 0);
+}
+
+int ast_dsp_silence(struct ast_dsp *dsp, struct ast_frame *f, int *totalsilence)
+{
+       return ast_dsp_silence_noise_with_energy(dsp, f, totalsilence, NULL, 0);
 }
 
 int ast_dsp_noise(struct ast_dsp *dsp, struct ast_frame *f, int *totalnoise)
 {
-       short *s;
-       int len;
-
-       if (f->frametype != AST_FRAME_VOICE) {
-               ast_log(LOG_WARNING, "Can't calculate noise on a non-voice frame\n");
-               return 0;
-       }
-       if (f->subclass != AST_FORMAT_SLINEAR) {
-               ast_log(LOG_WARNING, "Can only calculate noise on signed-linear frames :(\n");
-               return 0;
-       }
-       s = f->data.ptr;
-       len = f->datalen/2;
-       return __ast_dsp_silence_noise(dsp, s, len, NULL, totalnoise);
+       return ast_dsp_silence_noise_with_energy(dsp, f, totalnoise, NULL, 1);
 }
 
 
@@ -1271,31 +1490,35 @@ struct ast_frame *ast_dsp_process(struct ast_channel *chan, struct ast_dsp *dsp,
        int len;
        struct ast_frame *outf = NULL;
 
-       if (!af)
+       if (!af) {
                return NULL;
-       if (af->frametype != AST_FRAME_VOICE)
+       }
+       if (af->frametype != AST_FRAME_VOICE) {
                return af;
+       }
 
        odata = af->data.ptr;
        len = af->datalen;
        /* Make sure we have short data */
-       switch (af->subclass) {
-       case AST_FORMAT_SLINEAR:
+       if (ast_format_cache_is_slinear(af->subclass.format)) {
                shortdata = af->data.ptr;
                len = af->datalen / 2;
-               break;
-       case AST_FORMAT_ULAW:
-               shortdata = alloca(af->datalen * 2);
-               for (x = 0;x < len; x++) 
+       } else if (ast_format_cmp(af->subclass.format, ast_format_ulaw) == AST_FORMAT_CMP_EQUAL) {
+               shortdata = ast_alloca(af->datalen * 2);
+               for (x = 0; x < len; x++) {
                        shortdata[x] = AST_MULAW(odata[x]);
-               break;
-       case AST_FORMAT_ALAW:
-               shortdata = alloca(af->datalen * 2);
-               for (x = 0; x < len; x++) 
+               }
+       } else if (ast_format_cmp(af->subclass.format, ast_format_alaw) == AST_FORMAT_CMP_EQUAL) {
+               shortdata = ast_alloca(af->datalen * 2);
+               for (x = 0; x < len; x++) {
                        shortdata[x] = AST_ALAW(odata[x]);
-               break;
-       default:
-               ast_log(LOG_WARNING, "Inband DTMF is not supported on codec %s. Use RFC2833\n", ast_getformatname(af->subclass));
+               }
+       } else {
+               /*Display warning only once. Otherwise you would get hundreds of warnings every second */
+               if (dsp->display_inband_dtmf_warning) {
+                       ast_log(LOG_WARNING, "Inband DTMF is not supported on codec %s. Use RFC2833\n", ast_format_get_name(af->subclass.format));
+               }
+               dsp->display_inband_dtmf_warning = 0;
                return af;
        }
 
@@ -1304,25 +1527,23 @@ struct ast_frame *ast_dsp_process(struct ast_channel *chan, struct ast_dsp *dsp,
 
        /* Need to run the silence detection stuff for silence suppression and busy detection */
        if ((dsp->features & DSP_FEATURE_SILENCE_SUPPRESS) || (dsp->features & DSP_FEATURE_BUSY_DETECT)) {
-               res = __ast_dsp_silence_noise(dsp, shortdata, len, &silence, NULL);
+               res = __ast_dsp_silence_noise(dsp, shortdata, len, &silence, NULL, NULL);
        }
 
        if ((dsp->features & DSP_FEATURE_SILENCE_SUPPRESS) && silence) {
                memset(&dsp->f, 0, sizeof(dsp->f));
                dsp->f.frametype = AST_FRAME_NULL;
                ast_frfree(af);
-               ast_set_flag(&dsp->f, AST_FRFLAG_FROM_DSP);
-               return &dsp->f;
+               return ast_frisolate(&dsp->f);
        }
        if ((dsp->features & DSP_FEATURE_BUSY_DETECT) && ast_dsp_busydetect(dsp)) {
-               chan->_softhangup |= AST_SOFTHANGUP_DEV;
+               ast_channel_softhangup_internal_flag_add(chan, AST_SOFTHANGUP_DEV);
                memset(&dsp->f, 0, sizeof(dsp->f));
                dsp->f.frametype = AST_FRAME_CONTROL;
-               dsp->f.subclass = AST_CONTROL_BUSY;
+               dsp->f.subclass.integer = AST_CONTROL_BUSY;
                ast_frfree(af);
-               ast_debug(1, "Requesting Hangup because the busy tone was detected on channel %s\n", chan->name);
-               ast_set_flag(&dsp->f, AST_FRFLAG_FROM_DSP);
-               return &dsp->f;
+               ast_debug(1, "Requesting Hangup because the busy tone was detected on channel %s\n", ast_channel_name(chan));
+               return ast_frisolate(&dsp->f);
        }
 
        if ((dsp->features & DSP_FEATURE_FAX_DETECT)) {
@@ -1335,37 +1556,51 @@ struct ast_frame *ast_dsp_process(struct ast_channel *chan, struct ast_dsp *dsp,
                }
        }
 
-       if ((dsp->features & DSP_FEATURE_DIGIT_DETECT)) {
-               if ((dsp->digitmode & DSP_DIGITMODE_MF))
+       if (dsp->features & (DSP_FEATURE_DIGIT_DETECT | DSP_FEATURE_BUSY_DETECT)) {
+               if (dsp->digitmode & DSP_DIGITMODE_MF) {
                        digit = mf_detect(dsp, &dsp->digit_state, shortdata, len, (dsp->digitmode & DSP_DIGITMODE_NOQUELCH) == 0, (dsp->digitmode & DSP_DIGITMODE_RELAXDTMF));
-               else
+               } else {
                        digit = dtmf_detect(dsp, &dsp->digit_state, shortdata, len, (dsp->digitmode & DSP_DIGITMODE_NOQUELCH) == 0, (dsp->digitmode & DSP_DIGITMODE_RELAXDTMF));
+               }
 
                if (dsp->digit_state.current_digits) {
-                       int event = 0;
+                       int event = 0, event_len = 0;
                        char event_digit = 0;
 
                        if (!dsp->dtmf_began) {
                                /* We have not reported DTMF_BEGIN for anything yet */
 
-                               event = AST_FRAME_DTMF_BEGIN;
-                               event_digit = dsp->digit_state.digits[0];
+                               if (dsp->features & DSP_FEATURE_DIGIT_DETECT) {
+                                       event = AST_FRAME_DTMF_BEGIN;
+                                       event_digit = dsp->digit_state.digits[0];
+                               }
                                dsp->dtmf_began = 1;
 
                        } else if (dsp->digit_state.current_digits > 1 || digit != dsp->digit_state.digits[0]) {
                                /* Digit changed. This means digit we have reported with DTMF_BEGIN ended */
-       
-                               event = AST_FRAME_DTMF_END;
-                               event_digit = dsp->digit_state.digits[0];
-                               memmove(dsp->digit_state.digits, dsp->digit_state.digits + 1, dsp->digit_state.current_digits);
+                               if (dsp->features & DSP_FEATURE_DIGIT_DETECT) {
+                                       event = AST_FRAME_DTMF_END;
+                                       event_digit = dsp->digit_state.digits[0];
+                                       event_len = dsp->digit_state.digitlen[0] * 1000 / dsp->sample_rate;
+                               }
+                               memmove(&dsp->digit_state.digits[0], &dsp->digit_state.digits[1], dsp->digit_state.current_digits);
+                               memmove(&dsp->digit_state.digitlen[0], &dsp->digit_state.digitlen[1], dsp->digit_state.current_digits * sizeof(dsp->digit_state.digitlen[0]));
                                dsp->digit_state.current_digits--;
                                dsp->dtmf_began = 0;
+
+                               if (dsp->features & DSP_FEATURE_BUSY_DETECT) {
+                                       /* Reset Busy Detector as we have some confirmed activity */
+                                       memset(dsp->historicsilence, 0, sizeof(dsp->historicsilence));
+                                       memset(dsp->historicnoise, 0, sizeof(dsp->historicnoise));
+                                       ast_debug(1, "DTMF Detected - Reset busydetector\n");
+                               }
                        }
 
                        if (event) {
                                memset(&dsp->f, 0, sizeof(dsp->f));
                                dsp->f.frametype = event;
-                               dsp->f.subclass = event_digit;
+                               dsp->f.subclass.integer = event_digit;
+                               dsp->f.len = event_len;
                                outf = &dsp->f;
                                goto done;
                        }
@@ -1377,7 +1612,7 @@ struct ast_frame *ast_dsp_process(struct ast_channel *chan, struct ast_dsp *dsp,
 
                memset(&dsp->f, 0, sizeof(dsp->f));
                dsp->f.frametype = AST_FRAME_DTMF;
-               dsp->f.subclass = fax_digit;
+               dsp->f.subclass.integer = fax_digit;
                outf = &dsp->f;
                goto done;
        }
@@ -1393,15 +1628,18 @@ struct ast_frame *ast_dsp_process(struct ast_channel *chan, struct ast_dsp *dsp,
                        case AST_CONTROL_HANGUP:
                                memset(&dsp->f, 0, sizeof(dsp->f));
                                dsp->f.frametype = AST_FRAME_CONTROL;
-                               dsp->f.subclass = res;
+                               dsp->f.subclass.integer = res;
                                dsp->f.src = "dsp_progress";
-                               if (chan) 
+                               if (chan) {
                                        ast_queue_frame(chan, &dsp->f);
+                               }
                                break;
                        default:
                                ast_log(LOG_WARNING, "Don't know how to represent call progress message %d\n", res);
                        }
                }
+       } else if ((dsp->features & DSP_FEATURE_WAITDIALTONE)) {
+               res = __ast_dsp_call_progress(dsp, shortdata, len);
        }
 
 done:
@@ -1410,25 +1648,22 @@ done:
                memset(shortdata + dsp->mute_data[x].start, 0, sizeof(int16_t) * (dsp->mute_data[x].end - dsp->mute_data[x].start));
        }
 
-       switch (af->subclass) {
-       case AST_FORMAT_SLINEAR:
-               break;
-       case AST_FORMAT_ULAW:
-               for (x = 0; x < len; x++)
+       if (ast_format_cmp(af->subclass.format, ast_format_ulaw) == AST_FORMAT_CMP_EQUAL) {
+               for (x = 0; x < len; x++) {
                        odata[x] = AST_LIN2MU((unsigned short) shortdata[x]);
-               break;
-       case AST_FORMAT_ALAW:
-               for (x = 0; x < len; x++)
+               }
+       } else if (ast_format_cmp(af->subclass.format, ast_format_alaw) == AST_FORMAT_CMP_EQUAL) {
+               for (x = 0; x < len; x++) {
                        odata[x] = AST_LIN2A((unsigned short) shortdata[x]);
-               break;
+               }
        }
 
        if (outf) {
-               if (chan) 
+               if (chan) {
                        ast_queue_frame(chan, af);
+               }
                ast_frfree(af);
-               ast_set_flag(outf, AST_FRFLAG_FROM_DSP);
-               return outf;
+               return ast_frisolate(outf);
        } else {
                return af;
        }
@@ -1438,31 +1673,39 @@ static void ast_dsp_prog_reset(struct ast_dsp *dsp)
 {
        int max = 0;
        int x;
-       
+
        dsp->gsamp_size = modes[dsp->progmode].size;
        dsp->gsamps = 0;
-       for (x = 0; x < sizeof(modes[dsp->progmode].freqs) / sizeof(modes[dsp->progmode].freqs[0]); x++) {
+       for (x = 0; x < FREQ_ARRAY_SIZE; x++) {
                if (modes[dsp->progmode].freqs[x]) {
-                       goertzel_init(&dsp->freqs[x], (float)modes[dsp->progmode].freqs[x], dsp->gsamp_size);
+                       goertzel_init(&dsp->freqs[x], (float)modes[dsp->progmode].freqs[x], dsp->sample_rate);
                        max = x + 1;
                }
        }
        dsp->freqcount = max;
-       dsp->ringtimeout= 0;
+       dsp->ringtimeout = 0;
 }
 
-struct ast_dsp *ast_dsp_new(void)
+unsigned int ast_dsp_get_sample_rate(const struct ast_dsp *dsp)
+{
+       return dsp->sample_rate;
+}
+
+static struct ast_dsp *__ast_dsp_new(unsigned int sample_rate)
 {
        struct ast_dsp *dsp;
-       
-       if ((dsp = ast_calloc(1, sizeof(*dsp)))) {              
+
+       if ((dsp = ast_calloc(1, sizeof(*dsp)))) {
                dsp->threshold = DEFAULT_THRESHOLD;
                dsp->features = DSP_FEATURE_SILENCE_SUPPRESS;
                dsp->busycount = DSP_HISTORY;
                dsp->digitmode = DSP_DIGITMODE_DTMF;
                dsp->faxmode = DSP_FAXMODE_DETECT_CNG;
+               dsp->sample_rate = sample_rate;
+               dsp->freqcount = 0;
                /* Initialize digit detector */
-               ast_digit_detect_init(&dsp->digit_state, dsp->digitmode & DSP_DIGITMODE_MF);
+               ast_digit_detect_init(&dsp->digit_state, dsp->digitmode & DSP_DIGITMODE_MF, dsp->sample_rate);
+               dsp->display_inband_dtmf_warning = 1;
                /* Initialize initial DSP progress detect parameters */
                ast_dsp_prog_reset(dsp);
                /* Initialize fax detector */
@@ -1471,23 +1714,33 @@ struct ast_dsp *ast_dsp_new(void)
        return dsp;
 }
 
+struct ast_dsp *ast_dsp_new(void)
+{
+       return __ast_dsp_new(DEFAULT_SAMPLE_RATE);
+}
+
+struct ast_dsp *ast_dsp_new_with_rate(unsigned int sample_rate)
+{
+       return __ast_dsp_new(sample_rate);
+}
+
 void ast_dsp_set_features(struct ast_dsp *dsp, int features)
 {
        dsp->features = features;
+       if (!(features & DSP_FEATURE_DIGIT_DETECT)) {
+               dsp->display_inband_dtmf_warning = 0;
+       }
 }
 
-void ast_dsp_free(struct ast_dsp *dsp)
+
+int ast_dsp_get_features(struct ast_dsp *dsp)
 {
-       if (ast_test_flag(&dsp->f, AST_FRFLAG_FROM_DSP)) {
-               /* If this flag is still set, that means that the dsp's destruction 
-                * been torn down, while we still have a frame out there being used.
-                * When ast_frfree() gets called on that frame, this ast_trans_pvt
-                * will get destroyed, too. */
+        return (dsp->features);
+}
 
-               dsp->destroy = 1;
 
-               return;
-       }
+void ast_dsp_free(struct ast_dsp *dsp)
+{
        ast_free(dsp);
 }
 
@@ -1498,41 +1751,44 @@ void ast_dsp_set_threshold(struct ast_dsp *dsp, int threshold)
 
 void ast_dsp_set_busy_count(struct ast_dsp *dsp, int cadences)
 {
-       if (cadences < 4)
+       if (cadences < 4) {
                cadences = 4;
-       if (cadences > DSP_HISTORY)
+       }
+       if (cadences > DSP_HISTORY) {
                cadences = DSP_HISTORY;
+       }
        dsp->busycount = cadences;
 }
 
-void ast_dsp_set_busy_pattern(struct ast_dsp *dsp, int tonelength, int quietlength)
+void ast_dsp_set_busy_pattern(struct ast_dsp *dsp, const struct ast_dsp_busy_pattern *cadence)
 {
-       dsp->busy_tonelength = tonelength;
-       dsp->busy_quietlength = quietlength;
-       ast_debug(1, "dsp busy pattern set to %d,%d\n", tonelength, quietlength);
+       dsp->busy_cadence = *cadence;
+       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);
 }
 
 void ast_dsp_digitreset(struct ast_dsp *dsp)
 {
        int i;
-       
+
        dsp->dtmf_began = 0;
        if (dsp->digitmode & DSP_DIGITMODE_MF) {
                mf_detect_state_t *s = &dsp->digit_state.td.mf;
                /* Reinitialise the detector for the next block */
-               for (i = 0;  i < 6;  i++) {
+               for (i = 0; i < 6; i++) {
                        goertzel_reset(&s->tone_out[i]);
                }
-               s->hits[4] = s->hits[3] = s->hits[2] = s->hits[1] = s->hits[0] = s->current_hit = 0;
+               s->hits[4] = s->hits[3] = s->hits[2] = s->hits[1] = s->hits[0] = 0;
+               s->current_hit = 0;
                s->current_sample = 0;
        } else {
                dtmf_detect_state_t *s = &dsp->digit_state.td.dtmf;
                /* Reinitialise the detector for the next block */
-               for (i = 0;  i < 4;  i++) {
+               for (i = 0; i < 4; i++) {
                        goertzel_reset(&s->row_out[i]);
                        goertzel_reset(&s->col_out[i]);
                }
-               s->lasthit = s->current_hit = 0;
+               s->lasthit = 0;
+               s->current_hit = 0;
                s->energy = 0.0;
                s->current_sample = 0;
                s->hits = 0;
@@ -1546,26 +1802,27 @@ void ast_dsp_digitreset(struct ast_dsp *dsp)
 void ast_dsp_reset(struct ast_dsp *dsp)
 {
        int x;
-       
+
        dsp->totalsilence = 0;
        dsp->gsamps = 0;
-       for (x=0;x<4;x++)
+       for (x = 0; x < 4; x++) {
                dsp->freqs[x].v2 = dsp->freqs[x].v3 = 0.0;
+       }
        memset(dsp->historicsilence, 0, sizeof(dsp->historicsilence));
-       memset(dsp->historicnoise, 0, sizeof(dsp->historicnoise));      
-       dsp->ringtimeout= 0;
+       memset(dsp->historicnoise, 0, sizeof(dsp->historicnoise));
+       dsp->ringtimeout = 0;
 }
 
 int ast_dsp_set_digitmode(struct ast_dsp *dsp, int digitmode)
 {
        int new;
        int old;
-       
+
        old = dsp->digitmode & (DSP_DIGITMODE_DTMF | DSP_DIGITMODE_MF | DSP_DIGITMODE_MUTECONF | DSP_DIGITMODE_MUTEMAX);
        new = digitmode & (DSP_DIGITMODE_DTMF | DSP_DIGITMODE_MF | DSP_DIGITMODE_MUTECONF | DSP_DIGITMODE_MUTEMAX);
        if (old != new) {
                /* Must initialize structures if switching from MF to DTMF or vice-versa */
-               ast_digit_detect_init(&dsp->digit_state, new & DSP_DIGITMODE_MF);
+               ast_digit_detect_init(&dsp->digit_state, new & DSP_DIGITMODE_MF, dsp->sample_rate);
        }
        dsp->digitmode = digitmode;
        return 0;
@@ -1574,16 +1831,16 @@ int ast_dsp_set_digitmode(struct ast_dsp *dsp, int digitmode)
 int ast_dsp_set_faxmode(struct ast_dsp *dsp, int faxmode)
 {
        if (dsp->faxmode != faxmode) {
+               dsp->faxmode = faxmode;
                ast_fax_detect_init(dsp);
        }
-       dsp->faxmode = faxmode;
        return 0;
 }
 
 int ast_dsp_set_call_progress_zone(struct ast_dsp *dsp, char *zone)
 {
        int x;
-       
+
        for (x = 0; x < ARRAY_LEN(aliases); x++) {
                if (!strcasecmp(aliases[x].name, zone)) {
                        dsp->progmode = aliases[x].mode;
@@ -1599,35 +1856,101 @@ int ast_dsp_was_muted(struct ast_dsp *dsp)
        return (dsp->mute_fragments > 0);
 }
 
-int ast_dsp_get_tstate(struct ast_dsp *dsp) 
+int ast_dsp_get_tstate(struct ast_dsp *dsp)
 {
        return dsp->tstate;
 }
 
-int ast_dsp_get_tcount(struct ast_dsp *dsp) 
+int ast_dsp_get_tcount(struct ast_dsp *dsp)
 {
        return dsp->tcount;
 }
 
 static int _dsp_init(int reload)
 {
-       struct ast_flags config_flags = { reload ? CONFIG_FLAG_FILEUNCHANGED : 0 };
        struct ast_config *cfg;
+       struct ast_variable *v;
+       struct ast_flags config_flags = { reload ? CONFIG_FLAG_FILEUNCHANGED : 0 };
+       int cfg_threshold;
+       float cfg_twist;
 
-       cfg = ast_config_load2(CONFIG_FILE_NAME, "dsp", config_flags);
+       if ((cfg = ast_config_load2(CONFIG_FILE_NAME, "dsp", config_flags)) == CONFIG_STATUS_FILEUNCHANGED) {
+               return 0;
+       }
 
-       if (cfg && cfg != CONFIG_STATUS_FILEUNCHANGED) {
-               const char *value;
+       thresholds[THRESHOLD_SILENCE] = DEFAULT_SILENCE_THRESHOLD;
+       dtmf_normal_twist = DEF_DTMF_NORMAL_TWIST;
+       dtmf_reverse_twist = DEF_DTMF_REVERSE_TWIST;
+       relax_dtmf_normal_twist = DEF_RELAX_DTMF_NORMAL_TWIST;
+       relax_dtmf_reverse_twist = DEF_RELAX_DTMF_REVERSE_TWIST;
+        dtmf_hits_to_begin = DEF_DTMF_HITS_TO_BEGIN;
+        dtmf_misses_to_end = DEF_DTMF_MISSES_TO_END;
 
-               value = ast_variable_retrieve(cfg, "default", "silencethreshold");
-               if (value && sscanf(value, "%d", &thresholds[THRESHOLD_SILENCE]) != 1) {
-                       ast_log(LOG_WARNING, "%s: '%s' is not a valid silencethreshold value\n", CONFIG_FILE_NAME, value);
-                       thresholds[THRESHOLD_SILENCE] = 256;
-               } else if (!value)
-                       thresholds[THRESHOLD_SILENCE] = 256;
+       if (cfg == CONFIG_STATUS_FILEMISSING || cfg == CONFIG_STATUS_FILEINVALID) {
+               return 0;
+       }
 
-               ast_config_destroy(cfg);
+       for (v = ast_variable_browse(cfg, "default"); v; v = v->next) {
+               if (!strcasecmp(v->name, "silencethreshold")) {
+                       if (sscanf(v->value, "%30d", &cfg_threshold) < 1) {
+                               ast_log(LOG_WARNING, "Unable to convert '%s' to a numeric value.\n", v->value);
+                       } else if (cfg_threshold < 0) {
+                               ast_log(LOG_WARNING, "Invalid silence threshold '%d' specified, using default\n", cfg_threshold);
+                       } else {
+                               thresholds[THRESHOLD_SILENCE] = cfg_threshold;
+                       }
+               } else if (!strcasecmp(v->name, "dtmf_normal_twist")) {
+                       if (sscanf(v->value, "%30f", &cfg_twist) < 1) {
+                               ast_log(LOG_WARNING, "Unable to convert '%s' to a numeric value.\n", v->value);
+                       } else if ((cfg_twist < 2.0) || (cfg_twist > 100.0)) {          /* < 3.0dB or > 20dB */
+                               ast_log(LOG_WARNING, "Invalid dtmf_normal_twist value '%.2f' specified, using default of %.2f\n", cfg_twist, dtmf_normal_twist);
+                       } else {
+                               dtmf_normal_twist = cfg_twist;
+                       }
+               } else if (!strcasecmp(v->name, "dtmf_reverse_twist")) {
+                       if (sscanf(v->value, "%30f", &cfg_twist) < 1) {
+                               ast_log(LOG_WARNING, "Unable to convert '%s' to a numeric value.\n", v->value);
+                       } else if ((cfg_twist < 2.0) || (cfg_twist > 100.0)) {          /* < 3.0dB or > 20dB */
+                               ast_log(LOG_WARNING, "Invalid dtmf_reverse_twist value '%.2f' specified, using default of %.2f\n", cfg_twist, dtmf_reverse_twist);
+                       } else {
+                               dtmf_reverse_twist = cfg_twist;
+                       }
+               } else if (!strcasecmp(v->name, "relax_dtmf_normal_twist")) {
+                       if (sscanf(v->value, "%30f", &cfg_twist) < 1) {
+                               ast_log(LOG_WARNING, "Unable to convert '%s' to a numeric value.\n", v->value);
+                       } else if ((cfg_twist < 2.0) || (cfg_twist > 100.0)) {          /* < 3.0dB or > 20dB */
+                               ast_log(LOG_WARNING, "Invalid relax_dtmf_normal_twist value '%.2f' specified, using default of %.2f\n", cfg_twist, relax_dtmf_normal_twist);
+                       } else {
+                               relax_dtmf_normal_twist = cfg_twist;
+                       }
+               } else if (!strcasecmp(v->name, "relax_dtmf_reverse_twist")) {
+                       if (sscanf(v->value, "%30f", &cfg_twist) < 1) {
+                               ast_log(LOG_WARNING, "Unable to convert '%s' to a numeric value.\n", v->value);
+                       } else if ((cfg_twist < 2.0) || (cfg_twist > 100.0)) {          /* < 3.0dB or > 20dB */
+                               ast_log(LOG_WARNING, "Invalid relax_dtmf_reverse_twist value '%.2f' specified, using default of %.2f\n", cfg_twist, relax_dtmf_reverse_twist);
+                       } else {
+                               relax_dtmf_reverse_twist = cfg_twist;
+                       }
+               } else if (!strcasecmp(v->name, "dtmf_hits_to_begin")) {
+                       if (sscanf(v->value, "%30d", &cfg_threshold) < 1) {
+                               ast_log(LOG_WARNING, "Unable to convert '%s' to a numeric value.\n", v->value);
+                       } else if (cfg_threshold < 1) {         /* must be 1 or greater */
+                               ast_log(LOG_WARNING, "Invalid dtmf_hits_to_begin value '%d' specified, using default of %d\n", cfg_threshold, dtmf_hits_to_begin);
+                       } else {
+                               dtmf_hits_to_begin = cfg_threshold;
+                       }
+               } else if (!strcasecmp(v->name, "dtmf_misses_to_end")) {
+                       if (sscanf(v->value, "%30d", &cfg_threshold) < 1) {
+                               ast_log(LOG_WARNING, "Unable to convert '%s' to a numeric value.\n", v->value);
+                       } else if (cfg_threshold < 1) {         /* must be 1 or greater */
+                               ast_log(LOG_WARNING, "Invalid dtmf_misses_to_end value '%d' specified, using default of %d\n", cfg_threshold, dtmf_misses_to_end);
+                       } else {
+                               dtmf_misses_to_end = cfg_threshold;
+                       }
+               }
        }
+       ast_config_destroy(cfg);
+
        return 0;
 }
 
@@ -1636,26 +1959,463 @@ int ast_dsp_get_threshold_from_settings(enum threshold which)
        return thresholds[which];
 }
 
-int ast_dsp_init(void)
+#ifdef TEST_FRAMEWORK
+static void test_tone_sample_gen(short *slin_buf, int samples, int rate, int freq, short amplitude)
 {
-       return _dsp_init(0);
+       int idx;
+       double sample_step = 2.0 * M_PI * freq / rate;/* radians per step */
+
+       for (idx = 0; idx < samples; ++idx) {
+               slin_buf[idx] = amplitude * sin(sample_step * idx);
+       }
 }
+#endif
 
-int ast_dsp_reload(void)
+#ifdef TEST_FRAMEWORK
+static void test_tone_sample_gen_add(short *slin_buf, int samples, int rate, int freq, short amplitude)
 {
-       return _dsp_init(1);
+       int idx;
+       double sample_step = 2.0 * M_PI * freq / rate;/* radians per step */
+
+       for (idx = 0; idx < samples; ++idx) {
+               slin_buf[idx] += amplitude * sin(sample_step * idx);
+       }
+}
+#endif
+
+#ifdef TEST_FRAMEWORK
+static void test_dual_sample_gen(short *slin_buf, int samples, int rate, int f1, short a1, int f2, short a2)
+{
+       test_tone_sample_gen(slin_buf, samples, rate, f1, a1);
+       test_tone_sample_gen_add(slin_buf, samples, rate, f2, a2);
+}
+#endif
+
+#ifdef TEST_FRAMEWORK
+#define TONE_AMPLITUDE_MAX     0x7fff  /* Max signed linear amplitude */
+#define TONE_AMPLITUDE_MIN     80              /* Min signed linear amplitude detectable */
+
+static int test_tone_amplitude_sweep(struct ast_test *test, struct ast_dsp *dsp, tone_detect_state_t *tone_state)
+{
+       short slin_buf[tone_state->block_size];
+       int result;
+       int idx;
+       struct {
+               short amp_val;
+               int detect;
+       } amp_tests[] = {
+               { .amp_val = TONE_AMPLITUDE_MAX,        .detect = 1, },
+               { .amp_val = 10000,                                     .detect = 1, },
+               { .amp_val = 1000,                                      .detect = 1, },
+               { .amp_val = 100,                                       .detect = 1, },
+               { .amp_val = TONE_AMPLITUDE_MIN,        .detect = 1, },
+               { .amp_val = 75,                                        .detect = 0, },
+               { .amp_val = 10,                                        .detect = 0, },
+               { .amp_val = 1,                                         .detect = 0, },
+       };
+
+       result = 0;
+
+       for (idx = 0; idx < ARRAY_LEN(amp_tests); ++idx) {
+               int detected;
+               int duration;
+
+               ast_debug(1, "Test %d Hz at amplitude %d\n",
+                       tone_state->freq, amp_tests[idx].amp_val);
+               test_tone_sample_gen(slin_buf, tone_state->block_size, DEFAULT_SAMPLE_RATE,
+                       tone_state->freq, amp_tests[idx].amp_val);
+
+               detected = 0;
+               for (duration = 0; !detected && duration < tone_state->hits_required + 3; ++duration) {
+                       detected = tone_detect(dsp, tone_state, slin_buf, tone_state->block_size) ? 1 : 0;
+               }
+               if (amp_tests[idx].detect != detected) {
+                       /*
+                        * Both messages are needed.  ast_debug for when figuring out
+                        * what went wrong and the test update for normal output before
+                        * you start debugging.  The different logging methods are not
+                        * synchronized.
+                        */
+                       ast_debug(1,
+                               "Test %d Hz at amplitude %d failed.  Detected: %s\n",
+                               tone_state->freq, amp_tests[idx].amp_val,
+                               detected ? "yes" : "no");
+                       ast_test_status_update(test,
+                               "Test %d Hz at amplitude %d failed.  Detected: %s\n",
+                               tone_state->freq, amp_tests[idx].amp_val,
+                               detected ? "yes" : "no");
+                       result = -1;
+               }
+               tone_state->hit_count = 0;
+       }
+
+       return result;
 }
+#endif
+
+#ifdef TEST_FRAMEWORK
+static int test_dtmf_amplitude_sweep(struct ast_test *test, struct ast_dsp *dsp, int digit_index)
+{
+       short slin_buf[DTMF_GSIZE];
+       int result;
+       int row;
+       int column;
+       int idx;
+       struct {
+               short amp_val;
+               int digit;
+       } amp_tests[] = {
+               /*
+                * XXX Since there is no current DTMF level detection issue.  This test
+                * just checks the current detection levels.
+                */
+               { .amp_val = TONE_AMPLITUDE_MAX/2,      .digit = dtmf_positions[digit_index], },
+               { .amp_val = 10000,                                     .digit = dtmf_positions[digit_index], },
+               { .amp_val = 1000,                                      .digit = dtmf_positions[digit_index], },
+               { .amp_val = 500,                                       .digit = dtmf_positions[digit_index], },
+               { .amp_val = 250,                                       .digit = dtmf_positions[digit_index], },
+               { .amp_val = 200,                                       .digit = dtmf_positions[digit_index], },
+               { .amp_val = 180,                                       .digit = dtmf_positions[digit_index], },
+               /* Various digits detect and not detect in this range */
+               { .amp_val = 170,                                       .digit = 0, },
+               { .amp_val = 100,                                       .digit = 0, },
+               /*
+                * Amplitudes below TONE_AMPLITUDE_MIN start having questionable detection
+                * over quantization and background noise.
+                */
+               { .amp_val = TONE_AMPLITUDE_MIN,        .digit = 0, },
+               { .amp_val = 75,                                        .digit = 0, },
+               { .amp_val = 10,                                        .digit = 0, },
+               { .amp_val = 1,                                         .digit = 0, },
+       };
+
+       row = (digit_index >> 2) & 0x03;
+       column = digit_index & 0x03;
+
+       result = 0;
+
+       for (idx = 0; idx < ARRAY_LEN(amp_tests); ++idx) {
+               int digit;
+               int duration;
+
+               ast_debug(1, "Test '%c' at amplitude %d\n",
+                       dtmf_positions[digit_index], amp_tests[idx].amp_val);
+               test_dual_sample_gen(slin_buf, ARRAY_LEN(slin_buf), DEFAULT_SAMPLE_RATE,
+                       (int) dtmf_row[row], amp_tests[idx].amp_val,
+                       (int) dtmf_col[column], amp_tests[idx].amp_val);
+
+               digit = 0;
+               for (duration = 0; !digit && duration < 3; ++duration) {
+                       digit = dtmf_detect(dsp, &dsp->digit_state, slin_buf, ARRAY_LEN(slin_buf),
+                               0, 0);
+               }
+               if (amp_tests[idx].digit != digit) {
+                       /*
+                        * Both messages are needed.  ast_debug for when figuring out
+                        * what went wrong and the test update for normal output before
+                        * you start debugging.  The different logging methods are not
+                        * synchronized.
+                        */
+                       ast_debug(1,
+                               "Test '%c' at amplitude %d failed.  Detected Digit: '%c'\n",
+                               dtmf_positions[digit_index], amp_tests[idx].amp_val,
+                               digit ?: ' ');
+                       ast_test_status_update(test,
+                               "Test '%c' at amplitude %d failed.  Detected Digit: '%c'\n",
+                               dtmf_positions[digit_index], amp_tests[idx].amp_val,
+                               digit ?: ' ');
+                       result = -1;
+               }
+               ast_dsp_digitreset(dsp);
+       }
+
+       return result;
+}
+#endif
+
+#ifdef TEST_FRAMEWORK
+static int test_dtmf_twist_sweep(struct ast_test *test, struct ast_dsp *dsp, int digit_index)
+{
+       short slin_buf[DTMF_GSIZE];
+       int result;
+       int row;
+       int column;
+       int idx;
+       struct {
+               short amp_row;
+               short amp_col;
+               int digit;
+       } twist_tests[] = {
+               /*
+                * XXX Since there is no current DTMF twist detection issue.  This test
+                * just checks the current detection levels.
+                *
+                * Normal twist has the column higher than the row amplitude.
+                * Reverse twist is the other way.
+                */
+               { .amp_row = 1000 + 1800, .amp_col = 1000 +    0, .digit = 0, },
+               { .amp_row = 1000 + 1700, .amp_col = 1000 +    0, .digit = 0, },
+               /* Various digits detect and not detect in this range */
+               { .amp_row = 1000 + 1400, .amp_col = 1000 +    0, .digit = dtmf_positions[digit_index], },
+               { .amp_row = 1000 + 1300, .amp_col = 1000 +    0, .digit = dtmf_positions[digit_index], },
+               { .amp_row = 1000 + 1200, .amp_col = 1000 +    0, .digit = dtmf_positions[digit_index], },
+               { .amp_row = 1000 + 1100, .amp_col = 1000 +    0, .digit = dtmf_positions[digit_index], },
+               { .amp_row = 1000 + 1000, .amp_col = 1000 +    0, .digit = dtmf_positions[digit_index], },
+               { .amp_row = 1000 +  100, .amp_col = 1000 +    0, .digit = dtmf_positions[digit_index], },
+               { .amp_row = 1000 +    0, .amp_col = 1000 +  100, .digit = dtmf_positions[digit_index], },
+               { .amp_row = 1000 +    0, .amp_col = 1000 +  200, .digit = dtmf_positions[digit_index], },
+               { .amp_row = 1000 +    0, .amp_col = 1000 +  300, .digit = dtmf_positions[digit_index], },
+               { .amp_row = 1000 +    0, .amp_col = 1000 +  400, .digit = dtmf_positions[digit_index], },
+               { .amp_row = 1000 +    0, .amp_col = 1000 +  500, .digit = dtmf_positions[digit_index], },
+               { .amp_row = 1000 +    0, .amp_col = 1000 +  550, .digit = dtmf_positions[digit_index], },
+               /* Various digits detect and not detect in this range */
+               { .amp_row = 1000 +    0, .amp_col = 1000 +  650, .digit = 0, },
+               { .amp_row = 1000 +    0, .amp_col = 1000 +  700, .digit = 0, },
+               { .amp_row = 1000 +    0, .amp_col = 1000 +  800, .digit = 0, },
+       };
+       float save_normal_twist;
+       float save_reverse_twist;
+
+       save_normal_twist = dtmf_normal_twist;
+       save_reverse_twist = dtmf_reverse_twist;
+       dtmf_normal_twist = DEF_DTMF_NORMAL_TWIST;
+       dtmf_reverse_twist = DEF_DTMF_REVERSE_TWIST;
+
+       row = (digit_index >> 2) & 0x03;
+       column = digit_index & 0x03;
+
+       result = 0;
+
+       for (idx = 0; idx < ARRAY_LEN(twist_tests); ++idx) {
+               int digit;
+               int duration;
+
+               ast_debug(1, "Test '%c' twist row %d col %d amplitudes\n",
+                       dtmf_positions[digit_index],
+                       twist_tests[idx].amp_row, twist_tests[idx].amp_col);
+               test_dual_sample_gen(slin_buf, ARRAY_LEN(slin_buf), DEFAULT_SAMPLE_RATE,
+                       (int) dtmf_row[row], twist_tests[idx].amp_row,
+                       (int) dtmf_col[column], twist_tests[idx].amp_col);
+
+               digit = 0;
+               for (duration = 0; !digit && duration < 3; ++duration) {
+                       digit = dtmf_detect(dsp, &dsp->digit_state, slin_buf, ARRAY_LEN(slin_buf),
+                               0, 0);
+               }
+               if (twist_tests[idx].digit != digit) {
+                       /*
+                        * Both messages are needed.  ast_debug for when figuring out
+                        * what went wrong and the test update for normal output before
+                        * you start debugging.  The different logging methods are not
+                        * synchronized.
+                        */
+                       ast_debug(1,
+                               "Test '%c' twist row %d col %d amplitudes failed.  Detected Digit: '%c'\n",
+                               dtmf_positions[digit_index],
+                               twist_tests[idx].amp_row, twist_tests[idx].amp_col,
+                               digit ?: ' ');
+                       ast_test_status_update(test,
+                               "Test '%c' twist row %d col %d amplitudes failed.  Detected Digit: '%c'\n",
+                               dtmf_positions[digit_index],
+                               twist_tests[idx].amp_row, twist_tests[idx].amp_col,
+                               digit ?: ' ');
+                       result = -1;
+               }
+               ast_dsp_digitreset(dsp);
+       }
+
+       dtmf_normal_twist = save_normal_twist;
+       dtmf_reverse_twist = save_reverse_twist;
+
+       return result;
+}
+#endif
+
+#ifdef TEST_FRAMEWORK
+static int test_tone_freq_sweep(struct ast_test *test, struct ast_dsp *dsp, tone_detect_state_t *tone_state, short amplitude)
+{
+       short slin_buf[tone_state->block_size];
+       int result;
+       int freq;
+       int lower_freq;
+       int upper_freq;
+
+       /* Calculate detection frequency range */
+       lower_freq = tone_state->freq - 4;
+       upper_freq = tone_state->freq + 4;
 
-void ast_dsp_frame_freed(struct ast_frame *fr)
+       result = 0;
+
+       /* Sweep frequencies loop. */
+       for (freq = 100; freq <= 3500; freq += 1) {
+               int detected;
+               int duration;
+               int expect_detection;
+
+               if (freq == tone_state->freq) {
+                       /* This case is done by the amplitude sweep. */
+                       continue;
+               }
+
+               expect_detection = (lower_freq <= freq && freq <= upper_freq) ? 1 : 0;
+
+               ast_debug(1, "Test %d Hz detection given %d Hz tone at amplitude %d.  Range:%d-%d Expect detect: %s\n",
+                       tone_state->freq, freq, amplitude, lower_freq, upper_freq,
+                       expect_detection ? "yes" : "no");
+               test_tone_sample_gen(slin_buf, tone_state->block_size, DEFAULT_SAMPLE_RATE, freq,
+                       amplitude);
+
+               detected = 0;
+               for (duration = 0; !detected && duration < tone_state->hits_required + 3; ++duration) {
+                       detected = tone_detect(dsp, tone_state, slin_buf, tone_state->block_size) ? 1 : 0;
+               }
+               if (expect_detection != detected) {
+                       /*
+                        * Both messages are needed.  ast_debug for when figuring out
+                        * what went wrong and the test update for normal output before
+                        * you start debugging.  The different logging methods are not
+                        * synchronized.
+                        */
+                       ast_debug(1,
+                               "Test %d Hz detection given %d Hz tone at amplitude %d failed.  Range:%d-%d Detected: %s\n",
+                               tone_state->freq, freq, amplitude, lower_freq, upper_freq,
+                               detected ? "yes" : "no");
+                       ast_test_status_update(test,
+                               "Test %d Hz detection given %d Hz tone at amplitude %d failed.  Range:%d-%d Detected: %s\n",
+                               tone_state->freq, freq, amplitude, lower_freq, upper_freq,
+                               detected ? "yes" : "no");
+                       result = -1;
+               }
+               tone_state->hit_count = 0;
+       }
+
+       return result;
+}
+#endif
+
+#ifdef TEST_FRAMEWORK
+AST_TEST_DEFINE(test_dsp_fax_detect)
 {
        struct ast_dsp *dsp;
+       enum ast_test_result_state result;
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "fax";
+               info->category = "/main/dsp/";
+               info->summary = "DSP fax tone detect unit test";
+               info->description =
+                       "Tests fax tone detection code.";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
 
-       ast_clear_flag(fr, AST_FRFLAG_FROM_DSP);
+       dsp = ast_dsp_new();
+       if (!dsp) {
+               return AST_TEST_FAIL;
+       }
 
-       dsp = (struct ast_dsp *) (((char *) fr) - offsetof(struct ast_dsp, f));
+       result = AST_TEST_PASS;
+
+       /* Test CNG tone amplitude detection */
+       if (test_tone_amplitude_sweep(test, dsp, &dsp->cng_tone_state)) {
+               result = AST_TEST_FAIL;
+       }
+
+       /* Test CED tone amplitude detection */
+       if (test_tone_amplitude_sweep(test, dsp, &dsp->ced_tone_state)) {
+               result = AST_TEST_FAIL;
+       }
+
+       /* Test CNG tone frequency detection */
+       if (test_tone_freq_sweep(test, dsp, &dsp->cng_tone_state, TONE_AMPLITUDE_MAX)) {
+               result = AST_TEST_FAIL;
+       }
+       if (test_tone_freq_sweep(test, dsp, &dsp->cng_tone_state, TONE_AMPLITUDE_MIN)) {
+               result = AST_TEST_FAIL;
+       }
+
+       /* Test CED tone frequency detection */
+       if (test_tone_freq_sweep(test, dsp, &dsp->ced_tone_state, TONE_AMPLITUDE_MAX)) {
+               result = AST_TEST_FAIL;
+       }
+       if (test_tone_freq_sweep(test, dsp, &dsp->ced_tone_state, TONE_AMPLITUDE_MIN)) {
+               result = AST_TEST_FAIL;
+       }
 
-       if (!dsp->destroy)
-               return;
-       
        ast_dsp_free(dsp);
+       return result;
+}
+#endif
+
+#ifdef TEST_FRAMEWORK
+AST_TEST_DEFINE(test_dsp_dtmf_detect)
+{
+       int idx;
+       struct ast_dsp *dsp;
+       enum ast_test_result_state result;
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "dtmf";
+               info->category = "/main/dsp/";
+               info->summary = "DSP DTMF detect unit test";
+               info->description =
+                       "Tests DTMF detection code.";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       dsp = ast_dsp_new();
+       if (!dsp) {
+               return AST_TEST_FAIL;
+       }
+
+       result = AST_TEST_PASS;
+
+       for (idx = 0; dtmf_positions[idx]; ++idx) {
+               if (test_dtmf_amplitude_sweep(test, dsp, idx)) {
+                       result = AST_TEST_FAIL;
+               }
+       }
+
+       for (idx = 0; dtmf_positions[idx]; ++idx) {
+               if (test_dtmf_twist_sweep(test, dsp, idx)) {
+                       result = AST_TEST_FAIL;
+               }
+       }
+
+       ast_dsp_free(dsp);
+       return result;
+}
+#endif
+
+#ifdef TEST_FRAMEWORK
+static void test_dsp_shutdown(void)
+{
+       AST_TEST_UNREGISTER(test_dsp_fax_detect);
+       AST_TEST_UNREGISTER(test_dsp_dtmf_detect);
+}
+#endif
+
+int ast_dsp_init(void)
+{
+       int res = _dsp_init(0);
+
+#ifdef TEST_FRAMEWORK
+       if (!res) {
+               AST_TEST_REGISTER(test_dsp_fax_detect);
+               AST_TEST_REGISTER(test_dsp_dtmf_detect);
+
+               ast_register_cleanup(test_dsp_shutdown);
+       }
+#endif
+       return res;
+}
+
+int ast_dsp_reload(void)
+{
+       return _dsp_init(1);
 }