main/dsp.c

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