tdd.c File Reference

TTY/TDD Generation support. More...

#include "asterisk.h"
#include <time.h>
#include <math.h>
#include <ctype.h>
#include "asterisk/logger.h"
#include "asterisk/ulaw.h"
#include "asterisk/tdd.h"
#include "asterisk/fskmodem.h"
#include "asterisk/utils.h"
#include "ecdisa.h"

Include dependency graph for tdd.c:

Go to the source code of this file.

Data Structures
struct	tdd_state

Macros
#define	PUT_AUDIO_SAMPLE(y)
#define	PUT_BYTE(a)
#define	PUT_TDD(byte)
#define	PUT_TDD_BAUD(bit)
#define	PUT_TDD_MARKMS
#define	PUT_TDD_STOP
#define	TDD_MARK   1400.0 /* 1400 hz for "1" */
#define	TDD_SPACE   1800.0 /* 1800 hz for "0" */

Functions
int	ast_tdd_gen_ecdisa (unsigned char *outbuf, int len)
static int	tdd_decode_baudot (struct tdd_state *tdd, unsigned char data)
int	tdd_feed (struct tdd_state *tdd, unsigned char *ubuf, int len)
void	tdd_free (struct tdd_state *tdd)
int	tdd_gen_holdtone (unsigned char *buf)
int	tdd_generate (struct tdd_state *tdd, unsigned char *buf, const char *str)
static float	tdd_getcarrier (float *cr, float *ci, int bit)
void	tdd_init (void)
struct tdd_state *	tdd_new (void)

Variables
static float	di [4]
static float	dr [4]
static float	tddsb = 176.0

Detailed Description

TTY/TDD Generation support.

Author

Mark Spencer marks.nosp@m.ter@.nosp@m.digiu.nosp@m.m.co.nosp@m.m

Note

Includes code and algorithms from the Zapata library.

Definition in file tdd.c.

Macro Definition Documentation

PUT_AUDIO_SAMPLE

#define PUT_AUDIO_SAMPLE

(

y

)

Value:

    do { \
    int __pas_idx = (short)(rint(8192.0 * (y))); \
    *(buf++) = AST_LIN2MU(__pas_idx); \
    bytes++; \
} while(0)

Definition at line 242 of file tdd.c.

PUT_BYTE

#define PUT_BYTE

(

a

)

Value:

    do { \
    *(buf++) = (a); \
    bytes++; \
} while(0)

Definition at line 237 of file tdd.c.

PUT_TDD

#define PUT_TDD

(

byte

)

Definition at line 271 of file tdd.c.

PUT_TDD_BAUD

#define PUT_TDD_BAUD

(

bit

)

Definition at line 254 of file tdd.c.

PUT_TDD_MARKMS

#define PUT_TDD_MARKMS

Value:

    do { \
    int x; \
    for (x = 0; x < 8; x++) \
        PUT_AUDIO_SAMPLE(tdd_getcarrier(&cr, &ci, 1)); \
} while(0)

Definition at line 248 of file tdd.c.

PUT_TDD_STOP

#define PUT_TDD_STOP

Definition at line 262 of file tdd.c.

TDD_MARK

#define TDD_MARK   1400.0 /* 1400 hz for "1" */

Definition at line 62 of file tdd.c.

TDD_SPACE

#define TDD_SPACE   1800.0 /* 1800 hz for "0" */

Definition at line 61 of file tdd.c.

Function Documentation

ast_tdd_gen_ecdisa()

int ast_tdd_gen_ecdisa	(	unsigned char *	outbuf,
		int	len
	)

Generate Echo Canceller disable tone (2100HZ)

Parameters

outbuf	This is the buffer to receive the tone data
len	This is the length (in samples) of the tone data to generate Returns 0 if no error, and -1 if error.

Definition at line 148 of file tdd.c.

{
    int pos = 0;
    int cnt;
    while (len) {
        cnt = len > sizeof(ecdisa) ? sizeof(ecdisa) : len;
        memcpy(outbuf + pos, ecdisa, cnt);
        pos += cnt;
        len -= cnt;
    }
    return 0;
}

References ecdisa, len(), and tdd_state::pos.

Referenced by dahdi_setoption().

tdd_decode_baudot()

