tdd.c File Reference

#include <time.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <math.h>
#include <ctype.h>
#include <asterisk/ulaw.h>
#include <asterisk/tdd.h>
#include <asterisk/logger.h>
#include <asterisk/fskmodem.h>
#include "ecdisa.h"

Go to the source code of this file.

Defines
#define	TDD_SPACE   1800.0
#define	TDD_MARK   1400.0
#define	PUT_BYTE(a)
#define	PUT_AUDIO_SAMPLE(y)
#define	PUT_TDD_MARKMS
#define	PUT_TDD_BAUD(bit)
#define	PUT_TDD_STOP
#define	PUT_TDD(byte)
Functions
void	tdd_init (void)
	CallerID Initialization.
tdd_state *	tdd_new (void)
	Create a TDD state machine.
int	ast_tdd_gen_ecdisa (unsigned char *outbuf, int len)
	Generate Echo Canceller diable tone (2100HZ).
int	tdd_feed (struct tdd_state *tdd, unsigned char *ubuf, int len)
	Read samples into the state machine, and return character (if any).
void	tdd_free (struct tdd_state *tdd)
	Free a TDD state machine.
int	tdd_generate (struct tdd_state *tdd, unsigned char *buf, char *str)
	Generates a CallerID FSK stream in ulaw format suitable for transmission.

---

Define Documentation

#define PUT_AUDIO_SAMPLE (  y   )

Value: do { \ int index = (short)(rint(8192.0 * (y))); \ *(buf++) = AST_LIN2MU(index); \ bytes++; \ } while(0) Definition at line 196 of file tdd.c.

#define PUT_BYTE (  a   )

Value: do { \ *(buf++) = (a); \ bytes++; \ } while(0) Definition at line 191 of file tdd.c. Referenced by callerid_generate(), and vmwi_generate().

#define PUT_TDD (  byte   )

Definition at line 225 of file tdd.c. Referenced by tdd_generate().

#define PUT_TDD_BAUD (  bit   )

Definition at line 208 of file tdd.c.

#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 202 of file tdd.c.

#define PUT_TDD_STOP

Definition at line 216 of file tdd.c.

#define TDD_MARK   1400.0

Definition at line 45 of file tdd.c. Referenced by tdd_init().

#define TDD_SPACE   1800.0

Definition at line 44 of file tdd.c. Referenced by tdd_init().

---

Function Documentation

int ast_tdd_gen_ecdisa (  unsigned char *  outbuf, int  len )

Generate Echo Canceller diable 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 101 of file tdd.c. References tdd_state::pos. { int pos = 0; int cnt; while(len) { cnt = len; if (cnt > sizeof(ecdisa)) cnt = sizeof(ecdisa); memcpy(outbuf + pos, ecdisa, cnt); pos += cnt; len -= cnt; } return 0; }

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 buffer  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 116 of file tdd.c. References ast_log(), AST_MULAW, free, fsk_serie(), tdd_state::fskd, LOG_ERROR, LOG_NOTICE, LOG_WARNING, malloc, tdd_state::mode, tdd_state::oldlen, and tdd_state::oldstuff. { int mylen = len; int olen; int b = 'X'; int res; int c,x; short *buf = malloc(2 * len + tdd->oldlen); short *obuf = buf; if (!buf) { ast_log(LOG_WARNING, "Out of memory\n"); return -1; } memset(buf, 0, 2 * len + tdd->oldlen); 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_serie(&tdd->fskd, buf, &mylen, &b); if (mylen < 0) { ast_log(LOG_ERROR, "fsk_serie made mylen < 0 (%d) (olen was %d)\n", mylen,olen); free(obuf); return -1; } buf += (olen - mylen); if (res < 0) { ast_log(LOG_NOTICE, "fsk_serie failed\n"); 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; free(obuf); if (res) { tdd->mode = 2; /* put it in mode where it reliably puts teleprinter in correct shift mode */ return(c); } return 0; }

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 172 of file tdd.c. References free. { free(tdd); }

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

Generates a CallerID FSK stream in ulaw format suitable for transmission. Parameters: 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) Definition at line 236 of file tdd.c. References tdd_state::mode, and PUT_TDD. { int bytes=0; int i,x; char c; static unsigned char lstr[31] = "\000E\nA SIU\rDRJNFCKTZLWHYPQOBG\000MXV"; 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++) { 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; }

void tdd_init (  void   )

CallerID Initialization. Initializes the TDD system. Mostly stuff for inverse FFT Definition at line 67 of file tdd.c. References TDD_MARK, and TDD_SPACE. Referenced by main(). { /* 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); }

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 76 of file tdd.c. References ast_log(), LOG_WARNING, and malloc. { struct tdd_state *tdd; tdd = malloc(sizeof(struct tdd_state)); if (tdd) { memset(tdd, 0, sizeof(struct tdd_state)); 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.paridad = 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; } else ast_log(LOG_WARNING, "Out of memory\n"); return tdd; }

---