libteletone_generate.h File Reference

Tone Generation Routines. More...

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <math.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <assert.h>
#include <stdarg.h>
#include <libteletone.h>

Include dependency graph for libteletone_generate.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	teletone_dds_state
struct	teletone_generation_session
	An abstraction to store a tone generation session. More...

Macros
#define	TELETONE_VOL_DB_MAX   0
#define	TELETONE_VOL_DB_MIN   -63
#define	MAX_PHASE_TONES   4
#define	SINE_TABLE_MAX   128
#define	SINE_TABLE_LEN   (SINE_TABLE_MAX - 1)
#define	MAX_PHASE_ACCUMULATOR   0x10000 * 0x10000
#define	DBM0_MAX_POWER   (3.14f + 3.02f)

Typedefs
typedef struct teletone_dds_state	teletone_dds_state_t
typedef int16_t	teletone_audio_t
typedef int(*	tone_handler )(struct teletone_generation_session *ts, teletone_tone_map_t *map)
typedef struct teletone_generation_session	teletone_generation_session_t

Functions
float	powf (float, float)
static __inline__ int32_t	teletone_dds_phase_rate (teletone_process_t tone, uint32_t rate)
static __inline__ int16_t	teletone_dds_state_modulate_sample (teletone_dds_state_t *dds, uint32_t pindex)
static __inline__ void	teletone_dds_state_set_tx_level (teletone_dds_state_t *dds, float tx_level)
static __inline__ void	teletone_dds_state_reset_accum (teletone_dds_state_t *dds)
static __inline__ int	teletone_dds_state_set_tone (teletone_dds_state_t *dds, teletone_process_t tone, uint32_t rate, uint32_t pindex)
int	teletone_set_tone (teletone_generation_session_t *ts, int index,...)
	Assign a set of tones to a tone_session indexed by a paticular index/character. More...
int	teletone_set_map (teletone_tone_map_t *map,...)
	Assign a set of tones to a single tone map. More...
int	teletone_init_session (teletone_generation_session_t *ts, int buflen, tone_handler handler, void *user_data)
	Initilize a tone generation session. More...
int	teletone_destroy_session (teletone_generation_session_t *ts)
	Free the buffer allocated by a tone generation session. More...
int	teletone_mux_tones (teletone_generation_session_t *ts, teletone_tone_map_t *map)
	Execute a single tone generation instruction. More...
int	teletone_run (teletone_generation_session_t *ts, const char *cmd)
	Execute a tone generation script and call callbacks after each instruction. More...

Variables
int16_t	TELETONE_SINES [SINE_TABLE_MAX]

Detailed Description

Tone Generation Routines.

This module is responsible for tone generation specifics

Definition in file libteletone_generate.h.

Macro Definition Documentation

#define DBM0_MAX_POWER   (3.14f + 3.02f)

Definition at line 147 of file libteletone_generate.h.

Referenced by teletone_dds_state_set_tx_level().

#define MAX_PHASE_ACCUMULATOR   0x10000 * 0x10000

Definition at line 144 of file libteletone_generate.h.

Referenced by teletone_dds_phase_rate().

#define MAX_PHASE_TONES   4

Definition at line 132 of file libteletone_generate.h.

Referenced by teletone_dds_state_modulate_sample(), and teletone_dds_state_set_tone().

#define SINE_TABLE_LEN   (SINE_TABLE_MAX - 1)

Definition at line 143 of file libteletone_generate.h.

Referenced by teletone_dds_state_modulate_sample().

#define SINE_TABLE_MAX   128

Definition at line 142 of file libteletone_generate.h.

Referenced by teletone_dds_state_modulate_sample().

#define TELETONE_VOL_DB_MAX   0

Definition at line 130 of file libteletone_generate.h.

#define TELETONE_VOL_DB_MIN   -63

Definition at line 131 of file libteletone_generate.h.

Referenced by teletone_mux_tones(), and teletone_run().

Typedef Documentation

typedef int16_t teletone_audio_t

Definition at line 208 of file libteletone_generate.h.

typedef struct teletone_dds_state teletone_dds_state_t

Definition at line 140 of file libteletone_generate.h.

typedef struct teletone_generation_session teletone_generation_session_t

Definition at line 257 of file libteletone_generate.h.

typedef int(* tone_handler)(struct teletone_generation_session *ts, teletone_tone_map_t *map)

Definition at line 210 of file libteletone_generate.h.

Function Documentation

float powf	(	float	,
		float
	)

Referenced by teletone_dds_state_set_tx_level().

