You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

529 lines
14 KiB

/*
* BSD Telephony Of Mexico "Tormenta" Tone Zone Support 2/22/01
*
* Working with the "Tormenta ISA" Card
*
* Primary Author: Mark Spencer <markster@digium.com>
*
*/
/*
* See http://www.asterisk.org for more information about
* the Asterisk project. Please do not directly contact
* any of the maintainers of this project for assistance;
* the project provides a web site, mailing lists and IRC
* channels for your use.
*
* This program is free software, distributed under the terms of
* the GNU Lesser General Public License Version 2.1 as published
* by the Free Software Foundation. See the LICENSE.LGPL file
* included with this program for more details.
*
* In addition, when this program is distributed with Asterisk in
* any form that would qualify as a 'combined work' or as a
* 'derivative work' (but not mere aggregation), you can redistribute
* and/or modify the combination under the terms of the license
* provided with that copy of Asterisk, instead of the license
* terms granted here.
*/
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include "dahdi/user.h"
#include "tonezone.h"
#include "dahdi_tools_version.h"
#define DEFAULT_DAHDI_DEV "/dev/dahdi/ctl"
#define MAX_SIZE 16384
#define CLIP 32635
#define BIAS 0x84
#if 0
# define PRINT_DEBUG(x, ...) printf(x, __VA_ARGS__)
#else
# define PRINT_DEBUG(x, ...)
#endif
#ifndef ENODATA
#define ENODATA EINVAL
#endif
struct tone_zone *tone_zone_find(char *country)
{
struct tone_zone *z;
z = builtin_zones;
while(z->zone > -1) {
if (!strcasecmp(country, z->country))
return z;
z++;
}
return NULL;
}
struct tone_zone *tone_zone_find_by_num(int id)
{
struct tone_zone *z;
z = builtin_zones;
while(z->zone > -1) {
if (z->zone == id)
return z;
z++;
}
return NULL;
}
#define LEVEL -10
static int build_tone(void *data, size_t size, struct tone_zone_sound *t, int *count)
{
char *dup, *s;
struct dahdi_tone_def *td=NULL;
int firstnobang = -1;
int freq1, freq2, time;
int modulate = 0;
float db = 1.0;
float gain;
int used = 0;
dup = strdup(t->data);
s = strtok(dup, ",");
while(s && strlen(s)) {
/* Handle optional ! which signifies don't start here*/
if (s[0] == '!') {
s++;
} else if (firstnobang < 0) {
PRINT_DEBUG("First no bang: %s\n", s);
firstnobang = *count;
}
if (sscanf(s, "%d+%d/%d", &freq1, &freq2, &time) == 3) {
/* f1+f2/time format */
PRINT_DEBUG("f1+f2/time format: %d, %d, %d\n", freq1, freq2, time);
} else if (sscanf(s, "%d*%d/%d", &freq1, &freq2, &time) == 3) {
/* f1*f2/time format */
PRINT_DEBUG("f1+f2/time format: %d, %d, %d\n", freq1, freq2, time);
modulate = 1;
} else if (sscanf(s, "%d+%d", &freq1, &freq2) == 2) {
PRINT_DEBUG("f1+f2 format: %d, %d\n", freq1, freq2);
time = 0;
} else if (sscanf(s, "%d*%d", &freq1, &freq2) == 2) {
PRINT_DEBUG("f1+f2 format: %d, %d\n", freq1, freq2);
modulate = 1;
time = 0;
} else if (sscanf(s, "%d/%d", &freq1, &time) == 2) {
PRINT_DEBUG("f1/time format: %d, %d\n", freq1, time);
freq2 = 0;
} else if (sscanf(s, "%d@/%d", &freq1, &time) == 2) {
/* The "@" character has been added to enable an
* approximately -20db tone generation of any frequency This has been done
* primarily to generate the Australian congestion tone.
* Example: "425/375,0/375,425@/375,0/375"
*/
PRINT_DEBUG("f1 reduced amplitude/time format: %d, %d\n", freq1,time);
db = 0.3;
freq2 = 0;
} else if (sscanf(s, "%d", &freq1) == 1) {
PRINT_DEBUG("f1 format: %d\n", freq1);
firstnobang = *count;
freq2 = 0;
time = 0;
} else {
fprintf(stderr, "tone component '%s' of '%s' is a syntax error\n", s,t->data);
return -1;
}
PRINT_DEBUG("Using %d samples for %d and %d\n", time * 8, freq1, freq2);
if (size < sizeof(*td)) {
fprintf(stderr, "Not enough space for tones\n");
return -1;
}
td = data;
/* Bring it down -8 dbm */
gain = db*(pow(10.0, (LEVEL - 3.14) / 20.0) * 65536.0 / 2.0);
td->fac1 = 2.0 * cos(2.0 * M_PI * (freq1 / 8000.0)) * 32768.0;
td->init_v2_1 = sin(-4.0 * M_PI * (freq1 / 8000.0)) * gain;
td->init_v3_1 = sin(-2.0 * M_PI * (freq1 / 8000.0)) * gain;
td->fac2 = 2.0 * cos(2.0 * M_PI * (freq2 / 8000.0)) * 32768.0;
td->init_v2_2 = sin(-4.0 * M_PI * (freq2 / 8000.0)) * gain;
td->init_v3_2 = sin(-2.0 * M_PI * (freq2 / 8000.0)) * gain;
td->modulate = modulate;
data += sizeof(*td);
used += sizeof(*td);
size -= sizeof(*td);
td->tone = t->toneid;
if (time) {
/* We should move to the next tone */
td->next = *count + 1;
td->samples = time * 8;
} else {
/* Stay with us */
td->next = *count;
td->samples = 8000;
}
*count += 1;
s = strtok(NULL, ",");
}
if (td && time) {
/* If we don't end on a solid tone, return */
td->next = firstnobang;
}
if (firstnobang < 0)
fprintf(stderr, "tone '%s' does not end with a solid tone or silence (all tone components have an exclamation mark)\n", t->data);
return used;
}
char *tone_zone_tone_name(int id)
{
static char tmp[80];
switch(id) {
case DAHDI_TONE_DIALTONE:
return "Dialtone";
case DAHDI_TONE_BUSY:
return "Busy";
case DAHDI_TONE_RINGTONE:
return "Ringtone";
case DAHDI_TONE_CONGESTION:
return "Congestion";
case DAHDI_TONE_CALLWAIT:
return "Call Waiting";
case DAHDI_TONE_DIALRECALL:
return "Dial Recall";
case DAHDI_TONE_RECORDTONE:
return "Record Tone";
case DAHDI_TONE_CUST1:
return "Custom 1";
case DAHDI_TONE_CUST2:
return "Custom 2";
case DAHDI_TONE_INFO:
return "Special Information";
case DAHDI_TONE_STUTTER:
return "Stutter Dialtone";
default:
snprintf(tmp, sizeof(tmp), "Unknown tone %d", id);
return tmp;
}
}
#ifdef TONEZONE_DRIVER
static void dump_tone_zone(void *data, int size)
{
struct dahdi_tone_def_header *z;
struct dahdi_tone_def *td;
int x;
int len = sizeof(*z);
z = data;
data += sizeof(*z);
printf("Header: %d tones, %d bytes of data, zone %d (%s)\n",
z->count, size, z->zone, z->name);
for (x = 0; x < z->count; x++) {
td = data;
printf("Tone Fragment %d: tone is %d, next is %d, %d samples\n",
x, td->tone, td->next, td->samples);
data += sizeof(*td);
len += sizeof(*td);
}
printf("Total measured bytes of data: %d\n", len);
}
#endif
/* Tone frequency tables */
struct mf_tone {
int tone;
float f1; /* first freq */
float f2; /* second freq */
};
static struct mf_tone dtmf_tones[] = {
{ DAHDI_TONE_DTMF_0, 941.0, 1336.0 },
{ DAHDI_TONE_DTMF_1, 697.0, 1209.0 },
{ DAHDI_TONE_DTMF_2, 697.0, 1336.0 },
{ DAHDI_TONE_DTMF_3, 697.0, 1477.0 },
{ DAHDI_TONE_DTMF_4, 770.0, 1209.0 },
{ DAHDI_TONE_DTMF_5, 770.0, 1336.0 },
{ DAHDI_TONE_DTMF_6, 770.0, 1477.0 },
{ DAHDI_TONE_DTMF_7, 852.0, 1209.0 },
{ DAHDI_TONE_DTMF_8, 852.0, 1336.0 },
{ DAHDI_TONE_DTMF_9, 852.0, 1477.0 },
{ DAHDI_TONE_DTMF_s, 941.0, 1209.0 },
{ DAHDI_TONE_DTMF_p, 941.0, 1477.0 },
{ DAHDI_TONE_DTMF_A, 697.0, 1633.0 },
{ DAHDI_TONE_DTMF_B, 770.0, 1633.0 },
{ DAHDI_TONE_DTMF_C, 852.0, 1633.0 },
{ DAHDI_TONE_DTMF_D, 941.0, 1633.0 },
{ 0, 0, 0 }
};
static struct mf_tone mfr1_tones[] = {
{ DAHDI_TONE_MFR1_0, 1300.0, 1500.0 },
{ DAHDI_TONE_MFR1_1, 700.0, 900.0 },
{ DAHDI_TONE_MFR1_2, 700.0, 1100.0 },
{ DAHDI_TONE_MFR1_3, 900.0, 1100.0 },
{ DAHDI_TONE_MFR1_4, 700.0, 1300.0 },
{ DAHDI_TONE_MFR1_5, 900.0, 1300.0 },
{ DAHDI_TONE_MFR1_6, 1100.0, 1300.0 },
{ DAHDI_TONE_MFR1_7, 700.0, 1500.0 },
{ DAHDI_TONE_MFR1_8, 900.0, 1500.0 },
{ DAHDI_TONE_MFR1_9, 1100.0, 1500.0 },
{ DAHDI_TONE_MFR1_KP, 1100.0, 1700.0 }, /* KP */
{ DAHDI_TONE_MFR1_ST, 1500.0, 1700.0 }, /* ST */
{ DAHDI_TONE_MFR1_STP, 900.0, 1700.0 }, /* KP' or ST' */
{ DAHDI_TONE_MFR1_ST2P, 1300.0, 1700.0 }, /* KP'' or ST'' */
{ DAHDI_TONE_MFR1_ST3P, 700.0, 1700.0 }, /* KP''' or ST''' */
{ 0, 0, 0 }
};
static struct mf_tone mfr2_fwd_tones[] = {
{ DAHDI_TONE_MFR2_FWD_1, 1380.0, 1500.0 },
{ DAHDI_TONE_MFR2_FWD_2, 1380.0, 1620.0 },
{ DAHDI_TONE_MFR2_FWD_3, 1500.0, 1620.0 },
{ DAHDI_TONE_MFR2_FWD_4, 1380.0, 1740.0 },
{ DAHDI_TONE_MFR2_FWD_5, 1500.0, 1740.0 },
{ DAHDI_TONE_MFR2_FWD_6, 1620.0, 1740.0 },
{ DAHDI_TONE_MFR2_FWD_7, 1380.0, 1860.0 },
{ DAHDI_TONE_MFR2_FWD_8, 1500.0, 1860.0 },
{ DAHDI_TONE_MFR2_FWD_9, 1620.0, 1860.0 },
{ DAHDI_TONE_MFR2_FWD_10, 1740.0, 1860.0 },
{ DAHDI_TONE_MFR2_FWD_11, 1380.0, 1980.0 },
{ DAHDI_TONE_MFR2_FWD_12, 1500.0, 1980.0 },
{ DAHDI_TONE_MFR2_FWD_13, 1620.0, 1980.0 },
{ DAHDI_TONE_MFR2_FWD_14, 1740.0, 1980.0 },
{ DAHDI_TONE_MFR2_FWD_15, 1860.0, 1980.0 },
{ 0, 0, 0 }
};
static struct mf_tone mfr2_rev_tones[] = {
{ DAHDI_TONE_MFR2_REV_1, 1020.0, 1140.0 },
{ DAHDI_TONE_MFR2_REV_2, 900.0, 1140.0 },
{ DAHDI_TONE_MFR2_REV_3, 900.0, 1020.0 },
{ DAHDI_TONE_MFR2_REV_4, 780.0, 1140.0 },
{ DAHDI_TONE_MFR2_REV_5, 780.0, 1020.0 },
{ DAHDI_TONE_MFR2_REV_6, 780.0, 900.0 },
{ DAHDI_TONE_MFR2_REV_7, 660.0, 1140.0 },
{ DAHDI_TONE_MFR2_REV_8, 660.0, 1020.0 },
{ DAHDI_TONE_MFR2_REV_9, 660.0, 900.0 },
{ DAHDI_TONE_MFR2_REV_10, 660.0, 780.0 },
{ DAHDI_TONE_MFR2_REV_11, 540.0, 1140.0 },
{ DAHDI_TONE_MFR2_REV_12, 540.0, 1020.0 },
{ DAHDI_TONE_MFR2_REV_13, 540.0, 900.0 },
{ DAHDI_TONE_MFR2_REV_14, 540.0, 780.0 },
{ DAHDI_TONE_MFR2_REV_15, 540.0, 660.0 },
{ 0, 0, 0 }
};
static int build_mf_tones(void *data, size_t size, int *count, struct mf_tone *tone, int low_tone_level, int high_tone_level)
{
struct dahdi_tone_def *td;
float gain;
int used = 0;
while (tone->tone) {
if (size < sizeof(*td)) {
fprintf(stderr, "Not enough space for samples\n");
return -1;
}
td = data;
data += sizeof(*td);
used += sizeof(*td);
size -= sizeof(*td);
td->tone = tone->tone;
*count += 1;
/* Bring it down 6 dBm */
gain = pow(10.0, (low_tone_level - 3.14) / 20.0) * 65536.0 / 2.0;
td->fac1 = 2.0 * cos(2.0 * M_PI * (tone->f1 / 8000.0)) * 32768.0;
td->init_v2_1 = sin(-4.0 * M_PI * (tone->f1 / 8000.0)) * gain;
td->init_v3_1 = sin(-2.0 * M_PI * (tone->f1 / 8000.0)) * gain;
gain = pow(10.0, (high_tone_level - 3.14) / 20.0) * 65536.0 / 2.0;
td->fac2 = 2.0 * cos(2.0 * M_PI * (tone->f2 / 8000.0)) * 32768.0;
td->init_v2_2 = sin(-4.0 * M_PI * (tone->f2 / 8000.0)) * gain;
td->init_v3_2 = sin(-2.0 * M_PI * (tone->f2 / 8000.0)) * gain;
tone++;
}
return used;
}
int tone_zone_register_zone(int fd, struct tone_zone *z)
{
char buf[MAX_SIZE];
int res;
int count = 0;
int x;
size_t space = MAX_SIZE;
void *ptr = buf;
int iopenedit = 1;
struct dahdi_tone_def_header *h;
memset(buf, 0, sizeof(buf));
h = ptr;
ptr += sizeof(*h);
space -= sizeof(*h);
h->zone = z->zone;
dahdi_copy_string(h->name, z->description, sizeof(h->name));
for (x = 0; x < DAHDI_MAX_CADENCE; x++)
h->ringcadence[x] = z->ringcadence[x];
for (x = 0; x < DAHDI_TONE_MAX; x++) {
if (!strlen(z->tones[x].data))
continue;
PRINT_DEBUG("Tone: %d, string: %s\n", z->tones[x].toneid, z->tones[x].data);
if ((res = build_tone(ptr, space, &z->tones[x], &count)) < 0) {
fprintf(stderr, "Tone %d not built.\n", x);
return -1;
}
ptr += res;
space -= res;
}
if ((res = build_mf_tones(ptr, space, &count, dtmf_tones, z->dtmf_low_level, z->dtmf_high_level)) < 0) {
fprintf(stderr, "Could not build DTMF tones.\n");
return -1;
}
ptr += res;
space -= res;
if ((res = build_mf_tones(ptr, space, &count, mfr1_tones, z->mfr1_level, z->mfr1_level)) < 0) {
fprintf(stderr, "Could not build MFR1 tones.\n");
return -1;
}
ptr += res;
space -= res;
if ((res = build_mf_tones(ptr, space, &count, mfr2_fwd_tones, z->mfr2_level, z->mfr2_level)) < 0) {
fprintf(stderr, "Could not build MFR2 FWD tones.\n");
return -1;
}
ptr += res;
space -= res;
if ((res = build_mf_tones(ptr, space, &count, mfr2_rev_tones, z->mfr2_level, z->mfr2_level)) < 0) {
fprintf(stderr, "Could not build MFR2 REV tones.\n");
return -1;
}
ptr += res;
space -= res;
h->count = count;
if (fd < 0) {
if ((fd = open(DEFAULT_DAHDI_DEV, O_RDWR)) < 0) {
fprintf(stderr, "Unable to open %s and fd not provided\n", DEFAULT_DAHDI_DEV);
return -1;
}
iopenedit = 1;
}
x = z->zone;
if ((res = ioctl(fd, DAHDI_FREEZONE, &x))) {
if (errno != EBUSY)
fprintf(stderr, "ioctl(DAHDI_FREEZONE) failed: %s\n", strerror(errno));
return res;
}
#if defined(TONEZONE_DRIVER)
dump_tone_zone(h, MAX_SIZE - space);
#endif
#if defined(__FreeBSD__)
if ((res = ioctl(fd, DAHDI_LOADZONE, &h))) {
#else
if ((res = ioctl(fd, DAHDI_LOADZONE, h))) {
#endif
fprintf(stderr, "ioctl(DAHDI_LOADZONE) failed: %s\n", strerror(errno));
return res;
}
if (iopenedit)
close(fd);
return res;
}
int tone_zone_register(int fd, char *country)
{
struct tone_zone *z;
z = tone_zone_find(country);
if (z) {
return tone_zone_register_zone(-1, z);
} else {
return -1;
}
}
int tone_zone_set_zone(int fd, char *country)
{
int res=-1;
struct tone_zone *z;
if (fd > -1) {
z = tone_zone_find(country);
if (z)
res = ioctl(fd, DAHDI_SETTONEZONE, &z->zone);
if ((res < 0) && (errno == ENODATA)) {
tone_zone_register_zone(fd, z);
res = ioctl(fd, DAHDI_SETTONEZONE, &z->zone);
}
}
return res;
}
int tone_zone_get_zone(int fd)
{
int x=-1;
if (fd > -1) {
ioctl(fd, DAHDI_GETTONEZONE, &x);
return x;
}
return -1;
}
int tone_zone_play_tone(int fd, int tone)
{
struct tone_zone *z;
int res = -1;
int zone;
#if 0
fprintf(stderr, "Playing tone %d (%s) on %d\n", tone, tone_zone_tone_name(tone), fd);
#endif
if (fd > -1) {
res = ioctl(fd, DAHDI_SENDTONE, &tone);
if ((res < 0) && (errno == ENODATA)) {
ioctl(fd, DAHDI_GETTONEZONE, &zone);
z = tone_zone_find_by_num(zone);
if (z) {
res = tone_zone_register_zone(fd, z);
/* Recall the zone */
ioctl(fd, DAHDI_SETTONEZONE, &zone);
if (res < 0) {
fprintf(stderr, "Failed to register zone '%s': %s\n", z->description, strerror(errno));
} else {
res = ioctl(fd, DAHDI_SENDTONE, &tone);
}
} else
fprintf(stderr, "Don't know anything about zone %d\n", zone);
}
}
return res;
}