static int tdd_decode_baudot ( struct tdd_state *  tdd, unsigned char  data  )

static

Definition at line 64 of file tdd.c.

{
    static char ltrs[32] = { '<','E','\n','A',' ','S','I','U',
                             '\n','D','R','J','N','F','C','K',
                             'T','Z','L','W','H','Y','P','Q',
                             'O','B','G','^','M','X','V','^' };
    static char figs[32] = { '<','3','\n','-',' ','\'','8','7',
                             '\n','$','4','\'',',','!',':','(',
                             '5','\"',')','2','=','6','0','1',
                             '9','?','+','^','.','/',';','^' };
    int d = 0;  /* return 0 if not decodeable */
    if (data < 32) {
        switch (data) {
        case 0x1f:
            tdd->modo = 0;
            break;
        case 0x1b:
            tdd->modo = 1;
            break;
        default:
            if (tdd->modo == 0)
                d = ltrs[data];
            else
                d = figs[data];
            break;
        }
    }
    return d;
}

References d, and tdd_state::modo.

Referenced by tdd_feed().

tdd_feed()

int tdd_feed	(	struct tdd_state *	tdd,
		unsigned char *	ubuf,
		int	samples
	)

Read samples into the state machine, and return character (if any).

Parameters

tdd	Which state machine to act upon
ubuf	containing your samples
samples	number of samples contained within the buffer.

Send received audio to the TDD demodulator. Returns -1 on error, 0 for "needs more samples", and > 0 (the character) if reception of a character is complete.

Definition at line 161 of file tdd.c.

{
    int mylen = len;
    int olen;
    int b = 'X';
    int res;
    int c,x;
    short *buf = ast_calloc(1, 2 * len + tdd->oldlen);
    short *obuf = buf;
    if (!buf) {
        ast_log(LOG_WARNING, "Out of memory\n");
        return -1;
    }
    memcpy(buf, tdd->oldstuff, tdd->oldlen);
    mylen += tdd->oldlen / 2;
    for (x = 0; x < len; x++)
        buf[x + tdd->oldlen / 2] = AST_MULAW(ubuf[x]);
    c = res = 0;
    while (mylen >= 1320) { /* has to have enough to work on */
        olen = mylen;
        res = fsk_serial(&tdd->fskd, buf, &mylen, &b);
        if (mylen < 0) {
            ast_log(LOG_ERROR, "fsk_serial made mylen < 0 (%d) (olen was %d)\n", mylen, olen);
            ast_free(obuf);
            return -1;
        }
        buf += (olen - mylen);
        if (res < 0) {
            ast_log(LOG_NOTICE, "fsk_serial failed\n");
            ast_free(obuf);
            return -1;
        }
        if (res == 1) {
            /* Ignore invalid bytes */
            if (b > 0x7f)
                continue;
            c = tdd_decode_baudot(tdd, b);
            if ((c < 1) || (c > 126))
                continue; /* if not valid */
            break;
        }
    }
    if (mylen) {
        memcpy(tdd->oldstuff, buf, mylen * 2);
        tdd->oldlen = mylen * 2;
    } else
        tdd->oldlen = 0;
    ast_free(obuf);
    if (res) {
        tdd->mode = 2;
/* put it in mode where it
            reliably puts teleprinter in correct shift mode */
        return(c);
    }
    return 0;
}

References ast_calloc, ast_free, ast_log, AST_MULAW, b, buf, c, fsk_serial(), tdd_state::fskd, len(), LOG_ERROR, LOG_NOTICE, LOG_WARNING, tdd_state::mode, tdd_state::oldlen, tdd_state::oldstuff, and tdd_decode_baudot().

Referenced by dahdi_read().

tdd_free()

void tdd_free

(

struct tdd_state *

tdd

)

Free a TDD state machine

Parameters

tdd	This is the tdd_state state machine to free This function frees tdd_state tdd.

Definition at line 218 of file tdd.c.

{
    ast_free(tdd);
}

References ast_free.

Referenced by dahdi_setoption().

tdd_gen_holdtone()

int tdd_gen_holdtone

(

unsigned char *

buf

)

Generate TDD hold tone

Todo:

How big should this be?

Definition at line 285 of file tdd.c.