static __inline__ int32_t teletone_dds_phase_rate ( teletone_process_t  tone, uint32_t  rate  )

static

Definition at line 151 of file libteletone_generate.h.

References MAX_PHASE_ACCUMULATOR.

Referenced by teletone_dds_state_set_tone().

{
        return (int32_t) ((tone * MAX_PHASE_ACCUMULATOR) / rate);
}

static __inline__ int16_t teletone_dds_state_modulate_sample ( teletone_dds_state_t *  dds, uint32_t  pindex  )

static

Definition at line 156 of file libteletone_generate.h.

References MAX_PHASE_TONES, teletone_dds_state::phase_accumulator, teletone_dds_state::phase_rate, teletone_dds_state::scale_factor, SINE_TABLE_LEN, SINE_TABLE_MAX, and TELETONE_SINES.

Referenced by teletone_mux_tones().

{
        int32_t bitmask = dds->phase_accumulator, sine_index = (bitmask >>= 23) & SINE_TABLE_LEN;
        int16_t sample;

        if (pindex >= MAX_PHASE_TONES)  {
                pindex = 0;
        }

        if (bitmask & SINE_TABLE_MAX) {
                sine_index = SINE_TABLE_LEN - sine_index;
        }

        sample = TELETONE_SINES[sine_index];
        
        if (bitmask & (SINE_TABLE_MAX * 2)) {
                sample *= -1;
        }

        dds->phase_accumulator += dds->phase_rate[pindex];
        return (int16_t) (sample * dds->scale_factor >> 15);
}

static __inline__ void teletone_dds_state_reset_accum ( teletone_dds_state_t *  dds )

static

Definition at line 185 of file libteletone_generate.h.

References teletone_dds_state::phase_accumulator.

{
        dds->phase_accumulator = 0;
}

static __inline__ int teletone_dds_state_set_tone ( teletone_dds_state_t *  dds, teletone_process_t  tone, uint32_t  rate, uint32_t  pindex  )

static

Definition at line 190 of file libteletone_generate.h.

References MAX_PHASE_TONES, teletone_dds_state::phase_rate, and teletone_dds_phase_rate().

Referenced by teletone_mux_tones().

{
        if (pindex < MAX_PHASE_TONES)  {
                dds->phase_rate[pindex] = teletone_dds_phase_rate(tone, rate);
                return 0;
        }
        
        return -1;
}

static __inline__ void teletone_dds_state_set_tx_level ( teletone_dds_state_t *  dds, float  tx_level  )

static

Definition at line 179 of file libteletone_generate.h.

References DBM0_MAX_POWER, powf(), teletone_dds_state::scale_factor, and teletone_dds_state::tx_level.

Referenced by teletone_mux_tones().

{
        dds->scale_factor = (int) (powf(10.0f, (tx_level - DBM0_MAX_POWER) / 20.0f) * (32767.0f * 1.414214f));
        dds->tx_level = tx_level;
}

int teletone_destroy_session

(

teletone_generation_session_t *

ts

)

Free the buffer allocated by a tone generation session.

Parameters

ts	the tone generation session to destroy

Returns

0

Definition at line 177 of file libteletone_generate.c.

Referenced by inband_dtmf_generate_callback(), main(), setup_ringback(), switch_ivr_gentones(), switch_ivr_originate(), and switch_ivr_wait_for_answer().

{
        if (ts->buffer) {
                free(ts->buffer);
                ts->buffer = NULL;
                ts->samples = 0;
        }
        return 0;
}

int teletone_init_session	(	teletone_generation_session_t *	ts,
		int	buflen,
		tone_handler	handler,
		void *	user_data
	)

Initilize a tone generation session.

Parameters

ts	the tone generation session to initilize
buflen	the size of the buffer(in samples) to dynamically allocate
handler	a callback function to execute when a tone generation instruction is complete
user_data	optional user data to send

Returns

0

Definition at line 134 of file libteletone_generate.c.

References buflen, memset(), and teletone_set_tone().

Referenced by inband_dtmf_generate_callback(), main(), setup_ringback(), switch_ivr_gentones(), and switch_ivr_wait_for_answer().

