root/src/include/private/ftdm_core.h

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

INCLUDED FROM


DEFINITIONS

This source file includes following definitions.
  1. ftdm_clean_string
  2. FT_DECLARE
  3. ftdm_abort
  4. ftdm_set_state_all
  5. ftdm_check_state_all
  6. ftdm_set_flag_all
  7. ftdm_clear_flag_all
  8. ftdm_saturated_add

   1 /*
   2  * Copyright (c) 2010, Sangoma Technologies
   3  * Moises Silva <moy@sangoma.com>
   4  * All rights reserved.
   5  * 
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 
  10  * * Redistributions of source code must retain the above copyright
  11  * notice, this list of conditions and the following disclaimer.
  12  * 
  13  * * Redistributions in binary form must reproduce the above copyright
  14  * notice, this list of conditions and the following disclaimer in the
  15  * documentation and/or other materials provided with the distribution.
  16  * 
  17  * * Neither the name of the original author; nor the names of any contributors
  18  * may be used to endorse or promote products derived from this software
  19  * without specific prior written permission.
  20  * 
  21  * 
  22  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  23  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  24  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  25  * A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER
  26  * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  27  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  28  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  29  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  30  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  31  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  32  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  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)                  /* VC8+ */
  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 /* disable warning for zero length array in a struct */
  81 /* this will cause errors on c99 and ansi compliant compilers and will need to be fixed in the wanpipe header files */
  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   \brief Test for the existance of a flag on an arbitary object
 141   \command obj the object to test
 142   \command flag the or'd list of flags to test
 143   \return true value if the object has the flags defined
 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   \brief Set a flag on an arbitrary object
 155   \command obj the object to set the flags on
 156   \command flag the or'd list of flags to set
 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   \brief Clear a flag on an arbitrary object while locked
 178   \command obj the object to test
 179   \command flag the or'd list of flags to clear
 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 /* The while(0) below throws a conditional expression is constant warning */
 206 #pragma warning(disable:4127) 
 207 #endif
 208 
 209 /* this macro assumes obj is locked! */
 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   \brief Copy flags from one arbitrary object to another
 227   \command dest the object to copy the flags to
 228   \command src the object to copy the flags from
 229   \command flags the flags to copy
 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 /*! brief create a new queue */
 259 #define ftdm_queue_create(queue, capacity) g_ftdm_queue_handler.create(queue, capacity)
 260 
 261 /*! Enqueue an object */
 262 #define ftdm_queue_enqueue(queue, obj) g_ftdm_queue_handler.enqueue(queue, obj)
 263 
 264 /*! dequeue an object from the queue */
 265 #define ftdm_queue_dequeue(queue) g_ftdm_queue_handler.dequeue(queue)
 266 
 267 /*! wait ms milliseconds for a queue to have available objects, -1 to wait forever */
 268 #define ftdm_queue_wait(queue, ms) g_ftdm_queue_handler.wait(queue, ms)
 269 
 270 /*! get the internal interrupt object (to wait for elements to be added from the outside bypassing ftdm_queue_wait) */
 271 #define ftdm_queue_get_interrupt(queue, ms) g_ftdm_queue_handler.get_interrupt(queue, ms)
 272 
 273 /*! destroy the queue */ 
 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 /* number of bytes for the circular buffer (5 seconds worth of audio) */
 346 #define DTMF_DEBUG_SIZE 8 * 5000
 347 /* number of 20ms cycles before timeout and close the debug dtmf file (5 seconds) */
 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 /* 2^8 table size, one for each byte (sample) value */
 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  * \brief Retrieves an event from the span
 566  *
 567  * \note
 568  *      This function is non-reentrant and not thread-safe. 
 569  *      The event returned may be modified if the function is called again 
 570  *      from a different thread or even the same. It is recommended to
 571  *      handle events from the same span in a single thread.
 572  *      WARNING: this function used to be public ( in freetdm.h )
 573  *      but since is really of no use to users better keep it here
 574  *
 575  * \param span The span to retrieve the event from
 576  * \param event Pointer to store the pointer to the event
 577  *
 578  * \retval FTDM_SUCCESS success (at least one event available)
 579  * \retval FTDM_TIMEOUT Timed out waiting for events
 580  * \retval FTDM_FAIL failure
 581  */
 582 FT_DECLARE(ftdm_status_t) ftdm_span_next_event(ftdm_span_t *span, ftdm_event_t **event);
 583 
 584 /*! 
 585  * \brief Enqueue a DTMF string into the channel
 586  *
 587  * \param ftdmchan The channel to enqueue the dtmf string to
 588  * \param dtmf null-terminated DTMF string
 589  *
 590  * \retval FTDM_SUCCESS success
 591  * \retval FTDM_FAIL failure
 592  */
 593 FT_DECLARE(ftdm_status_t) ftdm_channel_queue_dtmf(ftdm_channel_t *ftdmchan, const char *dtmf);
 594 
 595 /* dequeue pending signals and notify the user via the span signal callback */
 596 FT_DECLARE(ftdm_status_t) ftdm_span_trigger_signals(const ftdm_span_t *span);
 597 
 598 /*! \brief clear the tone detector state */
 599 FT_DECLARE(void) ftdm_channel_clear_detected_tones(ftdm_channel_t *ftdmchan);
 600 
 601 
 602 /*!
 603   \brief Assert condition
 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   \brief Assert condition and return
 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   \brief Socket the given socket
 628   \command it the socket
 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 /* endif __PRIVATE_FTDM_CORE__ */

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