1 /*
2 * FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application
3 * Copyright (C) 2005-2014, Anthony Minessale II <anthm@freeswitch.org>
4 *
5 * Version: MPL 1.1
6 *
7 * The contents of this file are subject to the Mozilla Public License Version
8 * 1.1 (the "License"); you may not use this file except in compliance with
9 * the License. You may obtain a copy of the License at
10 * http://www.mozilla.org/MPL/
11 *
12 * Software distributed under the License is distributed on an "AS IS" basis,
13 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
14 * for the specific language governing rights and limitations under the
15 * License.
16 *
17 * The Original Code is FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application
18 *
19 * The Initial Developer of the Original Code is
20 * Anthony Minessale II <anthm@freeswitch.org>
21 * Portions created by the Initial Developer are Copyright (C)
22 * the Initial Developer. All Rights Reserved.
23 *
24 * Contributor(s):
25 *
26 * Anthony Minessale II <anthm@freeswitch.org>
27 *
28 * mod_fsk -- FSK data transfer
29 *
30 */
31
32 #include "switch.h"
33 #include "fsk_callerid.h"
34
bitstream_init(bitstream_t * bsp,uint8_t * data,uint32_t datalen,endian_t endian,uint8_t ss)35 void bitstream_init(bitstream_t *bsp, uint8_t *data, uint32_t datalen, endian_t endian, uint8_t ss)
36 {
37 memset(bsp, 0, sizeof(*bsp));
38 bsp->data = data;
39 bsp->datalen = datalen;
40 bsp->endian = endian;
41 bsp->ss = ss;
42
43 if (endian < 0) {
44 bsp->top = bsp->bit_index = 7;
45 bsp->bot = 0;
46 } else {
47 bsp->top = bsp->bit_index = 0;
48 bsp->bot = 7;
49 }
50
51 }
52
bitstream_get_bit(bitstream_t * bsp)53 int8_t bitstream_get_bit(bitstream_t *bsp)
54 {
55 int8_t bit = -1;
56
57
58 if (bsp->byte_index >= bsp->datalen) {
59 goto done;
60 }
61
62 if (bsp->ss) {
63 if (!bsp->ssv) {
64 bsp->ssv = 1;
65 return 0;
66 } else if (bsp->ssv == 2) {
67 bsp->byte_index++;
68 bsp->ssv = 0;
69 return 1;
70 }
71 }
72
73 bit = (bsp->data[bsp->byte_index] >> (bsp->bit_index)) & 1;
74
75 if (bsp->bit_index == bsp->bot) {
76 bsp->bit_index = bsp->top;
77 if (bsp->ss) {
78 bsp->ssv = 2;
79 goto done;
80 }
81
82 if (++bsp->byte_index > bsp->datalen) {
83 bit = -1;
84 goto done;
85 }
86
87 } else {
88 bsp->bit_index = bsp->bit_index + bsp->endian;
89 }
90
91
92 done:
93 return bit;
94 }
95
96
97
fsk_byte_handler(void * x,int data)98 static void fsk_byte_handler (void *x, int data)
99 {
100 fsk_data_state_t *state = (fsk_data_state_t *) x;
101 uint8_t byte = (uint8_t)data;
102
103 top:
104
105 if (state->init == 3) {
106 return;
107 }
108
109 if (state->dlen) {
110 goto add_byte;
111 }
112
113 if (state->bpos == 1) {
114 state->blen = byte;
115
116 if ((uint32_t)(state->dlen = state->bpos + byte + 2) > state->bufsize) {
117 state->dlen = state->bufsize;
118 }
119 goto top;
120 }
121
122 add_byte:
123
124 if (state->bpos <= state->dlen) {
125 state->buf[state->bpos++] = byte;
126 } else {
127 state->init = 3;
128 }
129 }
130
fsk_data_init(fsk_data_state_t * state,uint8_t * data,uint32_t datalen)131 switch_status_t fsk_data_init(fsk_data_state_t *state, uint8_t *data, uint32_t datalen)
132 {
133 memset(state, 0, sizeof(*state));
134 state->buf = data;
135 state->bufsize = datalen;
136 state->bpos = 2;
137
138 return SWITCH_STATUS_SUCCESS;
139 }
140
fsk_data_add_sdmf(fsk_data_state_t * state,const char * date,char * number)141 switch_status_t fsk_data_add_sdmf(fsk_data_state_t *state, const char *date, char *number)
142 {
143 size_t dlen = strlen(date);
144 size_t nlen = strlen(number);
145
146 state->buf[0] = CID_TYPE_SDMF;
147 memcpy(&state->buf[state->bpos], date, dlen);
148 state->bpos += dlen;
149 memcpy(&state->buf[state->bpos], number, nlen);
150 state->bpos += nlen;
151
152 return SWITCH_STATUS_SUCCESS;
153 }
154
fsk_data_add_mdmf(fsk_data_state_t * state,mdmf_type_t type,const uint8_t * data,uint32_t datalen)155 switch_status_t fsk_data_add_mdmf(fsk_data_state_t *state, mdmf_type_t type, const uint8_t *data, uint32_t datalen)
156 {
157 state->buf[0] = CID_TYPE_MDMF;
158 state->buf[state->bpos++] = type;
159 state->buf[state->bpos++] = (uint8_t)datalen;
160 memcpy(&state->buf[state->bpos], data, datalen);
161 state->bpos += datalen;
162 return SWITCH_STATUS_SUCCESS;
163 }
164
165
fsk_data_add_checksum(fsk_data_state_t * state)166 switch_status_t fsk_data_add_checksum(fsk_data_state_t *state)
167 {
168 uint32_t i;
169 uint8_t check = 0;
170
171 state->buf[1] = (uint8_t)(state->bpos - 2);
172
173 for (i = 0; i < state->bpos; i++) {
174 check = check + state->buf[i];
175 }
176
177 state->checksum = state->buf[state->bpos] = (uint8_t)(256 - check);
178 state->bpos++;
179
180 state->dlen = state->bpos;
181 state->blen = state->buf[1];
182
183 return SWITCH_STATUS_SUCCESS;
184 }
185
186
fsk_data_parse(fsk_data_state_t * state,size_t * type,char ** data,size_t * len)187 switch_status_t fsk_data_parse(fsk_data_state_t *state, size_t *type, char **data, size_t *len)
188 {
189
190 size_t i;
191 int sum = 0;
192
193 top:
194
195 if (state->checksum != 0 || state->ppos >= state->dlen - 1) {
196 return SWITCH_STATUS_FALSE;
197 }
198
199 if (!state->ppos) {
200 for(i = 0; i < state->bpos; i++) {
201 sum += state->buf[i];
202 }
203 state->checksum = sum % 256;
204 state->ppos = 2;
205
206 if (state->buf[0] != CID_TYPE_MDMF && state->buf[0] != CID_TYPE_SDMF) {
207 state->checksum = -1;
208 }
209 goto top;
210 }
211
212 if (state->buf[0] == CID_TYPE_SDMF) {
213 /* convert sdmf to mdmf so we don't need 2 parsers */
214 if (state->ppos == 2) {
215 *type = MDMF_DATETIME;
216 *len = 8;
217 } else {
218 if (state->buf[state->ppos] == 'P' || state->buf[state->ppos] == 'O') {
219 *type = MDMF_NO_NUM;
220 *len = 1;
221 } else {
222 *type = MDMF_PHONE_NUM;
223 *len = state->blen - 8;
224 }
225 }
226 *data = (char *)&state->buf[state->ppos];
227 state->ppos += *len;
228 return SWITCH_STATUS_SUCCESS;
229 } else if (state->buf[0] == CID_TYPE_MDMF) {
230 *type = state->buf[state->ppos++];
231 *len = state->buf[state->ppos++];
232 *data = (char *)&state->buf[state->ppos];
233 state->ppos += *len;
234 return SWITCH_STATUS_SUCCESS;
235 }
236
237 return SWITCH_STATUS_FALSE;
238 }
239
fsk_demod_feed(fsk_data_state_t * state,int16_t * data,size_t samples)240 switch_status_t fsk_demod_feed(fsk_data_state_t *state, int16_t *data, size_t samples)
241 {
242 uint32_t x;
243 int16_t *sp = data;
244
245 if (state->init == 3) {
246 return SWITCH_STATUS_FALSE;
247 }
248
249 for (x = 0; x < samples; x++) {
250 dsp_fsk_sample (state->fsk1200_handle, (double) *sp++ / 32767.0);
251 if (state->dlen && state->bpos >= state->dlen) {
252 state->init = 3;
253 return SWITCH_STATUS_FALSE;
254 }
255 }
256
257 return SWITCH_STATUS_SUCCESS;
258 }
259
fsk_demod_destroy(fsk_data_state_t * state)260 switch_status_t fsk_demod_destroy(fsk_data_state_t *state)
261 {
262 dsp_fsk_destroy(&state->fsk1200_handle);
263 memset(state, 0, sizeof(*state));
264 return SWITCH_STATUS_SUCCESS;
265 }
266
fsk_demod_init(fsk_data_state_t * state,int rate,uint8_t * buf,size_t bufsize)267 int fsk_demod_init(fsk_data_state_t *state, int rate, uint8_t *buf, size_t bufsize)
268 {
269
270 dsp_fsk_attr_t fsk1200_attr;
271
272 if (state->fsk1200_handle) {
273 dsp_fsk_destroy(&state->fsk1200_handle);
274 }
275
276 memset(state, 0, sizeof(*state));
277 memset(buf, 0, bufsize);
278 state->buf = buf;
279 state->bufsize = bufsize;
280
281 dsp_fsk_attr_init (&fsk1200_attr);
282 dsp_fsk_attr_set_samplerate (&fsk1200_attr, rate);
283 dsp_fsk_attr_set_bytehandler (&fsk1200_attr, fsk_byte_handler, state);
284 state->fsk1200_handle = dsp_fsk_create (&fsk1200_attr);
285
286 if (state->fsk1200_handle == NULL) {
287 return SWITCH_STATUS_FALSE;
288 }
289
290 return SWITCH_STATUS_SUCCESS;
291 }
292
fsk_modulator_generate_bit(fsk_modulator_t * fsk_trans,int8_t bit,int16_t * buf,size_t buflen)293 size_t fsk_modulator_generate_bit(fsk_modulator_t *fsk_trans, int8_t bit, int16_t *buf, size_t buflen)
294 {
295 size_t i;
296
297 for(i = 0 ; i < buflen; i++) {
298 fsk_trans->bit_accum += fsk_trans->bit_factor;
299 if (fsk_trans->bit_accum >= FSK_MOD_FACTOR) {
300 fsk_trans->bit_accum -= (FSK_MOD_FACTOR + fsk_trans->bit_factor);
301 break;
302 }
303
304 buf[i] = teletone_dds_state_modulate_sample(&fsk_trans->dds, bit);
305 }
306
307 return i;
308 }
309
310
fsk_modulator_generate_carrier_bits(fsk_modulator_t * fsk_trans,uint32_t bits)311 int32_t fsk_modulator_generate_carrier_bits(fsk_modulator_t *fsk_trans, uint32_t bits)
312 {
313 uint32_t i = 0;
314 size_t r = 0;
315 int8_t bit = 1;
316
317 for (i = 0; i < bits; i++) {
318 if ((r = fsk_modulator_generate_bit(fsk_trans, bit, fsk_trans->sample_buffer, sizeof(fsk_trans->sample_buffer) / 2))) {
319 if (fsk_trans->write_sample_callback(fsk_trans->sample_buffer, r, fsk_trans->user_data) != SWITCH_STATUS_SUCCESS) {
320 break;
321 }
322 } else {
323 break;
324 }
325 }
326
327 return i;
328 }
329
330
fsk_modulator_generate_chan_sieze(fsk_modulator_t * fsk_trans)331 void fsk_modulator_generate_chan_sieze(fsk_modulator_t *fsk_trans)
332 {
333 uint32_t i = 0;
334 size_t r = 0;
335 int8_t bit = 0;
336
337 for (i = 0; i < fsk_trans->chan_sieze_bits; i++) {
338 if ((r = fsk_modulator_generate_bit(fsk_trans, bit, fsk_trans->sample_buffer, sizeof(fsk_trans->sample_buffer) / 2))) {
339 if (fsk_trans->write_sample_callback(fsk_trans->sample_buffer, r, fsk_trans->user_data) != SWITCH_STATUS_SUCCESS) {
340 break;
341 }
342 } else {
343 break;
344 }
345 bit = !bit;
346 }
347
348
349 }
350
351
fsk_modulator_send_data(fsk_modulator_t * fsk_trans)352 void fsk_modulator_send_data(fsk_modulator_t *fsk_trans)
353 {
354 size_t r = 0;
355 int8_t bit = 0;
356
357 while((bit = bitstream_get_bit(&fsk_trans->bs)) > -1) {
358 if ((r = fsk_modulator_generate_bit(fsk_trans, bit, fsk_trans->sample_buffer, sizeof(fsk_trans->sample_buffer) / 2))) {
359 if (fsk_trans->write_sample_callback(fsk_trans->sample_buffer, r, fsk_trans->user_data) != SWITCH_STATUS_SUCCESS) {
360 break;
361 }
362 } else {
363 break;
364 }
365 }
366 }
367
368
fsk_modulator_init(fsk_modulator_t * fsk_trans,fsk_modem_types_t modem_type,uint32_t sample_rate,fsk_data_state_t * fsk_data,float db_level,uint32_t carrier_bits_start,uint32_t carrier_bits_stop,uint32_t chan_sieze_bits,fsk_write_sample_t write_sample_callback,void * user_data)369 switch_status_t fsk_modulator_init(fsk_modulator_t *fsk_trans,
370 fsk_modem_types_t modem_type,
371 uint32_t sample_rate,
372 fsk_data_state_t *fsk_data,
373 float db_level,
374 uint32_t carrier_bits_start,
375 uint32_t carrier_bits_stop,
376 uint32_t chan_sieze_bits,
377 fsk_write_sample_t write_sample_callback,
378 void *user_data)
379 {
380 memset(fsk_trans, 0, sizeof(*fsk_trans));
381 fsk_trans->modem_type = modem_type;
382 teletone_dds_state_set_tone(&fsk_trans->dds, fsk_modem_definitions[fsk_trans->modem_type].freq_space, sample_rate, 0);
383 teletone_dds_state_set_tone(&fsk_trans->dds, fsk_modem_definitions[fsk_trans->modem_type].freq_mark, sample_rate, 1);
384 fsk_trans->bit_factor = (uint32_t)((fsk_modem_definitions[fsk_trans->modem_type].baud_rate * FSK_MOD_FACTOR) / (float)sample_rate);
385 fsk_trans->samples_per_bit = (uint32_t) (sample_rate / fsk_modem_definitions[fsk_trans->modem_type].baud_rate);
386 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));
387 fsk_trans->bit_accum = 0;
388 fsk_trans->fsk_data = fsk_data;
389 teletone_dds_state_set_tx_level(&fsk_trans->dds, db_level);
390 bitstream_init(&fsk_trans->bs, fsk_trans->fsk_data->buf, (uint32_t)fsk_trans->fsk_data->dlen, ENDIAN_BIG, 1);
391 fsk_trans->carrier_bits_start = carrier_bits_start;
392 fsk_trans->carrier_bits_stop = carrier_bits_stop;
393 fsk_trans->chan_sieze_bits = chan_sieze_bits;
394 fsk_trans->write_sample_callback = write_sample_callback;
395 fsk_trans->user_data = user_data;
396 return SWITCH_STATUS_SUCCESS;
397 }
398
399