{
        memset(ts, 0, sizeof(*ts));
        ts->rate = 8000;
        ts->channels = 1;
        ts->duration = 2000;
        ts->wait = 500;
        ts->tmp_duration = -1;
        ts->tmp_wait = -1;
        ts->handler = handler;
        ts->user_data = user_data;
        ts->volume = -7;
        ts->decay_step = 0;
        ts->decay_factor = 1;
        if (buflen) {
                if ((ts->buffer = calloc(buflen, sizeof(teletone_audio_t))) == 0) {
                        return -1;
                }
                ts->datalen = buflen;
        } else {
                ts->dynamic = 1024;
        }
        /* Add Standard DTMF Tones */
        teletone_set_tone(ts, '1', 697.0, 1209.0, 0.0);
        teletone_set_tone(ts, '2', 697.0, 1336.0, 0.0);
        teletone_set_tone(ts, '3', 697.0, 1477.0, 0.0);
        teletone_set_tone(ts, 'A', 697.0, 1633.0, 0.0);
        teletone_set_tone(ts, '4', 770.0, 1209.0, 0.0);
        teletone_set_tone(ts, '5', 770.0, 1336.0, 0.0);
        teletone_set_tone(ts, '6', 770.0, 1477.0, 0.0);
        teletone_set_tone(ts, 'B', 770.0, 1633.0, 0.0);
        teletone_set_tone(ts, '7', 859.0, 1209.0, 0.0);
        teletone_set_tone(ts, '8', 859.0, 1336.0, 0.0);
        teletone_set_tone(ts, '9', 859.0, 1477.0, 0.0);
        teletone_set_tone(ts, 'C', 859.0, 1633.0, 0.0);
        teletone_set_tone(ts, '*', 941.0, 1209.0, 0.0);
        teletone_set_tone(ts, '0', 941.0, 1336.0, 0.0);
        teletone_set_tone(ts, '#', 941.0, 1477.0, 0.0);
        teletone_set_tone(ts, 'D', 941.0, 1633.0, 0.0);
        
        return 0;
}

int teletone_mux_tones	(	teletone_generation_session_t *	ts,
		teletone_tone_map_t *	map
	)

Execute a single tone generation instruction.

Parameters

ts	the tone generation session to consult for parameters
map	the tone mapping to use for the frequencies

Returns

0

Definition at line 206 of file libteletone_generate.c.

References ensure_buffer(), memset(), teletone_dds_state_modulate_sample(), teletone_dds_state_set_tone(), teletone_dds_state_set_tx_level(), TELETONE_MAX_TONES, and TELETONE_VOL_DB_MIN.

Referenced by teletone_dtmf_generate_handler(), and teletone_handler().

{
        /*teletone_process_t period = (1.0 / ts->rate) / ts->channels;*/
        int i, c;
        int freqlen = 0;
        teletone_dds_state_t tones[TELETONE_MAX_TONES+1];
        //int decay = 0;
        int duration;
        int wait = 0;
        int32_t sample;
        int32_t dc = 0;
        float vol = ts->volume;
        ts->samples = 0;
        memset(tones, 0, sizeof(tones[0]) * TELETONE_MAX_TONES);
        duration = (ts->tmp_duration > -1) ? ts->tmp_duration : ts->duration;
        wait = (ts->tmp_wait > -1) ? ts->tmp_wait : ts->wait;

        if (map->freqs[0] > 0) {
                for (freqlen = 0; freqlen < TELETONE_MAX_TONES && map->freqs[freqlen]; freqlen++) {
                        teletone_dds_state_set_tone(&tones[freqlen], map->freqs[freqlen], ts->rate, 0);
                        teletone_dds_state_set_tx_level(&tones[freqlen], vol);
                }
        
                if (ts->channels > 1) {
                        duration *= ts->channels;
                }

                if (ts->dynamic) {
                        if (ensure_buffer(ts, duration)) {
                                return -1;
                        }
                }

                for (ts->samples = 0; ts->samples < ts->datalen && ts->samples < duration; ts->samples++) {
                        if (ts->decay_direction && ++dc >= ts->decay_step) {
                                float nvol = vol + ts->decay_direction * ts->decay_factor;
                                int j;

                                if (nvol <= TELETONE_VOL_DB_MAX && nvol >= TELETONE_VOL_DB_MIN) {
                                        vol = nvol;
                                        for (j = 0; j < TELETONE_MAX_TONES && map->freqs[j]; j++) {                                     
                                                teletone_dds_state_set_tx_level(&tones[j], vol);
                                        }
                                        dc = 0;
                                }
                        }

                        sample = 128;

                        for (i = 0; i < freqlen; i++) {
                                int32_t s = teletone_dds_state_modulate_sample(&tones[i], 0);
                                sample += s;
                        }
                        sample /= freqlen;
                        ts->buffer[ts->samples] = (teletone_audio_t)sample;
                        
                        for (c = 1; c < ts->channels; c++) {
                                ts->buffer[ts->samples+1] = ts->buffer[ts->samples];
                                ts->samples++;
                        }
                        
                }
        }
        if (ts->dynamic) {
                if (ensure_buffer(ts, wait)) {
                        return -1;
                }
        }
        for (c = 0; c < ts->channels; c++) {
                for (i = 0; i < wait && ts->samples < ts->datalen; i++) {
                        ts->buffer[ts->samples++] = 0;
                }
        }

        if (ts->debug && ts->debug_stream) {
                if (map->freqs[0] <= 0) {
                        fprintf(ts->debug_stream, "wait %d (%dms)\n", wait, wait / (ts->rate / 1000));
                } else {
                        fprintf(ts->debug_stream, "Generate: (");

                        for (i = 0; i < TELETONE_MAX_TONES && map->freqs[i]; i++) {
                                fprintf(ts->debug_stream, "%s%0.2f", i == 0 ? "" : "+",map->freqs[i]);
                        }
                         
                        fprintf(ts->debug_stream, 
                                        ") [volume %0.2fdB; samples %d(%dms) x %d channel%s; wait %d(%dms); decay_factor %0.2fdB; decay_step %d(%dms); wrote %d bytes]\n",
                                        ts->volume,
                                        duration,
                                        duration / (ts->rate / 1000), 
                                        ts->channels,
                                        ts->channels == 1 ? "" : "s",
                                        wait,
                                        wait / (ts->rate / 1000),
                                        ts->decay_factor,
                                        ts->decay_step,
                                        ts->decay_step / (ts->rate / 1000),                                     
                                        ts->samples * 2);
                }
        }       
        return ts->samples / ts->channels;
}

