update

git-svn-id: http://svn.openzap.org/svn/openzap/trunk@192 a93c3328-9c30-0410-af19-c9cd2b2d52af

diff --git a/libs/freetdm/src/include/openzap.h b/libs/freetdm/src/include/openzap.h
index 55a5e8d14e2b53b1c6cb2a7ce341478ed9a9b08f..1fdb372087627ca295e1a239e0cfcd21b0501508 100644 (file)
--- a/libs/freetdm/src/include/openzap.h
+++ b/libs/freetdm/src/include/openzap.h
@@ -261,12 +261,13 @@ struct zap_channel {
        teletone_generation_session_t tone_session;
        zap_time_t last_event_time;
        char tokens[ZAP_MAX_TOKENS+1][ZAP_TOKEN_STRLEN];
-       uint8_t need_tone[ZAP_TONEMAP_INVALID+1];
+       uint8_t needed_tones[ZAP_TONEMAP_INVALID];
+       uint8_t detected_tones[ZAP_TONEMAP_INVALID];
+       zap_tonemap_t last_detected_tone;
+       
        uint32_t token_count;
        char chan_name[128];
        char chan_number[32];
-       zap_tonemap_t detected_tone;
-       zap_tonemap_t last_detected_tone;
        struct zap_caller_data caller_data;
        struct zap_span *span;
        struct zap_io_interface *zio;
@@ -341,6 +342,8 @@ struct zap_io_interface {
 
 zap_status_t zap_channel_outgoing_call(zap_channel_t *zchan);
 void zap_channel_rotate_tokens(zap_channel_t *zchan);
+void zap_channel_clear_detected_tones(zap_channel_t *zchan);
+void zap_channel_clear_needed_tones(zap_channel_t *zchan);
 zap_status_t zap_channel_clear_token(zap_channel_t *zchan, int32_t token_id);
 zap_status_t zap_channel_add_token(zap_channel_t *zchan, char *token);
 zap_status_t zap_channel_set_state(zap_channel_t *zchan, zap_channel_state_t state);

diff --git a/libs/freetdm/src/include/zap_types.h b/libs/freetdm/src/include/zap_types.h
index 2a828965e17bb4d3fda5f5451b809e01a6860408..3bd99d3b0d9182c7ed584dad982bce1b3a1dec96 100644 (file)
--- a/libs/freetdm/src/include/zap_types.h
+++ b/libs/freetdm/src/include/zap_types.h
@@ -61,10 +61,13 @@ typedef enum {
        ZAP_TONEMAP_DIAL,
        ZAP_TONEMAP_RING,
        ZAP_TONEMAP_BUSY,
+       ZAP_TONEMAP_FAIL1,
+       ZAP_TONEMAP_FAIL2,
+       ZAP_TONEMAP_FAIL3,
        ZAP_TONEMAP_ATTN,
        ZAP_TONEMAP_INVALID
 } zap_tonemap_t;
-#define TONEMAP_STRINGS "NONE", "DIAL", "RING", "BUSY", "ATTN", "INVALID"
+#define TONEMAP_STRINGS "NONE", "DIAL", "RING", "BUSY", "FAIL1", "FAIL2", "FAIL3", "ATTN", "INVALID"
 ZAP_STR2ENUM_P(zap_str2zap_tonemap, zap_tonemap2str, zap_tonemap_t)
 
 typedef enum {

diff --git a/libs/freetdm/src/zap_analog.c b/libs/freetdm/src/zap_analog.c
index a6feaabc07b1043fa6c17b1e443adc6365166b55..ada2ca804e314944c159f731cdb76493b5c52411 100644 (file)
--- a/libs/freetdm/src/zap_analog.c
+++ b/libs/freetdm/src/zap_analog.c
@@ -41,7 +41,7 @@ static ZIO_CHANNEL_OUTGOING_CALL_FUNCTION(analog_fxo_outgoing_call)
        if (!zap_test_flag(zchan, ZAP_CHANNEL_OFFHOOK) && !zap_test_flag(zchan, ZAP_CHANNEL_INTHREAD)) {                
                zap_channel_command(zchan, ZAP_COMMAND_OFFHOOK, NULL);
                zap_channel_command(zchan, ZAP_COMMAND_ENABLE_PROGRESS_DETECT, NULL);
-               zchan->need_tone[ZAP_TONEMAP_DIAL] = 1;
+               zchan->needed_tones[ZAP_TONEMAP_DIAL] = 1;
                zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_DIALING);
                zap_thread_create_detached(zap_analog_channel_run, zchan);
                return ZAP_SUCCESS;
@@ -118,10 +118,9 @@ static void *zap_analog_channel_run(zap_thread_t *me, void *obj)
        zap_size_t dtmf_offset = 0;
        zap_analog_data_t *data = chan->span->analog_data;
        zap_channel_t *closed_chan;
-       uint32_t state_counter = 0, elapsed = 0, interval = 0, last_digit = 0, indicate = 0;
+       uint32_t state_counter = 0, elapsed = 0, interval = 0, last_digit = 0, indicate = 0, dial_timeout = 30000;
        zap_sigmsg_t sig;
        zap_status_t status;
-
        
        zap_log(ZAP_LOG_DEBUG, "ANALOG CHANNEL thread starting.\n");
 
@@ -167,8 +166,8 @@ static void *zap_analog_channel_run(zap_thread_t *me, void *obj)
                        switch(chan->state) {
                        case ZAP_CHANNEL_STATE_DIALING:
                                {
-                                       if (state_counter > 5000) {
-                                               if (chan->need_tone[ZAP_TONEMAP_DIAL]) {
+                                       if (state_counter > dial_timeout) {
+                                               if (chan->needed_tones[ZAP_TONEMAP_DIAL]) {
                                                        zap_set_state_locked(chan, ZAP_CHANNEL_STATE_BUSY);
                                                } else {
                                                        zap_set_state_locked(chan, ZAP_CHANNEL_STATE_UP);
@@ -235,6 +234,7 @@ static void *zap_analog_channel_run(zap_thread_t *me, void *obj)
                        case ZAP_CHANNEL_STATE_UP:
                                {
                                        zap_channel_use(chan);
+                                       zap_channel_clear_needed_tones(chan);
 
                                        if (chan->type == ZAP_CHAN_TYPE_FXO && !zap_test_flag(chan, ZAP_CHANNEL_OFFHOOK)) {
                                                zap_channel_command(chan, ZAP_COMMAND_OFFHOOK, NULL);
@@ -352,45 +352,39 @@ static void *zap_analog_channel_run(zap_thread_t *me, void *obj)
                        goto done;
                }
 
-               if (chan->detected_tone) {
+               if (chan->type == ZAP_CHAN_TYPE_FXO && chan->detected_tones[0]) {
                        zap_sigmsg_t sig;
+                       int i;
                        memset(&sig, 0, sizeof(sig));
                        sig.chan_id = chan->chan_id;
                        sig.span_id = chan->span_id;
                        sig.channel = chan;
                        sig.event_id = ZAP_SIGEVENT_TONE_DETECTED;
-                       zap_log(ZAP_LOG_DEBUG, "Detected tone %s\n", zap_tonemap2str(chan->detected_tone));
-                       data->sig_cb(&sig);
                        
-                       if (chan->type == ZAP_CHAN_TYPE_FXO) {
-
-                               if (chan->need_tone[chan->detected_tone]) {
-                                       switch (chan->detected_tone) {
-                                       case ZAP_TONEMAP_DIAL:
-                                               {
-                                                       zap_channel_command(chan, ZAP_COMMAND_SEND_DTMF, chan->caller_data.ani);
-                                                       state_counter = 0;
-                                                       chan->need_tone[ZAP_TONEMAP_RING] = 1;
-                                                       chan->need_tone[ZAP_TONEMAP_BUSY] = 1;
-                                               }
-                                               break;
-                                       case ZAP_TONEMAP_RING:
-                                               {
-                                                       zap_set_state_locked(chan, ZAP_CHANNEL_STATE_UP);
-                                               }
-                                               break;
-                                       case ZAP_TONEMAP_BUSY:
-                                               {
-                                                       zap_set_state_locked(chan, ZAP_CHANNEL_STATE_BUSY);
-                                               }
-                                               break;
-                                       default:
-                                               break;
-                                       }
-                                       chan->need_tone[chan->detected_tone] = 0;
+                       for (i = 1; i < ZAP_TONEMAP_INVALID; i++) {
+                               if (chan->detected_tones[i]) {
+                                       zap_log(ZAP_LOG_DEBUG, "Detected tone %s\n", zap_tonemap2str(chan->detected_tones[i]));
+                                       sig.raw_data = &i;
+                                       data->sig_cb(&sig);
                                }
                        }
-                       chan->detected_tone = 0;
+                       
+                       if (chan->detected_tones[ZAP_TONEMAP_DIAL]) {
+                               zap_channel_command(chan, ZAP_COMMAND_SEND_DTMF, chan->caller_data.ani);
+                               state_counter = 0;
+                               chan->needed_tones[ZAP_TONEMAP_RING] = 1;
+                               chan->needed_tones[ZAP_TONEMAP_BUSY] = 1;
+                               chan->needed_tones[ZAP_TONEMAP_FAIL1] = 1;
+                               chan->needed_tones[ZAP_TONEMAP_FAIL2] = 1;
+                               chan->needed_tones[ZAP_TONEMAP_FAIL3] = 1;
+                               dial_timeout = (chan->dtmf_on + chan->dtmf_off) * strlen(chan->caller_data.ani) + 50;
+                       } else if (chan->detected_tones[ZAP_TONEMAP_RING]) {
+                               zap_set_state_locked(chan, ZAP_CHANNEL_STATE_UP);
+                       } else if (chan->detected_tones[ZAP_TONEMAP_BUSY]) {
+                               zap_set_state_locked(chan, ZAP_CHANNEL_STATE_BUSY);
+                       }
+                       
+                       zap_channel_clear_detected_tones(chan);
                }
 
                if (chan->dtmf_buffer && zap_buffer_inuse(chan->dtmf_buffer)) {

diff --git a/libs/freetdm/src/zap_io.c b/libs/freetdm/src/zap_io.c
index 6df7ee8bc47e071259a4f621384ca3a3aa5ff469..7816c8d662730def0ee519069dd2079b0ebf3f6a 100644 (file)
--- a/libs/freetdm/src/zap_io.c
+++ b/libs/freetdm/src/zap_io.c
@@ -269,19 +269,27 @@ zap_status_t zap_span_load_tones(zap_span_t *span, char *mapname)
        }
        
        while (zap_config_next_pair(&cfg, &var, &val)) {
+               int detect = 0;
+
                if (!strcasecmp(cfg.category, mapname) && var && val) {
-                       int index = zap_str2zap_tonemap(var);
-                       char valbuf[512];
+                       uint32_t index;
+                       char *mapname;
+
+                       if (!strncasecmp(var, "detect-", 7)) {
+                               mapname = var + 7;
+                               detect = 1;
+                       } else if (!strncasecmp(var, "generate-", 9)) {
+                               mapname = var + 9;
+                       }
+
+                       index = zap_str2zap_tonemap(mapname);
 
-                       if (index > ZAP_TONEMAP_INVALID || index == ZAP_TONEMAP_NONE) {
-                               zap_log(ZAP_LOG_WARNING, "Unknown tone name %s\n", var);
+                       if (index >= ZAP_TONEMAP_INVALID || index == ZAP_TONEMAP_NONE) {
+                               zap_log(ZAP_LOG_WARNING, "Unknown tone name %s\n", mapname);
                        } else {
-                               char *p, *next;
-                               int i = 0;
-                               zap_set_string(valbuf, val);
-                               val = valbuf;
-                               if ((p = strchr(val, ':'))) {
-                                       *p++ = '\0';
+                               if (detect) {
+                                       char *p = val, *next;
+                                       int i = 0;
                                        do {
                                                teletone_process_t this;
                                                next = strchr(p, ',');
@@ -291,12 +299,11 @@ zap_status_t zap_span_load_tones(zap_span_t *span, char *mapname)
                                                        p = next + 1;
                                                }
                                        } while (next);
-
+                                       zap_log(ZAP_LOG_DEBUG, "added tone detect [%s] = [%s]\n", mapname, val);
+                               }  else {
+                                       zap_log(ZAP_LOG_DEBUG, "added tone generation [%s] = [%s]\n", mapname, val);
                                        zap_copy_string(span->tone_map[index], val, sizeof(span->tone_map[index]));
-                                       
                                }
-                               zap_log(ZAP_LOG_DEBUG, "added tone [%s] = [%s]\n", var, val);
-                               zap_copy_string(span->tone_map[index], val, sizeof(span->tone_map[index]));
                                x++;
                        }
                }
@@ -848,6 +855,8 @@ zap_status_t zap_channel_command(zap_channel_t *zchan, zap_command_t command, vo
        case ZAP_COMMAND_DISABLE_PROGRESS_DETECT:
                {
                        zap_clear_flag_locked(zchan, ZAP_CHANNEL_PROGRESS_DETECT);
+                       zap_channel_clear_detected_tones(zchan);
+                       zap_channel_clear_needed_tones(zchan);
                        GOTO_STATUS(done, ZAP_SUCCESS);
                }
                break;
@@ -1121,6 +1130,16 @@ ZIO_CODEC_FUNCTION(zio_alaw2ulaw)
 
 /******************************/
 
+void zap_channel_clear_detected_tones(zap_channel_t *zchan)
+{
+       memset(zchan->detected_tones, 0, sizeof(zchan->detected_tones[0]) * ZAP_TONEMAP_INVALID);
+}
+
+void zap_channel_clear_needed_tones(zap_channel_t *zchan)
+{
+       memset(zchan->needed_tones, 0, sizeof(zchan->needed_tones[0]) * ZAP_TONEMAP_INVALID);
+}
+
 zap_size_t zap_channel_dequeue_dtmf(zap_channel_t *zchan, char *dtmf, zap_size_t len)
 {
        zap_size_t bytes = 0;
@@ -1251,11 +1270,12 @@ zap_status_t zap_channel_read(zap_channel_t *zchan, void *data, zap_size_t *data
                if (zap_test_flag(zchan, ZAP_CHANNEL_PROGRESS_DETECT)) {
                        uint32_t i;
                        
-                       for (i = 0; i < ZAP_TONEMAP_INVALID+1; i++) {
+                       for (i = 1; i < ZAP_TONEMAP_INVALID; i++) {
                                if (zchan->span->tone_finder[i].tone_count) {
-                                       if (teletone_multi_tone_detect(&zchan->span->tone_finder[i], sln, (int)slen) && i != zchan->last_detected_tone) {
-                                               zchan->detected_tone = i;
-                                               zchan->last_detected_tone = i;
+                                       if (zchan->needed_tones[i] && teletone_multi_tone_detect(&zchan->span->tone_finder[i], sln, (int)slen)) {
+                                               zchan->detected_tones[i] = 1;
+                                               zchan->needed_tones[i] = 0;
+                                               zchan->detected_tones[0]++;
                                        }
                                }
                        }