{
    int bytes = 0;
    float scont = 0.0, cr = 1.0, ci=0.0;
    while (scont < tddsb * 10.0) {
        PUT_AUDIO_SAMPLE(tdd_getcarrier(&cr, &ci, 1));
        scont += 1.0;
    }
    return bytes;
}

References PUT_AUDIO_SAMPLE, tdd_getcarrier(), and tddsb.

tdd_generate()

int tdd_generate	(	struct tdd_state *	tdd,
		unsigned char *	buf,
		const char *	string
	)

Generates a CallerID FSK stream in ulaw format suitable for transmission.

Parameters

tdd	tdd structure
buf	Buffer to use. This needs to be large enough to accomodate all the generated samples.
string	This is the string to send. This function creates a stream of TDD data in ulaw format. It returns the size (in bytes) of the data (if it returns a size of 0, there is probably an error)

Baudot letters

Baudot figures

Definition at line 296 of file tdd.c.

{
    int bytes = 0;
    int i,x;
    char c;
    /*! Baudot letters */
    static unsigned char lstr[31] = "\000E\nA SIU\rDRJNFCKTZLWHYPQOBG\000MXV";
    /*! Baudot figures */
    static unsigned char fstr[31] = "\0003\n- \00787\r$4',!:(5\")2\0006019?+\000./;";
    /* Initial carriers (real/imaginary) */
    float cr = 1.0;
    float ci = 0.0;
    float scont = 0.0;
 
    for(x = 0; str[x]; x++) {
        /* Do synch for each 72th character */
        if ( (tdd->charnum++) % 72 == 0)
            PUT_TDD(tdd->mode ? 27 /* FIGS */ : 31 /* LTRS */);
 
        c = toupper(str[x]);
#if 0
        printf("%c",c); fflush(stdout);
#endif
        if (c == 0) { /* send null */
            PUT_TDD(0);
            continue;
        }
        if (c == '\r') { /* send c/r */
            PUT_TDD(8);
            continue;
        }
        if (c == '\n') { /* send c/r and l/f */
            PUT_TDD(8);
            PUT_TDD(2);
            continue;
        }
        if (c == ' ') { /* send space */
            PUT_TDD(4);
            continue;
        }
        for (i = 0; i < 31; i++) {
            if (lstr[i] == c)
                break;
        }
        if (i < 31) {        /* if we found it */
            if (tdd->mode) { /* if in figs mode, change it */
                PUT_TDD(31); /* Send LTRS */
                tdd->mode = 0;
            }
            PUT_TDD(i);
            continue;
        }
        for (i = 0; i < 31; i++) {
            if (fstr[i] == c)
                break;
        }
        if (i < 31) {             /* if we found it */
            if (tdd->mode != 1) { /* if in ltrs mode, change it */
                PUT_TDD(27);      /* send FIGS */
                tdd->mode = 1;
            }
            PUT_TDD(i);           /* send byte */
            continue;
        }
    }
    return bytes;
}

References c, tdd_state::charnum, tdd_state::mode, PUT_TDD, and str.

Referenced by dahdi_sendtext().

tdd_getcarrier()

static float tdd_getcarrier ( float *  cr, float *  ci, int  bit  )

inlinestatic

Definition at line 223 of file tdd.c.

{
    /* Move along.  There's nothing to see here... */
    float t;
    t = *cr * dr[bit] - *ci * di[bit];
    *ci = *cr * di[bit] + *ci * dr[bit];
    *cr = t;
 
    t = 2.0 - (*cr * *cr + *ci * *ci);
    *cr *= t;
    *ci *= t;
    return *cr;
}

References di, and dr.

Referenced by tdd_gen_holdtone().

tdd_init()

void tdd_init

(

void

)

CallerID Initialization Initializes the TDD system. Mostly stuff for inverse FFT

Definition at line 94 of file tdd.c.

{
    /* Initialize stuff for inverse FFT */
    dr[0] = cos(TDD_SPACE * 2.0 * M_PI / 8000.0);
    di[0] = sin(TDD_SPACE * 2.0 * M_PI / 8000.0);
    dr[1] = cos(TDD_MARK * 2.0 * M_PI / 8000.0);
    di[1] = sin(TDD_MARK * 2.0 * M_PI / 8000.0);
}