int teletone_run	(	teletone_generation_session_t *	ts,
		const char *	cmd
	)

Execute a tone generation script and call callbacks after each instruction.

Parameters

ts	the tone generation session to execute on
cmd	the script to execute

Returns

0

Definition at line 321 of file libteletone_generate.c.

References cur, teletone_tone_map_t::freqs, memset(), my_strdup(), TELETONE_MAX_TONES, TELETONE_TONE_RANGE, and TELETONE_VOL_DB_MIN.

Referenced by inband_dtmf_generate_callback(), main(), setup_ringback(), switch_ivr_gentones(), and switch_ivr_wait_for_answer().

{
        char *data = NULL, *cur = NULL, *end = NULL;
        int LOOPING = 0;
        
        if (!cmd) {
                return -1;
        }

        do {
                if (!(data = my_strdup(cmd))) {
                        return -1;
                }

                cur = data;

                while (*cur) {
                        if (*cur == ' ' || *cur == '\r' || *cur == '\n') {
                                cur++;
                                continue;
                        }

                        if ((end = strchr(cur, ';')) != 0) {
                                *end++ = '\0';
                        }
                        
                        if (*(cur + 1) == '=') {
                                switch(*cur) {
                                case 'c':
                                        ts->channels = atoi(cur + 2);
                                        break;
                                case 'r':
                                        ts->rate = atoi(cur + 2);
                                        break;
                                case 'd':
                                        ts->duration = atoi(cur + 2) * (ts->rate / 1000);
                                        break;
                                case 'v':
                                        {
                                                float vol = (float)atof(cur + 2);
                                                if (vol <= TELETONE_VOL_DB_MAX && vol >= TELETONE_VOL_DB_MIN) {
                                                        ts->volume = vol;
                                                }
                                        }
                                        break;
                                case '>':
                                        ts->decay_step = atoi(cur + 2) * (ts->rate / 1000);
                                        ts->decay_direction = -1;
                                        break;
                                case '<':
                                        ts->decay_step = atoi(cur + 2) * (ts->rate / 1000);
                                        ts->decay_direction = 1;
                                        break;
                                case '+':
                                        ts->decay_factor = (float)atof(cur + 2);
                                        break;
                                case 'w':
                                        ts->wait = atoi(cur + 2) * (ts->rate / 1000);
                                        break;
                                case 'l':
                                        ts->loops = atoi(cur + 2); 
                                        break;
                                case 'L':
                                        if (!LOOPING) {
                                                int L;
                                                if ((L = atoi(cur + 2)) > 0) {
                                                        ts->LOOPS = L;
                                                        LOOPING++;
                                                }
                                        }
                                        break;
                                }
                        } else {
                                while (*cur) {
                                        char *p = NULL, *e = NULL;
                                        teletone_tone_map_t mymap, *mapp = NULL;

                                        if (*cur == ' ' || *cur == '\r' || *cur == '\n') {
                                                cur++;
                                                continue;
                                        }
                                        
                                        ts->tmp_duration = -1;
                                        ts->tmp_wait = -1;

                                        memset(&mymap, 0, sizeof(mymap));

                                        if (*(cur + 1) == '(') {
                                                p = cur + 2;
                                                if (*cur) {
                                                        char *next;
                                                        int i = 0;
                                                        if ((e = strchr(p, ')')) != 0) {
                                                                *e++ = '\0';
                                                        }
                                                        do {
#if (_MSC_VER == 1600)
                                                                if (!p) {
                                                                        break;
                                                                }
#endif
                                                                if ((next = strchr(p, ',')) != 0) {
                                                                        *next++ = '\0';
                                                                }
                                                                if (i == 0) {
                                                                        ts->tmp_duration = atoi(p) * (ts->rate / 1000);
                                                                        i++;
                                                                } else if (i == 1) {
                                                                        ts->tmp_wait = atoi(p) * (ts->rate / 1000);
                                                                        i++;
                                                                } else {
                                                                        mymap.freqs[i++ - 2] = atof(p);
                                                                }
                                                                p = next;

                                                        } while (next && (i-2) < TELETONE_MAX_TONES);
                                                        if (i > 2 && *cur == '%') {
                                                                mapp = &mymap;
                                                        } else if ((i != 2 || *cur == '%')) { 
                                                                if (ts->debug && ts->debug_stream) {
                                                                        fprintf(ts->debug_stream, "Syntax Error!\n");
                                                                }
                                                                goto bottom;
                                                        }
                                                } 
                                        }

                                        if (*cur && !mapp) {
                                                if (*cur > 0 && *cur < TELETONE_TONE_RANGE) { 
                                                        mapp = &ts->TONES[(int)*cur];
                                                } else if (ts->debug && ts->debug_stream) {
                                                        fprintf(ts->debug_stream, "Map [%c] Out Of Range!\n", *cur);
                                                }
                                        }

                                        if (mapp) {
                                                if (mapp->freqs[0]) {
                                                        if (ts->handler) {
                                                                do {
                                                                        ts->handler(ts, mapp);
                                                                        if (ts->loops > 0) {
                                                                                ts->loops--;
                                                                        }
                                                                } while (ts->loops);
                                                        }
                                                } else if (ts->debug && ts->debug_stream) {
                                                        fprintf(ts->debug_stream, "Ignoring Empty Map [%c]!\n", *cur);
                                                }
                                        }
                                        
                                        if (e) {
                                                cur = e;
                                        } else {
                                                cur++;
                                        }
                                }
                        }

                        if (end) {
                                cur = end;
                        } else if (*cur){
                                cur++;
                        }
                }
        bottom:
                free(data);
                data = NULL;

                if (ts->LOOPS > 0) {
                        ts->LOOPS--;
                }

        } while (ts->LOOPS);

        return 0;
}

