root/src/ftdm_callerid.c

/* [<][>][^][v][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. fsk_byte_handler
  2. FT_DECLARE
  3. FT_DECLARE
  4. FT_DECLARE
  5. FT_DECLARE
  6. FT_DECLARE
  7. FT_DECLARE
  8. FT_DECLARE
  9. FT_DECLARE
  10. FT_DECLARE
  11. FT_DECLARE
  12. FT_DECLARE
  13. FT_DECLARE
  14. FT_DECLARE

   1 #include "private/ftdm_core.h"
   2 #include "fsk.h"
   3 #include "uart.h"
   4 
   5 
   6 
   7 static void fsk_byte_handler (void *x, int data)
   8 {
   9         ftdm_fsk_data_state_t *state = (ftdm_fsk_data_state_t *) x;
  10         uint8_t byte = (uint8_t)data;
  11 
  12  top:
  13 
  14         if (state->init == 3) {
  15                 return;
  16         }
  17 
  18         if (state->dlen) {
  19                 goto add_byte;
  20         }
  21         
  22         if (state->bpos == 1) {
  23                 state->blen = byte;
  24 
  25                 if ((uint32_t)(state->dlen = state->bpos + byte + 2) > state->bufsize) {
  26                         state->dlen = state->bufsize;
  27                 }
  28                 goto top;
  29         }
  30 
  31  add_byte:
  32 
  33         if (state->bpos <= state->dlen) {
  34                 state->buf[state->bpos++] = byte;
  35         } else {
  36                 state->init = 3;
  37         }
  38 }
  39 
  40 FT_DECLARE(ftdm_status_t) ftdm_fsk_data_init(ftdm_fsk_data_state_t *state, uint8_t *data, uint32_t datalen)
  41 {
  42         memset(state, 0, sizeof(*state));
  43         state->buf = data;
  44         state->bufsize = datalen;
  45         state->bpos = 2;
  46 
  47         return FTDM_SUCCESS;
  48 }
  49 
  50 FT_DECLARE(ftdm_status_t) ftdm_fsk_data_add_sdmf(ftdm_fsk_data_state_t *state, const char *date, char *number)
  51 {
  52         size_t dlen = strlen(date);
  53         size_t nlen = strlen(number);
  54 
  55         state->buf[0] = FTDM_CID_TYPE_SDMF;
  56         memcpy(&state->buf[state->bpos], date, dlen);
  57         state->bpos += dlen;
  58         memcpy(&state->buf[state->bpos], number, nlen);
  59         state->bpos += nlen;
  60 
  61         return FTDM_SUCCESS;
  62 }
  63 
  64 FT_DECLARE(ftdm_status_t) ftdm_fsk_data_add_mdmf(ftdm_fsk_data_state_t *state, ftdm_mdmf_type_t type, const uint8_t *data, uint32_t datalen)
  65 {
  66         state->buf[0] = FTDM_CID_TYPE_MDMF;
  67         state->buf[state->bpos++] = type;
  68         state->buf[state->bpos++] = (uint8_t)datalen;
  69         memcpy(&state->buf[state->bpos], data, datalen);
  70         state->bpos += datalen;
  71         return FTDM_SUCCESS;
  72 }
  73 
  74 
  75 FT_DECLARE(ftdm_status_t) ftdm_fsk_data_add_checksum(ftdm_fsk_data_state_t *state)
  76 {
  77         uint32_t i;
  78         uint8_t check = 0;
  79 
  80         state->buf[1] = (uint8_t)(state->bpos - 2);
  81 
  82         for (i = 0; i < state->bpos; i++) {
  83                 check = check + state->buf[i];
  84         }
  85 
  86         state->checksum = state->buf[state->bpos] = (uint8_t)(256 - check);
  87         state->bpos++;
  88 
  89         state->dlen = state->bpos;
  90         state->blen = state->buf[1];
  91 
  92         return FTDM_SUCCESS;
  93 }
  94 
  95 
  96 FT_DECLARE(ftdm_status_t) ftdm_fsk_data_parse(ftdm_fsk_data_state_t *state, ftdm_size_t *type, char **data, ftdm_size_t *len)
  97 {
  98 
  99         ftdm_size_t i;
 100         int sum = 0;
 101         
 102  top:
 103 
 104         if (state->checksum != 0 || state->ppos >= state->dlen - 1) {
 105                 return FTDM_FAIL;
 106         }
 107 
 108         if (!state->ppos) {
 109                 for(i = 0; i < state->bpos; i++) {
 110                         sum += state->buf[i];
 111                 }
 112                 state->checksum = sum % 256;
 113                 state->ppos = 2;                
 114 
 115                 if (state->buf[0] != FTDM_CID_TYPE_MDMF && state->buf[0] != FTDM_CID_TYPE_SDMF) {
 116                         state->checksum = -1;
 117                 }
 118                 goto top;
 119         }
 120 
 121         if (state->buf[0] == FTDM_CID_TYPE_SDMF) {
 122                 /* convert sdmf to mdmf so we don't need 2 parsers */
 123                 if (state->ppos == 2) {
 124                         *type = MDMF_DATETIME;
 125                         *len = 8;
 126                 } else {
 127                         if (state->buf[state->ppos] == 'P' || state->buf[state->ppos] == 'O') {
 128                                 *type = MDMF_NO_NUM;
 129                                 *len = 1;
 130                         } else {
 131                                 *type = MDMF_PHONE_NUM;
 132                                 *len = state->blen - 8;
 133                         }
 134                 }
 135                 *data = (char *)&state->buf[state->ppos];
 136                 state->ppos += *len;            
 137                 return FTDM_SUCCESS;
 138         } else if (state->buf[0] == FTDM_CID_TYPE_MDMF) {
 139                 *type = state->buf[state->ppos++];
 140                 *len = state->buf[state->ppos++];
 141                 *data = (char *)&state->buf[state->ppos];
 142                 state->ppos += *len;
 143                 return FTDM_SUCCESS;
 144         }
 145 
 146         return FTDM_FAIL;
 147 }
 148 
 149 FT_DECLARE(ftdm_status_t) ftdm_fsk_demod_feed(ftdm_fsk_data_state_t *state, int16_t *data, ftdm_size_t samples)
 150 {
 151         uint32_t x;
 152         int16_t *sp = data;
 153 
 154         if (state->init == 3) {
 155                 return FTDM_FAIL;
 156         }
 157 
 158         for (x = 0; x < samples; x++) {
 159                 dsp_fsk_sample (state->fsk1200_handle, (double) *sp++ / 32767.0);
 160                 if (state->dlen && state->bpos >= state->dlen) {
 161                         state->init = 3;
 162                         return FTDM_FAIL;
 163                 }
 164         }
 165 
 166         return FTDM_SUCCESS;
 167 }
 168 
 169 FT_DECLARE(ftdm_status_t) ftdm_fsk_demod_destroy(ftdm_fsk_data_state_t *state)
 170 {
 171         dsp_fsk_destroy(&state->fsk1200_handle);
 172         memset(state, 0, sizeof(*state));
 173         return FTDM_SUCCESS;
 174 }
 175 
 176 FT_DECLARE(int) ftdm_fsk_demod_init(ftdm_fsk_data_state_t *state, int rate, uint8_t *buf, ftdm_size_t bufsize)
 177 {
 178 
 179         dsp_fsk_attr_t fsk1200_attr;
 180 
 181         if (state->fsk1200_handle) {
 182                 dsp_fsk_destroy(&state->fsk1200_handle);
 183         }
 184 
 185         memset(state, 0, sizeof(*state));
 186         memset(buf, 0, bufsize);
 187         state->buf = buf;
 188         state->bufsize = bufsize;
 189         
 190         dsp_fsk_attr_init (&fsk1200_attr);
 191         dsp_fsk_attr_set_samplerate (&fsk1200_attr, rate);
 192         dsp_fsk_attr_set_bytehandler (&fsk1200_attr, fsk_byte_handler, state);
 193         state->fsk1200_handle = dsp_fsk_create (&fsk1200_attr);
 194 
 195         if (state->fsk1200_handle == NULL) {
 196                 return FTDM_FAIL;
 197         }
 198 
 199         return FTDM_SUCCESS;
 200 }
 201 
 202 FT_DECLARE(ftdm_size_t) ftdm_fsk_modulator_generate_bit(ftdm_fsk_modulator_t *fsk_trans, int8_t bit, int16_t *buf, ftdm_size_t buflen)
 203 {
 204         ftdm_size_t i;
 205                 
 206         for(i = 0 ; i < buflen; i++) {
 207                 fsk_trans->bit_accum += fsk_trans->bit_factor;
 208                 if (fsk_trans->bit_accum >= FTDM_FSK_MOD_FACTOR) {
 209                         fsk_trans->bit_accum -= (FTDM_FSK_MOD_FACTOR + fsk_trans->bit_factor);
 210                         break;
 211                 }
 212 
 213                 buf[i] = teletone_dds_state_modulate_sample(&fsk_trans->dds, bit);
 214         }
 215 
 216         return i;
 217 }
 218 
 219 
 220 FT_DECLARE(int32_t) ftdm_fsk_modulator_generate_carrier_bits(ftdm_fsk_modulator_t *fsk_trans, uint32_t bits)
 221 {
 222         uint32_t i = 0;
 223         ftdm_size_t r = 0;
 224         int8_t bit = 1;
 225 
 226         for (i = 0; i < bits; i++) {
 227                 if ((r = ftdm_fsk_modulator_generate_bit(fsk_trans, bit, fsk_trans->sample_buffer, sizeof(fsk_trans->sample_buffer) / 2))) {
 228                         if (fsk_trans->write_sample_callback(fsk_trans->sample_buffer, r, fsk_trans->user_data) != FTDM_SUCCESS) {
 229                                 break;
 230                         }
 231                 } else {
 232                         break;
 233                 }
 234         }
 235 
 236         return i;
 237 }
 238 
 239 
 240 FT_DECLARE(void) ftdm_fsk_modulator_generate_chan_sieze(ftdm_fsk_modulator_t *fsk_trans)
 241 {
 242         uint32_t i = 0;
 243         ftdm_size_t r = 0;
 244         int8_t bit = 0;
 245         
 246         for (i = 0; i < fsk_trans->chan_sieze_bits; i++) {
 247                 if ((r = ftdm_fsk_modulator_generate_bit(fsk_trans, bit, fsk_trans->sample_buffer, sizeof(fsk_trans->sample_buffer) / 2))) {
 248                         if (fsk_trans->write_sample_callback(fsk_trans->sample_buffer, r, fsk_trans->user_data) != FTDM_SUCCESS) {
 249                                 break;
 250                         }
 251                 } else {
 252                         break;
 253                 }
 254                 bit = !bit;
 255         }
 256         
 257 
 258 }
 259 
 260 
 261 FT_DECLARE(void) ftdm_fsk_modulator_send_data(ftdm_fsk_modulator_t *fsk_trans)
 262 {
 263         ftdm_size_t r = 0;
 264         int8_t bit = 0;
 265 
 266         while((bit = ftdm_bitstream_get_bit(&fsk_trans->bs)) > -1) {
 267                 if ((r = ftdm_fsk_modulator_generate_bit(fsk_trans, bit, fsk_trans->sample_buffer, sizeof(fsk_trans->sample_buffer) / 2))) {
 268                         if (fsk_trans->write_sample_callback(fsk_trans->sample_buffer, r, fsk_trans->user_data) != FTDM_SUCCESS) {
 269                                 break;
 270                         }
 271                 } else {
 272                         break;
 273                 }
 274         }
 275 }
 276 
 277 
 278 FT_DECLARE(ftdm_status_t) ftdm_fsk_modulator_init(ftdm_fsk_modulator_t *fsk_trans,
 279                                                                         fsk_modem_types_t modem_type,
 280                                                                         uint32_t sample_rate,
 281                                                                         ftdm_fsk_data_state_t *fsk_data,
 282                                                                         float db_level,
 283                                                                         uint32_t carrier_bits_start,
 284                                                                         uint32_t carrier_bits_stop,
 285                                                                         uint32_t chan_sieze_bits,
 286                                                                         ftdm_fsk_write_sample_t write_sample_callback,
 287                                                                         void *user_data)
 288 {
 289         memset(fsk_trans, 0, sizeof(*fsk_trans));
 290         fsk_trans->modem_type = modem_type;
 291         teletone_dds_state_set_tone(&fsk_trans->dds, fsk_modem_definitions[fsk_trans->modem_type].freq_space, sample_rate, 0);
 292         teletone_dds_state_set_tone(&fsk_trans->dds, fsk_modem_definitions[fsk_trans->modem_type].freq_mark, sample_rate, 1);
 293         fsk_trans->bit_factor = (uint32_t)((fsk_modem_definitions[fsk_trans->modem_type].baud_rate * FTDM_FSK_MOD_FACTOR) / (float)sample_rate);
 294         fsk_trans->samples_per_bit = (uint32_t) (sample_rate / fsk_modem_definitions[fsk_trans->modem_type].baud_rate);
 295         fsk_trans->est_bytes = (int32_t)(((fsk_data->dlen * 10) + carrier_bits_start + carrier_bits_stop + chan_sieze_bits) * ((fsk_trans->samples_per_bit + 1) * 2));
 296         fsk_trans->bit_accum = 0;
 297         fsk_trans->fsk_data = fsk_data;
 298         teletone_dds_state_set_tx_level(&fsk_trans->dds, db_level);
 299         ftdm_bitstream_init(&fsk_trans->bs, fsk_trans->fsk_data->buf, (uint32_t)fsk_trans->fsk_data->dlen, FTDM_ENDIAN_BIG, 1);
 300         fsk_trans->carrier_bits_start = carrier_bits_start;
 301         fsk_trans->carrier_bits_stop = carrier_bits_stop;
 302         fsk_trans->chan_sieze_bits = chan_sieze_bits;
 303         fsk_trans->write_sample_callback = write_sample_callback;
 304         fsk_trans->user_data = user_data;
 305         return FTDM_SUCCESS;
 306 }
 307 

/* [<][>][^][v][top][bottom][index][help] */