a109763160
The Congestion tone in Australia must be reduced by 10 to 15 dB at every other cadence and the frequencies for both at cadences are 425 Hz. From: Armen Karlozian <armeniki@hotmail.com> Signed-off-by: Russ Meyerriecks <rmeyerriecks@digium.com>
533 lines
14 KiB
C
533 lines
14 KiB
C
/*
|
|
* 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, 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;
|
|
db = 1.0;
|
|
} else if (sscanf(s, "%d*%d", &freq1, &freq2) == 2) {
|
|
PRINT_DEBUG("f1+f2 format: %d, %d\n", freq1, freq2);
|
|
modulate = 1;
|
|
time = 0;
|
|
db = 1.0;
|
|
} else if (sscanf(s, "%d/%d", &freq1, &time) == 2) {
|
|
PRINT_DEBUG("f1/time format: %d, %d\n", freq1, time);
|
|
freq2 = 0;
|
|
db = 1.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;
|
|
db = 1.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;
|
|
}
|