int teletone_set_map	(	teletone_tone_map_t *	map,
			...
	)

Assign a set of tones to a single tone map.

Parameters

map	the map to assign the tones to
...	up to TELETONE_MAX_TONES frequencies terminated by 0.0

Returns

0

Definition at line 118 of file libteletone_generate.c.

References TELETONE_MAX_TONES.

{
        va_list ap;
        int i = 0;
        teletone_process_t x = 0;

        va_start(ap, map);
        while (i < TELETONE_MAX_TONES && (x = va_arg(ap, teletone_process_t))) {
                map->freqs[i++] = x;
        }
        va_end(ap);

        return (i > TELETONE_MAX_TONES) ? -1 : 0;
        
}

int teletone_set_tone	(	teletone_generation_session_t *	ts,
		int	index,
			...
	)

Assign a set of tones to a tone_session indexed by a paticular index/character.

Parameters

ts	the tone generation session
index	the index to map the tone to
...	up to TELETONE_MAX_TONES frequencies terminated by 0.0

Returns

0

Definition at line 102 of file libteletone_generate.c.

References TELETONE_MAX_TONES.

Referenced by teletone_init_session().

{
        va_list ap;
        int i = 0;
        teletone_process_t x = 0;

        va_start(ap, index);
        while (i < TELETONE_MAX_TONES && (x = va_arg(ap, teletone_process_t))) {
                ts->TONES[index].freqs[i++] = x;
        }
        va_end(ap);

        return (i > TELETONE_MAX_TONES) ? -1 : 0;
        
}

Variable Documentation

int16_t TELETONE_SINES[SINE_TABLE_MAX]

Definition at line 82 of file libteletone_generate.c.

Referenced by teletone_dds_state_modulate_sample().