tdd.h File Reference

TTY/TDD Generation support. More...

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

Go to the source code of this file.

Macros
#define	TDD_BYTES_PER_CHAR   2700

Typedefs
typedef struct tdd_state	TDDSTATE

Functions
int	ast_tdd_gen_ecdisa (unsigned char *outbuf, int len)
int	tdd_feed (struct tdd_state *tdd, unsigned char *ubuf, int samples)
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 *string)
void	tdd_init (void)
struct tdd_state *	tdd_new (void)

Detailed Description

TTY/TDD Generation support.

Note

Includes code and algorithms from the Zapata library.

Definition in file tdd.h.

Macro Definition Documentation

TDD_BYTES_PER_CHAR

#define TDD_BYTES_PER_CHAR   2700

Definition at line 27 of file tdd.h.

Typedef Documentation

TDDSTATE

typedef struct tdd_state TDDSTATE

Definition at line 30 of file tdd.h.

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_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 hold tone

Parameters

buf	This is the buffer to receive the tone data

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_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().