This source file includes following definitions.
- ftdm_clean_string
- FT_DECLARE
- ftdm_abort
- ftdm_set_state_all
- ftdm_check_state_all
- ftdm_set_flag_all
- ftdm_clear_flag_all
- ftdm_saturated_add
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35 #include "freetdm.h"
36
37 #ifndef __PRIVATE_FTDM_CORE__
38 #define __PRIVATE_FTDM_CORE__
39
40 #if !defined(_XOPEN_SOURCE) && !defined(__FreeBSD__)
41 #define _XOPEN_SOURCE 600
42 #endif
43
44 #ifndef HAVE_STRINGS_H
45 #define HAVE_STRINGS_H 1
46 #endif
47 #ifndef HAVE_SYS_SOCKET_H
48 #define HAVE_SYS_SOCKET_H 1
49 #endif
50
51 #ifdef _MSC_VER
52 #ifndef __inline__
53 #define __inline__ __inline
54 #endif
55 #if (_MSC_VER >= 1400)
56 #ifndef _CRT_SECURE_NO_DEPRECATE
57 #define _CRT_SECURE_NO_DEPRECATE
58 #endif
59 #ifndef _CRT_NONSTDC_NO_DEPRECATE
60 #define _CRT_NONSTDC_NO_DEPRECATE
61 #endif
62 #endif
63 #ifndef strcasecmp
64 #define strcasecmp(s1, s2) _stricmp(s1, s2)
65 #endif
66 #ifndef strncasecmp
67 #define strncasecmp(s1, s2, n) _strnicmp(s1, s2, n)
68 #endif
69 #ifndef snprintf
70 #define snprintf _snprintf
71 #endif
72 #ifndef S_IRUSR
73 #define S_IRUSR _S_IREAD
74 #endif
75 #ifndef S_IWUSR
76 #define S_IWUSR _S_IWRITE
77 #endif
78 #undef HAVE_STRINGS_H
79 #undef HAVE_SYS_SOCKET_H
80
81
82 #pragma warning(disable:4706)
83 #pragma comment(lib, "Winmm")
84 #endif
85
86 #define FTDM_THREAD_STACKSIZE 240 * 1024
87 #define FTDM_ENUM_NAMES(_NAME, _STRINGS) static const char * _NAME [] = { _STRINGS , NULL };
88
89 #define ftdm_true(expr) \
90 (expr && ( !strcasecmp(expr, "yes") || \
91 !strcasecmp(expr, "on") || \
92 !strcasecmp(expr, "true") || \
93 !strcasecmp(expr, "enabled") || \
94 !strcasecmp(expr, "active") || \
95 atoi(expr))) ? 1 : 0
96
97
98
99 #include <time.h>
100 #ifndef __WINDOWS__
101 #include <sys/time.h>
102 #endif
103
104 #include <stdio.h>
105 #include <stdlib.h>
106 #include <string.h>
107 #ifdef HAVE_STRINGS_H
108 #include <strings.h>
109 #endif
110 #include <assert.h>
111
112 #include "ftdm_types.h"
113 #include "hashtable.h"
114 #include "ftdm_config.h"
115 #include "g711.h"
116 #include "libteletone.h"
117 #include "ftdm_buffer.h"
118 #include "ftdm_threadmutex.h"
119 #include "ftdm_sched.h"
120 #include "ftdm_call_utils.h"
121
122 #ifdef __cplusplus
123 extern "C" {
124 #endif
125
126 #define GOTO_STATUS(label,st) status = st; goto label ;
127
128 #define ftdm_copy_string(x,y,z) strncpy(x, y, z - 1)
129 #define ftdm_set_string(x,y) strncpy(x, y, sizeof(x)-1)
130 #define ftdm_strlen_zero(s) (!s || *s == '\0')
131 #define ftdm_strlen_zero_buf(s) (*s == '\0')
132
133
134 #define ftdm_channel_test_feature(obj, flag) ((obj)->features & flag)
135 #define ftdm_channel_set_feature(obj, flag) (obj)->features |= (flag)
136 #define ftdm_channel_clear_feature(obj, flag) (obj)->features &= ~(flag)
137 #define ftdm_channel_set_member_locked(obj, _m, _v) ftdm_mutex_lock(obj->mutex); obj->_m = _v; ftdm_mutex_unlock(obj->mutex)
138
139
140
141
142
143
144
145 #define ftdm_test_flag(obj, flag) ((obj)->flags & flag)
146 #define ftdm_test_pflag(obj, flag) ((obj)->pflags & flag)
147 #define ftdm_test_sflag(obj, flag) ((obj)->sflags & flag)
148
149 #define ftdm_set_alarm_flag(obj, flag) (obj)->alarm_flags |= (flag)
150 #define ftdm_clear_alarm_flag(obj, flag) (obj)->alarm_flags &= ~(flag)
151 #define ftdm_test_alarm_flag(obj, flag) ((obj)->alarm_flags & flag)
152
153
154
155
156
157
158 #define ftdm_set_flag(obj, flag) (obj)->flags |= (flag)
159 #define ftdm_set_flag_locked(obj, flag) assert(obj->mutex != NULL); \
160 ftdm_mutex_lock(obj->mutex); \
161 (obj)->flags |= (flag); \
162 ftdm_mutex_unlock(obj->mutex);
163
164 #define ftdm_set_pflag(obj, flag) (obj)->pflags |= (flag)
165 #define ftdm_set_pflag_locked(obj, flag) assert(obj->mutex != NULL); \
166 ftdm_mutex_lock(obj->mutex); \
167 (obj)->pflags |= (flag); \
168 ftdm_mutex_unlock(obj->mutex);
169
170 #define ftdm_set_sflag(obj, flag) (obj)->sflags |= (flag)
171 #define ftdm_set_sflag_locked(obj, flag) assert(obj->mutex != NULL); \
172 ftdm_mutex_lock(obj->mutex); \
173 (obj)->sflags |= (flag); \
174 ftdm_mutex_unlock(obj->mutex);
175
176
177
178
179
180
181 #define ftdm_clear_flag(obj, flag) (obj)->flags &= ~(flag)
182
183 #define ftdm_clear_flag_locked(obj, flag) assert(obj->mutex != NULL); ftdm_mutex_lock(obj->mutex); (obj)->flags &= ~(flag); ftdm_mutex_unlock(obj->mutex);
184
185 #define ftdm_clear_pflag(obj, flag) (obj)->pflags &= ~(flag)
186
187 #define ftdm_clear_pflag_locked(obj, flag) assert(obj->mutex != NULL); ftdm_mutex_lock(obj->mutex); (obj)->pflags &= ~(flag); ftdm_mutex_unlock(obj->mutex);
188
189 #define ftdm_clear_sflag(obj, flag) (obj)->sflags &= ~(flag)
190
191 #define ftdm_clear_sflag_locked(obj, flag) assert(obj->mutex != NULL); ftdm_mutex_lock(obj->mutex); (obj)->sflags &= ~(flag); ftdm_mutex_unlock(obj->mutex);
192
193 #define ftdm_set_state(obj, s) ftdm_channel_set_state(__FILE__, __FUNCTION__, __LINE__, obj, s, 0); \
194
195 #define ftdm_set_state_locked(obj, s) \
196 do { \
197 ftdm_channel_lock(obj); \
198 ftdm_channel_set_state(__FILE__, __FUNCTION__, __LINE__, obj, s, 0); \
199 ftdm_channel_unlock(obj); \
200 } while(0);
201
202 #define ftdm_set_state_r(obj, s, r) r = ftdm_channel_set_state(__FILE__, __FUNCTION__, __LINE__, obj, s, 0);
203
204 #ifdef _MSC_VER
205
206 #pragma warning(disable:4127)
207 #endif
208
209
210 #define ftdm_wait_for_flag_cleared(obj, flag, time) \
211 do { \
212 int __safety = time; \
213 while(__safety-- && ftdm_test_flag(obj, flag)) { \
214 ftdm_mutex_unlock(obj->mutex); \
215 ftdm_sleep(10); \
216 ftdm_mutex_lock(obj->mutex); \
217 } \
218 if(!__safety) { \
219 ftdm_log(FTDM_LOG_CRIT, "flag %d was never cleared\n", flag); \
220 } \
221 } while(0);
222
223 #define ftdm_is_dtmf(key) ((key > 47 && key < 58) || (key > 64 && key < 69) || (key > 96 && key < 101) || key == 35 || key == 42 || key == 87 || key == 119)
224
225
226
227
228
229
230
231 #define ftdm_copy_flags(dest, src, flags) (dest)->flags &= ~(flags); (dest)->flags |= ((src)->flags & (flags))
232
233 struct ftdm_stream_handle {
234 ftdm_stream_handle_write_function_t write_function;
235 ftdm_stream_handle_raw_write_function_t raw_write_function;
236 void *data;
237 void *end;
238 ftdm_size_t data_size;
239 ftdm_size_t data_len;
240 ftdm_size_t alloc_len;
241 ftdm_size_t alloc_chunk;
242 };
243
244 FT_DECLARE_NONSTD(ftdm_status_t) ftdm_console_stream_raw_write(ftdm_stream_handle_t *handle, uint8_t *data, ftdm_size_t datalen);
245 FT_DECLARE_NONSTD(ftdm_status_t) ftdm_console_stream_write(ftdm_stream_handle_t *handle, const char *fmt, ...);
246
247 #define FTDM_CMD_CHUNK_LEN 1024
248 #define FTDM_STANDARD_STREAM(s) memset(&s, 0, sizeof(s)); s.data = ftdm_malloc(FTDM_CMD_CHUNK_LEN); \
249 assert(s.data); \
250 memset(s.data, 0, FTDM_CMD_CHUNK_LEN); \
251 s.end = s.data; \
252 s.data_size = FTDM_CMD_CHUNK_LEN; \
253 s.write_function = ftdm_console_stream_write; \
254 s.raw_write_function = ftdm_console_stream_raw_write; \
255 s.alloc_len = FTDM_CMD_CHUNK_LEN; \
256 s.alloc_chunk = FTDM_CMD_CHUNK_LEN
257
258
259 #define ftdm_queue_create(queue, capacity) g_ftdm_queue_handler.create(queue, capacity)
260
261
262 #define ftdm_queue_enqueue(queue, obj) g_ftdm_queue_handler.enqueue(queue, obj)
263
264
265 #define ftdm_queue_dequeue(queue) g_ftdm_queue_handler.dequeue(queue)
266
267
268 #define ftdm_queue_wait(queue, ms) g_ftdm_queue_handler.wait(queue, ms)
269
270
271 #define ftdm_queue_get_interrupt(queue, ms) g_ftdm_queue_handler.get_interrupt(queue, ms)
272
273
274 #define ftdm_queue_destroy(queue) g_ftdm_queue_handler.destroy(queue)
275
276 FT_DECLARE_DATA extern ftdm_queue_handler_t g_ftdm_queue_handler;
277
278 #define FTDM_TOKEN_STRLEN 128
279 #define FTDM_MAX_TOKENS 10
280
281 static __inline__ char *ftdm_clean_string(char *s)
282 {
283 char *p;
284
285 for (p = s; p && *p; p++) {
286 uint8_t x = (uint8_t) *p;
287 if (x < 32 || x > 127) {
288 *p = ' ';
289 }
290 }
291
292 return s;
293 }
294
295 struct ftdm_bitstream {
296 uint8_t *data;
297 uint32_t datalen;
298 uint32_t byte_index;
299 uint8_t bit_index;
300 int8_t endian;
301 uint8_t top;
302 uint8_t bot;
303 uint8_t ss;
304 uint8_t ssv;
305 };
306
307 struct ftdm_fsk_data_state {
308 dsp_fsk_handle_t *fsk1200_handle;
309 uint8_t init;
310 uint8_t *buf;
311 size_t bufsize;
312 ftdm_size_t blen;
313 ftdm_size_t bpos;
314 ftdm_size_t dlen;
315 ftdm_size_t ppos;
316 int checksum;
317 };
318
319 struct ftdm_fsk_modulator {
320 teletone_dds_state_t dds;
321 ftdm_bitstream_t bs;
322 uint32_t carrier_bits_start;
323 uint32_t carrier_bits_stop;
324 uint32_t chan_sieze_bits;
325 uint32_t bit_factor;
326 uint32_t bit_accum;
327 uint32_t sample_counter;
328 int32_t samples_per_bit;
329 int32_t est_bytes;
330 fsk_modem_types_t modem_type;
331 ftdm_fsk_data_state_t *fsk_data;
332 ftdm_fsk_write_sample_t write_sample_callback;
333 void *user_data;
334 int16_t sample_buffer[64];
335 };
336
337
338 typedef enum {
339 FTDM_TYPE_NONE,
340 FTDM_TYPE_SPAN = 0xFF,
341 FTDM_TYPE_CHANNEL
342 } ftdm_data_type_t;
343
344 #ifdef FTDM_DEBUG_DTMF
345
346 #define DTMF_DEBUG_SIZE 8 * 5000
347
348 #define DTMF_DEBUG_TIMEOUT 250
349 typedef struct {
350 FILE *file;
351 char buffer[DTMF_DEBUG_SIZE];
352 int windex;
353 int wrapped;
354 int closetimeout;
355 ftdm_mutex_t *mutex;
356 } ftdm_dtmf_debug_t;
357 #endif
358
359 typedef struct {
360 const char *file;
361 const char *func;
362 int line;
363 ftdm_channel_state_t state;
364 ftdm_channel_state_t last_state;
365 ftdm_time_t time;
366 } ftdm_channel_history_entry_t;
367
368
369 #define FTDM_GAINS_TABLE_SIZE 256
370 struct ftdm_channel {
371 ftdm_data_type_t data_type;
372 uint32_t span_id;
373 uint32_t chan_id;
374 uint32_t physical_span_id;
375 uint32_t physical_chan_id;
376 uint32_t rate;
377 uint32_t extra_id;
378 ftdm_chan_type_t type;
379 ftdm_socket_t sockfd;
380 uint32_t flags;
381 uint32_t pflags;
382 uint32_t sflags;
383 ftdm_alarm_flag_t alarm_flags;
384 ftdm_channel_feature_t features;
385 ftdm_codec_t effective_codec;
386 ftdm_codec_t native_codec;
387 uint32_t effective_interval;
388 uint32_t native_interval;
389 uint32_t packet_len;
390 ftdm_channel_state_t state;
391 ftdm_channel_state_t last_state;
392 ftdm_channel_state_t init_state;
393 ftdm_channel_history_entry_t history[10];
394 uint8_t hindex;
395 ftdm_mutex_t *mutex;
396 teletone_dtmf_detect_state_t dtmf_detect;
397 uint32_t buffer_delay;
398 ftdm_event_t event_header;
399 char last_error[256];
400 fio_event_cb_t event_callback;
401 uint32_t skip_read_frames;
402 ftdm_buffer_t *dtmf_buffer;
403 ftdm_buffer_t *gen_dtmf_buffer;
404 ftdm_buffer_t *pre_buffer;
405 ftdm_buffer_t *digit_buffer;
406 ftdm_buffer_t *fsk_buffer;
407 ftdm_mutex_t *pre_buffer_mutex;
408 uint32_t dtmf_on;
409 uint32_t dtmf_off;
410 char *dtmf_hangup_buf;
411 teletone_generation_session_t tone_session;
412 ftdm_time_t last_event_time;
413 ftdm_time_t ring_time;
414 char tokens[FTDM_MAX_TOKENS+1][FTDM_TOKEN_STRLEN];
415 uint8_t needed_tones[FTDM_TONEMAP_INVALID];
416 uint8_t detected_tones[FTDM_TONEMAP_INVALID];
417 ftdm_tonemap_t last_detected_tone;
418 uint32_t token_count;
419 char chan_name[128];
420 char chan_number[32];
421 ftdm_filehandle_t fds[2];
422 ftdm_fsk_data_state_t fsk;
423 uint8_t fsk_buf[80];
424 uint32_t ring_count;
425 void *mod_data;
426 void *call_data;
427 struct ftdm_caller_data caller_data;
428 struct ftdm_span *span;
429 struct ftdm_io_interface *fio;
430 ftdm_hash_t *variable_hash;
431 unsigned char rx_cas_bits;
432 uint32_t pre_buffer_size;
433 uint8_t rxgain_table[FTDM_GAINS_TABLE_SIZE];
434 uint8_t txgain_table[FTDM_GAINS_TABLE_SIZE];
435 float rxgain;
436 float txgain;
437 int availability_rate;
438 void *user_private;
439 ftdm_timer_id_t hangup_timer;
440 #ifdef FTDM_DEBUG_DTMF
441 ftdm_dtmf_debug_t dtmfdbg;
442 #endif
443 };
444
445 struct ftdm_span {
446 ftdm_data_type_t data_type;
447 char *name;
448 uint32_t span_id;
449 uint32_t chan_count;
450 ftdm_span_flag_t flags;
451 struct ftdm_io_interface *fio;
452 fio_event_cb_t event_callback;
453 ftdm_mutex_t *mutex;
454 ftdm_trunk_type_t trunk_type;
455 ftdm_analog_start_type_t start_type;
456 ftdm_signal_type_t signal_type;
457 void *signal_data;
458 fio_signal_cb_t signal_cb;
459 ftdm_event_t event_header;
460 char last_error[256];
461 char tone_map[FTDM_TONEMAP_INVALID+1][FTDM_TONEMAP_LEN];
462 teletone_tone_map_t tone_detect_map[FTDM_TONEMAP_INVALID+1];
463 teletone_multi_tone_t tone_finder[FTDM_TONEMAP_INVALID+1];
464 ftdm_channel_t *channels[FTDM_MAX_CHANNELS_SPAN+1];
465 fio_channel_outgoing_call_t outgoing_call;
466 fio_channel_set_sig_status_t set_channel_sig_status;
467 fio_channel_get_sig_status_t get_channel_sig_status;
468 fio_span_set_sig_status_t set_span_sig_status;
469 fio_span_get_sig_status_t get_span_sig_status;
470 fio_channel_request_t channel_request;
471 ftdm_span_start_t start;
472 ftdm_span_stop_t stop;
473 ftdm_channel_sig_read_t sig_read;
474 void *mod_data;
475 char *type;
476 char *dtmf_hangup;
477 size_t dtmf_hangup_len;
478 ftdm_state_map_t *state_map;
479 ftdm_caller_data_t default_caller_data;
480 ftdm_queue_t *pendingchans;
481 ftdm_queue_t *pendingsignals;
482 struct ftdm_span *next;
483 };
484
485 struct ftdm_group {
486 char *name;
487 uint32_t group_id;
488 uint32_t chan_count;
489 ftdm_channel_t *channels[FTDM_MAX_CHANNELS_GROUP];
490 uint32_t last_used_index;
491 ftdm_mutex_t *mutex;
492 struct ftdm_group *next;
493 };
494
495 FT_DECLARE_DATA extern ftdm_crash_policy_t g_ftdm_crash_policy;
496
497 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);
498 FT_DECLARE(int32_t) ftdm_fsk_modulator_generate_carrier_bits(ftdm_fsk_modulator_t *fsk_trans, uint32_t bits);
499 FT_DECLARE(void) ftdm_fsk_modulator_generate_chan_sieze(ftdm_fsk_modulator_t *fsk_trans);
500 FT_DECLARE(void) ftdm_fsk_modulator_send_data(ftdm_fsk_modulator_t *fsk_trans);
501 #define ftdm_fsk_modulator_send_all(_it) ftdm_fsk_modulator_generate_chan_sieze(_it); \
502 ftdm_fsk_modulator_generate_carrier_bits(_it, _it->carrier_bits_start); \
503 ftdm_fsk_modulator_send_data(_it); \
504 ftdm_fsk_modulator_generate_carrier_bits(_it, _it->carrier_bits_stop)
505
506 FT_DECLARE(ftdm_status_t) ftdm_fsk_modulator_init(ftdm_fsk_modulator_t *fsk_trans,
507 fsk_modem_types_t modem_type,
508 uint32_t sample_rate,
509 ftdm_fsk_data_state_t *fsk_data,
510 float db_level,
511 uint32_t carrier_bits_start,
512 uint32_t carrier_bits_stop,
513 uint32_t chan_sieze_bits,
514 ftdm_fsk_write_sample_t write_sample_callback,
515 void *user_data);
516 FT_DECLARE(int8_t) ftdm_bitstream_get_bit(ftdm_bitstream_t *bsp);
517 FT_DECLARE(void) ftdm_bitstream_init(ftdm_bitstream_t *bsp, uint8_t *data, uint32_t datalen, ftdm_endian_t endian, uint8_t ss);
518 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);
519 FT_DECLARE(ftdm_status_t) ftdm_fsk_demod_feed(ftdm_fsk_data_state_t *state, int16_t *data, size_t samples);
520 FT_DECLARE(ftdm_status_t) ftdm_fsk_demod_destroy(ftdm_fsk_data_state_t *state);
521 FT_DECLARE(int) ftdm_fsk_demod_init(ftdm_fsk_data_state_t *state, int rate, uint8_t *buf, size_t bufsize);
522 FT_DECLARE(ftdm_status_t) ftdm_fsk_data_init(ftdm_fsk_data_state_t *state, uint8_t *data, uint32_t datalen);
523 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);
524 FT_DECLARE(ftdm_status_t) ftdm_fsk_data_add_checksum(ftdm_fsk_data_state_t *state);
525 FT_DECLARE(ftdm_status_t) ftdm_fsk_data_add_sdmf(ftdm_fsk_data_state_t *state, const char *date, char *number);
526 FT_DECLARE(ftdm_status_t) ftdm_channel_send_fsk_data(ftdm_channel_t *ftdmchan, ftdm_fsk_data_state_t *fsk_data, float db_level);
527
528 FT_DECLARE(ftdm_status_t) ftdm_channel_set_state(const char *file, const char *func, int line,
529 ftdm_channel_t *ftdmchan, ftdm_channel_state_t state, int wait);
530
531 FT_DECLARE(ftdm_status_t) ftdm_span_load_tones(ftdm_span_t *span, const char *mapname);
532 FT_DECLARE(ftdm_time_t) ftdm_current_time_in_ms(void);
533
534 FT_DECLARE(ftdm_status_t) ftdm_channel_use(ftdm_channel_t *ftdmchan);
535
536 FT_DECLARE(void) ftdm_generate_sln_silence(int16_t *data, uint32_t samples, uint32_t divisor);
537
538 FT_DECLARE(uint32_t) ftdm_separate_string(char *buf, char delim, char **array, int arraylen);
539 FT_DECLARE(void) print_bits(uint8_t *b, int bl, char *buf, int blen, int e, uint8_t ss);
540 FT_DECLARE(void) print_hex_bytes(uint8_t *data, ftdm_size_t dlen, char *buf, ftdm_size_t blen);
541
542 FT_DECLARE_NONSTD(int) ftdm_hash_equalkeys(void *k1, void *k2);
543 FT_DECLARE_NONSTD(uint32_t) ftdm_hash_hashfromstring(void *ky);
544
545 FT_DECLARE(ftdm_status_t) ftdm_channel_complete_state(ftdm_channel_t *ftdmchan);
546
547 FT_DECLARE(int) ftdm_load_modules(void);
548
549 FT_DECLARE(ftdm_status_t) ftdm_unload_modules(void);
550
551 FT_DECLARE(ftdm_status_t) ftdm_span_send_signal(ftdm_span_t *span, ftdm_sigmsg_t *sigmsg);
552
553 FT_DECLARE(void) ftdm_channel_clear_needed_tones(ftdm_channel_t *ftdmchan);
554 FT_DECLARE(void) ftdm_channel_rotate_tokens(ftdm_channel_t *ftdmchan);
555
556 FT_DECLARE(int) ftdm_load_module(const char *name);
557 FT_DECLARE(int) ftdm_load_module_assume(const char *name);
558 FT_DECLARE(int) ftdm_vasprintf(char **ret, const char *fmt, va_list ap);
559 FT_DECLARE(ftdm_status_t) ftdm_channel_done(ftdm_channel_t *ftdmchan);
560
561 FT_DECLARE(ftdm_status_t) ftdm_span_close_all(void);
562 FT_DECLARE(ftdm_status_t) ftdm_channel_open_chan(ftdm_channel_t *ftdmchan);
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582 FT_DECLARE(ftdm_status_t) ftdm_span_next_event(ftdm_span_t *span, ftdm_event_t **event);
583
584
585
586
587
588
589
590
591
592
593 FT_DECLARE(ftdm_status_t) ftdm_channel_queue_dtmf(ftdm_channel_t *ftdmchan, const char *dtmf);
594
595
596 FT_DECLARE(ftdm_status_t) ftdm_span_trigger_signals(const ftdm_span_t *span);
597
598
599 FT_DECLARE(void) ftdm_channel_clear_detected_tones(ftdm_channel_t *ftdmchan);
600
601
602
603
604
605 #define ftdm_assert(assertion, msg) \
606 if (!(assertion)) { \
607 ftdm_log(FTDM_LOG_CRIT, msg); \
608 if (g_ftdm_crash_policy & FTDM_CRASH_ON_ASSERT) { \
609 ftdm_abort(); \
610 } \
611 }
612
613
614
615
616 #define ftdm_assert_return(assertion, retval, msg) \
617 if (!(assertion)) { \
618 ftdm_log(FTDM_LOG_CRIT, msg); \
619 if (g_ftdm_crash_policy & FTDM_CRASH_ON_ASSERT) { \
620 ftdm_abort(); \
621 } else { \
622 return retval; \
623 } \
624 }
625
626
627
628
629
630 #define ftdm_socket_close(it) if (it > -1) { close(it); it = -1;}
631
632 #define ftdm_channel_lock(chan) ftdm_mutex_lock(chan->mutex)
633 #define ftdm_channel_unlock(chan) ftdm_mutex_unlock(chan->mutex)
634 #define ftdm_log_chan_ex(fchan, file, func, line, level, format, ...) ftdm_log(file, func, line, level, "[s%dc%d][%d:%d] " format, fchan->span_id, fchan->chan_id, fchan->physical_span_id, fchan->physical_chan_id, __VA_ARGS__)
635 #define ftdm_log_chan(fchan, level, format, ...) ftdm_log(level, "[s%dc%d][%d:%d] " format, fchan->span_id, fchan->chan_id, fchan->physical_span_id, fchan->physical_chan_id, __VA_ARGS__)
636 #define ftdm_log_chan_msg(fchan, level, msg) ftdm_log(level, "[s%dc%d][%d:%d] " msg, fchan->span_id, fchan->chan_id, fchan->physical_span_id, fchan->physical_chan_id)
637
638 #define ftdm_span_lock(span) ftdm_mutex_lock(span->mutex)
639 #define ftdm_span_unlock(span) ftdm_mutex_unlock(span->mutex)
640
641 FT_DECLARE_DATA extern const char *FTDM_LEVEL_NAMES[9];
642
643 static __inline__ void ftdm_abort(void)
644 {
645 #ifdef __cplusplus
646 ::abort();
647 #else
648 abort();
649 #endif
650 }
651
652 static __inline__ void ftdm_set_state_all(ftdm_span_t *span, ftdm_channel_state_t state)
653 {
654 uint32_t j;
655 ftdm_mutex_lock(span->mutex);
656 for(j = 1; j <= span->chan_count; j++) {
657 if (!FTDM_IS_DCHAN(span->channels[j])) {
658 ftdm_set_state_locked((span->channels[j]), state);
659 }
660 }
661 ftdm_mutex_unlock(span->mutex);
662 }
663
664 static __inline__ int ftdm_check_state_all(ftdm_span_t *span, ftdm_channel_state_t state)
665 {
666 uint32_t j;
667 for(j = 1; j <= span->chan_count; j++) {
668 if (span->channels[j]->state != state || ftdm_test_flag(span->channels[j], FTDM_CHANNEL_STATE_CHANGE)) {
669 return 0;
670 }
671 }
672
673 return 1;
674 }
675
676 static __inline__ void ftdm_set_flag_all(ftdm_span_t *span, uint32_t flag)
677 {
678 uint32_t j;
679 ftdm_mutex_lock(span->mutex);
680 for(j = 1; j <= span->chan_count; j++) {
681 ftdm_set_flag_locked((span->channels[j]), flag);
682 }
683 ftdm_mutex_unlock(span->mutex);
684 }
685
686 static __inline__ void ftdm_clear_flag_all(ftdm_span_t *span, uint32_t flag)
687 {
688 uint32_t j;
689 ftdm_mutex_lock(span->mutex);
690 for(j = 1; j <= span->chan_count; j++) {
691 ftdm_clear_flag_locked((span->channels[j]), flag);
692 }
693 ftdm_mutex_unlock(span->mutex);
694 }
695
696 static __inline__ int16_t ftdm_saturated_add(int16_t sample1, int16_t sample2)
697 {
698 int addres;
699
700 addres = sample1 + sample2;
701 if (addres > 32767)
702 addres = 32767;
703 else if (addres < -32767)
704 addres = -32767;
705 return (int16_t)addres;
706 }
707
708 #ifdef __cplusplus
709 }
710 #endif
711
712 #endif