Wed Aug 18 22:33:51 2010

Asterisk developer's documentation


dsp.c

Go to the documentation of this file.
00001 /*
00002  * Asterisk -- An open source telephony toolkit.
00003  *
00004  * Copyright (C) 1999 - 2005, Digium, Inc.
00005  *
00006  * Mark Spencer <markster@digium.com>
00007  *
00008  * Goertzel routines are borrowed from Steve Underwood's tremendous work on the
00009  * DTMF detector.
00010  *
00011  * See http://www.asterisk.org for more information about
00012  * the Asterisk project. Please do not directly contact
00013  * any of the maintainers of this project for assistance;
00014  * the project provides a web site, mailing lists and IRC
00015  * channels for your use.
00016  *
00017  * This program is free software, distributed under the terms of
00018  * the GNU General Public License Version 2. See the LICENSE file
00019  * at the top of the source tree.
00020  */
00021 
00022 /*! \file
00023  *
00024  * \brief Convenience Signal Processing routines
00025  *
00026  * \author Mark Spencer <markster@digium.com>
00027  * \author Steve Underwood <steveu@coppice.org>
00028  */
00029 
00030 /* Some routines from tone_detect.c by Steven Underwood as published under the zapata library */
00031 /*
00032    tone_detect.c - General telephony tone detection, and specific
00033                detection of DTMF.
00034 
00035    Copyright (C) 2001  Steve Underwood <steveu@coppice.org>
00036 
00037    Despite my general liking of the GPL, I place this code in the
00038    public domain for the benefit of all mankind - even the slimy
00039    ones who might try to proprietize my work and use it to my
00040    detriment.
00041 */
00042 
00043 #include "asterisk.h"
00044 
00045 ASTERISK_FILE_VERSION(__FILE__, "$Revision: 235776 $")
00046 
00047 #include <math.h>
00048 
00049 #include "asterisk/frame.h"
00050 #include "asterisk/channel.h"
00051 #include "asterisk/dsp.h"
00052 #include "asterisk/ulaw.h"
00053 #include "asterisk/alaw.h"
00054 #include "asterisk/utils.h"
00055 #include "asterisk/options.h"
00056 #include "asterisk/config.h"
00057 
00058 /*! Number of goertzels for progress detect */
00059 enum gsamp_size {
00060    GSAMP_SIZE_NA = 183,       /*!< North America - 350, 440, 480, 620, 950, 1400, 1800 Hz */
00061    GSAMP_SIZE_CR = 188,       /*!< Costa Rica, Brazil - Only care about 425 Hz */
00062    GSAMP_SIZE_UK = 160        /*!< UK disconnect goertzel feed - should trigger 400hz */
00063 };
00064 
00065 enum prog_mode {
00066    PROG_MODE_NA = 0,
00067    PROG_MODE_CR,
00068    PROG_MODE_UK
00069 };
00070 
00071 enum freq_index { 
00072    /*! For US modes { */
00073    HZ_350 = 0,
00074    HZ_440,
00075    HZ_480,
00076    HZ_620,
00077    HZ_950,
00078    HZ_1400,
00079    HZ_1800, /*!< } */
00080 
00081    /*! For CR/BR modes */
00082    HZ_425 = 0,
00083 
00084    /*! For UK mode */
00085    HZ_400 = 0
00086 };
00087 
00088 static struct progalias {
00089    char *name;
00090    enum prog_mode mode;
00091 } aliases[] = {
00092    { "us", PROG_MODE_NA },
00093    { "ca", PROG_MODE_NA },
00094    { "cr", PROG_MODE_CR },
00095    { "br", PROG_MODE_CR },
00096    { "uk", PROG_MODE_UK },
00097 };
00098 
00099 static struct progress {
00100    enum gsamp_size size;
00101    int freqs[7];
00102 } modes[] = {
00103    { GSAMP_SIZE_NA, { 350, 440, 480, 620, 950, 1400, 1800 } }, /*!< North America */
00104    { GSAMP_SIZE_CR, { 425 } },                                 /*!< Costa Rica, Brazil */
00105    { GSAMP_SIZE_UK, { 400 } },                                 /*!< UK */
00106 };
00107 
00108 /*!\brief This value is the minimum threshold, calculated by averaging all
00109  * of the samples within a frame, for which a frame is determined to either
00110  * be silence (below the threshold) or noise (above the threshold).  Please
00111  * note that while the default threshold is an even exponent of 2, there is
00112  * no requirement that it be so.  The threshold will accept any value between
00113  * 0 and 32767.
00114  */
00115 #define DEFAULT_THRESHOLD  512
00116 
00117 enum busy_detect {
00118    BUSY_PERCENT = 10,      /*!< The percentage difference between the two last tone periods */
00119    BUSY_PAT_PERCENT = 8,   /*!< The percentage difference between measured and actual pattern */
00120    BUSY_THRESHOLD = 100,   /*!< Max number of ms difference between max and min times in busy */
00121    BUSY_MIN = 150,       /*!< Busy must be at least 150 ms in half-cadence */
00122    BUSY_MAX = 600          /*!< Busy can't be longer than 600 ms in half-cadence */
00123 };
00124 
00125 /*! Remember last 15 units */
00126 #define DSP_HISTORY     15
00127 
00128 #define TONE_THRESH     10.0  /*!< How much louder the tone should be than channel energy */
00129 #define TONE_MIN_THRESH    1e8   /*!< How much tone there should be at least to attempt */
00130 
00131 /*! All THRESH_XXX values are in GSAMP_SIZE chunks (us = 22ms) */
00132 enum gsamp_thresh {
00133    THRESH_RING = 8,           /*!< Need at least 150ms ring to accept */
00134    THRESH_TALK = 2,           /*!< Talk detection does not work continuously */
00135    THRESH_BUSY = 4,           /*!< Need at least 80ms to accept */
00136    THRESH_CONGESTION = 4,     /*!< Need at least 80ms to accept */
00137    THRESH_HANGUP = 60,        /*!< Need at least 1300ms to accept hangup */
00138    THRESH_RING2ANSWER = 300   /*!< Timeout from start of ring to answer (about 6600 ms) */
00139 };
00140 
00141 #define  MAX_DTMF_DIGITS      128
00142 
00143 /* Basic DTMF specs:
00144  *
00145  * Minimum tone on = 40ms
00146  * Minimum tone off = 50ms
00147  * Maximum digit rate = 10 per second
00148  * Normal twist <= 8dB accepted
00149  * Reverse twist <= 4dB accepted
00150  * S/N >= 15dB will detect OK
00151  * Attenuation <= 26dB will detect OK
00152  * Frequency tolerance +- 1.5% will detect, +-3.5% will reject
00153  */
00154 
00155 #define DTMF_THRESHOLD     8.0e7
00156 #define FAX_THRESHOLD      8.0e7
00157 #define FAX_2ND_HARMONIC   2.0     /* 4dB */
00158 #define DTMF_NORMAL_TWIST  6.3     /* 8dB */
00159 #ifdef   RADIO_RELAX
00160 #define DTMF_REVERSE_TWIST          (relax ? 6.5 : 2.5)     /* 4dB normal */
00161 #else
00162 #define DTMF_REVERSE_TWIST          (relax ? 4.0 : 2.5)     /* 4dB normal */
00163 #endif
00164 #define DTMF_RELATIVE_PEAK_ROW   6.3     /* 8dB */
00165 #define DTMF_RELATIVE_PEAK_COL   6.3     /* 8dB */
00166 #define DTMF_2ND_HARMONIC_ROW       (relax ? 1.7 : 2.5)     /* 4dB normal */
00167 #define DTMF_2ND_HARMONIC_COL 63.1    /* 18dB */
00168 #define DTMF_TO_TOTAL_ENERGY  42.0
00169 
00170 #define BELL_MF_THRESHOLD  1.6e9
00171 #define BELL_MF_TWIST      4.0     /* 6dB */
00172 #define BELL_MF_RELATIVE_PEAK 12.6    /* 11dB */
00173 
00174 #if defined(BUSYDETECT_TONEONLY) && defined(BUSYDETECT_COMPARE_TONE_AND_SILENCE)
00175 #error You cant use BUSYDETECT_TONEONLY together with BUSYDETECT_COMPARE_TONE_AND_SILENCE
00176 #endif
00177 
00178 /* The CNG signal consists of the transmission of 1100 Hz for 1/2 second,
00179  * followed by a 3 second silent (2100 Hz OFF) period.
00180  */
00181 #define FAX_TONE_CNG_FREQ  1100
00182 #define FAX_TONE_CNG_DURATION 500
00183 #define FAX_TONE_CNG_DB    16
00184 
00185 /* This signal may be sent by the Terminating FAX machine anywhere between
00186  * 1.8 to 2.5 seconds AFTER answering the call.  The CED signal consists
00187  * of a 2100 Hz tone that is from 2.6 to 4 seconds in duration.
00188 */
00189 #define FAX_TONE_CED_FREQ  2100
00190 #define FAX_TONE_CED_DURATION 2600
00191 #define FAX_TONE_CED_DB    16
00192 
00193 #define SAMPLE_RATE     8000
00194 
00195 /* How many samples a frame has.  This constant is used when calculating
00196  * Goertzel block size for tone_detect.  It is only important if we want to
00197  * remove (squelch) the tone. In this case it is important to have block
00198  * size not to exceed size of voice frame.  Otherwise by the moment the tone
00199  * is detected it is too late to squelch it from previous frames.
00200  */
00201 #define SAMPLES_IN_FRAME   160
00202 
00203 /* MF goertzel size */
00204 #define MF_GSIZE     120
00205 
00206 /* DTMF goertzel size */
00207 #define DTMF_GSIZE      102
00208 
00209 /* How many successive hits needed to consider begin of a digit */
00210 #define DTMF_HITS_TO_BEGIN 2
00211 /* How many successive misses needed to consider end of a digit */
00212 #define DTMF_MISSES_TO_END 3
00213 
00214 #define CONFIG_FILE_NAME "dsp.conf"
00215 
00216 typedef struct {
00217    int v2;
00218    int v3;
00219    int chunky;
00220    int fac;
00221    int samples;
00222 } goertzel_state_t;
00223 
00224 typedef struct {
00225    int value;
00226    int power;
00227 } goertzel_result_t;
00228 
00229 typedef struct
00230 {
00231    int freq;
00232    int block_size;
00233    int squelch;      /* Remove (squelch) tone */
00234    goertzel_state_t tone;
00235    float energy;     /* Accumulated energy of the current block */
00236    int samples_pending; /* Samples remain to complete the current block */
00237    int mute_samples; /* How many additional samples needs to be muted to suppress already detected tone */
00238 
00239    int hits_required;   /* How many successive blocks with tone we are looking for */
00240    float threshold;  /* Energy of the tone relative to energy from all other signals to consider a hit */
00241 
00242    int hit_count;    /* How many successive blocks we consider tone present */
00243    int last_hit;     /* Indicates if the last processed block was a hit */
00244 
00245 } tone_detect_state_t;
00246 
00247 typedef struct
00248 {
00249    goertzel_state_t row_out[4];
00250    goertzel_state_t col_out[4];
00251    int hits_to_begin;      /* How many successive hits needed to consider begin of a digit */
00252    int misses_to_end;      /* How many successive misses needed to consider end of a digit */
00253    int hits;         /* How many successive hits we have seen already */
00254    int misses;       /* How many successive misses we have seen already */
00255    int lasthit;
00256    int current_hit;
00257    float energy;
00258    int current_sample;
00259    int mute_samples;
00260 } dtmf_detect_state_t;
00261 
00262 typedef struct
00263 {
00264    goertzel_state_t tone_out[6];
00265    int current_hit;
00266    int hits[5];
00267    int current_sample;
00268    int mute_samples;
00269 } mf_detect_state_t;
00270 
00271 typedef struct
00272 {
00273    char digits[MAX_DTMF_DIGITS + 1];
00274    int current_digits;
00275    int detected_digits;
00276    int lost_digits;
00277 
00278    union {
00279       dtmf_detect_state_t dtmf;
00280       mf_detect_state_t mf;
00281    } td;
00282 } digit_detect_state_t;
00283 
00284 static float dtmf_row[] =
00285 {
00286    697.0,  770.0,  852.0,  941.0
00287 };
00288 static float dtmf_col[] =
00289 {
00290    1209.0, 1336.0, 1477.0, 1633.0
00291 };
00292 
00293 static float mf_tones[] =
00294 {
00295    700.0, 900.0, 1100.0, 1300.0, 1500.0, 1700.0
00296 };
00297 
00298 static char dtmf_positions[] = "123A" "456B" "789C" "*0#D";
00299 
00300 static char bell_mf_positions[] = "1247C-358A--69*---0B----#";
00301 
00302 static int thresholds[THRESHOLD_MAX];
00303 
00304 static inline void goertzel_sample(goertzel_state_t *s, short sample)
00305 {
00306    int v1;
00307    
00308    v1 = s->v2;
00309    s->v2 = s->v3;
00310    
00311    s->v3 = (s->fac * s->v2) >> 15;
00312    s->v3 = s->v3 - v1 + (sample >> s->chunky);
00313    if (abs(s->v3) > 32768) {
00314       s->chunky++;
00315       s->v3 = s->v3 >> 1;
00316       s->v2 = s->v2 >> 1;
00317       v1 = v1 >> 1;
00318    }
00319 }
00320 
00321 static inline void goertzel_update(goertzel_state_t *s, short *samps, int count)
00322 {
00323    int i;
00324    
00325    for (i=0;i<count;i++) 
00326       goertzel_sample(s, samps[i]);
00327 }
00328 
00329 
00330 static inline float goertzel_result(goertzel_state_t *s)
00331 {
00332    goertzel_result_t r;
00333    r.value = (s->v3 * s->v3) + (s->v2 * s->v2);
00334    r.value -= ((s->v2 * s->v3) >> 15) * s->fac;
00335    r.power = s->chunky * 2;
00336    return (float)r.value * (float)(1 << r.power);
00337 }
00338 
00339 static inline void goertzel_init(goertzel_state_t *s, float freq, int samples)
00340 {
00341    s->v2 = s->v3 = s->chunky = 0.0;
00342    s->fac = (int)(32768.0 * 2.0 * cos(2.0 * M_PI * freq / SAMPLE_RATE));
00343    s->samples = samples;
00344 }
00345 
00346 static inline void goertzel_reset(goertzel_state_t *s)
00347 {
00348    s->v2 = s->v3 = s->chunky = 0.0;
00349 }
00350 
00351 typedef struct {
00352    int start;
00353    int end;
00354 } fragment_t;
00355 
00356 /* Note on tone suppression (squelching). Individual detectors (DTMF/MF/generic tone)
00357  * report fragmens of the frame in which detected tone resides and which needs
00358  * to be "muted" in order to suppress the tone. To mark fragment for muting,
00359  * detectors call mute_fragment passing fragment_t there. Multiple fragments
00360  * can be marked and ast_dsp_process later will mute all of them.
00361  *
00362  * Note: When tone starts in the middle of a Goertzel block, it won't be properly
00363  * detected in that block, only in the next. If we only mute the next block
00364  * where tone is actually detected, the user will still hear beginning
00365  * of the tone in preceeding block. This is why we usually want to mute some amount
00366  * of samples preceeding and following the block where tone was detected.
00367 */
00368 
00369 struct ast_dsp {
00370    struct ast_frame f;
00371    int threshold;
00372    int totalsilence;
00373    int totalnoise;
00374    int features;
00375    int ringtimeout;
00376    int busymaybe;
00377    int busycount;
00378    int busytoneonly;
00379    int busycompare;
00380    int busy_tonelength;
00381    int busy_quietlength;
00382    int busy_pattern_fuzzy;
00383    int historicnoise[DSP_HISTORY];
00384    int historicsilence[DSP_HISTORY];
00385    goertzel_state_t freqs[7];
00386    int freqcount;
00387    int gsamps;
00388    enum gsamp_size gsamp_size;
00389    enum prog_mode progmode;
00390    int tstate;
00391    int tcount;
00392    int digitmode;
00393    int faxmode;
00394    int dtmf_began;
00395    int display_inband_dtmf_warning;
00396    float genergy;
00397    int mute_fragments;
00398    fragment_t mute_data[5];
00399    digit_detect_state_t digit_state;
00400    tone_detect_state_t cng_tone_state;
00401    tone_detect_state_t ced_tone_state;
00402 };
00403 
00404 static void mute_fragment(struct ast_dsp *dsp, fragment_t *fragment)
00405 {
00406    if (dsp->mute_fragments >= ARRAY_LEN(dsp->mute_data)) {
00407       ast_log(LOG_ERROR, "Too many fragments to mute. Ignoring\n");
00408       return;
00409    }
00410 
00411    dsp->mute_data[dsp->mute_fragments++] = *fragment;
00412 }
00413 
00414 static void ast_tone_detect_init(tone_detect_state_t *s, int freq, int duration, int amp)
00415 {
00416    int duration_samples;
00417    float x;
00418    int periods_in_block;
00419 
00420    s->freq = freq;
00421 
00422    /* Desired tone duration in samples */
00423    duration_samples = duration * SAMPLE_RATE / 1000;
00424    /* We want to allow 10% deviation of tone duration */
00425    duration_samples = duration_samples * 9 / 10;
00426 
00427    /* If we want to remove tone, it is important to have block size not
00428       to exceed frame size. Otherwise by the moment tone is detected it is too late
00429       to squelch it from previous frames */
00430    s->block_size = SAMPLES_IN_FRAME;
00431 
00432    periods_in_block = s->block_size * freq / SAMPLE_RATE;
00433 
00434    /* Make sure we will have at least 5 periods at target frequency for analisys.
00435       This may make block larger than expected packet and will make squelching impossible
00436       but at least we will be detecting the tone */
00437    if (periods_in_block < 5)
00438       periods_in_block = 5;
00439 
00440    /* Now calculate final block size. It will contain integer number of periods */
00441    s->block_size = periods_in_block * SAMPLE_RATE / freq;
00442 
00443    /* tone_detect is currently only used to detect fax tones and we
00444       do not need suqlching the fax tones */
00445    s->squelch = 0;
00446 
00447    /* Account for the first and the last block to be incomplete
00448       and thus no tone will be detected in them */
00449    s->hits_required = (duration_samples - (s->block_size - 1)) / s->block_size;
00450 
00451    goertzel_init(&s->tone, freq, s->block_size);
00452 
00453    s->samples_pending = s->block_size;
00454    s->hit_count = 0;
00455    s->last_hit = 0;
00456    s->energy = 0.0;
00457 
00458    /* We want tone energy to be amp decibels above the rest of the signal (the noise).
00459       According to Parseval's theorem the energy computed in time domain equals to energy
00460       computed in frequency domain. So subtracting energy in the frequency domain (Goertzel result)
00461       from the energy in the time domain we will get energy of the remaining signal (without the tone
00462       we are detecting). We will be checking that
00463       10*log(Ew / (Et - Ew)) > amp
00464       Calculate threshold so that we will be actually checking
00465       Ew > Et * threshold
00466    */
00467 
00468    x = pow(10.0, amp / 10.0);
00469    s->threshold = x / (x + 1);
00470 
00471    ast_debug(1, "Setup tone %d Hz, %d ms, block_size=%d, hits_required=%d\n", freq, duration, s->block_size, s->hits_required);
00472 }
00473 
00474 static void ast_fax_detect_init(struct ast_dsp *s)
00475 {
00476    ast_tone_detect_init(&s->cng_tone_state, FAX_TONE_CNG_FREQ, FAX_TONE_CNG_DURATION, FAX_TONE_CNG_DB);
00477    ast_tone_detect_init(&s->ced_tone_state, FAX_TONE_CED_FREQ, FAX_TONE_CED_DURATION, FAX_TONE_CED_DB);
00478 }
00479 
00480 static void ast_dtmf_detect_init (dtmf_detect_state_t *s)
00481 {
00482    int i;
00483 
00484    s->lasthit = 0;
00485    s->current_hit = 0;
00486    for (i = 0;  i < 4;  i++) {
00487       goertzel_init (&s->row_out[i], dtmf_row[i], DTMF_GSIZE);
00488       goertzel_init (&s->col_out[i], dtmf_col[i], DTMF_GSIZE);
00489       s->energy = 0.0;
00490    }
00491    s->current_sample = 0;
00492    s->hits = 0;
00493    s->misses = 0;
00494 
00495    s->hits_to_begin = DTMF_HITS_TO_BEGIN;
00496    s->misses_to_end = DTMF_MISSES_TO_END;
00497 }
00498 
00499 static void ast_mf_detect_init (mf_detect_state_t *s)
00500 {
00501    int i;
00502    s->hits[0] = s->hits[1] = s->hits[2] = s->hits[3] = s->hits[4] = 0;
00503    for (i = 0;  i < 6;  i++) {
00504       goertzel_init (&s->tone_out[i], mf_tones[i], 160);
00505    }
00506    s->current_sample = 0;
00507    s->current_hit = 0;
00508 }
00509 
00510 static void ast_digit_detect_init(digit_detect_state_t *s, int mf)
00511 {
00512    s->current_digits = 0;
00513    s->detected_digits = 0;
00514    s->lost_digits = 0;
00515    s->digits[0] = '\0';
00516 
00517    if (mf)
00518       ast_mf_detect_init(&s->td.mf);
00519    else
00520       ast_dtmf_detect_init(&s->td.dtmf);
00521 }
00522 
00523 static int tone_detect(struct ast_dsp *dsp, tone_detect_state_t *s, int16_t *amp, int samples)
00524 {
00525    float tone_energy;
00526    int i;
00527    int hit = 0;
00528    int limit;
00529    int res = 0;
00530    int16_t *ptr;
00531    int start, end;
00532    fragment_t mute = {0, 0};
00533 
00534    if (s->squelch && s->mute_samples > 0) {
00535       mute.end = (s->mute_samples < samples) ? s->mute_samples : samples;
00536       s->mute_samples -= mute.end;
00537    }
00538 
00539    for (start = 0;  start < samples;  start = end) {
00540       /* Process in blocks. */
00541       limit = samples - start;
00542       if (limit > s->samples_pending)
00543          limit = s->samples_pending;
00544       end = start + limit;
00545 
00546       for (i = limit, ptr = amp ; i > 0; i--, ptr++) {
00547          /* signed 32 bit int should be enough to suqare any possible signed 16 bit value */
00548          s->energy += (int32_t) *ptr * (int32_t) *ptr;
00549 
00550          goertzel_sample(&s->tone, *ptr);
00551       }
00552 
00553       s->samples_pending -= limit;
00554 
00555       if (s->samples_pending) {
00556          /* Finished incomplete (last) block */
00557          break;
00558       }
00559 
00560       tone_energy = goertzel_result(&s->tone);
00561 
00562       /* Scale to make comparable */
00563       tone_energy *= 2.0;
00564       s->energy *= s->block_size;
00565 
00566       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));
00567       hit = 0;
00568       if (tone_energy > s->energy * s->threshold) {
00569          ast_debug(10, "Hit! count=%d\n", s->hit_count);
00570          hit = 1;
00571       }
00572 
00573       if (s->hit_count)
00574          s->hit_count++;
00575 
00576       if (hit == s->last_hit) {
00577          if (!hit) {
00578             /* Two successive misses. Tone ended */
00579             s->hit_count = 0;
00580          } else if (!s->hit_count) {
00581             s->hit_count++;
00582          }
00583 
00584       }
00585 
00586       if (s->hit_count == s->hits_required) {
00587          ast_debug(1, "%d Hz done detected\n", s->freq);
00588          res = 1;
00589       }
00590 
00591       s->last_hit = hit;
00592 
00593       /* If we had a hit in this block, include it into mute fragment */
00594       if (s->squelch && hit) {
00595          if (mute.end < start - s->block_size) {
00596             /* There is a gap between fragments */
00597             mute_fragment(dsp, &mute);
00598             mute.start = (start > s->block_size) ? (start - s->block_size) : 0;
00599          }
00600          mute.end = end + s->block_size;
00601       }
00602 
00603       /* Reinitialise the detector for the next block */
00604       /* Reset for the next block */
00605       goertzel_reset(&s->tone);
00606 
00607       /* Advance to the next block */
00608       s->energy = 0.0;
00609       s->samples_pending = s->block_size;
00610 
00611       amp += limit;
00612    }
00613 
00614    if (s->squelch && mute.end) {
00615       if (mute.end > samples) {
00616          s->mute_samples = mute.end - samples;
00617          mute.end = samples;
00618       }
00619       mute_fragment(dsp, &mute);
00620    }
00621 
00622    return res;
00623 }
00624 
00625 static void store_digit(digit_detect_state_t *s, char digit)
00626 {
00627    s->detected_digits++;
00628    if (s->current_digits < MAX_DTMF_DIGITS) {
00629       s->digits[s->current_digits++] = digit;
00630       s->digits[s->current_digits] = '\0';
00631    } else {
00632       ast_log(LOG_WARNING, "Digit lost due to full buffer\n");
00633       s->lost_digits++;
00634    }
00635 }
00636 
00637 static int dtmf_detect(struct ast_dsp *dsp, digit_detect_state_t *s, int16_t amp[], int samples, int squelch, int relax)
00638 {
00639    float row_energy[4];
00640    float col_energy[4];
00641    float famp;
00642    int i;
00643    int j;
00644    int sample;
00645    int best_row;
00646    int best_col;
00647    int hit;
00648    int limit;
00649    fragment_t mute = {0, 0};
00650 
00651    if (squelch && s->td.dtmf.mute_samples > 0) {
00652       mute.end = (s->td.dtmf.mute_samples < samples) ? s->td.dtmf.mute_samples : samples;
00653       s->td.dtmf.mute_samples -= mute.end;
00654    }
00655 
00656    hit = 0;
00657    for (sample = 0;  sample < samples;  sample = limit) {
00658       /* DTMF_GSIZE is optimised to meet the DTMF specs. */
00659       if ((samples - sample) >= (DTMF_GSIZE - s->td.dtmf.current_sample))
00660          limit = sample + (DTMF_GSIZE - s->td.dtmf.current_sample);
00661       else
00662          limit = samples;
00663       /* The following unrolled loop takes only 35% (rough estimate) of the 
00664          time of a rolled loop on the machine on which it was developed */
00665       for (j = sample; j < limit; j++) {
00666          famp = amp[j];
00667          s->td.dtmf.energy += famp*famp;
00668          /* With GCC 2.95, the following unrolled code seems to take about 35%
00669             (rough estimate) as long as a neat little 0-3 loop */
00670          goertzel_sample(s->td.dtmf.row_out, amp[j]);
00671          goertzel_sample(s->td.dtmf.col_out, amp[j]);
00672          goertzel_sample(s->td.dtmf.row_out + 1, amp[j]);
00673          goertzel_sample(s->td.dtmf.col_out + 1, amp[j]);
00674          goertzel_sample(s->td.dtmf.row_out + 2, amp[j]);
00675          goertzel_sample(s->td.dtmf.col_out + 2, amp[j]);
00676          goertzel_sample(s->td.dtmf.row_out + 3, amp[j]);
00677          goertzel_sample(s->td.dtmf.col_out + 3, amp[j]);
00678       }
00679       s->td.dtmf.current_sample += (limit - sample);
00680       if (s->td.dtmf.current_sample < DTMF_GSIZE) {
00681          continue;
00682       }
00683       /* We are at the end of a DTMF detection block */
00684       /* Find the peak row and the peak column */
00685       row_energy[0] = goertzel_result (&s->td.dtmf.row_out[0]);
00686       col_energy[0] = goertzel_result (&s->td.dtmf.col_out[0]);
00687 
00688       for (best_row = best_col = 0, i = 1;  i < 4;  i++) {
00689          row_energy[i] = goertzel_result (&s->td.dtmf.row_out[i]);
00690          if (row_energy[i] > row_energy[best_row])
00691             best_row = i;
00692          col_energy[i] = goertzel_result (&s->td.dtmf.col_out[i]);
00693          if (col_energy[i] > col_energy[best_col])
00694             best_col = i;
00695       }
00696       hit = 0;
00697       /* Basic signal level test and the twist test */
00698       if (row_energy[best_row] >= DTMF_THRESHOLD && 
00699           col_energy[best_col] >= DTMF_THRESHOLD &&
00700           col_energy[best_col] < row_energy[best_row]*DTMF_REVERSE_TWIST &&
00701           col_energy[best_col]*DTMF_NORMAL_TWIST > row_energy[best_row]) {
00702          /* Relative peak test */
00703          for (i = 0;  i < 4;  i++) {
00704             if ((i != best_col &&
00705                 col_energy[i]*DTMF_RELATIVE_PEAK_COL > col_energy[best_col]) ||
00706                 (i != best_row 
00707                  && row_energy[i]*DTMF_RELATIVE_PEAK_ROW > row_energy[best_row])) {
00708                break;
00709             }
00710          }
00711          /* ... and fraction of total energy test */
00712          if (i >= 4 &&
00713              (row_energy[best_row] + col_energy[best_col]) > DTMF_TO_TOTAL_ENERGY*s->td.dtmf.energy) {
00714             /* Got a hit */
00715             hit = dtmf_positions[(best_row << 2) + best_col];
00716          }
00717       } 
00718 
00719       if (s->td.dtmf.current_hit) {
00720          /* We are in the middle of a digit already */
00721          if (hit != s->td.dtmf.current_hit) {
00722             s->td.dtmf.misses++;
00723             if (s->td.dtmf.misses == s->td.dtmf.misses_to_end) {
00724                /* There were enough misses to consider digit ended */
00725                s->td.dtmf.current_hit = 0;
00726             }
00727          } else {
00728             s->td.dtmf.misses = 0;
00729          }
00730       }
00731 
00732       /* Look for a start of a new digit no matter if we are already in the middle of some
00733          digit or not. This is because hits_to_begin may be smaller than misses_to_end
00734          and we may find begin of new digit before we consider last one ended. */
00735       if (hit) {
00736          if (hit == s->td.dtmf.lasthit) {
00737             s->td.dtmf.hits++;
00738          } else {
00739             s->td.dtmf.hits = 1;
00740          }
00741 
00742          if (s->td.dtmf.hits == s->td.dtmf.hits_to_begin && hit != s->td.dtmf.current_hit) {
00743             store_digit(s, hit);
00744             s->td.dtmf.current_hit = hit;
00745             s->td.dtmf.misses = 0;
00746          }
00747       } else {
00748          s->td.dtmf.hits = 0;
00749       }
00750 
00751       s->td.dtmf.lasthit = hit;
00752 
00753       /* If we had a hit in this block, include it into mute fragment */
00754       if (squelch && hit) {
00755          if (mute.end < sample - DTMF_GSIZE) {
00756             /* There is a gap between fragments */
00757             mute_fragment(dsp, &mute);
00758             mute.start = (sample > DTMF_GSIZE) ? (sample - DTMF_GSIZE) : 0;
00759          }
00760          mute.end = limit + DTMF_GSIZE;
00761       }
00762 
00763       /* Reinitialise the detector for the next block */
00764       for (i = 0;  i < 4;  i++) {
00765          goertzel_reset(&s->td.dtmf.row_out[i]);
00766          goertzel_reset(&s->td.dtmf.col_out[i]);
00767       }
00768       s->td.dtmf.energy = 0.0;
00769       s->td.dtmf.current_sample = 0;
00770    }
00771 
00772    if (squelch && mute.end) {
00773       if (mute.end > samples) {
00774          s->td.dtmf.mute_samples = mute.end - samples;
00775          mute.end = samples;
00776       }
00777       mute_fragment(dsp, &mute);
00778    }
00779 
00780    return (s->td.dtmf.current_hit); /* return the debounced hit */
00781 }
00782 
00783 static int mf_detect(struct ast_dsp *dsp, digit_detect_state_t *s, int16_t amp[],
00784                  int samples, int squelch, int relax)
00785 {
00786    float energy[6];
00787    int best;
00788    int second_best;
00789    float famp;
00790    int i;
00791    int j;
00792    int sample;
00793    int hit;
00794    int limit;
00795    fragment_t mute = {0, 0};
00796 
00797    if (squelch && s->td.mf.mute_samples > 0) {
00798       mute.end = (s->td.mf.mute_samples < samples) ? s->td.mf.mute_samples : samples;
00799       s->td.mf.mute_samples -= mute.end;
00800    }
00801 
00802    hit = 0;
00803    for (sample = 0;  sample < samples;  sample = limit) {
00804       /* 80 is optimised to meet the MF specs. */
00805       /* XXX So then why is MF_GSIZE defined as 120? */
00806       if ((samples - sample) >= (MF_GSIZE - s->td.mf.current_sample))
00807          limit = sample + (MF_GSIZE - s->td.mf.current_sample);
00808       else
00809          limit = samples;
00810       /* The following unrolled loop takes only 35% (rough estimate) of the 
00811          time of a rolled loop on the machine on which it was developed */
00812       for (j = sample;  j < limit;  j++) {
00813          famp = amp[j];
00814          /* With GCC 2.95, the following unrolled code seems to take about 35%
00815             (rough estimate) as long as a neat little 0-3 loop */
00816          goertzel_sample(s->td.mf.tone_out, amp[j]);
00817          goertzel_sample(s->td.mf.tone_out + 1, amp[j]);
00818          goertzel_sample(s->td.mf.tone_out + 2, amp[j]);
00819          goertzel_sample(s->td.mf.tone_out + 3, amp[j]);
00820          goertzel_sample(s->td.mf.tone_out + 4, amp[j]);
00821          goertzel_sample(s->td.mf.tone_out + 5, amp[j]);
00822       }
00823       s->td.mf.current_sample += (limit - sample);
00824       if (s->td.mf.current_sample < MF_GSIZE) {
00825          continue;
00826       }
00827       /* We're at the end of an MF detection block.  */
00828       /* Find the two highest energies. The spec says to look for
00829          two tones and two tones only. Taking this literally -ie
00830          only two tones pass the minimum threshold - doesn't work
00831          well. The sinc function mess, due to rectangular windowing
00832          ensure that! Find the two highest energies and ensure they
00833          are considerably stronger than any of the others. */
00834       energy[0] = goertzel_result(&s->td.mf.tone_out[0]);
00835       energy[1] = goertzel_result(&s->td.mf.tone_out[1]);
00836       if (energy[0] > energy[1]) {
00837          best = 0;
00838          second_best = 1;
00839       } else {
00840          best = 1;
00841          second_best = 0;
00842       }
00843       /*endif*/
00844       for (i=2;i<6;i++) {
00845          energy[i] = goertzel_result(&s->td.mf.tone_out[i]);
00846          if (energy[i] >= energy[best]) {
00847             second_best = best;
00848             best = i;
00849          } else if (energy[i] >= energy[second_best]) {
00850             second_best = i;
00851          }
00852       }
00853       /* Basic signal level and twist tests */
00854       hit = 0;
00855       if (energy[best] >= BELL_MF_THRESHOLD && energy[second_best] >= BELL_MF_THRESHOLD
00856                && energy[best] < energy[second_best]*BELL_MF_TWIST
00857                && energy[best]*BELL_MF_TWIST > energy[second_best]) {
00858          /* Relative peak test */
00859          hit = -1;
00860          for (i=0;i<6;i++) {
00861             if (i != best && i != second_best) {
00862                if (energy[i]*BELL_MF_RELATIVE_PEAK >= energy[second_best]) {
00863                   /* The best two are not clearly the best */
00864                   hit = 0;
00865                   break;
00866                }
00867             }
00868          }
00869       }
00870       if (hit) {
00871          /* Get the values into ascending order */
00872          if (second_best < best) {
00873             i = best;
00874             best = second_best;
00875             second_best = i;
00876          }
00877          best = best*5 + second_best - 1;
00878          hit = bell_mf_positions[best];
00879          /* Look for two successive similar results */
00880          /* The logic in the next test is:
00881             For KP we need 4 successive identical clean detects, with
00882             two blocks of something different preceeding it. For anything
00883             else we need two successive identical clean detects, with
00884             two blocks of something different preceeding it. */
00885          if (hit == s->td.mf.hits[4] && hit == s->td.mf.hits[3] &&
00886             ((hit != '*' && hit != s->td.mf.hits[2] && hit != s->td.mf.hits[1])||
00887              (hit == '*' && hit == s->td.mf.hits[2] && hit != s->td.mf.hits[1] && 
00888              hit != s->td.mf.hits[0]))) {
00889             store_digit(s, hit);
00890          }
00891       }
00892 
00893 
00894       if (hit != s->td.mf.hits[4] && hit != s->td.mf.hits[3]) {
00895          /* Two successive block without a hit terminate current digit */
00896          s->td.mf.current_hit = 0;
00897       }
00898 
00899       s->td.mf.hits[0] = s->td.mf.hits[1];
00900       s->td.mf.hits[1] = s->td.mf.hits[2];
00901       s->td.mf.hits[2] = s->td.mf.hits[3];
00902       s->td.mf.hits[3] = s->td.mf.hits[4];
00903       s->td.mf.hits[4] = hit;
00904 
00905       /* If we had a hit in this block, include it into mute fragment */
00906       if (squelch && hit) {
00907          if (mute.end < sample - MF_GSIZE) {
00908             /* There is a gap between fragments */
00909             mute_fragment(dsp, &mute);
00910             mute.start = (sample > MF_GSIZE) ? (sample - MF_GSIZE) : 0;
00911          }
00912          mute.end = limit + DTMF_GSIZE;
00913       }
00914 
00915       /* Reinitialise the detector for the next block */
00916       for (i = 0;  i < 6;  i++)
00917          goertzel_reset(&s->td.mf.tone_out[i]);
00918       s->td.mf.current_sample = 0;
00919    }
00920 
00921    if (squelch && mute.end) {
00922       if (mute.end > samples) {
00923          s->td.mf.mute_samples = mute.end - samples;
00924          mute.end = samples;
00925       }
00926       mute_fragment(dsp, &mute);
00927    }
00928 
00929    return (s->td.mf.current_hit); /* return the debounced hit */
00930 }
00931 
00932 static inline int pair_there(float p1, float p2, float i1, float i2, float e)
00933 {
00934    /* See if p1 and p2 are there, relative to i1 and i2 and total energy */
00935    /* Make sure absolute levels are high enough */
00936    if ((p1 < TONE_MIN_THRESH) || (p2 < TONE_MIN_THRESH))
00937       return 0;
00938    /* Amplify ignored stuff */
00939    i2 *= TONE_THRESH;
00940    i1 *= TONE_THRESH;
00941    e *= TONE_THRESH;
00942    /* Check first tone */
00943    if ((p1 < i1) || (p1 < i2) || (p1 < e))
00944       return 0;
00945    /* And second */
00946    if ((p2 < i1) || (p2 < i2) || (p2 < e))
00947       return 0;
00948    /* Guess it's there... */
00949    return 1;
00950 }
00951 
00952 static int __ast_dsp_call_progress(struct ast_dsp *dsp, short *s, int len)
00953 {
00954    int x;
00955    int y;
00956    int pass;
00957    int newstate = DSP_TONE_STATE_SILENCE;
00958    int res = 0;
00959    while (len) {
00960       /* Take the lesser of the number of samples we need and what we have */
00961       pass = len;
00962       if (pass > dsp->gsamp_size - dsp->gsamps) 
00963          pass = dsp->gsamp_size - dsp->gsamps;
00964       for (x=0;x<pass;x++) {
00965          for (y=0;y<dsp->freqcount;y++) 
00966             goertzel_sample(&dsp->freqs[y], s[x]);
00967          dsp->genergy += s[x] * s[x];
00968       }
00969       s += pass;
00970       dsp->gsamps += pass;
00971       len -= pass;
00972       if (dsp->gsamps == dsp->gsamp_size) {
00973          float hz[7];
00974          for (y=0;y<7;y++)
00975             hz[y] = goertzel_result(&dsp->freqs[y]);
00976          switch (dsp->progmode) {
00977          case PROG_MODE_NA:
00978             if (pair_there(hz[HZ_480], hz[HZ_620], hz[HZ_350], hz[HZ_440], dsp->genergy)) {
00979                newstate = DSP_TONE_STATE_BUSY;
00980             } else if (pair_there(hz[HZ_440], hz[HZ_480], hz[HZ_350], hz[HZ_620], dsp->genergy)) {
00981                newstate = DSP_TONE_STATE_RINGING;
00982             } else if (pair_there(hz[HZ_350], hz[HZ_440], hz[HZ_480], hz[HZ_620], dsp->genergy)) {
00983                newstate = DSP_TONE_STATE_DIALTONE;
00984             } else if (hz[HZ_950] > TONE_MIN_THRESH * TONE_THRESH) {
00985                newstate = DSP_TONE_STATE_SPECIAL1;
00986             } else if (hz[HZ_1400] > TONE_MIN_THRESH * TONE_THRESH) {
00987                if (dsp->tstate == DSP_TONE_STATE_SPECIAL1)
00988                   newstate = DSP_TONE_STATE_SPECIAL2;
00989             } else if (hz[HZ_1800] > TONE_MIN_THRESH * TONE_THRESH) {
00990                if (dsp->tstate == DSP_TONE_STATE_SPECIAL2)
00991                   newstate = DSP_TONE_STATE_SPECIAL3;
00992             } else if (dsp->genergy > TONE_MIN_THRESH * TONE_THRESH) {
00993                newstate = DSP_TONE_STATE_TALKING;
00994             } else
00995                newstate = DSP_TONE_STATE_SILENCE;
00996             break;
00997          case PROG_MODE_CR:
00998             if (hz[HZ_425] > TONE_MIN_THRESH * TONE_THRESH) {
00999                newstate = DSP_TONE_STATE_RINGING;
01000             } else if (dsp->genergy > TONE_MIN_THRESH * TONE_THRESH) {
01001                newstate = DSP_TONE_STATE_TALKING;
01002             } else
01003                newstate = DSP_TONE_STATE_SILENCE;
01004             break;
01005          case PROG_MODE_UK:
01006             if (hz[HZ_400] > TONE_MIN_THRESH * TONE_THRESH) {
01007                newstate = DSP_TONE_STATE_HUNGUP;
01008             }
01009             break;
01010          default:
01011             ast_log(LOG_WARNING, "Can't process in unknown prog mode '%d'\n", dsp->progmode);
01012          }
01013          if (newstate == dsp->tstate) {
01014             dsp->tcount++;
01015             if (dsp->ringtimeout)
01016                dsp->ringtimeout++;
01017             switch (dsp->tstate) {
01018                case DSP_TONE_STATE_RINGING:
01019                   if ((dsp->features & DSP_PROGRESS_RINGING) &&
01020                       (dsp->tcount==THRESH_RING)) {
01021                      res = AST_CONTROL_RINGING;
01022                      dsp->ringtimeout= 1;
01023                   }
01024                   break;
01025                case DSP_TONE_STATE_BUSY:
01026                   if ((dsp->features & DSP_PROGRESS_BUSY) &&
01027                       (dsp->tcount==THRESH_BUSY)) {
01028                      res = AST_CONTROL_BUSY;
01029                      dsp->features &= ~DSP_FEATURE_CALL_PROGRESS;
01030                   }
01031                   break;
01032                case DSP_TONE_STATE_TALKING:
01033                   if ((dsp->features & DSP_PROGRESS_TALK) &&
01034                       (dsp->tcount==THRESH_TALK)) {
01035                      res = AST_CONTROL_ANSWER;
01036                      dsp->features &= ~DSP_FEATURE_CALL_PROGRESS;
01037                   }
01038                   break;
01039                case DSP_TONE_STATE_SPECIAL3:
01040                   if ((dsp->features & DSP_PROGRESS_CONGESTION) &&
01041                       (dsp->tcount==THRESH_CONGESTION)) {
01042                      res = AST_CONTROL_CONGESTION;
01043                      dsp->features &= ~DSP_FEATURE_CALL_PROGRESS;
01044                   }
01045                   break;
01046                case DSP_TONE_STATE_HUNGUP:
01047                   if ((dsp->features & DSP_FEATURE_CALL_PROGRESS) &&
01048                       (dsp->tcount==THRESH_HANGUP)) {
01049                      res = AST_CONTROL_HANGUP;
01050                      dsp->features &= ~DSP_FEATURE_CALL_PROGRESS;
01051                   }
01052                   break;
01053             }
01054             if (dsp->ringtimeout==THRESH_RING2ANSWER) {
01055                ast_debug(1, "Consider call as answered because of timeout after last ring\n");
01056                res = AST_CONTROL_ANSWER;
01057                dsp->features &= ~DSP_FEATURE_CALL_PROGRESS;
01058             }
01059          } else {
01060             ast_debug(5, "Stop state %d with duration %d\n", dsp->tstate, dsp->tcount);
01061             ast_debug(5, "Start state %d\n", newstate);
01062             dsp->tstate = newstate;
01063             dsp->tcount = 1;
01064          }
01065          
01066          /* Reset goertzel */                
01067          for (x=0;x<7;x++)
01068             dsp->freqs[x].v2 = dsp->freqs[x].v3 = 0.0;
01069          dsp->gsamps = 0;
01070          dsp->genergy = 0.0;
01071       }
01072    }
01073 
01074    return res;
01075 }
01076 
01077 int ast_dsp_call_progress(struct ast_dsp *dsp, struct ast_frame *inf)
01078 {
01079    if (inf->frametype != AST_FRAME_VOICE) {
01080       ast_log(LOG_WARNING, "Can't check call progress of non-voice frames\n");
01081       return 0;
01082    }
01083    if (inf->subclass != AST_FORMAT_SLINEAR) {
01084       ast_log(LOG_WARNING, "Can only check call progress in signed-linear frames\n");
01085       return 0;
01086    }
01087    return __ast_dsp_call_progress(dsp, inf->data.ptr, inf->datalen / 2);
01088 }
01089 
01090 static int __ast_dsp_silence_noise(struct ast_dsp *dsp, short *s, int len, int *totalsilence, int *totalnoise)
01091 {
01092    int accum;
01093    int x;
01094    int res = 0;
01095 
01096    if (!len)
01097       return 0;
01098    accum = 0;
01099    for (x=0;x<len; x++) 
01100       accum += abs(s[x]);
01101    accum /= len;
01102    if (accum < dsp->threshold) {
01103       /* Silent */
01104       dsp->totalsilence += len/8;
01105 #ifdef DEBUG_DSP_BUSYDETECT
01106       fprintf(stderr, "SILENCE: len = %d, level = %d\n", dsp->totalsilence, accum);
01107 #endif
01108       if (dsp->totalnoise) {
01109          /* Move and save history */
01110          memmove(dsp->historicnoise + DSP_HISTORY - dsp->busycount, dsp->historicnoise + DSP_HISTORY - dsp->busycount + 1, (dsp->busycount-1)*sizeof(dsp->historicnoise[0]));
01111          dsp->historicnoise[DSP_HISTORY - 1] = dsp->totalnoise;
01112          /* check if previous tone differs BUSY_PERCENT from the one before it */
01113          int tone1 = dsp->historicnoise[DSP_HISTORY - 1];
01114          int tone2 = dsp->historicnoise[DSP_HISTORY - 2];
01115          if (tone1 < tone2) {
01116            if ((tone1 + tone1*BUSY_PERCENT/100) >= tone2)
01117                dsp->busymaybe = 1;
01118            else
01119                dsp->busymaybe = 0;
01120          } else {
01121            if ((tone1 - tone1*BUSY_PERCENT/100) <= tone2)
01122                dsp->busymaybe = 1;
01123             else
01124                dsp->busymaybe = 0;
01125          }
01126       }
01127       dsp->totalnoise = 0;
01128       res = 1;
01129    } else {
01130       /* Not silent */
01131       dsp->totalnoise += len/8;
01132 #ifdef DEBUG_DSP_BUSYDETECT
01133       fprintf(stderr, "NOISE: len = %d, level = %d\n", dsp->totalnoise, accum);
01134 #endif     
01135       if (dsp->totalsilence) {
01136          /* Move and save history */
01137          memmove(dsp->historicsilence + DSP_HISTORY - dsp->busycount, dsp->historicsilence + DSP_HISTORY - dsp->busycount + 1, (dsp->busycount-1)*sizeof(dsp->historicsilence[0]));
01138          dsp->historicsilence[DSP_HISTORY - 1] = dsp->totalsilence;
01139       }
01140       dsp->totalsilence = 0;
01141    }
01142    if (totalsilence)
01143       *totalsilence = dsp->totalsilence;
01144    if (totalnoise)
01145       *totalnoise = dsp->totalnoise;
01146    return res;
01147 }
01148 
01149 int ast_dsp_busydetect(struct ast_dsp *dsp)
01150 {
01151    int res = 0, x;
01152    int avgsilence = 0, hitsilence = 0;
01153    int avgtone = 0, hittone = 0;
01154 #ifdef DEBUG_DSP_BUSYDETECT
01155    char buf[16];
01156    char silence_list[64]="", tone_list[64]="";
01157 #endif
01158    
01159    if (!dsp->busymaybe)
01160       return res;
01161    dsp->busymaybe = 0;
01162 
01163    for (x=DSP_HISTORY - dsp->busycount;x<DSP_HISTORY;x++) {
01164       avgsilence += dsp->historicsilence[x];
01165       avgtone += dsp->historicnoise[x];
01166    }
01167    avgsilence /= dsp->busycount;
01168    avgtone /= dsp->busycount;
01169 #ifdef DEBUG_DSP_BUSYDETECT
01170    sprintf(silence_list,"Silences: ");
01171    sprintf(tone_list,"Tones:    ");
01172 #endif
01173    for (x=DSP_HISTORY - dsp->busycount; x<DSP_HISTORY; x++) {
01174 #ifdef DEBUG_DSP_BUSYDETECT
01175       snprintf(buf, sizeof(buf), "%5d ", dsp->historicsilence[x]);
01176       strcat(silence_list, buf);
01177       snprintf(buf, sizeof(buf), "%5d ", dsp->historicnoise[x]);
01178       strcat(tone_list, buf); 
01179 #endif
01180       if (!dsp->busytoneonly) {
01181          if (avgsilence > dsp->historicsilence[x]) {
01182             if (avgsilence - (avgsilence*BUSY_PERCENT/100) <= dsp->historicsilence[x])
01183                hitsilence++;
01184          } else {
01185             if (avgsilence + (avgsilence*BUSY_PERCENT/100) >= dsp->historicsilence[x])
01186                hitsilence++;
01187          }
01188       }
01189       if (avgtone > dsp->historicnoise[x]) {
01190          if (avgtone - (avgtone*BUSY_PERCENT/100) <= dsp->historicnoise[x])
01191             hittone++;
01192       } else {
01193          if (avgtone + (avgtone*BUSY_PERCENT/100) >= dsp->historicnoise[x])
01194             hittone++;
01195       }
01196    }
01197 #ifdef DEBUG_DSP_BUSYDETECT
01198    fprintf(stderr, "BUSY DETECTOR\n");   
01199    fprintf(stderr, "%s\n", tone_list);
01200    fprintf(stderr, "%s\n", silence_list)
01201 #endif
01202    if ((dsp->busytoneonly || 
01203        (hitsilence >= dsp->busycount - 1 && avgsilence >= BUSY_MIN && avgsilence <= BUSY_MAX)) &&
01204       (hittone >= dsp->busycount - 1 && avgtone >= BUSY_MIN && avgtone <= BUSY_MAX)) {
01205       if (dsp->busycompare) {
01206            if (dsp->busytoneonly) {
01207              res = 1;
01208             ast_log(LOG_ERROR, "You can't use busytoneonly together with busycompare");
01209          } else {
01210               if (avgtone > avgsilence) {
01211                  if (avgtone - avgtone*BUSY_PERCENT/100 <= avgsilence)
01212                     res = 1;
01213             } else {
01214                  if (avgtone + avgtone*BUSY_PERCENT/100 >= avgsilence)
01215                    res = 1;
01216             }
01217          }
01218       } else {
01219          res = 1;
01220       }
01221    }
01222    /* If we know the expected busy tone length, check we are in the range */
01223    if (res && (dsp->busy_tonelength > 0)) {
01224       if (abs(avgtone - dsp->busy_tonelength) > (dsp->busy_tonelength*dsp->busy_pattern_fuzzy/100)) {
01225 #ifdef BUSYDETECT_DEBUG
01226             ast_debug(5, "busy detector: avgtone of %d not close enough to desired %d\n", avgtone, dsp->busy_tonelength);
01227 #endif
01228          res = 0;
01229       }
01230    }
01231    /* If we know the expected busy tone silent-period length, check we are in the range */
01232    if (res && (!dsp->busytoneonly) && (dsp->busy_quietlength > 0)) {
01233       if (abs(avgsilence - dsp->busy_quietlength) > (dsp->busy_quietlength*dsp->busy_pattern_fuzzy/100)) {
01234 #ifdef BUSYDETECT_DEBUG
01235             ast_debug(5, "busy detector: avgsilence of %d not close enough to desired %d\n", avgsilence, dsp->busy_quietlength);
01236 #endif
01237          res = 0;
01238       }
01239    }
01240    if (res) {
01241       if (option_debug)
01242          ast_log(LOG_NOTICE, "ast_dsp_busydetect detected busy sequence, avgtone: %d, avgsilence %d\n", avgtone, avgsilence);
01243    } else {
01244          ast_debug(5, "busy detector: FAILED with avgtone: %d, avgsilence %d\n", avgtone, avgsilence);
01245    }
01246    return res;
01247 }
01248 
01249 int ast_dsp_silence(struct ast_dsp *dsp, struct ast_frame *f, int *totalsilence)
01250 {
01251    short *s;
01252    int len;
01253    
01254    if (f->frametype != AST_FRAME_VOICE) {
01255       ast_log(LOG_WARNING, "Can't calculate silence on a non-voice frame\n");
01256       return 0;
01257    }
01258    if (f->subclass != AST_FORMAT_SLINEAR) {
01259       ast_log(LOG_WARNING, "Can only calculate silence on signed-linear frames :(\n");
01260       return 0;
01261    }
01262    s = f->data.ptr;
01263    len = f->datalen/2;
01264    return __ast_dsp_silence_noise(dsp, s, len, totalsilence, NULL);
01265 }
01266 
01267 int ast_dsp_noise(struct ast_dsp *dsp, struct ast_frame *f, int *totalnoise)
01268 {
01269        short *s;
01270        int len;
01271 
01272        if (f->frametype != AST_FRAME_VOICE) {
01273                ast_log(LOG_WARNING, "Can't calculate noise on a non-voice frame\n");
01274                return 0;
01275        }
01276        if (f->subclass != AST_FORMAT_SLINEAR) {
01277                ast_log(LOG_WARNING, "Can only calculate noise on signed-linear frames :(\n");
01278                return 0;
01279        }
01280        s = f->data.ptr;
01281        len = f->datalen/2;
01282        return __ast_dsp_silence_noise(dsp, s, len, NULL, totalnoise);
01283 }
01284 
01285 
01286 struct ast_frame *ast_dsp_process(struct ast_channel *chan, struct ast_dsp *dsp, struct ast_frame *af)
01287 {
01288    int silence;
01289    int res;
01290    int digit = 0, fax_digit = 0;
01291    int x;
01292    short *shortdata;
01293    unsigned char *odata;
01294    int len;
01295    struct ast_frame *outf = NULL;
01296 
01297    if (!af)
01298       return NULL;
01299    if (af->frametype != AST_FRAME_VOICE)
01300       return af;
01301 
01302    odata = af->data.ptr;
01303    len = af->datalen;
01304    /* Make sure we have short data */
01305    switch (af->subclass) {
01306    case AST_FORMAT_SLINEAR:
01307       shortdata = af->data.ptr;
01308       len = af->datalen / 2;
01309       break;
01310    case AST_FORMAT_ULAW:
01311       shortdata = alloca(af->datalen * 2);
01312       for (x = 0;x < len; x++) 
01313          shortdata[x] = AST_MULAW(odata[x]);
01314       break;
01315    case AST_FORMAT_ALAW:
01316       shortdata = alloca(af->datalen * 2);
01317       for (x = 0; x < len; x++) 
01318          shortdata[x] = AST_ALAW(odata[x]);
01319       break;
01320    default:
01321       /*Display warning only once. Otherwise you would get hundreds of warnings every second */
01322       if (dsp->display_inband_dtmf_warning)
01323          ast_log(LOG_WARNING, "Inband DTMF is not supported on codec %s. Use RFC2833\n", ast_getformatname(af->subclass));
01324       dsp->display_inband_dtmf_warning = 0;
01325       return af;
01326    }
01327 
01328    /* Initially we do not want to mute anything */
01329    dsp->mute_fragments = 0;
01330 
01331    /* Need to run the silence detection stuff for silence suppression and busy detection */
01332    if ((dsp->features & DSP_FEATURE_SILENCE_SUPPRESS) || (dsp->features & DSP_FEATURE_BUSY_DETECT)) {
01333       res = __ast_dsp_silence_noise(dsp, shortdata, len, &silence, NULL);
01334    }
01335 
01336    if ((dsp->features & DSP_FEATURE_SILENCE_SUPPRESS) && silence) {
01337       memset(&dsp->f, 0, sizeof(dsp->f));
01338       dsp->f.frametype = AST_FRAME_NULL;
01339       ast_frfree(af);
01340       return ast_frisolate(&dsp->f);
01341    }
01342    if ((dsp->features & DSP_FEATURE_BUSY_DETECT) && ast_dsp_busydetect(dsp)) {
01343       chan->_softhangup |= AST_SOFTHANGUP_DEV;
01344       memset(&dsp->f, 0, sizeof(dsp->f));
01345       dsp->f.frametype = AST_FRAME_CONTROL;
01346       dsp->f.subclass = AST_CONTROL_BUSY;
01347       ast_frfree(af);
01348       ast_debug(1, "Requesting Hangup because the busy tone was detected on channel %s\n", chan->name);
01349       return ast_frisolate(&dsp->f);
01350    }
01351 
01352    if ((dsp->features & DSP_FEATURE_FAX_DETECT)) {
01353       if ((dsp->faxmode & DSP_FAXMODE_DETECT_CNG) && tone_detect(dsp, &dsp->cng_tone_state, shortdata, len)) {
01354          fax_digit = 'f';
01355       }
01356 
01357       if ((dsp->faxmode & DSP_FAXMODE_DETECT_CED) && tone_detect(dsp, &dsp->ced_tone_state, shortdata, len)) {
01358          fax_digit = 'e';
01359       }
01360    }
01361 
01362    if (dsp->features & (DSP_FEATURE_DIGIT_DETECT | DSP_FEATURE_BUSY_DETECT)) {
01363       if (dsp->digitmode & DSP_DIGITMODE_MF)
01364          digit = mf_detect(dsp, &dsp->digit_state, shortdata, len, (dsp->digitmode & DSP_DIGITMODE_NOQUELCH) == 0, (dsp->digitmode & DSP_DIGITMODE_RELAXDTMF));
01365       else
01366          digit = dtmf_detect(dsp, &dsp->digit_state, shortdata, len, (dsp->digitmode & DSP_DIGITMODE_NOQUELCH) == 0, (dsp->digitmode & DSP_DIGITMODE_RELAXDTMF));
01367 
01368       if (dsp->digit_state.current_digits) {
01369          int event = 0;
01370          char event_digit = 0;
01371 
01372          if (!dsp->dtmf_began) {
01373             /* We have not reported DTMF_BEGIN for anything yet */
01374 
01375             if (dsp->features & DSP_FEATURE_DIGIT_DETECT) {
01376                event = AST_FRAME_DTMF_BEGIN;
01377                event_digit = dsp->digit_state.digits[0];
01378             }
01379             dsp->dtmf_began = 1;
01380 
01381          } else if (dsp->digit_state.current_digits > 1 || digit != dsp->digit_state.digits[0]) {
01382             /* Digit changed. This means digit we have reported with DTMF_BEGIN ended */
01383             if (dsp->features & DSP_FEATURE_DIGIT_DETECT) {
01384                event = AST_FRAME_DTMF_END;
01385                event_digit = dsp->digit_state.digits[0];
01386             }
01387             memmove(dsp->digit_state.digits, dsp->digit_state.digits + 1, dsp->digit_state.current_digits);
01388             dsp->digit_state.current_digits--;
01389             dsp->dtmf_began = 0;
01390 
01391             if (dsp->features & DSP_FEATURE_BUSY_DETECT) {
01392                /* Reset Busy Detector as we have some confirmed activity */ 
01393                memset(dsp->historicsilence, 0, sizeof(dsp->historicsilence));
01394                memset(dsp->historicnoise, 0, sizeof(dsp->historicnoise));
01395                ast_debug(1, "DTMF Detected - Reset busydetector\n");
01396             }
01397          }
01398 
01399          if (event) {
01400             memset(&dsp->f, 0, sizeof(dsp->f));
01401             dsp->f.frametype = event;
01402             dsp->f.subclass = event_digit;
01403             outf = &dsp->f;
01404             goto done;
01405          }
01406       }
01407    }
01408 
01409    if (fax_digit) {
01410       /* Fax was detected - digit is either 'f' or 'e' */
01411 
01412       memset(&dsp->f, 0, sizeof(dsp->f));
01413       dsp->f.frametype = AST_FRAME_DTMF;
01414       dsp->f.subclass = fax_digit;
01415       outf = &dsp->f;
01416       goto done;
01417    }
01418 
01419    if ((dsp->features & DSP_FEATURE_CALL_PROGRESS)) {
01420       res = __ast_dsp_call_progress(dsp, shortdata, len);
01421       if (res) {
01422          switch (res) {
01423          case AST_CONTROL_ANSWER:
01424          case AST_CONTROL_BUSY:
01425          case AST_CONTROL_RINGING:
01426          case AST_CONTROL_CONGESTION:
01427          case AST_CONTROL_HANGUP:
01428             memset(&dsp->f, 0, sizeof(dsp->f));
01429             dsp->f.frametype = AST_FRAME_CONTROL;
01430             dsp->f.subclass = res;
01431             dsp->f.src = "dsp_progress";
01432             if (chan) 
01433                ast_queue_frame(chan, &dsp->f);
01434             break;
01435          default:
01436             ast_log(LOG_WARNING, "Don't know how to represent call progress message %d\n", res);
01437          }
01438       }
01439    }
01440 
01441 done:
01442    /* Mute fragment of the frame */
01443    for (x = 0; x < dsp->mute_fragments; x++) {
01444       memset(shortdata + dsp->mute_data[x].start, 0, sizeof(int16_t) * (dsp->mute_data[x].end - dsp->mute_data[x].start));
01445    }
01446 
01447    switch (af->subclass) {
01448    case AST_FORMAT_SLINEAR:
01449       break;
01450    case AST_FORMAT_ULAW:
01451       for (x = 0; x < len; x++)
01452          odata[x] = AST_LIN2MU((unsigned short) shortdata[x]);
01453       break;
01454    case AST_FORMAT_ALAW:
01455       for (x = 0; x < len; x++)
01456          odata[x] = AST_LIN2A((unsigned short) shortdata[x]);
01457       break;
01458    }
01459 
01460    if (outf) {
01461       if (chan) 
01462          ast_queue_frame(chan, af);
01463       ast_frfree(af);
01464       return ast_frisolate(outf);
01465    } else {
01466       return af;
01467    }
01468 }
01469 
01470 static void ast_dsp_prog_reset(struct ast_dsp *dsp)
01471 {
01472    int max = 0;
01473    int x;
01474    
01475    dsp->gsamp_size = modes[dsp->progmode].size;
01476    dsp->gsamps = 0;
01477    for (x = 0; x < ARRAY_LEN(modes[dsp->progmode].freqs); x++) {
01478       if (modes[dsp->progmode].freqs[x]) {
01479          goertzel_init(&dsp->freqs[x], (float)modes[dsp->progmode].freqs[x], dsp->gsamp_size);
01480          max = x + 1;
01481       }
01482    }
01483    dsp->freqcount = max;
01484    dsp->ringtimeout= 0;
01485 }
01486 
01487 struct ast_dsp *ast_dsp_new(void)
01488 {
01489    struct ast_dsp *dsp;
01490    
01491    if ((dsp = ast_calloc(1, sizeof(*dsp)))) {      
01492       dsp->threshold = DEFAULT_THRESHOLD;
01493       dsp->features = DSP_FEATURE_SILENCE_SUPPRESS;
01494       dsp->busycount = DSP_HISTORY;
01495       dsp->digitmode = DSP_DIGITMODE_DTMF;
01496       dsp->faxmode = DSP_FAXMODE_DETECT_CNG;
01497       dsp->busy_pattern_fuzzy = BUSY_PAT_PERCENT;
01498 #ifdef BUSYDETECT_TONEONLY
01499       dsp->busytoneonly = 1;
01500 #ifdef BUSYDETECT_COMPARE_TONE_AND_SILENCE
01501 #error "You can't use BUSYDETECT_TONEONLY together with BUSYDETECT_COMPARE_TONE_AND_SILENCE");
01502 #endif
01503 #else
01504    dsp->busytoneonly = 0;
01505 #ifdef BUSYDETECT_COMPARE_TONE_AND_SILENCE
01506    dsp->busycompare = 1;
01507 #else
01508    dsp->busycompare = 0;
01509 #endif
01510 #endif
01511       /* Initialize digit detector */
01512       ast_digit_detect_init(&dsp->digit_state, dsp->digitmode & DSP_DIGITMODE_MF);
01513       dsp->display_inband_dtmf_warning = 1;
01514       /* Initialize initial DSP progress detect parameters */
01515       ast_dsp_prog_reset(dsp);
01516       /* Initialize fax detector */
01517       ast_fax_detect_init(dsp);
01518    }
01519    return dsp;
01520 }
01521 
01522 void ast_dsp_set_features(struct ast_dsp *dsp, int features)
01523 {
01524    dsp->features = features;
01525 }
01526 
01527 void ast_dsp_free(struct ast_dsp *dsp)
01528 {
01529    ast_free(dsp);
01530 }
01531 
01532 void ast_dsp_set_threshold(struct ast_dsp *dsp, int threshold)
01533 {
01534    if (threshold < 256)
01535      dsp->threshold = 256;
01536    else
01537      dsp->threshold = threshold;
01538 }
01539 
01540 void ast_dsp_set_busy_count(struct ast_dsp *dsp, int cadences)
01541 {
01542    if (cadences < 4)
01543       cadences = 4;
01544    if (cadences > DSP_HISTORY)
01545       cadences = DSP_HISTORY;
01546    dsp->busycount = cadences;
01547 }
01548 
01549 void ast_dsp_set_busy_compare(struct ast_dsp *dsp, int compare)
01550 {
01551   if (compare > 0)
01552       dsp->busycompare = 1;
01553   else
01554       dsp->busycompare = 0;
01555 }
01556 
01557 void ast_dsp_set_busy_pattern(struct ast_dsp *dsp, int tonelength, int quietlength, int fuzzy)
01558 {
01559    dsp->busy_tonelength = tonelength;
01560    if (quietlength > 0)
01561       dsp->busy_quietlength = quietlength;
01562    else 
01563      dsp->busytoneonly = 1;
01564    ast_debug(1, "dsp busy pattern set to %d,%d\n", tonelength, quietlength);
01565    if( fuzzy > 0 && fuzzy < 50 ) 
01566       dsp->busy_pattern_fuzzy = fuzzy;
01567 }
01568 
01569 void ast_dsp_digitreset(struct ast_dsp *dsp)
01570 {
01571    int i;
01572    
01573    dsp->dtmf_began = 0;
01574    if (dsp->digitmode & DSP_DIGITMODE_MF) {
01575       mf_detect_state_t *s = &dsp->digit_state.td.mf;
01576       /* Reinitialise the detector for the next block */
01577       for (i = 0;  i < 6;  i++) {
01578          goertzel_reset(&s->tone_out[i]);
01579       }
01580       s->hits[4] = s->hits[3] = s->hits[2] = s->hits[1] = s->hits[0] = s->current_hit = 0;
01581       s->current_sample = 0;
01582    } else {
01583       dtmf_detect_state_t *s = &dsp->digit_state.td.dtmf;
01584       /* Reinitialise the detector for the next block */
01585       for (i = 0;  i < 4;  i++) {
01586          goertzel_reset(&s->row_out[i]);
01587          goertzel_reset(&s->col_out[i]);
01588       }
01589       s->lasthit = s->current_hit = 0;
01590       s->energy = 0.0;
01591       s->current_sample = 0;
01592       s->hits = 0;
01593       s->misses = 0;
01594    }
01595 
01596    dsp->digit_state.digits[0] = '\0';
01597    dsp->digit_state.current_digits = 0;
01598 }
01599 
01600 void ast_dsp_reset(struct ast_dsp *dsp)
01601 {
01602    int x;
01603    
01604    dsp->totalsilence = 0;
01605    dsp->gsamps = 0;
01606    for (x=0;x<4;x++)
01607       dsp->freqs[x].v2 = dsp->freqs[x].v3 = 0.0;
01608    memset(dsp->historicsilence, 0, sizeof(dsp->historicsilence));
01609    memset(dsp->historicnoise, 0, sizeof(dsp->historicnoise));  
01610    dsp->ringtimeout= 0;
01611 }
01612 
01613 int ast_dsp_set_digitmode(struct ast_dsp *dsp, int digitmode)
01614 {
01615    int new;
01616    int old;
01617    
01618    old = dsp->digitmode & (DSP_DIGITMODE_DTMF | DSP_DIGITMODE_MF | DSP_DIGITMODE_MUTECONF | DSP_DIGITMODE_MUTEMAX);
01619    new = digitmode & (DSP_DIGITMODE_DTMF | DSP_DIGITMODE_MF | DSP_DIGITMODE_MUTECONF | DSP_DIGITMODE_MUTEMAX);
01620    if (old != new) {
01621       /* Must initialize structures if switching from MF to DTMF or vice-versa */
01622       ast_digit_detect_init(&dsp->digit_state, new & DSP_DIGITMODE_MF);
01623    }
01624    dsp->digitmode = digitmode;
01625    return 0;
01626 }
01627 
01628 int ast_dsp_set_faxmode(struct ast_dsp *dsp, int faxmode)
01629 {
01630    if (dsp->faxmode != faxmode) {
01631       ast_fax_detect_init(dsp);
01632    }
01633    dsp->faxmode = faxmode;
01634    return 0;
01635 }
01636 
01637 int ast_dsp_set_call_progress_zone(struct ast_dsp *dsp, char *zone)
01638 {
01639    int x;
01640    
01641    for (x = 0; x < ARRAY_LEN(aliases); x++) {
01642       if (!strcasecmp(aliases[x].name, zone)) {
01643          dsp->progmode = aliases[x].mode;
01644          ast_dsp_prog_reset(dsp);
01645          return 0;
01646       }
01647    }
01648    return -1;
01649 }
01650 
01651 int ast_dsp_was_muted(struct ast_dsp *dsp)
01652 {
01653    return (dsp->mute_fragments > 0);
01654 }
01655 
01656 int ast_dsp_get_tstate(struct ast_dsp *dsp) 
01657 {
01658    return dsp->tstate;
01659 }
01660 
01661 int ast_dsp_get_tcount(struct ast_dsp *dsp) 
01662 {
01663    return dsp->tcount;
01664 }
01665 
01666 static int _dsp_init(int reload)
01667 {
01668    struct ast_flags config_flags = { reload ? CONFIG_FLAG_FILEUNCHANGED : 0 };
01669    struct ast_config *cfg;
01670 
01671    cfg = ast_config_load2(CONFIG_FILE_NAME, "dsp", config_flags);
01672 
01673    if (cfg && cfg != CONFIG_STATUS_FILEUNCHANGED) {
01674       const char *value;
01675 
01676       value = ast_variable_retrieve(cfg, "default", "silencethreshold");
01677       if (value && sscanf(value, "%30d", &thresholds[THRESHOLD_SILENCE]) != 1) {
01678          ast_log(LOG_WARNING, "%s: '%s' is not a valid silencethreshold value\n", CONFIG_FILE_NAME, value);
01679          thresholds[THRESHOLD_SILENCE] = 256;
01680       } else if (!value)
01681          thresholds[THRESHOLD_SILENCE] = 256;
01682 
01683       ast_config_destroy(cfg);
01684    }
01685    return 0;
01686 }
01687 
01688 int ast_dsp_get_threshold_from_settings(enum threshold which)
01689 {
01690    return thresholds[which];
01691 }
01692 
01693 int ast_dsp_init(void)
01694 {
01695    return _dsp_init(0);
01696 }
01697 
01698 int ast_dsp_reload(void)
01699 {
01700    return _dsp_init(1);
01701 }
01702 

Generated on Wed Aug 18 22:33:51 2010 for Asterisk - the Open Source PBX by  doxygen 1.4.7