References cos, di, dr, M_PI, TDD_MARK, and TDD_SPACE.

Referenced by asterisk_daemon().

tdd_new()

struct tdd_state * tdd_new

(

void

)

Create a TDD state machine This function returns a malloc'd instance of the tdd_state data structure. Returns a pointer to a malloc'd tdd_state structure, or NULL on error.

Definition at line 103 of file tdd.c.

{
    struct tdd_state *tdd;
    tdd = ast_calloc(1, sizeof(*tdd));
    if (tdd) {
#ifdef INTEGER_CALLERID
        tdd->fskd.ispb = 176;        /* 45.5 baud */
        /* Set up for 45.5 / 8000 freq *32 to allow ints */
        tdd->fskd.pllispb  = (int)((8000 * 32 * 2) / 90);
        tdd->fskd.pllids   = tdd->fskd.pllispb / 32;
        tdd->fskd.pllispb2 = tdd->fskd.pllispb / 2;
        tdd->fskd.hdlc = 0;         /* Async */
        tdd->fskd.nbit = 5;         /* 5 bits */
        tdd->fskd.instop = 1;       /* integer rep of 1.5 stop bits */
        tdd->fskd.parity = 0;       /* No parity */
        tdd->fskd.bw=0;             /* Filter 75 Hz */
        tdd->fskd.f_mark_idx = 0;   /* 1400 Hz */
        tdd->fskd.f_space_idx = 1;  /* 1800 Hz */
        tdd->fskd.xi0  = 0;
        tdd->fskd.state = 0;
        tdd->pos = 0;
        tdd->mode = 0;
        fskmodem_init(&tdd->fskd);
#else
        tdd->fskd.spb = 176;        /* 45.5 baud */
        tdd->fskd.hdlc = 0;         /* Async */
        tdd->fskd.nbit = 5;         /* 5 bits */
        tdd->fskd.nstop = 1.5;      /* 1.5 stop bits */
        tdd->fskd.parity = 0;       /* No parity */
        tdd->fskd.bw=0;             /* Filter 75 Hz */
        tdd->fskd.f_mark_idx = 0;   /* 1400 Hz */
        tdd->fskd.f_space_idx = 1;  /* 1800 Hz */
        tdd->fskd.pcola = 0;        /* No clue */
        tdd->fskd.cont = 0;         /* Digital PLL reset */
        tdd->fskd.x0 = 0.0;
        tdd->fskd.state = 0;
        tdd->pos = 0;
        tdd->mode = 2;
#endif
        tdd->charnum = 0;
    } else
        ast_log(LOG_WARNING, "Out of memory\n");
    return tdd;
}

References ast_calloc, ast_log, fsk_data::bw, tdd_state::charnum, fsk_data::cont, fsk_data::f_mark_idx, fsk_data::f_space_idx, tdd_state::fskd, fskmodem_init(), fsk_data::hdlc, fsk_data::instop, fsk_data::ispb, LOG_WARNING, tdd_state::mode, fsk_data::nbit, fsk_data::nstop, fsk_data::parity, fsk_data::pcola, fsk_data::pllids, fsk_data::pllispb, fsk_data::pllispb2, tdd_state::pos, fsk_data::spb, fsk_data::state, fsk_data::x0, and fsk_data::xi0.

Referenced by dahdi_setoption().

Variable Documentation

di

float di[4]

static

Definition at line 58 of file tdd.c.

Referenced by destroy_callback(), detect_callback(), detect_read(), detect_write(), P4(), tdd_getcarrier(), and tdd_init().

dr

float dr[4]

static

Definition at line 58 of file tdd.c.

Referenced by abort_request(), append_transaction(), build_transactions(), cancel_request(), check_request(), discover_transactions(), dundi_do_lookup(), dundi_lookup_internal(), dundi_lookup_local(), dundi_lookup_thread(), dundi_precache_internal(), dundi_prop_precache(), dundi_query_eid_internal(), dundifunc_read(), mbl_load_adapter(), optimize_transactions(), precache_trans(), precache_transactions(), query_transactions(), register_request(), tdd_getcarrier(), tdd_init(), and unregister_request().

tddsb

float tddsb = 176.0

static

Definition at line 59 of file tdd.c.

Referenced by tdd_gen_holdtone().