コード例 #1
0
static switch_bool_t inband_dtmf_callback(switch_media_bug_t *bug, void *user_data, switch_abc_type_t type)
{
	switch_inband_dtmf_t *pvt = (switch_inband_dtmf_t *) user_data;
	switch_frame_t *frame = NULL;

	switch (type) {
	case SWITCH_ABC_TYPE_INIT: {
		pvt->dtmf_detect = dtmf_rx_init(NULL, NULL, NULL);
		dtmf_rx_parms(pvt->dtmf_detect, pvt->filter_dialtone, pvt->twist, pvt->reverse_twist, pvt->threshold);
		dtmf_rx_set_realtime_callback(pvt->dtmf_detect, spandsp_dtmf_rx_realtime_callback, pvt);
		break;
	}
	case SWITCH_ABC_TYPE_CLOSE:
		if (pvt->dtmf_detect) {
			dtmf_rx_free(pvt->dtmf_detect);
		}
		break;
	case SWITCH_ABC_TYPE_READ_REPLACE:
		if ((frame = switch_core_media_bug_get_read_replace_frame(bug))) {
			dtmf_rx(pvt->dtmf_detect, frame->data, frame->samples);
			switch_core_media_bug_set_read_replace_frame(bug, frame);
		}
		break;
	case SWITCH_ABC_TYPE_WRITE:
	default:
		break;
	}

	return SWITCH_TRUE;
}
コード例 #2
0
ファイル: testadsi.c プロジェクト: avesus/guruchat
void channel_read_adsi_channel(uc_t *uc, int chan, void *user_data, uint8_t *buf, int len)
{
    int i;
    int xlen;
    int16_t pcm_buf[1024];
    char *s;
    int outframes;
    
    for (i = 0;  i < len;  i++)
        pcm_buf[i] = alaw_to_linear(buf[i]);
    /*endfor*/
    outframes = afWriteFrames(rxhandle,
                              AF_DEFAULT_TRACK,
                              pcm_buf,
                              len);
    if (outframes != len)
    {
        printf("Failed to write %d samples\n", len);
        exit(2);
    }
    
    dtmf_rx(&chan_stuff[chan].dtmf_state, pcm_buf, len);
    xlen = dtmf_rx_get(&chan_stuff[chan].dtmf_state,
                       chan_stuff[chan].dtmf + chan_stuff[chan].dtmf_ptr,
                       100 - chan_stuff[chan].dtmf_ptr);
    if (xlen > 0)
    {
        s = chan_stuff[chan].dtmf + chan_stuff[chan].dtmf_ptr;
        while (*s)
        {
            if (*s == '#')
            {
                uc_set_channel_read_callback(uc, 0, NULL, 0);
                uc_set_channel_write_callback(uc, 0, NULL, 0);
                if (uc_call_control(uc, UC_OP_DROPCALL, chan_stuff[chan].crn, (void *) UC_CAUSE_NORMAL_CLEARING))
                    printf ("A Drop Call failed\n");
                /*endif*/
                break;
            }
            /*endif*/
            s++;
        }
        /*endwhile*/
        printf("Got '%s'\n", chan_stuff[chan].dtmf);
        chan_stuff[chan].dtmf_ptr += xlen;
    }
    /*endif*/
    adsi_rx(&(chan_stuff[chan].adsi_rx), pcm_buf, len);
}
コード例 #3
0
ファイル: testfax.c プロジェクト: Jaroslav23/sipxtapi
void channel_read_fax_channel(uc_t *uc, int chan, void *user_data, uint8_t *buf, int len)
{
    int i;
    int xlen;
    char *s;
    int outframes;

#if 0
    outframes = afWriteFrames(rxhandle,
                              AF_DEFAULT_TRACK,
                              buf,
                              len >> 1);
    if (outframes != len)
    {
        printf("Failed to write %d samples\n", len);
        exit(2);
    }
#endif
    dtmf_rx(&chan_stuff[chan].dtmf_state, (int16_t *) buf, len);
    xlen = dtmf_rx_get(&chan_stuff[chan].dtmf_state,
                       chan_stuff[chan].dtmf + chan_stuff[chan].dtmf_ptr,
                       100 - chan_stuff[chan].dtmf_ptr);
    if (xlen > 0)
    {
        s = chan_stuff[chan].dtmf + chan_stuff[chan].dtmf_ptr;
        while (*s)
        {
            if (*s == '#')
            {
                uc_set_channel_read_callback(uc, 0, NULL, 0);
                uc_set_channel_write_callback(uc, 0, NULL, 0);
                if (uc_call_control(uc, UC_OP_DROPCALL, chan_stuff[chan].crn, (void *) UC_CAUSE_NORMAL_CLEARING))
                    printf ("A Drop Call failed\n");
                /*endif*/
                break;
            }
            /*endif*/
            s++;
        }
        /*endwhile*/
        printf("Got '%s'\n", chan_stuff[chan].dtmf);
        chan_stuff[chan].dtmf_ptr += xlen;
    }
    /*endif*/
    t30_rx(&(chan_stuff[chan].fax), (int16_t *) buf, len);
}
コード例 #4
0
ファイル: TestDtmf.cpp プロジェクト: ixc-software/lucksi
void SpanDtmfProbe()
{
    std::string dtmfCode = "*1234567890#ABCD";
    iDSP::DtmfGeneratorProfile prof;
    prof.Level = 0;
    prof.DurationMs = 80; // 70 мало
    prof.PauseMs = 40; // 50 20-мало
    iDSP::DtmfGenerator gen;
    gen.Add(dtmfCode);

    // Init:
    digits_rx_callback_t callback = 0;//EvDigitDetected;
    void* pUserData = 0;
    dtmf_rx_state_t state;
    dtmf_rx_state_t* pState = &state;
    dtmf_rx_init(pState, callback, pUserData);

    // Adjust detector:
    bool rej350_440 = false;
    int fwTwist = 8;    //8 Db максимальная разница уровней частот в комбинации
    int revTwist = 8;  //-4 Db ?
    int threshold = -26; //Db минимальный уровень сигнала
    dtmf_rx_parms(pState, rej350_440, fwTwist, revTwist, threshold);


    while (gen.RestSampleCount() != 0)
    {
        int16_t sample = gen.NextSample();
        dtmf_rx(pState, &sample, 1);
    }


    const int CMaxSymbols = 100;
    char dtmfCodeRx[CMaxSymbols];
    int size = dtmf_rx_get(pState, dtmfCodeRx, CMaxSymbols);
    TUT_ASSERT(size == dtmfCode.size());
    dtmfCodeRx[size] = '\0';
    TUT_ASSERT(dtmfCode == dtmfCodeRx);


    // delete pState;
    //dtmf_rx_free(pState);
    //pState = 0;
}
コード例 #5
0
ファイル: ademco_contactid.c プロジェクト: odmanV2/freecenter
SPAN_DECLARE(int) ademco_contactid_receiver_rx(ademco_contactid_receiver_state_t *s, const int16_t amp[], int samples)
{
    return dtmf_rx(&s->dtmf, amp, samples);
}
コード例 #6
0
ファイル: mfdetectors.c プロジェクト: Distrotech/openr2
int main(int argc, char *argv[])
{
	int rc = 0;
	short readbuf[160];
	char digitsbuf[255];
	int fd = open(argv[1], O_RDONLY);

#if defined(BELL_DETECTOR)
	bell_mf_rx_state_t *rxstate = NULL;
	if (!(rxstate = bell_mf_rx_init(rxstate, NULL, NULL))) {
		fprintf(stderr, "bell_mf_rx_init\n");
		return -1;
	}
#elif defined(MF_DETECTOR_FWD)
	r2_mf_rx_state_t *rxstate = NULL;
	if (!(rxstate = r2_mf_rx_init(rxstate, 1, NULL, NULL))) {
		fprintf(stderr, "r2_mf_rx_init fwd\n");
		return -1;
	}
#elif defined(MF_DETECTOR_BWD)
	r2_mf_rx_state_t *rxstate = NULL;
	if (!(rxstate = r2_mf_rx_init(rxstate, 0, NULL, NULL))) {
		fprintf(stderr, "r2_mf_rx_init backward\n");
		return -1;
	}
#elif defined(DTMF_DETECTOR)
	dtmf_rx_state_t *rxstate = NULL;
	if (!(rxstate = dtmf_rx_init(rxstate, NULL, NULL))) {
		fprintf(stderr, "dtmf_rx_init\n");
		return -1;
	}
#else
#error "define detector type!"
#endif

	if (fd == -1) {
		perror("fopen");
		return -1;
	}

	while (1) {
		rc = read(fd, readbuf, sizeof(readbuf)/sizeof(readbuf[0]));
		if (rc < 0) {
			perror("read");
			break;
		}
		if (!rc) {
			break;
		}
#if defined(BELL_DETECTOR)
		rc = bell_mf_rx(rxstate, readbuf, rc/2);
		if (rc != 0) {
			fprintf(stderr, "Unprocessed samples: %d\n", rc);
			break;
		}
		digitsbuf[0] = '\0';
		rc = bell_mf_rx_get(rxstate, digitsbuf, sizeof(digitsbuf)-1);
		if (rc > 0) {
			printf("Rx digits: %s\n", digitsbuf);
		}
#elif defined(MF_DETECTOR_FWD) || defined(MF_DETECTOR_BWD)
		rc = r2_mf_rx(rxstate, readbuf, rc/2);
		if (rc != 0) {
			fprintf(stderr, "Unprocessed samples: %d\n", rc);
			break;
		}
		rc = r2_mf_rx_get(rxstate);
		if (rc > 0) {
			printf("Rx digit: %c\n", rc);
		}
#elif defined(DTMF_DETECTOR)
		rc = dtmf_rx(rxstate, readbuf, rc/2);
		if (rc != 0) {
			fprintf(stderr, "Unprocessed samples: %d\n", rc);
			break;
		}
		digitsbuf[0] = '\0';
		rc = dtmf_rx_get(rxstate, digitsbuf, sizeof(digitsbuf)-1);
		if (rc > 0) {
			printf("Rx digit: %s\n", digitsbuf);
		}
#else
#error "define detector type!"
#endif
	}

#if defined(BELL_DETECTOR)
	bell_mf_rx_free(rxstate);
#elif defined(MF_DETECTOR_FWD) || defined(MF_DETECTOR_BWD)
	r2_mf_rx_free(rxstate);
#elif defined(DTMF_DETECTOR)
	dtmf_rx_free(rxstate);
#endif

	close(fd);
	return 0;
}
コード例 #7
0
ファイル: dtmf_detect.c プロジェクト: moises-silva/openr2
int main(int argc, char *argv[])
{
	struct stat statbuf;
	FILE *audiofp;
	short slinear_buffer[CHUNK_SAMPLES];
	char alaw_buffer[CHUNK_SAMPLES];
	char *chunk_buffer;
	size_t chunksize = 0;
	int format = FORMAT_INVALID;
	int i = 0;
	char digit = 0;
	char currdigit = 0;
	dtmf_rx_state_t *rxstate = NULL;

	printf("Running DTMF Detection Test - alaw or slinear 8000hz only\n");

	if (argc < 3) {
		fprintf(stderr, USAGE, argv[0]);
		exit(1);
	}

	if (!strncasecmp(argv[1], "alaw", sizeof("alaw")-1)) {
		format = FORMAT_ALAW;
		chunksize = sizeof(alaw_buffer);
		chunk_buffer = alaw_buffer;
	} else if (!strncasecmp(argv[1], "slinear", sizeof("slinear")-1)) {
		format = FORMAT_SLINEAR;
		chunksize = sizeof(slinear_buffer);
		chunk_buffer = (char *)slinear_buffer;
	} else {
		fprintf(stderr, USAGE, argv[0]);
		exit(1);
	}

	printf("Using file %s\n", argv[2]);
	if (stat(argv[2], &statbuf)) {
		perror("could not stat audio file");
		exit(1);
	}

	audiofp = fopen(argv[2], "r");
	if (!audiofp) {
		perror("could not open audio file");
		exit(1);
	}

	rxstate = dtmf_rx_init(rxstate, on_dtmf_detected, NULL);
	printf("reading chunks of %d bytes\n", chunksize);
	while (fread(chunk_buffer, chunksize, 1, audiofp) == 1) {
		if (format == FORMAT_ALAW) {
			/* chunksize == bytes == samples */
			for (i = 0; i < chunksize; i++) {
				slinear_buffer[i] = alaw_to_linear(chunk_buffer[i]);
			}
		} 
		dtmf_rx(rxstate, slinear_buffer, CHUNK_SAMPLES);
		digit = dtmf_rx_status(rxstate);
		if (digit) {
			currdigit = digit;
			printf("%c ON\n", currdigit);
		} else if (currdigit) {
			printf("%c OFF\n", currdigit);
			currdigit = 0;
		}
	}
	dtmf_rx_free(rxstate);
	fclose(audiofp);
	return 0;
}
コード例 #8
0
static GstFlowReturn
gst_dtmf_detect_transform_ip (GstBaseTransform * trans, GstBuffer * buf)
{
  GstDtmfDetect *self = GST_DTMF_DETECT (trans);
  gint dtmf_count;
  gchar dtmfbuf[MAX_DTMF_DIGITS] = "";
  gint i;
  GstMapInfo map;

  if (GST_BUFFER_IS_DISCONT (buf))
    gst_dtmf_detect_state_reset (self);
  if (GST_BUFFER_FLAG_IS_SET (buf, GST_BUFFER_FLAG_GAP))
    return GST_FLOW_OK;

  gst_buffer_map (buf, &map, GST_MAP_READ);

  dtmf_rx (self->dtmf_state, (gint16 *) map.data, map.size / 2);

  dtmf_count = dtmf_rx_get (self->dtmf_state, dtmfbuf, MAX_DTMF_DIGITS);

  if (dtmf_count)
    GST_DEBUG_OBJECT (self, "Got %d DTMF events: %s", dtmf_count, dtmfbuf);
  else
    GST_LOG_OBJECT (self, "Got no DTMF events");

  gst_buffer_unmap (buf, &map);

  for (i = 0; i < dtmf_count; i++) {
    GstMessage *dtmf_message = NULL;
    GstStructure *structure;
    gint dtmf_payload_event;

    GST_DEBUG_OBJECT (self, "Got DTMF event %c", dtmfbuf[i]);

    switch (dtmfbuf[i]) {
      case '0':
        dtmf_payload_event = 0;
        break;
      case '1':
        dtmf_payload_event = 1;
        break;
      case '2':
        dtmf_payload_event = 2;
        break;
      case '3':
        dtmf_payload_event = 3;
        break;
      case '4':
        dtmf_payload_event = 4;
        break;
      case '5':
        dtmf_payload_event = 5;
        break;
      case '6':
        dtmf_payload_event = 6;
        break;
      case '7':
        dtmf_payload_event = 7;
        break;
      case '8':
        dtmf_payload_event = 8;
        break;
      case '9':
        dtmf_payload_event = 9;
        break;
      case '*':
        dtmf_payload_event = 10;
        break;
      case '#':
        dtmf_payload_event = 11;
        break;
      case 'A':
        dtmf_payload_event = 12;
        break;
      case 'B':
        dtmf_payload_event = 13;
        break;
      case 'C':
        dtmf_payload_event = 14;
        break;
      case 'D':
        dtmf_payload_event = 15;
        break;
      default:
        continue;
    }

    structure = gst_structure_new ("dtmf-event",
        "type", G_TYPE_INT, 1,
        "number", G_TYPE_INT, dtmf_payload_event,
        "method", G_TYPE_INT, 2, NULL);
    dtmf_message = gst_message_new_element (GST_OBJECT (self), structure);
    gst_element_post_message (GST_ELEMENT (self), dtmf_message);
  }

  return GST_FLOW_OK;
}