#include "asterisk.h"
#include <math.h>
#include "asterisk/frame.h"
#include "asterisk/channel.h"
#include "asterisk/dsp.h"
#include "asterisk/ulaw.h"
#include "asterisk/alaw.h"
#include "asterisk/utils.h"
#include "asterisk/options.h"
#include "asterisk/config.h"
Go to the source code of this file.
Data Structures | |
struct | ast_dsp |
struct | digit_detect_state_t |
struct | dtmf_detect_state_t |
struct | fragment_t |
struct | goertzel_result_t |
struct | goertzel_state_t |
struct | mf_detect_state_t |
struct | progalias |
struct | progress |
struct | tone_detect_state_t |
Defines | |
#define | BELL_MF_RELATIVE_PEAK 12.6 |
#define | BELL_MF_THRESHOLD 1.6e9 |
#define | BELL_MF_TWIST 4.0 |
#define | CONFIG_FILE_NAME "dsp.conf" |
#define | DEFAULT_THRESHOLD 512 |
This value is the minimum threshold, calculated by averaging all of the samples within a frame, for which a frame is determined to either be silence (below the threshold) or noise (above the threshold). Please note that while the default threshold is an even exponent of 2, there is no requirement that it be so. The threshold will accept any value between 0 and 32767. | |
#define | DSP_HISTORY 15 |
#define | DTMF_2ND_HARMONIC_COL 63.1 |
#define | DTMF_2ND_HARMONIC_ROW (relax ? 1.7 : 2.5) |
#define | DTMF_GSIZE 102 |
#define | DTMF_HITS_TO_BEGIN 2 |
#define | DTMF_MISSES_TO_END 3 |
#define | DTMF_NORMAL_TWIST 6.3 |
#define | DTMF_RELATIVE_PEAK_COL 6.3 |
#define | DTMF_RELATIVE_PEAK_ROW 6.3 |
#define | DTMF_REVERSE_TWIST (relax ? 4.0 : 2.5) |
#define | DTMF_THRESHOLD 8.0e7 |
#define | DTMF_TO_TOTAL_ENERGY 42.0 |
#define | FAX_2ND_HARMONIC 2.0 |
#define | FAX_THRESHOLD 8.0e7 |
#define | FAX_TONE_CED_DB 16 |
#define | FAX_TONE_CED_DURATION 2600 |
#define | FAX_TONE_CED_FREQ 2100 |
#define | FAX_TONE_CNG_DB 16 |
#define | FAX_TONE_CNG_DURATION 500 |
#define | FAX_TONE_CNG_FREQ 1100 |
#define | MAX_DTMF_DIGITS 128 |
#define | MF_GSIZE 120 |
#define | SAMPLE_RATE 8000 |
#define | SAMPLES_IN_FRAME 160 |
#define | TONE_MIN_THRESH 1e8 |
#define | TONE_THRESH 10.0 |
Enumerations | |
enum | busy_detect { BUSY_PERCENT = 10, BUSY_PAT_PERCENT = 8, BUSY_THRESHOLD = 100, BUSY_MIN = 150, BUSY_MAX = 600 } |
enum | freq_index { HZ_350 = 0, HZ_440, HZ_480, HZ_620, HZ_950, HZ_1400, HZ_1800, HZ_425 = 0, HZ_400 = 0 } |
enum | gsamp_size { GSAMP_SIZE_NA = 183, GSAMP_SIZE_CR = 188, GSAMP_SIZE_UK = 160 } |
enum | gsamp_thresh { THRESH_RING = 8, THRESH_TALK = 2, THRESH_BUSY = 4, THRESH_CONGESTION = 4, THRESH_HANGUP = 60, THRESH_RING2ANSWER = 300 } |
enum | prog_mode { PROG_MODE_NA = 0, PROG_MODE_CR, PROG_MODE_UK } |
Functions | |
static int | __ast_dsp_call_progress (struct ast_dsp *dsp, short *s, int len) |
static int | __ast_dsp_silence_noise (struct ast_dsp *dsp, short *s, int len, int *totalsilence, int *totalnoise) |
static int | _dsp_init (int reload) |
static void | ast_digit_detect_init (digit_detect_state_t *s, int mf) |
int | ast_dsp_busydetect (struct ast_dsp *dsp) |
Return non-zero if historically this should be a busy, request that ast_dsp_silence has already been called. | |
int | ast_dsp_call_progress (struct ast_dsp *dsp, struct ast_frame *inf) |
Scans for progress indication in audio. | |
void | ast_dsp_digitreset (struct ast_dsp *dsp) |
Reset DTMF detector. | |
void | ast_dsp_free (struct ast_dsp *dsp) |
int | ast_dsp_get_tcount (struct ast_dsp *dsp) |
Get tcount (Threshold counter). | |
int | ast_dsp_get_threshold_from_settings (enum threshold which) |
Get silence threshold from dsp.conf. | |
int | ast_dsp_get_tstate (struct ast_dsp *dsp) |
Get tstate (Tone State). | |
int | ast_dsp_init (void) |
Load dsp settings from dsp.conf. | |
ast_dsp * | ast_dsp_new (void) |
int | ast_dsp_noise (struct ast_dsp *dsp, struct ast_frame *f, int *totalnoise) |
Return non-zero if this is noise. Updates "totalnoise" with the total number of seconds of noise. | |
ast_frame * | ast_dsp_process (struct ast_channel *chan, struct ast_dsp *dsp, struct ast_frame *af) |
Return AST_FRAME_NULL frames when there is silence, AST_FRAME_BUSY on busies, and call progress, all dependent upon which features are enabled. | |
static void | ast_dsp_prog_reset (struct ast_dsp *dsp) |
int | ast_dsp_reload (void) |
Reloads dsp settings from dsp.conf. | |
void | ast_dsp_reset (struct ast_dsp *dsp) |
Reset total silence count. | |
void | ast_dsp_set_busy_compare (struct ast_dsp *dsp, int compare) |
Set if silence and noice lengths must be compared for busy. | |
void | ast_dsp_set_busy_count (struct ast_dsp *dsp, int cadences) |
Set number of required cadences for busy. | |
void | ast_dsp_set_busy_pattern (struct ast_dsp *dsp, int tonelength, int quietlength, int fuzzy) |
Set expected lengths of the busy tones. | |
int | ast_dsp_set_call_progress_zone (struct ast_dsp *dsp, char *zone) |
Set zone for doing progress detection. | |
int | ast_dsp_set_digitmode (struct ast_dsp *dsp, int digitmode) |
Set digit mode. | |
int | ast_dsp_set_faxmode (struct ast_dsp *dsp, int faxmode) |
Set fax mode. | |
void | ast_dsp_set_features (struct ast_dsp *dsp, int features) |
Select feature set. | |
void | ast_dsp_set_threshold (struct ast_dsp *dsp, int threshold) |
Set threshold value for silence. | |
int | ast_dsp_silence (struct ast_dsp *dsp, struct ast_frame *f, int *totalsilence) |
Return non-zero if this is silence. Updates "totalsilence" with the total number of seconds of silence. | |
int | ast_dsp_was_muted (struct ast_dsp *dsp) |
Returns true if DSP code was muting any fragment of the last processed frame. Muting (squelching) happens when DSP code removes DTMF/MF/generic tones from the audio. | |
static void | ast_dtmf_detect_init (dtmf_detect_state_t *s) |
static void | ast_fax_detect_init (struct ast_dsp *s) |
static void | ast_mf_detect_init (mf_detect_state_t *s) |
static void | ast_tone_detect_init (tone_detect_state_t *s, int freq, int duration, int amp) |
static int | dtmf_detect (struct ast_dsp *dsp, digit_detect_state_t *s, int16_t amp[], int samples, int squelch, int relax) |
static void | goertzel_init (goertzel_state_t *s, float freq, int samples) |
static void | goertzel_reset (goertzel_state_t *s) |
static float | goertzel_result (goertzel_state_t *s) |
static void | goertzel_sample (goertzel_state_t *s, short sample) |
static void | goertzel_update (goertzel_state_t *s, short *samps, int count) |
static int | mf_detect (struct ast_dsp *dsp, digit_detect_state_t *s, int16_t amp[], int samples, int squelch, int relax) |
static void | mute_fragment (struct ast_dsp *dsp, fragment_t *fragment) |
static int | pair_there (float p1, float p2, float i1, float i2, float e) |
static void | store_digit (digit_detect_state_t *s, char digit) |
static int | tone_detect (struct ast_dsp *dsp, tone_detect_state_t *s, int16_t *amp, int samples) |
Variables | |
static struct progalias | aliases [] |
static char | bell_mf_positions [] = "1247C-358A--69*---0B----#" |
static float | dtmf_col [] |
static char | dtmf_positions [] = "123A" "456B" "789C" "*0#D" |
static float | dtmf_row [] |
static float | mf_tones [] |
static struct progress | modes [] |
static int | thresholds [THRESHOLD_MAX] |
Steve Underwood <steveu@coppice.org>
Definition in file dsp.c.
#define BELL_MF_RELATIVE_PEAK 12.6 |
#define BELL_MF_THRESHOLD 1.6e9 |
#define BELL_MF_TWIST 4.0 |
#define CONFIG_FILE_NAME "dsp.conf" |
Definition at line 214 of file dsp.c.
Referenced by _dsp_init(), conf_exec(), find_conf(), and load_config_meetme().
#define DEFAULT_THRESHOLD 512 |
This value is the minimum threshold, calculated by averaging all of the samples within a frame, for which a frame is determined to either be silence (below the threshold) or noise (above the threshold). Please note that while the default threshold is an even exponent of 2, there is no requirement that it be so. The threshold will accept any value between 0 and 32767.
Definition at line 115 of file dsp.c.
Referenced by ast_dsp_new().
#define DSP_HISTORY 15 |
Remember last 15 units
Definition at line 126 of file dsp.c.
Referenced by __ast_dsp_silence_noise(), ast_dsp_busydetect(), ast_dsp_new(), and ast_dsp_set_busy_count().
#define DTMF_GSIZE 102 |
#define DTMF_HITS_TO_BEGIN 2 |
#define DTMF_MISSES_TO_END 3 |
#define DTMF_NORMAL_TWIST 6.3 |
#define DTMF_RELATIVE_PEAK_COL 6.3 |
#define DTMF_RELATIVE_PEAK_ROW 6.3 |
#define DTMF_REVERSE_TWIST (relax ? 4.0 : 2.5) |
#define DTMF_THRESHOLD 8.0e7 |
#define DTMF_TO_TOTAL_ENERGY 42.0 |
#define FAX_TONE_CED_DB 16 |
#define FAX_TONE_CED_DURATION 2600 |
#define FAX_TONE_CED_FREQ 2100 |
#define FAX_TONE_CNG_DB 16 |
#define FAX_TONE_CNG_DURATION 500 |
#define FAX_TONE_CNG_FREQ 1100 |
#define MAX_DTMF_DIGITS 128 |
#define MF_GSIZE 120 |
#define SAMPLE_RATE 8000 |
Definition at line 193 of file dsp.c.
Referenced by ast_tone_detect_init(), goertzel_init(), and open_stream().
#define SAMPLES_IN_FRAME 160 |
#define TONE_MIN_THRESH 1e8 |
How much tone there should be at least to attempt
Definition at line 129 of file dsp.c.
Referenced by pair_there().
#define TONE_THRESH 10.0 |
How much louder the tone should be than channel energy
Definition at line 128 of file dsp.c.
Referenced by pair_there().
enum busy_detect |
Definition at line 117 of file dsp.c.
00117 { 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 };
enum freq_index |
HZ_350 | For US modes { |
HZ_440 | |
HZ_480 | |
HZ_620 | |
HZ_950 | |
HZ_1400 | |
HZ_1800 | } |
HZ_425 | For CR/BR modes |
HZ_400 | For UK mode |
Definition at line 71 of file dsp.c.
00071 { 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 };
enum gsamp_size |
Number of goertzels for progress detect
GSAMP_SIZE_NA | North America - 350, 440, 480, 620, 950, 1400, 1800 Hz |
GSAMP_SIZE_CR | Costa Rica, Brazil - Only care about 425 Hz |
GSAMP_SIZE_UK | UK disconnect goertzel feed - should trigger 400hz |
Definition at line 59 of file dsp.c.
00059 { 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 };
enum gsamp_thresh |
All THRESH_XXX values are in GSAMP_SIZE chunks (us = 22ms)
Definition at line 132 of file dsp.c.
00132 { 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 };
enum prog_mode |
Definition at line 65 of file dsp.c.
00065 { 00066 PROG_MODE_NA = 0, 00067 PROG_MODE_CR, 00068 PROG_MODE_UK 00069 };
static int __ast_dsp_call_progress | ( | struct ast_dsp * | dsp, | |
short * | s, | |||
int | len | |||
) | [static] |
Definition at line 952 of file dsp.c.
References DSP_TONE_STATE_BUSY, DSP_TONE_STATE_RINGING, DSP_TONE_STATE_SILENCE, ast_dsp::freqcount, ast_dsp::freqs, ast_dsp::genergy, goertzel_result(), goertzel_sample(), ast_dsp::gsamp_size, ast_dsp::gsamps, HZ_350, HZ_440, HZ_480, HZ_620, pair_there(), pass, PROG_MODE_NA, and ast_dsp::progmode.
Referenced by ast_dsp_call_progress().
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 }
static int __ast_dsp_silence_noise | ( | struct ast_dsp * | dsp, | |
short * | s, | |||
int | len, | |||
int * | totalsilence, | |||
int * | totalnoise | |||
) | [static] |
Definition at line 1090 of file dsp.c.
References BUSY_PERCENT, ast_dsp::busycount, ast_dsp::busymaybe, DSP_HISTORY, ast_dsp::historicnoise, ast_dsp::totalnoise, and ast_dsp::totalsilence.
Referenced by ast_dsp_noise(), ast_dsp_process(), and ast_dsp_silence().
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 }
static int _dsp_init | ( | int | reload | ) | [static] |
Definition at line 1666 of file dsp.c.
References ast_config_destroy(), ast_config_load2(), ast_log(), ast_variable_retrieve(), CONFIG_FILE_NAME, CONFIG_FLAG_FILEUNCHANGED, config_flags, CONFIG_STATUS_FILEUNCHANGED, LOG_WARNING, THRESHOLD_SILENCE, and thresholds.
Referenced by ast_dsp_init(), and ast_dsp_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 }
static void ast_digit_detect_init | ( | digit_detect_state_t * | s, | |
int | mf | |||
) | [static] |
Definition at line 510 of file dsp.c.
References ast_dtmf_detect_init(), ast_mf_detect_init(), and s.
Referenced by ast_dsp_new(), and ast_dsp_set_digitmode().
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 }
int ast_dsp_busydetect | ( | struct ast_dsp * | dsp | ) |
Return non-zero if historically this should be a busy, request that ast_dsp_silence has already been called.
Definition at line 1149 of file dsp.c.
References ast_debug, ast_log(), buf, BUSY_MAX, BUSY_MIN, ast_dsp::busy_pattern_fuzzy, BUSY_PERCENT, ast_dsp::busy_quietlength, ast_dsp::busy_tonelength, ast_dsp::busycompare, ast_dsp::busycount, ast_dsp::busymaybe, ast_dsp::busytoneonly, DSP_HISTORY, ast_dsp::historicnoise, ast_dsp::historicsilence, LOG_ERROR, LOG_NOTICE, and option_debug.
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 }
Scans for progress indication in audio.
Definition at line 1077 of file dsp.c.
References __ast_dsp_call_progress(), AST_FORMAT_SLINEAR, AST_FRAME_VOICE, ast_log(), ast_frame::data, ast_frame::datalen, ast_frame::frametype, LOG_WARNING, ast_frame::ptr, and ast_frame::subclass.
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 }
void ast_dsp_digitreset | ( | struct ast_dsp * | dsp | ) |
Reset DTMF detector.
Definition at line 1569 of file dsp.c.
References digit_detect_state_t::current_digits, ast_dsp::digit_state, ast_dsp::digitmode, digit_detect_state_t::digits, digit_detect_state_t::dtmf, ast_dsp::dtmf_began, goertzel_reset(), digit_detect_state_t::mf, s, and digit_detect_state_t::td.
Referenced by ss_thread().
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 }
void ast_dsp_free | ( | struct ast_dsp * | dsp | ) |
Definition at line 1527 of file dsp.c.
References ast_free.
Referenced by __ast_play_and_record(), __oh323_destroy(), background_detect_exec(), cl_dequeue_chan(), cleanup_connection(), conf_run(), dahdi_hangup(), do_waiting(), handle_recordfile(), isAnsweringMachine(), mgcp_hangup(), sip_dtmfmode(), sip_hangup(), sip_rtp_read(), ss_thread(), and unload_module().
01528 { 01529 ast_free(dsp); 01530 }
int ast_dsp_get_tcount | ( | struct ast_dsp * | dsp | ) |
Get tcount (Threshold counter).
Definition at line 1661 of file dsp.c.
References ast_dsp::tcount.
01662 { 01663 return dsp->tcount; 01664 }
int ast_dsp_get_threshold_from_settings | ( | enum threshold | which | ) |
Get silence threshold from dsp.conf.
Definition at line 1688 of file dsp.c.
References thresholds.
Referenced by app_exec(), ast_record_review(), conf_run(), do_waiting(), handle_recordfile(), load_config(), and setup_privacy_args().
01689 { 01690 return thresholds[which]; 01691 }
int ast_dsp_get_tstate | ( | struct ast_dsp * | dsp | ) |
Get tstate (Tone State).
Definition at line 1656 of file dsp.c.
References ast_dsp::tstate.
01657 { 01658 return dsp->tstate; 01659 }
int ast_dsp_init | ( | void | ) |
Load dsp settings from dsp.conf.
Definition at line 1693 of file dsp.c.
References _dsp_init().
Referenced by main().
01694 { 01695 return _dsp_init(0); 01696 }
struct ast_dsp* ast_dsp_new | ( | void | ) |
Definition at line 1487 of file dsp.c.
References ast_calloc, ast_digit_detect_init(), ast_dsp_prog_reset(), ast_fax_detect_init(), BUSY_PAT_PERCENT, DEFAULT_THRESHOLD, DSP_DIGITMODE_DTMF, DSP_HISTORY, and ast_dsp::threshold.
Referenced by __ast_play_and_record(), __oh323_new(), background_detect_exec(), conf_run(), dahdi_new(), do_waiting(), handle_recordfile(), isAnsweringMachine(), mgcp_new(), misdn_set_opt_exec(), read_config(), sip_dtmfmode(), sip_new(), and store_config().
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 }
Return non-zero if this is noise. Updates "totalnoise" with the total number of seconds of noise.
Definition at line 1267 of file dsp.c.
References __ast_dsp_silence_noise(), AST_FORMAT_SLINEAR, AST_FRAME_VOICE, ast_log(), f, len(), LOG_WARNING, and s.
Referenced by do_waiting().
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 }
struct ast_frame* ast_dsp_process | ( | struct ast_channel * | chan, | |
struct ast_dsp * | dsp, | |||
struct ast_frame * | af | |||
) |
Return AST_FRAME_NULL frames when there is silence, AST_FRAME_BUSY on busies, and call progress, all dependent upon which features are enabled.
Definition at line 1286 of file dsp.c.
References __ast_dsp_silence_noise(), AST_ALAW, AST_FORMAT_ALAW, AST_FORMAT_SLINEAR, AST_FORMAT_ULAW, AST_FRAME_VOICE, ast_getformatname(), ast_log(), AST_MULAW, ast_frame::data, ast_frame::datalen, ast_dsp::display_inband_dtmf_warning, DSP_FEATURE_BUSY_DETECT, DSP_FEATURE_SILENCE_SUPPRESS, ast_dsp::features, ast_frame::frametype, len(), LOG_WARNING, ast_dsp::mute_fragments, ast_frame::ptr, and ast_frame::subclass.
Referenced by dahdi_read(), mgcp_rtp_read(), oh323_rtp_read(), process_ast_dsp(), sip_rtp_read(), and usbradio_read().
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 }
static void ast_dsp_prog_reset | ( | struct ast_dsp * | dsp | ) | [static] |
Definition at line 1470 of file dsp.c.
References ARRAY_LEN, ast_dsp::freqcount, ast_dsp::freqs, goertzel_init(), ast_dsp::gsamp_size, ast_dsp::gsamps, modes, ast_dsp::progmode, ast_dsp::ringtimeout, and progress::size.
Referenced by ast_dsp_new(), and ast_dsp_set_call_progress_zone().
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 }
int ast_dsp_reload | ( | void | ) |
Reloads dsp settings from dsp.conf.
Definition at line 1698 of file dsp.c.
References _dsp_init().
01699 { 01700 return _dsp_init(1); 01701 }
void ast_dsp_reset | ( | struct ast_dsp * | dsp | ) |
Reset total silence count.
Definition at line 1600 of file dsp.c.
References ast_dsp::freqs, ast_dsp::gsamps, ast_dsp::historicnoise, ast_dsp::historicsilence, ast_dsp::ringtimeout, ast_dsp::totalsilence, goertzel_state_t::v2, and goertzel_state_t::v3.
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 }
void ast_dsp_set_busy_compare | ( | struct ast_dsp * | dsp, | |
int | compare | |||
) |
Set if silence and noice lengths must be compared for busy.
Definition at line 1549 of file dsp.c.
References ast_dsp::busycompare.
Referenced by dahdi_new().
01550 { 01551 if (compare > 0) 01552 dsp->busycompare = 1; 01553 else 01554 dsp->busycompare = 0; 01555 }
void ast_dsp_set_busy_count | ( | struct ast_dsp * | dsp, | |
int | cadences | |||
) |
Set number of required cadences for busy.
Definition at line 1540 of file dsp.c.
References ast_dsp::busycount, and DSP_HISTORY.
Referenced by dahdi_new().
01541 { 01542 if (cadences < 4) 01543 cadences = 4; 01544 if (cadences > DSP_HISTORY) 01545 cadences = DSP_HISTORY; 01546 dsp->busycount = cadences; 01547 }
void ast_dsp_set_busy_pattern | ( | struct ast_dsp * | dsp, | |
int | tonelength, | |||
int | quietlength, | |||
int | fuzzy | |||
) |
Set expected lengths of the busy tones.
Definition at line 1557 of file dsp.c.
References ast_debug, ast_dsp::busy_pattern_fuzzy, ast_dsp::busy_quietlength, ast_dsp::busy_tonelength, and ast_dsp::busytoneonly.
Referenced by dahdi_new().
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 }
int ast_dsp_set_call_progress_zone | ( | struct ast_dsp * | dsp, | |
char * | zone | |||
) |
Set zone for doing progress detection.
Definition at line 1637 of file dsp.c.
References aliases, ARRAY_LEN, ast_dsp_prog_reset(), progalias::mode, name, and ast_dsp::progmode.
Referenced by dahdi_new().
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 }
int ast_dsp_set_digitmode | ( | struct ast_dsp * | dsp, | |
int | digitmode | |||
) |
Set digit mode.
Definition at line 1613 of file dsp.c.
References ast_digit_detect_init(), ast_dsp::digit_state, ast_dsp::digitmode, DSP_DIGITMODE_DTMF, DSP_DIGITMODE_MUTECONF, and DSP_DIGITMODE_MUTEMAX.
Referenced by dahdi_hangup(), dahdi_new(), dahdi_setoption(), mgcp_new(), sip_new(), ss_thread(), and store_config().
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 }
int ast_dsp_set_faxmode | ( | struct ast_dsp * | dsp, | |
int | faxmode | |||
) |
Set fax mode.
Definition at line 1628 of file dsp.c.
References ast_fax_detect_init(), and ast_dsp::faxmode.
01629 { 01630 if (dsp->faxmode != faxmode) { 01631 ast_fax_detect_init(dsp); 01632 } 01633 dsp->faxmode = faxmode; 01634 return 0; 01635 }
void ast_dsp_set_features | ( | struct ast_dsp * | dsp, | |
int | features | |||
) |
Select feature set.
Definition at line 1522 of file dsp.c.
References ast_dsp::features.
Referenced by __oh323_new(), dahdi_new(), disable_dtmf_detect(), enable_dtmf_detect(), mgcp_new(), misdn_set_opt_exec(), read_config(), sip_dtmfmode(), sip_new(), sip_rtp_read(), and store_config().
01523 { 01524 dsp->features = features; 01525 }
void ast_dsp_set_threshold | ( | struct ast_dsp * | dsp, | |
int | threshold | |||
) |
Set threshold value for silence.
Definition at line 1532 of file dsp.c.
References ast_dsp::threshold.
Referenced by __ast_play_and_record(), dahdi_new(), do_waiting(), handle_recordfile(), and isAnsweringMachine().
01533 { 01534 if (threshold < 256) 01535 dsp->threshold = 256; 01536 else 01537 dsp->threshold = threshold; 01538 }
Return non-zero if this is silence. Updates "totalsilence" with the total number of seconds of silence.
Definition at line 1249 of file dsp.c.
References __ast_dsp_silence_noise(), AST_FORMAT_SLINEAR, AST_FRAME_VOICE, ast_log(), f, len(), LOG_WARNING, and s.
Referenced by __ast_play_and_record(), background_detect_exec(), conf_run(), do_waiting(), handle_recordfile(), and isAnsweringMachine().
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 }
int ast_dsp_was_muted | ( | struct ast_dsp * | dsp | ) |
Returns true if DSP code was muting any fragment of the last processed frame. Muting (squelching) happens when DSP code removes DTMF/MF/generic tones from the audio.
Definition at line 1651 of file dsp.c.
References ast_dsp::mute_fragments.
Referenced by dahdi_read().
01652 { 01653 return (dsp->mute_fragments > 0); 01654 }
static void ast_dtmf_detect_init | ( | dtmf_detect_state_t * | s | ) | [static] |
Definition at line 480 of file dsp.c.
References DTMF_GSIZE, DTMF_HITS_TO_BEGIN, DTMF_MISSES_TO_END, goertzel_init(), and s.
Referenced by ast_digit_detect_init().
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 }
static void ast_fax_detect_init | ( | struct ast_dsp * | s | ) | [static] |
Definition at line 474 of file dsp.c.
References ast_tone_detect_init(), FAX_TONE_CED_DB, FAX_TONE_CED_DURATION, FAX_TONE_CED_FREQ, FAX_TONE_CNG_DB, FAX_TONE_CNG_DURATION, FAX_TONE_CNG_FREQ, and s.
Referenced by ast_dsp_new(), and ast_dsp_set_faxmode().
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 }
static void ast_mf_detect_init | ( | mf_detect_state_t * | s | ) | [static] |
Definition at line 499 of file dsp.c.
References goertzel_init(), and s.
Referenced by ast_digit_detect_init().
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 }
static void ast_tone_detect_init | ( | tone_detect_state_t * | s, | |
int | freq, | |||
int | duration, | |||
int | amp | |||
) | [static] |
Definition at line 414 of file dsp.c.
References ast_debug, goertzel_init(), s, SAMPLE_RATE, and SAMPLES_IN_FRAME.
Referenced by ast_fax_detect_init().
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 }
static int dtmf_detect | ( | struct ast_dsp * | dsp, | |
digit_detect_state_t * | s, | |||
int16_t | amp[], | |||
int | samples, | |||
int | squelch, | |||
int | relax | |||
) | [static] |
Definition at line 637 of file dsp.c.
References DTMF_GSIZE, DTMF_NORMAL_TWIST, DTMF_RELATIVE_PEAK_COL, DTMF_RELATIVE_PEAK_ROW, DTMF_REVERSE_TWIST, DTMF_THRESHOLD, DTMF_TO_TOTAL_ENERGY, fragment_t::end, goertzel_result(), goertzel_sample(), and s.
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 }
static void goertzel_init | ( | goertzel_state_t * | s, | |
float | freq, | |||
int | samples | |||
) | [inline, static] |
Definition at line 339 of file dsp.c.
References cos, s, and SAMPLE_RATE.
Referenced by ast_dsp_prog_reset(), ast_dtmf_detect_init(), ast_mf_detect_init(), and ast_tone_detect_init().
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 }
static void goertzel_reset | ( | goertzel_state_t * | s | ) | [inline, static] |
Definition at line 346 of file dsp.c.
References s.
Referenced by ast_dsp_digitreset(), and tone_detect().
static float goertzel_result | ( | goertzel_state_t * | s | ) | [inline, static] |
Definition at line 330 of file dsp.c.
References goertzel_result_t::power, s, and goertzel_result_t::value.
Referenced by __ast_dsp_call_progress(), dtmf_detect(), mf_detect(), and tone_detect().
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 }
static void goertzel_sample | ( | goertzel_state_t * | s, | |
short | sample | |||
) | [inline, static] |
Definition at line 304 of file dsp.c.
References s.
Referenced by __ast_dsp_call_progress(), dtmf_detect(), goertzel_update(), mf_detect(), and tone_detect().
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 }
static void goertzel_update | ( | goertzel_state_t * | s, | |
short * | samps, | |||
int | count | |||
) | [inline, static] |
Definition at line 321 of file dsp.c.
References goertzel_sample(), and s.
00322 { 00323 int i; 00324 00325 for (i=0;i<count;i++) 00326 goertzel_sample(s, samps[i]); 00327 }
static int mf_detect | ( | struct ast_dsp * | dsp, | |
digit_detect_state_t * | s, | |||
int16_t | amp[], | |||
int | samples, | |||
int | squelch, | |||
int | relax | |||
) | [static] |
Definition at line 783 of file dsp.c.
References bell_mf_positions, BELL_MF_RELATIVE_PEAK, BELL_MF_THRESHOLD, BELL_MF_TWIST, fragment_t::end, goertzel_result(), goertzel_sample(), MF_GSIZE, s, and store_digit().
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 }
static void mute_fragment | ( | struct ast_dsp * | dsp, | |
fragment_t * | fragment | |||
) | [static] |
Definition at line 404 of file dsp.c.
References ARRAY_LEN, ast_log(), LOG_ERROR, ast_dsp::mute_data, and ast_dsp::mute_fragments.
Referenced by tone_detect().
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 }
static int pair_there | ( | float | p1, | |
float | p2, | |||
float | i1, | |||
float | i2, | |||
float | e | |||
) | [inline, static] |
Definition at line 932 of file dsp.c.
References TONE_MIN_THRESH, and TONE_THRESH.
Referenced by __ast_dsp_call_progress().
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 }
static void store_digit | ( | digit_detect_state_t * | s, | |
char | digit | |||
) | [static] |
Definition at line 625 of file dsp.c.
References ast_log(), LOG_WARNING, MAX_DTMF_DIGITS, and s.
Referenced by mf_detect().
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 }
static int tone_detect | ( | struct ast_dsp * | dsp, | |
tone_detect_state_t * | s, | |||
int16_t * | amp, | |||
int | samples | |||
) | [static] |
Definition at line 523 of file dsp.c.
References ast_debug, fragment_t::end, goertzel_reset(), goertzel_result(), goertzel_sample(), mute_fragment(), ast_frame::ptr, s, and fragment_t::start.
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 }
Referenced by ast_dsp_set_call_progress_zone(), and find_alias().
char bell_mf_positions[] = "1247C-358A--69*---0B----#" [static] |
float dtmf_col[] [static] |
char dtmf_positions[] = "123A" "456B" "789C" "*0#D" [static] |
float dtmf_row[] [static] |
float mf_tones[] [static] |
Referenced by ast_dsp_prog_reset(), and setrem().
int thresholds[THRESHOLD_MAX] [static] |
Definition at line 302 of file dsp.c.
Referenced by _dsp_init(), and ast_dsp_get_threshold_from_settings().