start API cleanup by moving private headers and data structures into private/ include directory

libs/freetdm/src/include/private/fsk.h

@@ -0,0 +1,121 @@
+/*
+ *	bell202.h
+ *
+ *	Copyright (c) 2005 Robert Krten.  All Rights Reserved.
+ *
+ *	Redistribution and use in source and binary forms, with or without
+ *	modification, are permitted provided that the following conditions
+ *	are met:
+ *
+ *	1. Redistributions of source code must retain the above copyright
+ *	   notice, this list of conditions and the following disclaimer.
+ *	2. Redistributions in binary form must reproduce the above copyright
+ *	   notice, this list of conditions and the following disclaimer in the
+ *	   documentation and/or other materials provided with the distribution.
+ *
+ *	THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND
+ *	ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ *	IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ *	ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE
+ *	FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ *	DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ *	OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *	HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ *	LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ *	OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ *	SUCH DAMAGE.
+ *
+ *	This module contains the manifest constants and declarations for
+ *	the Bell-202 1200 baud FSK modem.
+ *
+ *	2005 03 20	R. Krten		created
+*/
+
+#ifndef	__FSK_H__
+#define	__FSK_H__
+#include "uart.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+    int freq_space;		/* Frequency of the 0 bit				*/
+    int freq_mark;		/* Frequency of the 1 bit				*/
+    int baud_rate;		/* baud rate for the modem				*/
+} fsk_modem_definition_t;
+
+/* Must be kept in sync with fsk_modem_definitions array in fsk.c	*/
+/* V.23 definitions: http://www.itu.int/rec/recommendation.asp?type=folders&lang=e&parent=T-REC-V.23 */
+typedef enum {
+    FSK_V23_FORWARD_MODE1 = 0,	/* Maximum 600 bps for long haul	*/
+    FSK_V23_FORWARD_MODE2,		/* Standard 1200 bps V.23			*/
+    FSK_V23_BACKWARD,			/* 75 bps return path for V.23		*/
+    FSK_BELL202					/* Bell 202 half-duplex 1200 bps	*/
+} fsk_modem_types_t;
+
+typedef enum {
+	FSK_STATE_CHANSEIZE = 0,
+	FSK_STATE_CARRIERSIG,
+	FSK_STATE_DATA
+} fsk_state_t;
+
+typedef struct dsp_fsk_attr_s
+{
+	int					sample_rate;					/* sample rate in HZ */
+	bithandler_func_t	bithandler;						/* bit handler */
+	void				*bithandler_arg;				/* arbitrary ID passed to bithandler as first argument */
+	bytehandler_func_t	bytehandler;					/* byte handler */
+	void				*bytehandler_arg;				/* arbitrary ID passed to bytehandler as first argument */
+}	dsp_fsk_attr_t;
+
+typedef struct
+{
+	fsk_state_t			state;
+	dsp_fsk_attr_t		attr;							/* attributes structure */
+	double				*correlates[4];					/* one for each of sin/cos for mark/space */
+	int					corrsize;						/* correlate size (also number of samples in ring buffer) */
+	double				*buffer;						/* sample ring buffer */
+	int					ringstart;						/* ring buffer start offset */
+	double				cellpos;						/* bit cell position */
+	double				celladj;						/* bit cell adjustment for each sample */
+	int					previous_bit;					/* previous bit (for detecting a transition to sync-up cell position) */
+	int					current_bit;					/* current bit */
+	int					last_bit;
+	int					downsampling_count;				/* number of samples to skip */
+	int					current_downsample;				/* current skip count */
+	int					conscutive_state_bits;			/* number of bits in a row that matches the pattern for the current state */
+}	dsp_fsk_handle_t;
+
+/*
+ *	Function prototypes
+ *
+ *	General calling order is:
+ *		a) create the attributes structure (dsp_fsk_attr_init)
+ *		b) initialize fields in the attributes structure (dsp_fsk_attr_set_*)
+ *		c) create a Bell-202 handle (dsp_fsk_create)
+ *		d) feed samples through the handler (dsp_fsk_sample)
+*/
+
+void					dsp_fsk_attr_init(dsp_fsk_attr_t *attributes);
+
+bithandler_func_t		dsp_fsk_attr_get_bithandler(dsp_fsk_attr_t *attributes, void **bithandler_arg);
+void					dsp_fsk_attr_set_bithandler(dsp_fsk_attr_t *attributes, bithandler_func_t bithandler, void *bithandler_arg);
+bytehandler_func_t		dsp_fsk_attr_get_bytehandler(dsp_fsk_attr_t *attributes, void **bytehandler_arg);
+void					dsp_fsk_attr_set_bytehandler(dsp_fsk_attr_t *attributes, bytehandler_func_t bytehandler, void *bytehandler_arg);
+int						dsp_fsk_attr_get_samplerate(dsp_fsk_attr_t *attributes);
+int						dsp_fsk_attr_set_samplerate(dsp_fsk_attr_t *attributes, int samplerate);
+
+dsp_fsk_handle_t *	dsp_fsk_create(dsp_fsk_attr_t *attributes);
+void					dsp_fsk_destroy(dsp_fsk_handle_t **handle);
+
+void					dsp_fsk_sample(dsp_fsk_handle_t *handle, double normalized_sample);
+
+extern fsk_modem_definition_t fsk_modem_definitions[];
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+#endif	
+

libs/freetdm/src/include/private/ftdm_buffer.h

@@ -0,0 +1,154 @@
+/*
+ * Copyright (c) 2007, Anthony Minessale II
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 
+ * * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 
+ * * Neither the name of the original author; nor the names of any contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ * 
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER
+ * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef FTDM_BUFFER_H
+#define FTDM_BUFFER_H
+
+#include "freetdm.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @defgroup ftdm_buffer Buffer Routines
+ * @ingroup buffer
+ * The purpose of this module is to make a plain buffering interface that can be used for read/write buffers
+ * throughout the application.
+ * @{
+ */
+struct ftdm_buffer;
+typedef struct ftdm_buffer ftdm_buffer_t;
+
+/*! \brief Allocate a new dynamic ftdm_buffer 
+ * \param buffer returned pointer to the new buffer
+ * \param blocksize length to realloc by as data is added
+ * \param start_len ammount of memory to reserve initially
+ * \param max_len length the buffer is allowed to grow to
+ * \return status
+ */
+FT_DECLARE(ftdm_status_t) ftdm_buffer_create(ftdm_buffer_t **buffer, ftdm_size_t blocksize, ftdm_size_t start_len, ftdm_size_t max_len);
+
+/*! \brief Get the length of a ftdm_buffer_t 
+ * \param buffer any buffer of type ftdm_buffer_t
+ * \return int size of the buffer.
+ */
+FT_DECLARE(ftdm_size_t) ftdm_buffer_len(ftdm_buffer_t *buffer);
+
+/*! \brief Get the freespace of a ftdm_buffer_t 
+ * \param buffer any buffer of type ftdm_buffer_t
+ * \return int freespace in the buffer.
+ */
+FT_DECLARE(ftdm_size_t) ftdm_buffer_freespace(ftdm_buffer_t *buffer);
+
+/*! \brief Get the in use amount of a ftdm_buffer_t 
+ * \param buffer any buffer of type ftdm_buffer_t
+ * \return int ammount of buffer curently in use
+ */
+FT_DECLARE(ftdm_size_t) ftdm_buffer_inuse(ftdm_buffer_t *buffer);
+
+/*! \brief Read data from a ftdm_buffer_t up to the ammount of datalen if it is available.  Remove read data from buffer. 
+ * \param buffer any buffer of type ftdm_buffer_t
+ * \param data pointer to the read data to be returned
+ * \param datalen amount of data to be returned
+ * \return int ammount of data actually read
+ */
+FT_DECLARE(ftdm_size_t) ftdm_buffer_read(ftdm_buffer_t *buffer, void *data, ftdm_size_t datalen);
+
+/*! \brief Read data endlessly from a ftdm_buffer_t 
+ * \param buffer any buffer of type ftdm_buffer_t
+ * \param data pointer to the read data to be returned
+ * \param datalen amount of data to be returned
+ * \return int ammount of data actually read
+ * \note Once you have read all the data from the buffer it will loop around.
+ */
+FT_DECLARE(ftdm_size_t) ftdm_buffer_read_loop(ftdm_buffer_t *buffer, void *data, ftdm_size_t datalen);
+
+/*! \brief Assign a number of loops to read
+ * \param buffer any buffer of type ftdm_buffer_t
+ * \param loops the number of loops (-1 for infinite)
+ */
+FT_DECLARE(void) ftdm_buffer_set_loops(ftdm_buffer_t *buffer, int32_t loops);
+
+/*! \brief Write data into a ftdm_buffer_t up to the length of datalen
+ * \param buffer any buffer of type ftdm_buffer_t
+ * \param data pointer to the data to be written
+ * \param datalen amount of data to be written
+ * \return int amount of buffer used after the write, or 0 if no space available
+ */
+FT_DECLARE(ftdm_size_t) ftdm_buffer_write(ftdm_buffer_t *buffer, const void *data, ftdm_size_t datalen);
+
+/*! \brief Remove data from the buffer
+ * \param buffer any buffer of type ftdm_buffer_t
+ * \param datalen amount of data to be removed
+ * \return int size of buffer, or 0 if unable to toss that much data
+ */
+FT_DECLARE(ftdm_size_t) ftdm_buffer_toss(ftdm_buffer_t *buffer, ftdm_size_t datalen);
+
+/*! \brief Remove all data from the buffer
+ * \param buffer any buffer of type ftdm_buffer_t
+ */
+FT_DECLARE(void) ftdm_buffer_zero(ftdm_buffer_t *buffer);
+
+/*! \brief Destroy the buffer
+ * \param buffer buffer to destroy
+ * \note only neccessary on dynamic buffers (noop on pooled ones)
+ */
+FT_DECLARE(void) ftdm_buffer_destroy(ftdm_buffer_t **buffer);
+
+/*! \brief Seek to offset from the beginning of the buffer
+ * \param buffer buffer to seek
+ * \param datalen offset in bytes
+ * \return new position
+ */
+FT_DECLARE(ftdm_size_t) ftdm_buffer_seek(ftdm_buffer_t *buffer, ftdm_size_t datalen);
+
+/** @} */
+
+FT_DECLARE(ftdm_size_t) ftdm_buffer_zwrite(ftdm_buffer_t *buffer, const void *data, ftdm_size_t datalen);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/* For Emacs:
+ * Local Variables:
+ * mode:c
+ * indent-tabs-mode:t
+ * tab-width:4
+ * c-basic-offset:4
+ * End:
+ * For VIM:
+ * vim:set softtabstop=4 shiftwidth=4 tabstop=4:
+ */

libs/freetdm/src/include/private/ftdm_config.h

@@ -0,0 +1,145 @@
+/*
+ * Copyright (c) 2007, Anthony Minessale II
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 
+ * * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 
+ * * Neither the name of the original author; nor the names of any contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ * 
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER
+ * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/**
+ * @defgroup config Config File Parser
+ * @ingroup config
+ * This module implements a basic interface and file format parser
+ * 
+ * <pre>
+ *
+ * EXAMPLE 
+ * 
+ * [category1]
+ * var1 => val1
+ * var2 => val2
+ * \# lines that begin with \# are comments
+ * \#var3 => val3
+ * </pre>
+ * @{
+ */
+
+#ifndef FTDM_CONFIG_H
+#define FTDM_CONFIG_H
+
+#include "freetdm.h"
+#define FTDM_URL_SEPARATOR "://"
+
+
+#ifdef WIN32
+#define FTDM_PATH_SEPARATOR "\\"
+#ifndef FTDM_CONFIG_DIR
+#define FTDM_CONFIG_DIR "c:\\freetdm"
+#endif
+#define ftdm_is_file_path(file) (*(file +1) == ':' || *file == '/' || strstr(file, SWITCH_URL_SEPARATOR))
+#else
+#define FTDM_PATH_SEPARATOR "/"
+#ifndef FTDM_CONFIG_DIR
+#define FTDM_CONFIG_DIR "/etc/freetdm"
+#endif
+#define ftdm_is_file_path(file) ((*file == '/') || strstr(file, SWITCH_URL_SEPARATOR))
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct ftdm_config ftdm_config_t;
+
+/*! \brief A simple file handle representing an open configuration file **/
+struct ftdm_config {
+	/*! FILE stream buffer to the opened file */
+	FILE *file;
+	/*! path to the file */
+	char path[512];
+	/*! current category */
+	char category[256];
+	/*! current section */
+	char section[256];
+	/*! buffer of current line being read */
+	char buf[1024];
+	/*! current line number in file */
+	int lineno;
+	/*! current category number in file */
+	int catno;
+	/*! current section number in file */
+	int sectno;
+
+	int lockto;
+};
+
+/*!
+  \brief Open a configuration file
+  \param cfg (ftdm_config_t *) config handle to use
+  \param file_path path to the file
+  \return 1 (true) on success 0 (false) on failure
+*/
+int ftdm_config_open_file(ftdm_config_t * cfg, const char *file_path);
+
+/*!
+  \brief Close a previously opened configuration file
+  \param cfg (ftdm_config_t *) config handle to use
+*/
+void ftdm_config_close_file(ftdm_config_t * cfg);
+
+/*!
+  \brief Retrieve next name/value pair from configuration file
+  \param cfg (ftdm_config_t *) config handle to use
+  \param var pointer to aim at the new variable name
+  \param val pointer to aim at the new value
+*/
+int ftdm_config_next_pair(ftdm_config_t * cfg, char **var, char **val);
+
+/*!
+  \brief Retrieve the CAS bits from a configuration string value
+  \param strvalue pointer to the configuration string value (expected to be in format whatever:xxxx)
+  \param outbits pointer to aim at the CAS bits
+*/
+FT_DECLARE (int) ftdm_config_get_cas_bits(char *strvalue, unsigned char *outbits);
+
+#ifdef __cplusplus
+}
+#endif
+
+/** @} */
+#endif
+/* For Emacs:
+ * Local Variables:
+ * mode:c
+ * indent-tabs-mode:t
+ * tab-width:4
+ * c-basic-offset:4
+ * End:
+ * For VIM:
+ * vim:set softtabstop=4 shiftwidth=4 tabstop=4:
+ */

libs/freetdm/src/include/private/ftdm_core.h

@@ -0,0 +1,697 @@
+/*
+ * Copyright (c) 2010, Sangoma Technologies
+ * Moises Silva <moy@sangoma.com>
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 
+ * * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 
+ * * Neither the name of the original author; nor the names of any contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ * 
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER
+ * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __PRIVATE_FTDM_CORE__
+#define __PRIVATE_FTDM_CORE__
+
+#if !defined(_XOPEN_SOURCE) && !defined(__FreeBSD__)
+#define _XOPEN_SOURCE 600
+#endif
+
+#ifndef HAVE_STRINGS_H
+#define HAVE_STRINGS_H 1
+#endif
+#ifndef HAVE_SYS_SOCKET_H
+#define HAVE_SYS_SOCKET_H 1
+#endif
+
+#ifdef _MSC_VER
+#ifndef __inline__
+#define __inline__ __inline
+#endif
+#if (_MSC_VER >= 1400)			/* VC8+ */
+#ifndef _CRT_SECURE_NO_DEPRECATE
+#define _CRT_SECURE_NO_DEPRECATE
+#endif
+#ifndef _CRT_NONSTDC_NO_DEPRECATE
+#define _CRT_NONSTDC_NO_DEPRECATE
+#endif
+#endif
+#ifndef strcasecmp
+#define strcasecmp(s1, s2) _stricmp(s1, s2)
+#endif
+#ifndef strncasecmp
+#define strncasecmp(s1, s2, n) _strnicmp(s1, s2, n)
+#endif
+#ifndef snprintf
+#define snprintf _snprintf
+#endif
+#ifndef S_IRUSR
+#define S_IRUSR _S_IREAD
+#endif
+#ifndef S_IWUSR
+#define S_IWUSR _S_IWRITE
+#endif
+#undef HAVE_STRINGS_H
+#undef HAVE_SYS_SOCKET_H
+/* disable warning for zero length array in a struct */
+/* this will cause errors on c99 and ansi compliant compilers and will need to be fixed in the wanpipe header files */
+#pragma warning(disable:4706)
+#pragma comment(lib, "Winmm")
+#endif
+
+#define FTDM_THREAD_STACKSIZE 240 * 1024
+#define FTDM_ENUM_NAMES(_NAME, _STRINGS) static const char * _NAME [] = { _STRINGS , NULL };
+	
+#define ftdm_true(expr)							\
+	(expr && ( !strcasecmp(expr, "yes") ||		\
+			   !strcasecmp(expr, "on") ||		\
+			   !strcasecmp(expr, "true") ||		\
+			   !strcasecmp(expr, "enabled") ||	\
+			   !strcasecmp(expr, "active") ||	\
+			   atoi(expr))) ? 1 : 0
+
+
+
+#include <time.h>
+#ifndef __WINDOWS__
+#include <sys/time.h>
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#ifdef HAVE_STRINGS_H
+#include <strings.h>
+#endif
+#include <assert.h>
+
+#include "freetdm.h"
+#include "ftdm_types.h"
+#include "hashtable.h"
+#include "ftdm_config.h"
+#include "g711.h"
+#include "libteletone.h"
+#include "ftdm_buffer.h"
+#include "ftdm_threadmutex.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define FTDM_MAX_CHANNELS_PHYSICAL_SPAN 32
+#define FTDM_MAX_PHYSICAL_SPANS_PER_LOGICAL_SPAN 32
+#define FTDM_MAX_CHANNELS_SPAN FTDM_MAX_CHANNELS_PHYSICAL_SPAN * FTDM_MAX_PHYSICAL_SPANS_PER_LOGICAL_SPAN
+#define FTDM_MAX_SPANS_INTERFACE 128
+
+#define FTDM_MAX_CHANNELS_GROUP 1024
+#define FTDM_MAX_GROUPS_INTERFACE FTDM_MAX_SPANS_INTERFACE
+
+#define GOTO_STATUS(label,st) status = st; goto label ;
+
+#define ftdm_copy_string(x,y,z) strncpy(x, y, z - 1) 
+#define ftdm_set_string(x,y) strncpy(x, y, sizeof(x)-1) 
+#define ftdm_strlen_zero(s) (!s || *s == '\0')
+#define ftdm_strlen_zero_buf(s) (*s == '\0')
+
+
+#define ftdm_channel_test_feature(obj, flag) ((obj)->features & flag)
+#define ftdm_channel_set_feature(obj, flag) (obj)->features |= (flag)
+#define ftdm_channel_clear_feature(obj, flag) (obj)->features &= ~(flag)
+#define ftdm_channel_set_member_locked(obj, _m, _v) ftdm_mutex_lock(obj->mutex); obj->_m = _v; ftdm_mutex_unlock(obj->mutex)
+
+/*!
+  \brief Test for the existance of a flag on an arbitary object
+  \command obj the object to test
+  \command flag the or'd list of flags to test
+  \return true value if the object has the flags defined
+*/
+#define ftdm_test_flag(obj, flag) ((obj)->flags & flag)
+#define ftdm_test_pflag(obj, flag) ((obj)->pflags & flag)
+#define ftdm_test_sflag(obj, flag) ((obj)->sflags & flag)
+
+#define ftdm_set_alarm_flag(obj, flag) (obj)->alarm_flags |= (flag)
+#define ftdm_clear_alarm_flag(obj, flag) (obj)->alarm_flags &= ~(flag)
+#define ftdm_test_alarm_flag(obj, flag) ((obj)->alarm_flags & flag)
+
+/*!
+  \brief Set a flag on an arbitrary object
+  \command obj the object to set the flags on
+  \command flag the or'd list of flags to set
+*/
+#define ftdm_set_flag(obj, flag) (obj)->flags |= (flag)
+#define ftdm_set_flag_locked(obj, flag) assert(obj->mutex != NULL);	\
+	ftdm_mutex_lock(obj->mutex);										\
+	(obj)->flags |= (flag);          	   	                        \
+	ftdm_mutex_unlock(obj->mutex);
+
+#define ftdm_set_pflag(obj, flag) (obj)->pflags |= (flag)
+#define ftdm_set_pflag_locked(obj, flag) assert(obj->mutex != NULL);	\
+	ftdm_mutex_lock(obj->mutex);										\
+	(obj)->pflags |= (flag);											\
+	ftdm_mutex_unlock(obj->mutex);
+
+#define ftdm_set_sflag(obj, flag) (obj)->sflags |= (flag)
+#define ftdm_set_sflag_locked(obj, flag) assert(obj->mutex != NULL);	\
+	ftdm_mutex_lock(obj->mutex);										\
+	(obj)->sflags |= (flag);											\
+	ftdm_mutex_unlock(obj->mutex);
+
+/*!
+  \brief Clear a flag on an arbitrary object while locked
+  \command obj the object to test
+  \command flag the or'd list of flags to clear
+*/
+#define ftdm_clear_flag(obj, flag) (obj)->flags &= ~(flag)
+
+#define ftdm_clear_flag_locked(obj, flag) assert(obj->mutex != NULL); ftdm_mutex_lock(obj->mutex); (obj)->flags &= ~(flag); ftdm_mutex_unlock(obj->mutex);
+
+#define ftdm_clear_pflag(obj, flag) (obj)->pflags &= ~(flag)
+
+#define ftdm_clear_pflag_locked(obj, flag) assert(obj->mutex != NULL); ftdm_mutex_lock(obj->mutex); (obj)->pflags &= ~(flag); ftdm_mutex_unlock(obj->mutex);
+
+#define ftdm_clear_sflag(obj, flag) (obj)->sflags &= ~(flag)
+
+#define ftdm_clear_sflag_locked(obj, flag) assert(obj->mutex != NULL); ftdm_mutex_lock(obj->mutex); (obj)->sflags &= ~(flag); ftdm_mutex_unlock(obj->mutex);
+
+
+#define ftdm_set_state_locked(obj, s) if ( obj->state == s ) {			\
+		ftdm_log(FTDM_LOG_WARNING, "Why bother changing state on %d:%d from %s to %s\n", obj->span_id, obj->chan_id, ftdm_channel_state2str(obj->state), ftdm_channel_state2str(s)); \
+	} else if (ftdm_test_flag(obj, FTDM_CHANNEL_READY)) {									\
+		ftdm_channel_state_t st = obj->state;											\
+		ftdm_channel_set_state(obj, s, 1);									\
+		if (obj->state == s) ftdm_log(FTDM_LOG_DEBUG, "Changing state on %d:%d from %s to %s\n", obj->span_id, obj->chan_id, ftdm_channel_state2str(st), ftdm_channel_state2str(s)); \
+		else ftdm_log(FTDM_LOG_WARNING, "VETO Changing state on %d:%d from %s to %s\n", obj->span_id, obj->chan_id, ftdm_channel_state2str(st), ftdm_channel_state2str(s)); \
+	}
+
+#define ftdm_set_state(obj, s) if ( obj->state == s ) {			\
+		ftdm_log(FTDM_LOG_WARNING, "Why bother changing state on %d:%d from %s to %s\n", obj->span_id, obj->chan_id, ftdm_channel_state2str(obj->state), ftdm_channel_state2str(s)); \
+	} else if (ftdm_test_flag(obj, FTDM_CHANNEL_READY)) {									\
+		ftdm_channel_state_t st = obj->state;											\
+		ftdm_channel_set_state(obj, s, 0);									\
+		if (obj->state == s) ftdm_log(FTDM_LOG_DEBUG, "Changing state on %d:%d from %s to %s\n", obj->span_id, obj->chan_id, ftdm_channel_state2str(st), ftdm_channel_state2str(s)); \
+		else ftdm_log(FTDM_LOG_WARNING, "VETO Changing state on %d:%d from %s to %s\n", obj->span_id, obj->chan_id, ftdm_channel_state2str(st), ftdm_channel_state2str(s)); \
+	}
+
+#ifdef _MSC_VER
+/* The while(0) below throws a conditional expression is constant warning */
+#pragma warning(disable:4127) 
+#endif
+
+#define ftdm_set_state_locked_wait(obj, s) 						\
+	do {										\
+		int __safety = 100;							\
+		ftdm_set_state_locked(obj, s);						\
+		while(__safety-- && ftdm_test_flag(obj, FTDM_CHANNEL_STATE_CHANGE)) {	\
+			ftdm_sleep(10);							\
+		}									\
+		if(!__safety) {								\
+			ftdm_log(FTDM_LOG_CRIT, "State change not completed\n");		\
+		}									\
+	} while(0);
+
+#define ftdm_wait_for_flag_cleared(obj, flag, time) 					\
+	do {										\
+		int __safety = time;							\
+		while(__safety-- && ftdm_test_flag(obj, flag)) { 			\
+			ftdm_mutex_unlock(obj->mutex);					\
+			ftdm_sleep(10);							\
+			ftdm_mutex_lock(obj->mutex);					\
+		}									\
+		if(!__safety) {								\
+			ftdm_log(FTDM_LOG_CRIT, "flag %d was never cleared\n", flag);	\
+		}									\
+	} while(0);
+
+#define ftdm_set_state_wait(obj, s) 						\
+	do {										\
+		ftdm_channel_set_state(obj, s, 0);					\
+		ftdm_wait_for_flag_cleared(obj, FTDM_CHANNEL_STATE_CHANGE, 100);     \
+	} while(0);
+
+
+#define ftdm_set_state_r(obj, s, l, r) if ( obj->state == s ) {	\
+		if (s != FTDM_CHANNEL_STATE_HANGUP) ftdm_log(FTDM_LOG_WARNING, "Why bother changing state on %d:%d from %s to %s\n", obj->span_id, obj->chan_id, ftdm_channel_state2str(obj->state), ftdm_channel_state2str(s)); r = FTDM_STATE_CHANGE_SAME; \
+	} else if (ftdm_test_flag(obj, FTDM_CHANNEL_READY)) {					\
+		int st = obj->state;											\
+		r = (ftdm_channel_set_state(obj, s, l) == FTDM_SUCCESS) ? FTDM_STATE_CHANGE_SUCCESS : FTDM_STATE_CHANGE_FAIL; \
+		if (obj->state == s) {ftdm_log(FTDM_LOG_DEBUG, "Changing state on %d:%d from %s to %s\n", obj->span_id, obj->chan_id, ftdm_channel_state2str(st), ftdm_channel_state2str(s));} \
+		else ftdm_log(FTDM_LOG_WARNING, "VETO Changing state on %d:%d from %s to %s\n", obj->span_id, obj->chan_id, ftdm_channel_state2str(st), ftdm_channel_state2str(s)); \
+	}
+
+
+#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)
+
+/*!
+  \brief Copy flags from one arbitrary object to another
+  \command dest the object to copy the flags to
+  \command src the object to copy the flags from
+  \command flags the flags to copy
+*/
+#define ftdm_copy_flags(dest, src, flags) (dest)->flags &= ~(flags);	(dest)->flags |= ((src)->flags & (flags))
+
+struct ftdm_stream_handle {
+	ftdm_stream_handle_write_function_t write_function;
+	ftdm_stream_handle_raw_write_function_t raw_write_function;
+	void *data;
+	void *end;
+	ftdm_size_t data_size;
+	ftdm_size_t data_len;
+	ftdm_size_t alloc_len;
+	ftdm_size_t alloc_chunk;
+};
+
+FT_DECLARE_NONSTD(ftdm_status_t) ftdm_console_stream_raw_write(ftdm_stream_handle_t *handle, uint8_t *data, ftdm_size_t datalen);
+FT_DECLARE_NONSTD(ftdm_status_t) ftdm_console_stream_write(ftdm_stream_handle_t *handle, const char *fmt, ...);
+
+#define FTDM_CMD_CHUNK_LEN 1024
+#define FTDM_STANDARD_STREAM(s) memset(&s, 0, sizeof(s)); s.data = ftdm_malloc(FTDM_CMD_CHUNK_LEN); \
+	assert(s.data);														\
+	memset(s.data, 0, FTDM_CMD_CHUNK_LEN);								\
+	s.end = s.data;														\
+	s.data_size = FTDM_CMD_CHUNK_LEN;									\
+	s.write_function = ftdm_console_stream_write;						\
+	s.raw_write_function = ftdm_console_stream_raw_write;				\
+	s.alloc_len = FTDM_CMD_CHUNK_LEN;									\
+	s.alloc_chunk = FTDM_CMD_CHUNK_LEN
+
+/*! brief create a new queue */
+#define ftdm_queue_create(queue, capacity) g_ftdm_queue_handler.create(queue, capacity)
+
+/*! Enqueue an object */
+#define ftdm_queue_enqueue(queue, obj) g_ftdm_queue_handler.enqueue(queue, obj)
+
+/*! dequeue an object from the queue */
+#define ftdm_queue_dequeue(queue) g_ftdm_queue_handler.dequeue(queue)
+
+/*! wait ms milliseconds for a queue to have available objects, -1 to wait forever */
+#define ftdm_queue_wait(queue, ms) g_ftdm_queue_handler.wait(queue, ms)
+
+/*! get the internal interrupt object (to wait for elements to be added from the outside bypassing ftdm_queue_wait) */
+#define ftdm_queue_get_interrupt(queue, ms) g_ftdm_queue_handler.get_interrupt(queue, ms)
+
+/*! destroy the queue */ 
+#define ftdm_queue_destroy(queue) g_ftdm_queue_handler.destroy(queue)
+
+FT_DECLARE_DATA extern ftdm_queue_handler_t g_ftdm_queue_handler;
+
+#define FTDM_TOKEN_STRLEN 128
+#define FTDM_MAX_TOKENS 10
+
+static __inline__ char *ftdm_clean_string(char *s)
+{
+	char *p;
+
+	for (p = s; p && *p; p++) {
+		uint8_t x = (uint8_t) *p;
+		if (x < 32 || x > 127) {
+			*p = ' ';
+		}
+	}
+
+	return s;
+}
+
+struct ftdm_bitstream {
+	uint8_t *data;
+	uint32_t datalen;
+	uint32_t byte_index;
+	uint8_t bit_index;
+	int8_t endian;
+	uint8_t top;
+	uint8_t bot;
+	uint8_t ss;
+	uint8_t ssv;
+};
+
+struct ftdm_fsk_data_state {
+	dsp_fsk_handle_t *fsk1200_handle;
+	uint8_t init;
+	uint8_t *buf;
+	size_t bufsize;
+	ftdm_size_t blen;
+	ftdm_size_t bpos;
+	ftdm_size_t dlen;
+	ftdm_size_t ppos;
+	int checksum;
+};
+
+struct ftdm_fsk_modulator {
+	teletone_dds_state_t dds;
+	ftdm_bitstream_t bs;
+	uint32_t carrier_bits_start;
+	uint32_t carrier_bits_stop;
+	uint32_t chan_sieze_bits;
+	uint32_t bit_factor;
+	uint32_t bit_accum;
+	uint32_t sample_counter;
+	int32_t samples_per_bit;
+	int32_t est_bytes;
+	fsk_modem_types_t modem_type;
+	ftdm_fsk_data_state_t *fsk_data;
+	ftdm_fsk_write_sample_t write_sample_callback;
+	void *user_data;
+	int16_t sample_buffer[64];
+};
+
+
+typedef enum {
+	FTDM_TYPE_NONE,
+	FTDM_TYPE_SPAN = 0xFF,
+	FTDM_TYPE_CHANNEL
+} ftdm_data_type_t;
+
+/* 2^8 table size, one for each byte (sample) value */
+#define FTDM_GAINS_TABLE_SIZE 256
+struct ftdm_channel {
+	ftdm_data_type_t data_type;
+	uint32_t span_id;
+	uint32_t chan_id;
+	uint32_t physical_span_id;
+	uint32_t physical_chan_id;
+	uint32_t rate;
+	uint32_t extra_id;
+	ftdm_chan_type_t type;
+	ftdm_socket_t sockfd;
+	uint32_t flags;
+	uint32_t pflags;
+	uint32_t sflags;
+	ftdm_alarm_flag_t alarm_flags;
+	ftdm_channel_feature_t features;
+	ftdm_codec_t effective_codec;
+	ftdm_codec_t native_codec;
+	uint32_t effective_interval;
+	uint32_t native_interval;
+	uint32_t packet_len;
+	ftdm_channel_state_t state;
+	ftdm_channel_state_t last_state;
+	ftdm_channel_state_t init_state;
+	ftdm_mutex_t *mutex;
+	teletone_dtmf_detect_state_t dtmf_detect;
+	uint32_t buffer_delay;
+	ftdm_event_t event_header;
+	char last_error[256];
+	fio_event_cb_t event_callback;
+	uint32_t skip_read_frames;
+	ftdm_buffer_t *dtmf_buffer;
+	ftdm_buffer_t *gen_dtmf_buffer;
+	ftdm_buffer_t *pre_buffer;
+	ftdm_buffer_t *digit_buffer;
+	ftdm_buffer_t *fsk_buffer;
+	ftdm_mutex_t *pre_buffer_mutex;
+	uint32_t dtmf_on;
+	uint32_t dtmf_off;
+	char *dtmf_hangup_buf;
+	teletone_generation_session_t tone_session;
+	ftdm_time_t last_event_time;
+	ftdm_time_t ring_time;
+	char tokens[FTDM_MAX_TOKENS+1][FTDM_TOKEN_STRLEN];
+	uint8_t needed_tones[FTDM_TONEMAP_INVALID];
+	uint8_t detected_tones[FTDM_TONEMAP_INVALID];
+	ftdm_tonemap_t last_detected_tone;	
+	uint32_t token_count;
+	char chan_name[128];
+	char chan_number[32];
+	ftdm_filehandle_t fds[2];
+	ftdm_fsk_data_state_t fsk;
+	uint8_t fsk_buf[80];
+	uint32_t ring_count;
+	void *mod_data;
+	void *call_data;
+	struct ftdm_caller_data caller_data;
+	struct ftdm_span *span;
+	struct ftdm_io_interface *fio;
+	ftdm_hash_t *variable_hash;
+	unsigned char rx_cas_bits;
+	uint32_t pre_buffer_size;
+	uint8_t rxgain_table[FTDM_GAINS_TABLE_SIZE];
+	uint8_t txgain_table[FTDM_GAINS_TABLE_SIZE];
+	float rxgain;
+	float txgain;
+};
+
+struct ftdm_span {
+	ftdm_data_type_t data_type;
+	char *name;
+	uint32_t span_id;
+	uint32_t chan_count;
+	ftdm_span_flag_t flags;
+	struct ftdm_io_interface *fio;
+	fio_event_cb_t event_callback;
+	ftdm_mutex_t *mutex;
+	ftdm_trunk_type_t trunk_type;
+	ftdm_analog_start_type_t start_type;
+	ftdm_signal_type_t signal_type;
+	void *signal_data;
+	fio_signal_cb_t signal_cb;
+	ftdm_event_t event_header;
+	char last_error[256];
+	char tone_map[FTDM_TONEMAP_INVALID+1][FTDM_TONEMAP_LEN];
+	teletone_tone_map_t tone_detect_map[FTDM_TONEMAP_INVALID+1];
+	teletone_multi_tone_t tone_finder[FTDM_TONEMAP_INVALID+1];
+	ftdm_channel_t *channels[FTDM_MAX_CHANNELS_SPAN+1];
+	fio_channel_outgoing_call_t outgoing_call;
+	fio_channel_set_sig_status_t set_channel_sig_status;
+	fio_channel_get_sig_status_t get_channel_sig_status;
+	fio_span_set_sig_status_t set_span_sig_status;
+	fio_span_get_sig_status_t get_span_sig_status;
+	fio_channel_request_t channel_request;
+	ftdm_span_start_t start;
+	ftdm_span_stop_t stop;
+	void *mod_data;
+	char *type;
+	char *dtmf_hangup;
+	size_t dtmf_hangup_len;
+	ftdm_state_map_t *state_map;
+	ftdm_caller_data_t default_caller_data;
+	ftdm_queue_t *pendingchans;
+	struct ftdm_span *next;
+};
+
+struct ftdm_group {
+	char *name;
+	uint32_t group_id;
+	uint32_t chan_count;
+	ftdm_channel_t *channels[FTDM_MAX_CHANNELS_GROUP];
+	uint32_t last_used_index;
+	ftdm_mutex_t *mutex;
+	struct ftdm_group *next;
+};
+
+FT_DECLARE_DATA extern ftdm_crash_policy_t g_ftdm_crash_policy;
+
+FT_DECLARE_DATA extern ftdm_memory_handler_t g_ftdm_mem_handler;
+
+/*! \brief Duplicate string */
+FT_DECLARE(char *) ftdm_strdup(const char *str);
+FT_DECLARE(char *) ftdm_strndup(const char *str, ftdm_size_t inlen);
+
+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);
+FT_DECLARE(int32_t) ftdm_fsk_modulator_generate_carrier_bits(ftdm_fsk_modulator_t *fsk_trans, uint32_t bits);
+FT_DECLARE(void) ftdm_fsk_modulator_generate_chan_sieze(ftdm_fsk_modulator_t *fsk_trans);
+FT_DECLARE(void) ftdm_fsk_modulator_send_data(ftdm_fsk_modulator_t *fsk_trans);
+#define ftdm_fsk_modulator_send_all(_it) ftdm_fsk_modulator_generate_chan_sieze(_it); \
+	ftdm_fsk_modulator_generate_carrier_bits(_it, _it->carrier_bits_start); \
+	ftdm_fsk_modulator_send_data(_it); \
+	ftdm_fsk_modulator_generate_carrier_bits(_it, _it->carrier_bits_stop)
+
+FT_DECLARE(ftdm_status_t) ftdm_fsk_modulator_init(ftdm_fsk_modulator_t *fsk_trans,
+									fsk_modem_types_t modem_type,
+									uint32_t sample_rate,
+									ftdm_fsk_data_state_t *fsk_data,
+									float db_level,
+									uint32_t carrier_bits_start,
+									uint32_t carrier_bits_stop,
+									uint32_t chan_sieze_bits,
+									ftdm_fsk_write_sample_t write_sample_callback,
+									void *user_data);
+FT_DECLARE(int8_t) ftdm_bitstream_get_bit(ftdm_bitstream_t *bsp);
+FT_DECLARE(void) ftdm_bitstream_init(ftdm_bitstream_t *bsp, uint8_t *data, uint32_t datalen, ftdm_endian_t endian, uint8_t ss);
+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);
+FT_DECLARE(ftdm_status_t) ftdm_fsk_demod_feed(ftdm_fsk_data_state_t *state, int16_t *data, size_t samples);
+FT_DECLARE(ftdm_status_t) ftdm_fsk_demod_destroy(ftdm_fsk_data_state_t *state);
+FT_DECLARE(int) ftdm_fsk_demod_init(ftdm_fsk_data_state_t *state, int rate, uint8_t *buf, size_t bufsize);
+FT_DECLARE(ftdm_status_t) ftdm_fsk_data_init(ftdm_fsk_data_state_t *state, uint8_t *data, uint32_t datalen);
+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);
+FT_DECLARE(ftdm_status_t) ftdm_fsk_data_add_checksum(ftdm_fsk_data_state_t *state);
+FT_DECLARE(ftdm_status_t) ftdm_fsk_data_add_sdmf(ftdm_fsk_data_state_t *state, const char *date, char *number);
+FT_DECLARE(ftdm_status_t) ftdm_channel_send_fsk_data(ftdm_channel_t *ftdmchan, ftdm_fsk_data_state_t *fsk_data, float db_level);
+
+FT_DECLARE(ftdm_status_t) ftdm_channel_set_state(ftdm_channel_t *ftdmchan, ftdm_channel_state_t state, int lock);
+
+FT_DECLARE(ftdm_status_t) ftdm_span_load_tones(ftdm_span_t *span, const char *mapname);
+FT_DECLARE(ftdm_time_t) ftdm_current_time_in_ms(void);
+FT_DECLARE(ftdm_status_t) ftdm_channel_done(ftdm_channel_t *ftdmchan);
+
+FT_DECLARE(ftdm_status_t) ftdm_channel_use(ftdm_channel_t *ftdmchan);
+
+FT_DECLARE(void) ftdm_generate_sln_silence(int16_t *data, uint32_t samples, uint32_t divisor);
+
+FT_DECLARE(uint32_t) ftdm_separate_string(char *buf, char delim, char **array, int arraylen);
+FT_DECLARE(void) print_bits(uint8_t *b, int bl, char *buf, int blen, int e, uint8_t ss);
+FT_DECLARE(void) print_hex_bytes(uint8_t *data, ftdm_size_t dlen, char *buf, ftdm_size_t blen);
+
+FT_DECLARE_NONSTD(int) ftdm_hash_equalkeys(void *k1, void *k2);
+FT_DECLARE_NONSTD(uint32_t) ftdm_hash_hashfromstring(void *ky);
+
+FT_DECLARE(ftdm_status_t) ftdm_channel_complete_state(ftdm_channel_t *ftdmchan);
+
+FT_DECLARE(int) ftdm_load_modules(void);
+
+FT_DECLARE(ftdm_status_t) ftdm_unload_modules(void);
+
+FT_DECLARE(ftdm_status_t) ftdm_span_send_signal(ftdm_span_t *span, ftdm_sigmsg_t *sigmsg);
+
+FT_DECLARE(char *) ftdm_build_dso_path(const char *name, char *path, ftdm_size_t len);
+
+FT_DECLARE(int) ftdm_load_module(const char *name);
+FT_DECLARE(int) ftdm_load_module_assume(const char *name);
+FT_DECLARE(int) ftdm_vasprintf(char **ret, const char *fmt, va_list ap);
+
+FIO_CODEC_FUNCTION(fio_slin2ulaw);
+FIO_CODEC_FUNCTION(fio_ulaw2slin);
+FIO_CODEC_FUNCTION(fio_slin2alaw);
+FIO_CODEC_FUNCTION(fio_alaw2slin);
+FIO_CODEC_FUNCTION(fio_ulaw2alaw);
+FIO_CODEC_FUNCTION(fio_alaw2ulaw);
+
+/*!
+  \brief Assert condition
+*/
+#define ftdm_assert(assertion, msg) \
+	if (!(assertion)) { \
+		ftdm_log(FTDM_LOG_CRIT, msg); \
+		if (g_ftdm_crash_policy & FTDM_CRASH_ON_ASSERT) { \
+			ftdm_abort();  \
+		} \
+	}
+
+/*!
+  \brief Assert condition and return
+*/
+#define ftdm_assert_return(assertion, retval, msg) \
+	if (!(assertion)) { \
+		ftdm_log(FTDM_LOG_CRIT, msg); \
+		if (g_ftdm_crash_policy & FTDM_CRASH_ON_ASSERT) { \
+			ftdm_abort();  \
+		} else { \
+			return retval; \
+		} \
+	}
+
+/*!
+  \brief Allocate uninitialized memory
+  \command chunksize the chunk size
+*/
+#define ftdm_malloc(chunksize) g_ftdm_mem_handler.malloc(g_ftdm_mem_handler.pool, chunksize)
+
+/*!
+  \brief Reallocates memory
+  \command buff the buffer
+  \command chunksize the chunk size
+*/
+#define ftdm_realloc(buff, chunksize) g_ftdm_mem_handler.realloc(g_ftdm_mem_handler.pool, buff, chunksize)
+
+/*!
+  \brief Allocate initialized memory
+  \command chunksize the chunk size
+*/
+#define ftdm_calloc(elements, chunksize) g_ftdm_mem_handler.calloc(g_ftdm_mem_handler.pool, elements, chunksize)
+
+/*!
+  \brief Free chunk of memory
+  \command chunksize the chunk size
+*/
+#define ftdm_free(chunk) g_ftdm_mem_handler.free(g_ftdm_mem_handler.pool, chunk)
+
+/*!
+  \brief Free a pointer and set it to NULL unless it already is NULL
+  \command it the pointer
+*/
+#define ftdm_safe_free(it) if (it) { ftdm_free(it); it = NULL; }
+
+/*!
+  \brief Socket the given socket
+  \command it the socket
+*/
+#define ftdm_socket_close(it) if (it > -1) { close(it); it = -1;}
+
+#define ftdm_array_len(array) sizeof(array)/sizeof(array[0])
+
+static __inline__ void ftdm_abort(void)
+{
+#ifdef __cplusplus
+	::abort();
+#else
+	abort();
+#endif
+}
+
+static __inline__ void ftdm_set_state_all(ftdm_span_t *span, ftdm_channel_state_t state)
+{
+	uint32_t j;
+	ftdm_mutex_lock(span->mutex);
+	for(j = 1; j <= span->chan_count; j++) {
+		ftdm_set_state_locked((span->channels[j]), state);
+	}
+	ftdm_mutex_unlock(span->mutex);
+}
+
+static __inline__ int ftdm_check_state_all(ftdm_span_t *span, ftdm_channel_state_t state)
+{
+	uint32_t j;
+	for(j = 1; j <= span->chan_count; j++) {
+		if (span->channels[j]->state != state || ftdm_test_flag(span->channels[j], FTDM_CHANNEL_STATE_CHANGE)) {
+			return 0;
+		}
+	}
+
+	return 1;
+}
+
+static __inline__ void ftdm_set_flag_all(ftdm_span_t *span, uint32_t flag)
+{
+	uint32_t j;
+	ftdm_mutex_lock(span->mutex);
+	for(j = 1; j <= span->chan_count; j++) {
+		ftdm_set_flag_locked((span->channels[j]), flag);
+	}
+	ftdm_mutex_unlock(span->mutex);
+}
+
+static __inline__ void ftdm_clear_flag_all(ftdm_span_t *span, uint32_t flag)
+{
+	uint32_t j;
+	ftdm_mutex_lock(span->mutex);
+	for(j = 1; j <= span->chan_count; j++) {
+		ftdm_clear_flag_locked((span->channels[j]), flag);
+	}
+	ftdm_mutex_unlock(span->mutex);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* endif __PRIVATE_FTDM_CORE__ */

libs/freetdm/src/include/private/ftdm_cpu_monitor.h

@@ -0,0 +1,75 @@
+/* 
+ * Copyright (c) 2010, Sangoma Technologies
+ * Moises Silva <moy@sangoma.com>
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 
+ * * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 
+ * * Neither the name of the original author; nor the names of any contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ * 
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER
+ * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ * 
+ * Contributors:
+ * David Yat Sin <dyatsin@sangoma.com>
+ * 
+ */
+
+/*! \brief opaque cpu stats structure */
+struct ftdm_cpu_monitor_stats;
+
+/*! 
+ * \brief create a new cpu monitor
+ * \return profile timer structure previously created with new_profile_timer, NULL on error
+ */
+FT_DECLARE(struct ftdm_cpu_monitor_stats*) ftdm_new_cpu_monitor(void);
+
+/*! 
+ * \brief Deletes cpu_monitor
+ */
+FT_DECLARE(void) ftdm_delete_cpu_monitor(struct ftdm_cpu_monitor_stats *p);
+
+/*! 
+ * \brief provides the percentage of idle system time
+ * \param p cpu_stats structure previously created with ftdm_new_cpu_monitor
+ * \param pointer to store the percentage of idle time
+ * \return -1 on error 0 for success
+ */
+FT_DECLARE(ftdm_status_t) ftdm_cpu_get_system_idle_time (struct ftdm_cpu_monitor_stats *p, double *idle_percentage);
+
+
+
+
+
+/* For Emacs:
+ * Local Variables:
+ * mode:c
+ * indent-tabs-mode:t
+ * tab-width:4
+ * c-basic-offset:4
+ * End:
+ * For VIM:
+ * vim:set softtabstop=4 shiftwidth=4 tabstop=4:
+ */

libs/freetdm/src/include/private/ftdm_dso.h

@@ -0,0 +1,51 @@
+/* 
+ * Cross Platform dso/dll load abstraction
+ * Copyright(C) 2008 Michael Jerris
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so.
+ *
+ * This work is provided under this license on an "as is" basis, without warranty of any kind,
+ * either expressed or implied, including, without limitation, warranties that the covered code
+ * is free of defects, merchantable, fit for a particular purpose or non-infringing. The entire
+ * risk as to the quality and performance of the covered code is with you. Should any covered
+ * code prove defective in any respect, you (not the initial developer or any other contributor)
+ * assume the cost of any necessary servicing, repair or correction. This disclaimer of warranty
+ * constitutes an essential part of this license. No use of any covered code is authorized hereunder
+ * except under this disclaimer. 
+ *
+ */
+
+
+#ifndef _FTDM_DSO_H
+#define _FTDM_DSO_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void (*ftdm_func_ptr_t) (void);
+typedef void * ftdm_dso_lib_t;
+
+FT_DECLARE(void) ftdm_dso_destroy(ftdm_dso_lib_t *lib);
+FT_DECLARE(ftdm_dso_lib_t) ftdm_dso_open(const char *path, char **err);
+FT_DECLARE(void *) ftdm_dso_func_sym(ftdm_dso_lib_t lib, const char *sym, char **err);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+/* For Emacs:
+ * Local Variables:
+ * mode:c
+ * indent-tabs-mode:t
+ * tab-width:4
+ * c-basic-offset:4
+ * End:
+ * For VIM:
+ * vim:set softtabstop=4 shiftwidth=4 tabstop=4
+ */
+

libs/freetdm/src/include/private/ftdm_m3ua.h

@@ -0,0 +1,134 @@
+/*
+ *  ftdm_m3ua.h
+ *  freetdm
+ *
+ *  Created by Shane Burrell on 4/3/08.
+ *  Copyright 2008 Shane Burrell. All rights reserved.
+ *
+ * Copyright (c) 2007, Anthony Minessale II, Nenad Corbic
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 
+ * * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 
+ * * Neither the name of the original author; nor the names of any contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ * 
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER
+ * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+
+//#include "m3ua_client.h"
+#include "freetdm.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+enum	e_sigboost_event_id_values
+{
+	SIGBOOST_EVENT_CALL_START			= 0x80, /*128*/
+	SIGBOOST_EVENT_CALL_START_ACK			= 0x81, /*129*/
+	SIGBOOST_EVENT_CALL_START_NACK			= 0x82, /*130*/
+	SIGBOOST_EVENT_CALL_START_NACK_ACK		= 0x83, /*131*/
+	SIGBOOST_EVENT_CALL_ANSWERED			= 0x84, /*132*/
+	SIGBOOST_EVENT_CALL_STOPPED			= 0x85, /*133*/
+	SIGBOOST_EVENT_CALL_STOPPED_ACK			= 0x86, /*134*/
+	SIGBOOST_EVENT_SYSTEM_RESTART			= 0x87, /*135*/
+	SIGBOOST_EVENT_SYSTEM_RESTART_ACK		= 0x88, /*136*/
+	/* Following IDs are ss7boost to sangoma_mgd only. */
+	SIGBOOST_EVENT_HEARTBEAT			= 0x89, /*137*/
+	SIGBOOST_EVENT_INSERT_CHECK_LOOP		= 0x8a, /*138*/
+	SIGBOOST_EVENT_REMOVE_CHECK_LOOP		= 0x8b, /*139*/
+	SIGBOOST_EVENT_AUTO_CALL_GAP_ABATE		= 0x8c, /*140*/
+};
+enum	e_sigboost_release_cause_values
+{
+	SIGBOOST_RELEASE_CAUSE_UNDEFINED		= 0,
+	SIGBOOST_RELEASE_CAUSE_NORMAL			= 16,
+	SIGBOOST_RELEASE_CAUSE_BUSY			= 17,
+	/* probable elimination */
+	//SIGBOOST_RELEASE_CAUSE_BUSY			= 0x91, /* 145 */
+	//SIGBOOST_RELEASE_CAUSE_CALLED_NOT_EXIST	= 0x92, /* 146 */
+	//SIGBOOST_RELEASE_CAUSE_CIRCUIT_RESET		= 0x93, /* 147 */
+	//SIGBOOST_RELEASE_CAUSE_NOANSWER		= 0x94, /* 148 */
+};
+
+enum	e_sigboost_call_setup_ack_nack_cause_values
+{
+	SIGBOOST_CALL_SETUP_NACK_ALL_CKTS_BUSY		= 117, /* unused Q.850 value */
+	SIGBOOST_CALL_SETUP_NACK_TEST_CKT_BUSY		= 118, /* unused Q.850 value */
+	SIGBOOST_CALL_SETUP_NACK_INVALID_NUMBER		= 28,
+	/* probable elimination */
+	//SIGBOOST_CALL_SETUP_RESERVED			= 0x00,
+	//SIGBOOST_CALL_SETUP_CIRCUIT_RESET		= 0x10,
+	//SIGBOOST_CALL_SETUP_NACK_CKT_START_TIMEOUT	= 0x11,
+	//SIGBOOST_CALL_SETUP_NACK_AUTO_CALL_GAP	= 0x17,
+};
+typedef enum {
+	M3UA_SPAN_SIGNALING_M3UA,
+	M3UA_SPAN_SIGNALING_SS7BOX,
+	
+} M3UA_TSpanSignaling;
+#define M3UA_SPAN_STRINGS "M3UA", "SS7BOX"
+FTDM_STR2ENUM_P(m3ua_str2span, m3ua_span2str, M3UA_TSpanSignaling)
+
+
+
+typedef enum {
+	FTDM_M3UA_RUNNING = (1 << 0)
+} ftdm_m3uat_flag_t;
+
+/*typedef struct m3ua_data {
+	m3uac_connection_t mcon;
+	m3uac_connection_t pcon;
+	fio_signal_cb_t signal_cb;
+	uint32_t flags;
+} m3ua_data_t;
+
+*/
+/*typedef struct mu3a_link {
+	ss7bc_connection_t mcon;
+	ss7bc_connection_t pcon;
+	fio_signal_cb_t signal_cb;
+	uint32_t flags;
+} ftdm_m3ua_data_t;
+*/
+
+ftdm_status_t m3ua_init(ftdm_io_interface_t **zint);
+ftdm_status_t m3ua_destroy(void);
+ftdm_status_t m3ua_start(ftdm_span_t *span);
+
+#ifdef __cplusplus
+}
+#endif
+
+/* For Emacs:
+ * Local Variables:
+ * mode:c
+ * indent-tabs-mode:t
+ * tab-width:4
+ * c-basic-offset:4
+ * End:
+ * For VIM:
+ * vim:set softtabstop=4 shiftwidth=4 tabstop=4:
+ */
+

libs/freetdm/src/include/private/ftdm_types.h

@@ -0,0 +1,451 @@
+/*
+ * Copyright (c) 2007, Anthony Minessale II
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 
+ * * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 
+ * * Neither the name of the original author; nor the names of any contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ * 
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER
+ * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Contributors: 
+ *
+ * Moises Silva <moy@sangoma.com>
+ *
+ */
+
+#ifndef FTDM_TYPES_H
+#define FTDM_TYPES_H
+
+#include "freetdm.h"
+
+#include "fsk.h"
+
+#ifdef WIN32
+typedef intptr_t ftdm_ssize_t;
+typedef int ftdm_filehandle_t;
+#else
+#include <sys/types.h>
+#include <sys/ioctl.h>
+#include <stdarg.h>
+typedef ssize_t ftdm_ssize_t;
+typedef int ftdm_filehandle_t;
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define FTDM_COMMAND_OBJ_INT *((int *)obj)
+#define FTDM_COMMAND_OBJ_CHAR_P (char *)obj
+#define FTDM_COMMAND_OBJ_FLOAT *(float *)obj
+#define FTDM_FSK_MOD_FACTOR 0x10000
+#define FTDM_DEFAULT_DTMF_ON 250
+#define FTDM_DEFAULT_DTMF_OFF 50
+
+#define FTDM_END -1
+#define FTDM_ANY_STATE -1
+
+typedef uint64_t ftdm_time_t; 
+
+typedef enum {
+	FTDM_ENDIAN_BIG = 1,
+	FTDM_ENDIAN_LITTLE = -1
+} ftdm_endian_t;
+
+typedef enum {
+	FTDM_CID_TYPE_SDMF = 0x04,
+	FTDM_CID_TYPE_MDMF = 0x80
+} ftdm_cid_type_t;
+
+typedef enum {
+	MDMF_DATETIME = 1,
+	MDMF_PHONE_NUM = 2,
+	MDMF_DDN = 3,
+	MDMF_NO_NUM = 4,
+	MDMF_PHONE_NAME = 7,
+	MDMF_NO_NAME = 8,
+	MDMF_ALT_ROUTE = 9,
+	MDMF_INVALID = 10
+} ftdm_mdmf_type_t;
+#define MDMF_STRINGS "X", "DATETIME", "PHONE_NUM", "DDN", "NO_NUM", "X", "X", "PHONE_NAME", "NO_NAME", "ALT_ROUTE", "INVALID"
+FTDM_STR2ENUM_P(ftdm_str2ftdm_mdmf_type, ftdm_mdmf_type2str, ftdm_mdmf_type_t)
+
+#define FTDM_TONEMAP_LEN 128
+typedef enum {
+	FTDM_TONEMAP_NONE,
+	FTDM_TONEMAP_DIAL,
+	FTDM_TONEMAP_RING,
+	FTDM_TONEMAP_BUSY,
+	FTDM_TONEMAP_FAIL1,
+	FTDM_TONEMAP_FAIL2,
+	FTDM_TONEMAP_FAIL3,
+	FTDM_TONEMAP_ATTN,
+	FTDM_TONEMAP_CALLWAITING_CAS,
+	FTDM_TONEMAP_CALLWAITING_SAS,
+	FTDM_TONEMAP_CALLWAITING_ACK,
+	FTDM_TONEMAP_INVALID
+} ftdm_tonemap_t;
+#define TONEMAP_STRINGS "NONE", "DIAL", "RING", "BUSY", "FAIL1", "FAIL2", "FAIL3", "ATTN", "CALLWAITING-CAS", "CALLWAITING-SAS", "CALLWAITING-ACK", "INVALID"
+FTDM_STR2ENUM_P(ftdm_str2ftdm_tonemap, ftdm_tonemap2str, ftdm_tonemap_t)
+
+typedef enum {
+	FTDM_TRUNK_E1,
+	FTDM_TRUNK_T1,
+	FTDM_TRUNK_J1,
+	FTDM_TRUNK_BRI,
+	FTDM_TRUNK_BRI_PTMP,
+	FTDM_TRUNK_FXO,
+	FTDM_TRUNK_FXS,
+	FTDM_TRUNK_EM,
+	FTDM_TRUNK_NONE
+} ftdm_trunk_type_t;
+#define TRUNK_STRINGS "E1", "T1", "J1", "BRI", "BRI_PTMP", "FXO", "FXS", "EM", "NONE"
+FTDM_STR2ENUM_P(ftdm_str2ftdm_trunk_type, ftdm_trunk_type2str, ftdm_trunk_type_t)
+
+typedef enum {
+	FTDM_ANALOG_START_KEWL,
+	FTDM_ANALOG_START_LOOP,
+	FTDM_ANALOG_START_GROUND,
+	FTDM_ANALOG_START_WINK,
+	FTDM_ANALOG_START_NA
+} ftdm_analog_start_type_t;
+#define START_TYPE_STRINGS "KEWL", "LOOP", "GROUND", "WINK", "NA"
+FTDM_STR2ENUM_P(ftdm_str2ftdm_analog_start_type, ftdm_analog_start_type2str, ftdm_analog_start_type_t)
+
+typedef enum {
+	FTDM_OOB_ONHOOK,
+	FTDM_OOB_OFFHOOK,
+	FTDM_OOB_WINK,
+	FTDM_OOB_FLASH,
+	FTDM_OOB_RING_START,
+	FTDM_OOB_RING_STOP,
+	FTDM_OOB_ALARM_TRAP,
+	FTDM_OOB_ALARM_CLEAR,
+	FTDM_OOB_NOOP,
+	FTDM_OOB_CAS_BITS_CHANGE,
+	FTDM_OOB_INVALID
+} ftdm_oob_event_t;
+#define OOB_STRINGS "DTMF", "ONHOOK", "OFFHOOK", "WINK", "FLASH", "RING_START", "RING_STOP", "ALARM_TRAP", "ALARM_CLEAR", "NOOP", "CAS_BITS_CHANGE", "INVALID"
+FTDM_STR2ENUM_P(ftdm_str2ftdm_oob_event, ftdm_oob_event2str, ftdm_oob_event_t)
+
+typedef enum {
+	FTDM_ALARM_NONE = 0,
+	FTDM_ALARM_RECOVER = (1 << 0),
+	FTDM_ALARM_LOOPBACK = (1 << 2),
+	FTDM_ALARM_YELLOW = (1 << 3),
+	FTDM_ALARM_RED = (1 << 4),
+	FTDM_ALARM_BLUE = (1 << 5),
+	FTDM_ALARM_NOTOPEN = ( 1 << 6),
+	FTDM_ALARM_AIS = ( 1 << 7),
+	FTDM_ALARM_RAI = ( 1 << 8),
+	FTDM_ALARM_GENERAL = ( 1 << 30)
+} ftdm_alarm_flag_t;
+
+typedef enum {
+	FTDM_SIGTYPE_NONE,
+	FTDM_SIGTYPE_ISDN,
+	FTDM_SIGTYPE_RBS,
+	FTDM_SIGTYPE_ANALOG,
+	FTDM_SIGTYPE_SANGOMABOOST,
+	FTDM_SIGTYPE_M3UA,
+	FTDM_SIGTYPE_R2
+} ftdm_signal_type_t;
+
+typedef enum {
+	FTDM_TONE_DTMF = (1 << 0)
+} ftdm_tone_type_t;
+
+typedef enum {
+	FTDM_SPAN_CONFIGURED = (1 << 0),
+	FTDM_SPAN_READY = (1 << 1),
+	FTDM_SPAN_STATE_CHANGE = (1 << 2),
+	FTDM_SPAN_SUSPENDED = (1 << 3),
+	FTDM_SPAN_IN_THREAD = (1 << 4),
+	FTDM_SPAN_STOP_THREAD = (1 << 5),
+	FTDM_SPAN_USE_CHAN_QUEUE = (1 << 6),
+	FTDM_SPAN_SUGGEST_CHAN_ID = (1 << 7),
+} ftdm_span_flag_t;
+
+typedef enum {
+	FTDM_CHANNEL_FEATURE_DTMF_DETECT = (1 << 0),
+	FTDM_CHANNEL_FEATURE_DTMF_GENERATE = (1 << 1),
+	FTDM_CHANNEL_FEATURE_CODECS = (1 << 2),
+	FTDM_CHANNEL_FEATURE_INTERVAL = (1 << 3),
+	FTDM_CHANNEL_FEATURE_CALLERID = (1 << 4),
+	FTDM_CHANNEL_FEATURE_PROGRESS = (1 << 5)
+} ftdm_channel_feature_t;
+
+typedef enum {
+	FTDM_CHANNEL_STATE_DOWN,
+	FTDM_CHANNEL_STATE_HOLD,
+	FTDM_CHANNEL_STATE_SUSPENDED,
+	FTDM_CHANNEL_STATE_DIALTONE,
+	FTDM_CHANNEL_STATE_COLLECT,
+	FTDM_CHANNEL_STATE_RING,
+	FTDM_CHANNEL_STATE_BUSY,
+	FTDM_CHANNEL_STATE_ATTN,
+	FTDM_CHANNEL_STATE_GENRING,
+	FTDM_CHANNEL_STATE_DIALING,
+	FTDM_CHANNEL_STATE_GET_CALLERID,
+	FTDM_CHANNEL_STATE_CALLWAITING,
+	FTDM_CHANNEL_STATE_RESTART,
+	FTDM_CHANNEL_STATE_PROGRESS,
+	FTDM_CHANNEL_STATE_PROGRESS_MEDIA,
+	FTDM_CHANNEL_STATE_UP,
+	FTDM_CHANNEL_STATE_IDLE,
+	FTDM_CHANNEL_STATE_TERMINATING,
+	FTDM_CHANNEL_STATE_CANCEL,
+	FTDM_CHANNEL_STATE_HANGUP,
+	FTDM_CHANNEL_STATE_HANGUP_COMPLETE,
+	FTDM_CHANNEL_STATE_IN_LOOP,
+	FTDM_CHANNEL_STATE_INVALID
+} ftdm_channel_state_t;
+#define CHANNEL_STATE_STRINGS "DOWN", "HOLD", "SUSPENDED", "DIALTONE", "COLLECT", \
+		"RING", "BUSY", "ATTN", "GENRING", "DIALING", "GET_CALLERID", "CALLWAITING", \
+		"RESTART", "PROGRESS", "PROGRESS_MEDIA", "UP", "IDLE", "TERMINATING", "CANCEL", \
+		"HANGUP", "HANGUP_COMPLETE", "IN_LOOP", "INVALID"
+FTDM_STR2ENUM_P(ftdm_str2ftdm_channel_state, ftdm_channel_state2str, ftdm_channel_state_t)
+
+typedef enum {
+	FTDM_CHANNEL_CONFIGURED = (1 << 0),
+	FTDM_CHANNEL_READY = (1 << 1),
+	FTDM_CHANNEL_OPEN = (1 << 2),
+	FTDM_CHANNEL_DTMF_DETECT = (1 << 3),
+	FTDM_CHANNEL_SUPRESS_DTMF = (1 << 4),
+	FTDM_CHANNEL_TRANSCODE = (1 << 5),
+	FTDM_CHANNEL_BUFFER = (1 << 6),
+	FTDM_CHANNEL_EVENT = (1 << 7),
+	FTDM_CHANNEL_INTHREAD = (1 << 8),
+	FTDM_CHANNEL_WINK = (1 << 9),
+	FTDM_CHANNEL_FLASH = (1 << 10),
+	FTDM_CHANNEL_STATE_CHANGE = (1 << 11),
+	FTDM_CHANNEL_HOLD = (1 << 12),
+	FTDM_CHANNEL_INUSE = (1 << 13),
+	FTDM_CHANNEL_OFFHOOK = (1 << 14),
+	FTDM_CHANNEL_RINGING = (1 << 15),
+	FTDM_CHANNEL_PROGRESS_DETECT = (1 << 16),
+	FTDM_CHANNEL_CALLERID_DETECT = (1 << 17),
+	FTDM_CHANNEL_OUTBOUND = (1 << 18),
+	FTDM_CHANNEL_SUSPENDED = (1 << 19),
+	FTDM_CHANNEL_3WAY = (1 << 20),
+	FTDM_CHANNEL_PROGRESS = (1 << 21),
+	FTDM_CHANNEL_MEDIA = (1 << 22),
+	FTDM_CHANNEL_ANSWERED = (1 << 23),
+	FTDM_CHANNEL_MUTE = (1 << 24),
+	FTDM_CHANNEL_USE_RX_GAIN = (1 << 25),
+	FTDM_CHANNEL_USE_TX_GAIN = (1 << 26),
+	FTDM_CHANNEL_IN_ALARM = (1 << 27),
+} ftdm_channel_flag_t;
+#if defined(__cplusplus) && defined(WIN32) 
+    // fix C2676 
+__inline__ ftdm_channel_flag_t operator|=(ftdm_channel_flag_t a, int32_t b) {
+    a = (ftdm_channel_flag_t)(a | b);
+    return a;
+}
+__inline__ ftdm_channel_flag_t operator&=(ftdm_channel_flag_t a, int32_t b) {
+    a = (ftdm_channel_flag_t)(a & b);
+    return a;
+}
+#endif
+
+typedef enum {
+	ZSM_NONE,
+	ZSM_UNACCEPTABLE,
+	ZSM_ACCEPTABLE
+} ftdm_state_map_type_t;
+
+typedef enum {
+	ZSD_INBOUND,
+	ZSD_OUTBOUND,
+} ftdm_state_direction_t;
+
+#define FTDM_MAP_NODE_SIZE 512
+#define FTDM_MAP_MAX FTDM_CHANNEL_STATE_INVALID+2
+
+struct ftdm_state_map_node {
+	ftdm_state_direction_t direction;
+	ftdm_state_map_type_t type;
+	ftdm_channel_state_t check_states[FTDM_MAP_MAX];
+	ftdm_channel_state_t states[FTDM_MAP_MAX];
+};
+typedef struct ftdm_state_map_node ftdm_state_map_node_t;
+
+struct ftdm_state_map {
+	ftdm_state_map_node_t nodes[FTDM_MAP_NODE_SIZE];
+};
+typedef struct ftdm_state_map ftdm_state_map_t;
+
+typedef enum ftdm_channel_hw_link_status {
+	FTDM_HW_LINK_DISCONNECTED = 0,
+	FTDM_HW_LINK_CONNECTED
+} ftdm_channel_hw_link_status_t;
+
+typedef ftdm_status_t (*ftdm_stream_handle_raw_write_function_t) (ftdm_stream_handle_t *handle, uint8_t *data, ftdm_size_t datalen);
+typedef ftdm_status_t (*ftdm_stream_handle_write_function_t) (ftdm_stream_handle_t *handle, const char *fmt, ...);
+
+#include "ftdm_dso.h"
+
+#define FTDM_NODE_NAME_SIZE 50
+struct ftdm_conf_node {
+	/* node name */
+	char name[FTDM_NODE_NAME_SIZE];
+
+	/* total slots for parameters */
+	unsigned int t_parameters;
+
+	/* current number of parameters */
+	unsigned int n_parameters;
+
+	/* array of parameters */
+	ftdm_conf_parameter_t *parameters;
+
+	/* first node child */
+	struct ftdm_conf_node *child;
+
+	/* next node sibling */
+	struct ftdm_conf_node *next;
+
+	/* my parent if any */
+	struct ftdm_conf_node *parent;
+};
+
+typedef struct ftdm_module {
+	char name[256];
+	fio_io_load_t io_load;
+	fio_io_unload_t io_unload;
+	fio_sig_load_t sig_load;
+	fio_sig_configure_t sig_configure;
+	fio_sig_unload_t sig_unload;
+	/*! 
+	  \brief configure a given span signaling 
+	  \see sig_configure
+	  This is just like sig_configure but receives
+	  an an ftdm_conf_node_t instead
+	  I'd like to deprecate sig_configure and move
+	  all modules to use configure_span_signaling
+	 */
+	fio_configure_span_signaling_t configure_span_signaling;
+	ftdm_dso_lib_t lib;
+	char path[256];
+} ftdm_module_t;
+
+#ifndef __FUNCTION__
+#define __FUNCTION__ (const char *)__func__
+#endif
+
+typedef struct ftdm_fsk_data_state ftdm_fsk_data_state_t;
+typedef int (*ftdm_fsk_data_decoder_t)(ftdm_fsk_data_state_t *state);
+typedef ftdm_status_t (*ftdm_fsk_write_sample_t)(int16_t *buf, ftdm_size_t buflen, void *user_data);
+typedef struct hashtable ftdm_hash_t;
+typedef struct hashtable_iterator ftdm_hash_iterator_t;
+typedef struct key ftdm_hash_key_t;
+typedef struct value ftdm_hash_val_t;
+typedef struct ftdm_bitstream ftdm_bitstream_t;
+typedef struct ftdm_fsk_modulator ftdm_fsk_modulator_t;
+typedef ftdm_status_t (*ftdm_span_start_t)(ftdm_span_t *span);
+typedef ftdm_status_t (*ftdm_span_stop_t)(ftdm_span_t *span);
+
+typedef enum {
+	FTDM_CAUSE_NONE = 0,
+	FTDM_CAUSE_UNALLOCATED = 1,
+	FTDM_CAUSE_NO_ROUTE_TRANSIT_NET = 2,
+	FTDM_CAUSE_NO_ROUTE_DESTINATION = 3,
+	FTDM_CAUSE_CHANNEL_UNACCEPTABLE = 6,
+	FTDM_CAUSE_CALL_AWARDED_DELIVERED = 7,
+	FTDM_CAUSE_NORMAL_CLEARING = 16,
+	FTDM_CAUSE_USER_BUSY = 17,
+	FTDM_CAUSE_NO_USER_RESPONSE = 18,
+	FTDM_CAUSE_NO_ANSWER = 19,
+	FTDM_CAUSE_SUBSCRIBER_ABSENT = 20,
+	FTDM_CAUSE_CALL_REJECTED = 21,
+	FTDM_CAUSE_NUMBER_CHANGED = 22,
+	FTDM_CAUSE_REDIRECTION_TO_NEW_DESTINATION = 23,
+	FTDM_CAUSE_EXCHANGE_ROUTING_ERROR = 25,
+	FTDM_CAUSE_DESTINATION_OUT_OF_ORDER = 27,
+	FTDM_CAUSE_INVALID_NUMBER_FORMAT = 28,
+	FTDM_CAUSE_FACILITY_REJECTED = 29,
+	FTDM_CAUSE_RESPONSE_TO_STATUS_ENQUIRY = 30,
+	FTDM_CAUSE_NORMAL_UNSPECIFIED = 31,
+	FTDM_CAUSE_NORMAL_CIRCUIT_CONGESTION = 34,
+	FTDM_CAUSE_NETWORK_OUT_OF_ORDER = 38,
+	FTDM_CAUSE_NORMAL_TEMPORARY_FAILURE = 41,
+	FTDM_CAUSE_SWITCH_CONGESTION = 42,
+	FTDM_CAUSE_ACCESS_INFO_DISCARDED = 43,
+	FTDM_CAUSE_REQUESTED_CHAN_UNAVAIL = 44,
+	FTDM_CAUSE_PRE_EMPTED = 45,
+	FTDM_CAUSE_FACILITY_NOT_SUBSCRIBED = 50,
+	FTDM_CAUSE_OUTGOING_CALL_BARRED = 52,
+	FTDM_CAUSE_INCOMING_CALL_BARRED = 54,
+	FTDM_CAUSE_BEARERCAPABILITY_NOTAUTH = 57,
+	FTDM_CAUSE_BEARERCAPABILITY_NOTAVAIL = 58,
+	FTDM_CAUSE_SERVICE_UNAVAILABLE = 63,
+	FTDM_CAUSE_BEARERCAPABILITY_NOTIMPL = 65,
+	FTDM_CAUSE_CHAN_NOT_IMPLEMENTED = 66,
+	FTDM_CAUSE_FACILITY_NOT_IMPLEMENTED = 69,
+	FTDM_CAUSE_SERVICE_NOT_IMPLEMENTED = 79,
+	FTDM_CAUSE_INVALID_CALL_REFERENCE = 81,
+	FTDM_CAUSE_INCOMPATIBLE_DESTINATION = 88,
+	FTDM_CAUSE_INVALID_MSG_UNSPECIFIED = 95,
+	FTDM_CAUSE_MANDATORY_IE_MISSING = 96,
+	FTDM_CAUSE_MESSAGE_TYPE_NONEXIST = 97,
+	FTDM_CAUSE_WRONG_MESSAGE = 98,
+	FTDM_CAUSE_IE_NONEXIST = 99,
+	FTDM_CAUSE_INVALID_IE_CONTENTS = 100,
+	FTDM_CAUSE_WRONG_CALL_STATE = 101,
+	FTDM_CAUSE_RECOVERY_ON_TIMER_EXPIRE = 102,
+	FTDM_CAUSE_MANDATORY_IE_LENGTH_ERROR = 103,
+	FTDM_CAUSE_PROTOCOL_ERROR = 111,
+	FTDM_CAUSE_INTERWORKING = 127,
+	FTDM_CAUSE_SUCCESS = 142,
+	FTDM_CAUSE_ORIGINATOR_CANCEL = 487,
+	FTDM_CAUSE_CRASH = 500,
+	FTDM_CAUSE_SYSTEM_SHUTDOWN = 501,
+	FTDM_CAUSE_LOSE_RACE = 502,
+	FTDM_CAUSE_MANAGER_REQUEST = 503,
+	FTDM_CAUSE_BLIND_TRANSFER = 600,
+	FTDM_CAUSE_ATTENDED_TRANSFER = 601,
+	FTDM_CAUSE_ALLOTTED_TIMEOUT = 602,
+	FTDM_CAUSE_USER_CHALLENGE = 603,
+	FTDM_CAUSE_MEDIA_TIMEOUT = 604
+} ftdm_call_cause_t;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+/* For Emacs:
+ * Local Variables:
+ * mode:c
+ * indent-tabs-mode:t
+ * tab-width:4
+ * c-basic-offset:4
+ * End:
+ * For VIM:
+ * vim:set softtabstop=4 shiftwidth=4 tabstop=4:
+ */
+

libs/freetdm/src/include/private/g711.h

@@ -0,0 +1,395 @@
+/*
+ * SpanDSP - a series of DSP components for telephony
+ *
+ * g711.h - In line A-law and u-law conversion routines
+ *
+ * Written by Steve Underwood <steveu@coppice.org>
+ *
+ * Copyright (C) 2001 Steve Underwood
+ *
+ *  Despite my general liking of the GPL, I place this code in the
+ *  public domain for the benefit of all mankind - even the slimy
+ *  ones who might try to proprietize my work and use it to my
+ *  detriment.
+ *
+ * $Id: g711.h,v 1.1 2006/06/07 15:46:39 steveu Exp $
+ */
+
+/*! \file */
+
+/*! \page g711_page A-law and mu-law handling
+  Lookup tables for A-law and u-law look attractive, until you consider the impact
+  on the CPU cache. If it causes a substantial area of your processor cache to get
+  hit too often, cache sloshing will severely slow things down. The main reason
+  these routines are slow in C, is the lack of direct access to the CPU's "find
+  the first 1" instruction. A little in-line assembler fixes that, and the
+  conversion routines can be faster than lookup tables, in most real world usage.
+  A "find the first 1" instruction is available on most modern CPUs, and is a
+  much underused feature. 
+
+  If an assembly language method of bit searching is not available, these routines
+  revert to a method that can be a little slow, so the cache thrashing might not
+  seem so bad :(
+
+  Feel free to submit patches to add fast "find the first 1" support for your own
+  favourite processor.
+
+  Look up tables are used for transcoding between A-law and u-law, since it is
+  difficult to achieve the precise transcoding procedure laid down in the G.711
+  specification by other means.
+*/
+
+#if !defined(_G711_H_)
+#define _G711_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef _MSC_VER
+#ifndef __inline__
+#define __inline__ __inline
+#endif
+	typedef unsigned __int8 uint8_t;
+	typedef __int16 int16_t;
+	typedef __int32 int32_t;
+	typedef unsigned __int16 uint16_t;
+#else
+#include <stdint.h>
+#endif
+
+#if defined(__i386__)
+	/*! \brief Find the bit position of the highest set bit in a word
+	  \param bits The word to be searched
+	  \return The bit number of the highest set bit, or -1 if the word is zero. */
+	static __inline__ int top_bit(unsigned int bits)
+	{
+		int res;
+
+		__asm__ __volatile__(" movl $-1,%%edx;\n"
+							 " bsrl %%eax,%%edx;\n"
+							 : "=d" (res)
+							 : "a" (bits));
+		return res;
+	}
+	/*- End of function --------------------------------------------------------*/
+
+	/*! \brief Find the bit position of the lowest set bit in a word
+	  \param bits The word to be searched
+	  \return The bit number of the lowest set bit, or -1 if the word is zero. */
+	static __inline__ int bottom_bit(unsigned int bits)
+	{
+		int res;
+
+		__asm__ __volatile__(" movl $-1,%%edx;\n"
+							 " bsfl %%eax,%%edx;\n"
+							 : "=d" (res)
+							 : "a" (bits));
+		return res;
+	}
+	/*- End of function --------------------------------------------------------*/
+#elif defined(__x86_64__)
+	static __inline__ int top_bit(unsigned int bits)
+	{
+		int res;
+
+		__asm__ __volatile__(" movq $-1,%%rdx;\n"
+							 " bsrq %%rax,%%rdx;\n"
+							 : "=d" (res)
+							 : "a" (bits));
+		return res;
+	}
+	/*- End of function --------------------------------------------------------*/
+
+	static __inline__ int bottom_bit(unsigned int bits)
+	{
+		int res;
+
+		__asm__ __volatile__(" movq $-1,%%rdx;\n"
+							 " bsfq %%rax,%%rdx;\n"
+							 : "=d" (res)
+							 : "a" (bits));
+		return res;
+	}
+	/*- End of function --------------------------------------------------------*/
+#else
+	static __inline__ int top_bit(unsigned int bits)
+	{
+		int i;
+    
+		if (bits == 0)
+			return -1;
+		i = 0;
+		if (bits & 0xFFFF0000)
+			{
+				bits &= 0xFFFF0000;
+				i += 16;
+			}
+		if (bits & 0xFF00FF00)
+			{
+				bits &= 0xFF00FF00;
+				i += 8;
+			}
+		if (bits & 0xF0F0F0F0)
+			{
+				bits &= 0xF0F0F0F0;
+				i += 4;
+			}
+		if (bits & 0xCCCCCCCC)
+			{
+				bits &= 0xCCCCCCCC;
+				i += 2;
+			}
+		if (bits & 0xAAAAAAAA)
+			{
+				bits &= 0xAAAAAAAA;
+				i += 1;
+			}
+		return i;
+	}
+	/*- End of function --------------------------------------------------------*/
+
+	static __inline__ int bottom_bit(unsigned int bits)
+	{
+		int i;
+    
+		if (bits == 0)
+			return -1;
+		i = 32;
+		if (bits & 0x0000FFFF)
+			{
+				bits &= 0x0000FFFF;
+				i -= 16;
+			}
+		if (bits & 0x00FF00FF)
+			{
+				bits &= 0x00FF00FF;
+				i -= 8;
+			}
+		if (bits & 0x0F0F0F0F)
+			{
+				bits &= 0x0F0F0F0F;
+				i -= 4;
+			}
+		if (bits & 0x33333333)
+			{
+				bits &= 0x33333333;
+				i -= 2;
+			}
+		if (bits & 0x55555555)
+			{
+				bits &= 0x55555555;
+				i -= 1;
+			}
+		return i;
+	}
+	/*- End of function --------------------------------------------------------*/
+#endif
+
+	/* N.B. It is tempting to use look-up tables for A-law and u-law conversion.
+	 *      However, you should consider the cache footprint.
+	 *
+	 *      A 64K byte table for linear to x-law and a 512 byte table for x-law to
+	 *      linear sound like peanuts these days, and shouldn't an array lookup be
+	 *      real fast? No! When the cache sloshes as badly as this one will, a tight
+	 *      calculation may be better. The messiest part is normally finding the
+	 *      segment, but a little inline assembly can fix that on an i386, x86_64 and
+	 *      many other modern processors.
+	 */
+ 
+	/*
+	 * Mu-law is basically as follows:
+	 *
+	 *      Biased Linear Input Code        Compressed Code
+	 *      ------------------------        ---------------
+	 *      00000001wxyza                   000wxyz
+	 *      0000001wxyzab                   001wxyz
+	 *      000001wxyzabc                   010wxyz
+	 *      00001wxyzabcd                   011wxyz
+	 *      0001wxyzabcde                   100wxyz
+	 *      001wxyzabcdef                   101wxyz
+	 *      01wxyzabcdefg                   110wxyz
+	 *      1wxyzabcdefgh                   111wxyz
+	 *
+	 * Each biased linear code has a leading 1 which identifies the segment
+	 * number. The value of the segment number is equal to 7 minus the number
+	 * of leading 0's. The quantization interval is directly available as the
+	 * four bits wxyz.  * The trailing bits (a - h) are ignored.
+	 *
+	 * Ordinarily the complement of the resulting code word is used for
+	 * transmission, and so the code word is complemented before it is returned.
+	 *
+	 * For further information see John C. Bellamy's Digital Telephony, 1982,
+	 * John Wiley & Sons, pps 98-111 and 472-476.
+	 */
+
+	/*#define ULAW_ZEROTRAP*/                 /* turn on the trap as per the MIL-STD */
+#define ULAW_BIAS        0x84           /* Bias for linear code. */
+
+	/*! \brief Encode a linear sample to u-law
+	  \param linear The sample to encode.
+	  \return The u-law value.
+	*/
+	static __inline__ uint8_t linear_to_ulaw(int linear)
+	{
+		uint8_t u_val;
+		int mask;
+		int seg;
+
+		/* Get the sign and the magnitude of the value. */
+		if (linear < 0)
+			{
+				linear = ULAW_BIAS - linear;
+				mask = 0x7F;
+			}
+		else
+			{
+				linear = ULAW_BIAS + linear;
+				mask = 0xFF;
+			}
+
+		seg = top_bit(linear | 0xFF) - 7;
+
+		/*
+		 * Combine the sign, segment, quantization bits,
+		 * and complement the code word.
+		 */
+		if (seg >= 8)
+			u_val = (uint8_t) (0x7F ^ mask);
+		else
+			u_val = (uint8_t) (((seg << 4) | ((linear >> (seg + 3)) & 0xF)) ^ mask);
+#ifdef ULAW_ZEROTRAP
+		/* Optional ITU trap */
+		if (u_val == 0)
+			u_val = 0x02;
+#endif
+		return  u_val;
+	}
+	/*- End of function --------------------------------------------------------*/
+
+	/*! \brief Decode an u-law sample to a linear value.
+	  \param ulaw The u-law sample to decode.
+	  \return The linear value.
+	*/
+	static __inline__ int16_t ulaw_to_linear(uint8_t ulaw)
+	{
+		int t;
+    
+		/* Complement to obtain normal u-law value. */
+		ulaw = ~ulaw;
+		/*
+		 * Extract and bias the quantization bits. Then
+		 * shift up by the segment number and subtract out the bias.
+		 */
+		t = (((ulaw & 0x0F) << 3) + ULAW_BIAS) << (((int) ulaw & 0x70) >> 4);
+		return  (int16_t) ((ulaw & 0x80)  ?  (ULAW_BIAS - t)  :  (t - ULAW_BIAS));
+	}
+	/*- End of function --------------------------------------------------------*/
+
+	/*
+	 * A-law is basically as follows:
+	 *
+	 *      Linear Input Code        Compressed Code
+	 *      -----------------        ---------------
+	 *      0000000wxyza             000wxyz
+	 *      0000001wxyza             001wxyz
+	 *      000001wxyzab             010wxyz
+	 *      00001wxyzabc             011wxyz
+	 *      0001wxyzabcd             100wxyz
+	 *      001wxyzabcde             101wxyz
+	 *      01wxyzabcdef             110wxyz
+	 *      1wxyzabcdefg             111wxyz
+	 *
+	 * For further information see John C. Bellamy's Digital Telephony, 1982,
+	 * John Wiley & Sons, pps 98-111 and 472-476.
+	 */
+
+#define ALAW_AMI_MASK       0x55
+
+	/*! \brief Encode a linear sample to A-law
+	  \param linear The sample to encode.
+	  \return The A-law value.
+	*/
+	static __inline__ uint8_t linear_to_alaw(int linear)
+	{
+		int mask;
+		int seg;
+    
+		if (linear >= 0)
+			{
+				/* Sign (bit 7) bit = 1 */
+				mask = ALAW_AMI_MASK | 0x80;
+			}
+		else
+			{
+				/* Sign (bit 7) bit = 0 */
+				mask = ALAW_AMI_MASK;
+				linear = -linear - 8;
+			}
+
+		/* Convert the scaled magnitude to segment number. */
+		seg = top_bit(linear | 0xFF) - 7;
+		if (seg >= 8)
+			{
+				if (linear >= 0)
+					{
+						/* Out of range. Return maximum value. */
+						return (uint8_t) (0x7F ^ mask);
+					}
+				/* We must be just a tiny step below zero */
+				return (uint8_t) (0x00 ^ mask);
+			}
+		/* Combine the sign, segment, and quantization bits. */
+		return (uint8_t) (((seg << 4) | ((linear >> ((seg)  ?  (seg + 3)  :  4)) & 0x0F)) ^ mask);
+	}
+	/*- End of function --------------------------------------------------------*/
+
+	/*! \brief Decode an A-law sample to a linear value.
+	  \param alaw The A-law sample to decode.
+	  \return The linear value.
+	*/
+	static __inline__ int16_t alaw_to_linear(uint8_t alaw)
+	{
+		int i;
+		int seg;
+
+		alaw ^= ALAW_AMI_MASK;
+		i = ((alaw & 0x0F) << 4);
+		seg = (((int) alaw & 0x70) >> 4);
+		if (seg)
+			i = (i + 0x108) << (seg - 1);
+		else
+			i += 8;
+		return (int16_t) ((alaw & 0x80)  ?  i  :  -i);
+	}
+	/*- End of function --------------------------------------------------------*/
+
+	/*! \brief Transcode from A-law to u-law, using the procedure defined in G.711.
+	  \param alaw The A-law sample to transcode.
+	  \return The best matching u-law value.
+	*/
+	uint8_t alaw_to_ulaw(uint8_t alaw);
+
+	/*! \brief Transcode from u-law to A-law, using the procedure defined in G.711.
+	  \param alaw The u-law sample to transcode.
+	  \return The best matching A-law value.
+	*/
+	uint8_t ulaw_to_alaw(uint8_t ulaw);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/*- End of file ------------------------------------------------------------*/
+
+/* For Emacs:
+ * Local Variables:
+ * mode:c
+ * indent-tabs-mode:t
+ * tab-width:4
+ * c-basic-offset:4
+ * End:
+ * For VIM:
+ * vim:set softtabstop=4 shiftwidth=4 tabstop=4:
+ */

libs/freetdm/src/include/private/hashtable.h

@@ -0,0 +1,235 @@
+/* Copyright (C) 2002 Christopher Clark <firstname.lastname@cl.cam.ac.uk> */
+
+#ifndef __HASHTABLE_CWC22_H__
+#define __HASHTABLE_CWC22_H__
+#ifdef _MSC_VER
+#ifndef __inline__
+#define __inline__ __inline
+#endif
+#endif
+#include "freetdm.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+struct hashtable;
+struct hashtable_iterator;
+
+/* Example of use:
+ *
+ *      struct hashtable  *h;
+ *      struct some_key   *k;
+ *      struct some_value *v;
+ *
+ *      static unsigned int         hash_from_key_fn( void *k );
+ *      static int                  keys_equal_fn ( void *key1, void *key2 );
+ *
+ *      h = create_hashtable(16, hash_from_key_fn, keys_equal_fn);
+ *      k = (struct some_key *)     malloc(sizeof(struct some_key));
+ *      v = (struct some_value *)   malloc(sizeof(struct some_value));
+ *
+ *      (initialise k and v to suitable values)
+ * 
+ *      if (! hashtable_insert(h,k,v) )
+ *      {     exit(-1);               }
+ *
+ *      if (NULL == (found = hashtable_search(h,k) ))
+ *      {    printf("not found!");                  }
+ *
+ *      if (NULL == (found = hashtable_remove(h,k) ))
+ *      {    printf("Not found\n");                 }
+ *
+ */
+
+/* Macros may be used to define type-safe(r) hashtable access functions, with
+ * methods specialized to take known key and value types as parameters.
+ * 
+ * Example:
+ *
+ * Insert this at the start of your file:
+ *
+ * DEFINE_HASHTABLE_INSERT(insert_some, struct some_key, struct some_value);
+ * DEFINE_HASHTABLE_SEARCH(search_some, struct some_key, struct some_value);
+ * DEFINE_HASHTABLE_REMOVE(remove_some, struct some_key, struct some_value);
+ *
+ * This defines the functions 'insert_some', 'search_some' and 'remove_some'.
+ * These operate just like hashtable_insert etc., with the same parameters,
+ * but their function signatures have 'struct some_key *' rather than
+ * 'void *', and hence can generate compile time errors if your program is
+ * supplying incorrect data as a key (and similarly for value).
+ *
+ * Note that the hash and key equality functions passed to create_hashtable
+ * still take 'void *' parameters instead of 'some key *'. This shouldn't be
+ * a difficult issue as they're only defined and passed once, and the other
+ * functions will ensure that only valid keys are supplied to them.
+ *
+ * The cost for this checking is increased code size and runtime overhead
+ * - if performance is important, it may be worth switching back to the
+ * unsafe methods once your program has been debugged with the safe methods.
+ * This just requires switching to some simple alternative defines - eg:
+ * #define insert_some hashtable_insert
+ *
+ */
+
+/*****************************************************************************
+ * create_hashtable
+   
+ * @name                    create_hashtable
+ * @param   minsize         minimum initial size of hashtable
+ * @param   hashfunction    function for hashing keys
+ * @param   key_eq_fn       function for determining key equality
+ * @return                  newly created hashtable or NULL on failure
+ */
+
+FT_DECLARE(struct hashtable *)
+create_hashtable(unsigned int minsize,
+                 unsigned int (*hashfunction) (void*),
+                 int (*key_eq_fn) (void*,void*));
+
+/*****************************************************************************
+ * hashtable_insert
+   
+ * @name        hashtable_insert
+ * @param   h   the hashtable to insert into
+ * @param   k   the key - hashtable claims ownership and will free on removal
+ * @param   v   the value - does not claim ownership
+ * @return      non-zero for successful insertion
+ *
+ * This function will cause the table to expand if the insertion would take
+ * the ratio of entries to table size over the maximum load factor.
+ *
+ * This function does not check for repeated insertions with a duplicate key.
+ * The value returned when using a duplicate key is undefined -- when
+ * the hashtable changes size, the order of retrieval of duplicate key
+ * entries is reversed.
+ * If in doubt, remove before insert.
+ */
+
+
+typedef enum {
+	HASHTABLE_FLAG_NONE = 0,
+	HASHTABLE_FLAG_FREE_KEY = (1 << 0),
+	HASHTABLE_FLAG_FREE_VALUE = (1 << 1)
+} hashtable_flag_t;
+
+FT_DECLARE(int)
+hashtable_insert(struct hashtable *h, void *k, void *v, hashtable_flag_t flags);
+
+#define DEFINE_HASHTABLE_INSERT(fnname, keytype, valuetype)		\
+	int fnname (struct hashtable *h, keytype *k, valuetype *v)	\
+	{															\
+		return hashtable_insert(h,k,v);							\
+	}
+
+/*****************************************************************************
+ * hashtable_search
+   
+ * @name        hashtable_search
+ * @param   h   the hashtable to search
+ * @param   k   the key to search for  - does not claim ownership
+ * @return      the value associated with the key, or NULL if none found
+ */
+
+FT_DECLARE(void *)
+hashtable_search(struct hashtable *h, void *k);
+
+#define DEFINE_HASHTABLE_SEARCH(fnname, keytype, valuetype) \
+	valuetype * fnname (struct hashtable *h, keytype *k)	\
+	{														\
+		return (valuetype *) (hashtable_search(h,k));		\
+	}
+
+/*****************************************************************************
+ * hashtable_remove
+   
+ * @name        hashtable_remove
+ * @param   h   the hashtable to remove the item from
+ * @param   k   the key to search for  - does not claim ownership
+ * @return      the value associated with the key, or NULL if none found
+ */
+
+FT_DECLARE(void *) /* returns value */
+hashtable_remove(struct hashtable *h, void *k);
+
+#define DEFINE_HASHTABLE_REMOVE(fnname, keytype, valuetype) \
+	valuetype * fnname (struct hashtable *h, keytype *k)	\
+	{														\
+		return (valuetype *) (hashtable_remove(h,k));		\
+	}
+
+
+/*****************************************************************************
+ * hashtable_count
+   
+ * @name        hashtable_count
+ * @param   h   the hashtable
+ * @return      the number of items stored in the hashtable
+ */
+FT_DECLARE(unsigned int)
+hashtable_count(struct hashtable *h);
+
+
+/*****************************************************************************
+ * hashtable_destroy
+   
+ * @name        hashtable_destroy
+ * @param   h   the hashtable
+ * @param       free_values     whether to call 'free' on the remaining values
+ */
+
+FT_DECLARE(void)
+hashtable_destroy(struct hashtable *h);
+
+FT_DECLARE(struct hashtable_iterator*) hashtable_first(struct hashtable *h);
+FT_DECLARE(struct hashtable_iterator*) hashtable_next(struct hashtable_iterator *i);
+FT_DECLARE(void) hashtable_this(struct hashtable_iterator *i, const void **key, int *klen, void **val);
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+#endif /* __HASHTABLE_CWC22_H__ */
+
+/*
+ * Copyright (c) 2002, Christopher Clark
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 
+ * * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 
+ * * Neither the name of the original author; nor the names of any contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ * 
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER
+ * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/* For Emacs:
+ * Local Variables:
+ * mode:c
+ * indent-tabs-mode:t
+ * tab-width:4
+ * c-basic-offset:4
+ * End:
+ * For VIM:
+ * vim:set softtabstop=4 shiftwidth=4 tabstop=4:
+ */

libs/freetdm/src/include/private/hashtable_itr.h

@@ -0,0 +1,134 @@
+/* Copyright (C) 2002, 2004 Christopher Clark <firstname.lastname@cl.cam.ac.uk> */
+
+#ifndef __HASHTABLE_ITR_CWC22__
+#define __HASHTABLE_ITR_CWC22__
+#include "hashtable.h"
+#include "hashtable_private.h" /* needed to enable inlining */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*****************************************************************************/
+/* This struct is only concrete here to allow the inlining of two of the
+ * accessor functions. */
+struct hashtable_itr
+{
+    struct hashtable *h;
+    struct entry *e;
+    struct entry *parent;
+    unsigned int index;
+};
+
+
+/*****************************************************************************/
+/* hashtable_iterator
+ */
+
+struct hashtable_itr *
+hashtable_iterator(struct hashtable *h);
+
+/*****************************************************************************/
+/* hashtable_iterator_key
+ * - return the value of the (key,value) pair at the current position */
+extern __inline__ void *
+hashtable_iterator_key(struct hashtable_itr *i);
+
+extern __inline__ void *
+hashtable_iterator_key(struct hashtable_itr *i)
+{
+    return i->e->k;
+}
+
+/*****************************************************************************/
+/* value - return the value of the (key,value) pair at the current position */
+
+extern __inline__ void *
+hashtable_iterator_value(struct hashtable_itr *i);
+
+extern __inline__ void *
+hashtable_iterator_value(struct hashtable_itr *i)
+{
+    return i->e->v;
+}
+
+/*****************************************************************************/
+/* advance - advance the iterator to the next element
+ *           returns zero if advanced to end of table */
+
+int
+hashtable_iterator_advance(struct hashtable_itr *itr);
+
+/*****************************************************************************/
+/* remove - remove current element and advance the iterator to the next element
+ *          NB: if you need the value to free it, read it before
+ *          removing. ie: beware memory leaks!
+ *          returns zero if advanced to end of table */
+
+int
+hashtable_iterator_remove(struct hashtable_itr *itr);
+
+/*****************************************************************************/
+/* search - overwrite the supplied iterator, to point to the entry
+ *          matching the supplied key.
+ h points to the hashtable to be searched.
+ *          returns zero if not found. */
+int
+hashtable_iterator_search(struct hashtable_itr *itr,
+                          struct hashtable *h, void *k);
+
+#define DEFINE_HASHTABLE_ITERATOR_SEARCH(fnname, keytype)				\
+	int fnname (struct hashtable_itr *i, struct hashtable *h, keytype *k) \
+	{																	\
+		return (hashtable_iterator_search(i,h,k));						\
+	}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __HASHTABLE_ITR_CWC22__*/
+
+/*
+ * Copyright (c) 2002, 2004, Christopher Clark
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 
+ * * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 
+ * * Neither the name of the original author; nor the names of any contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ * 
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER
+ * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/* For Emacs:
+ * Local Variables:
+ * mode:c
+ * indent-tabs-mode:t
+ * tab-width:4
+ * c-basic-offset:4
+ * End:
+ * For VIM:
+ * vim:set softtabstop=4 shiftwidth=4 tabstop=4:
+ */
+

libs/freetdm/src/include/private/hashtable_private.h

@@ -0,0 +1,110 @@
+/* Copyright (C) 2002, 2004 Christopher Clark <firstname.lastname@cl.cam.ac.uk> */
+
+#ifndef __HASHTABLE_PRIVATE_CWC22_H__
+#define __HASHTABLE_PRIVATE_CWC22_H__
+
+#include "hashtable.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*****************************************************************************/
+
+struct entry
+{
+    void *k, *v;
+    unsigned int h;
+	hashtable_flag_t flags;
+    struct entry *next;
+};
+
+struct hashtable_iterator {
+	unsigned int pos;
+	struct entry *e;
+	struct hashtable *h;
+};
+
+struct hashtable {
+    unsigned int tablelength;
+    struct entry **table;
+    unsigned int entrycount;
+    unsigned int loadlimit;
+    unsigned int primeindex;
+    unsigned int (*hashfn) (void *k);
+    int (*eqfn) (void *k1, void *k2);
+	struct hashtable_iterator iterator;
+};
+
+/*****************************************************************************/
+unsigned int
+hash(struct hashtable *h, void *k);
+
+/*****************************************************************************/
+/* indexFor */
+static __inline__ unsigned int
+indexFor(unsigned int tablelength, unsigned int hashvalue) {
+    return (hashvalue % tablelength);
+}
+
+/* Only works if tablelength == 2^N */
+/*static inline unsigned int
+  indexFor(unsigned int tablelength, unsigned int hashvalue)
+  {
+  return (hashvalue & (tablelength - 1u));
+  }
+*/
+
+/*****************************************************************************/
+#define freekey(X) free(X)
+/*define freekey(X) ; */
+
+#ifdef __cplusplus
+}
+#endif
+
+/*****************************************************************************/
+
+#endif /* __HASHTABLE_PRIVATE_CWC22_H__*/
+
+/*
+ * Copyright (c) 2002, Christopher Clark
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 
+ * * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 
+ * * Neither the name of the original author; nor the names of any contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ * 
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER
+ * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/* For Emacs:
+ * Local Variables:
+ * mode:c
+ * indent-tabs-mode:t
+ * tab-width:4
+ * c-basic-offset:4
+ * End:
+ * For VIM:
+ * vim:set softtabstop=4 shiftwidth=4 tabstop=4:
+ */

libs/freetdm/src/include/private/libteletone.h

@@ -0,0 +1,161 @@
+/* 
+ * libteletone
+ * Copyright (C) 2005/2006, Anthony Minessale II <anthmct@yahoo.com>
+ *
+ * Version: MPL 1.1
+ *
+ * The contents of this file are subject to the Mftilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mftilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is libteletone
+ *
+ * The Initial Developer of the Original Code is
+ * Anthony Minessale II <anthmct@yahoo.com>
+ * Portions created by the Initial Developer are Copyright (C)
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ * 
+ * Anthony Minessale II <anthmct@yahoo.com>
+ *
+ *
+ * libteletone.h -- Tone Generator/Detector
+ *
+ *
+ *
+ * Exception:
+ * The author hereby grants the use of this source code under the 
+ * following license if and only if the source code is distributed
+ * as part of the freetdm library.  Any use or distribution of this
+ * source code outside the scope of the freetdm library will nullify the
+ * following license and reinact the MPL 1.1 as stated above.
+ *
+ * Copyright (c) 2007, Anthony Minessale II
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 
+ * * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 
+ * * Neither the name of the original author; nor the names of any contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ * 
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER
+ * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef LIBTELETONE_H
+#define LIBTELETONE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <math.h>
+
+#define	TELETONE_MAX_DTMF_DIGITS 128
+#define TELETONE_MAX_TONES 18
+#define TELETONE_TONE_RANGE 127
+
+typedef double teletone_process_t;
+
+/*! \file libteletone.h
+    \brief Top level include file
+
+	This file should be included by applications using the library
+*/
+
+/*! \brief An abstraction to store a tone mapping */
+typedef struct {
+	/*! An array of tone frequencies */
+	teletone_process_t freqs[TELETONE_MAX_TONES];
+} teletone_tone_map_t;
+
+#if !defined(M_PI)
+/* C99 systems may not define M_PI */
+#define M_PI 3.14159265358979323846264338327
+#endif
+
+#ifdef _MSC_VER
+typedef __int16 int16_t;
+#endif
+
+#if (_MSC_VER >= 1400)			// VC8+
+#define teletone_assert(expr) assert(expr);__analysis_assume( expr )
+#else
+#define teletone_assert(expr) assert(expr)
+#endif
+
+#ifdef _MSC_VER
+#if defined(TT_DECLARE_STATIC)
+#define TELETONE_API(type)			type __stdcall
+#define TELETONE_API_NONSTD(type)		type __cdecl
+#define TELETONE_API_DATA
+#elif defined(TELETONE_EXPORTS)
+#define TELETONE_API(type)			__declspec(dllexport) type __stdcall
+#define TELETONE_API_NONSTD(type)		__declspec(dllexport) type __cdecl
+#define TELETONE_API_DATA				__declspec(dllexport)
+#else
+#define TELETONE_API(type)			__declspec(dllimport) type __stdcall
+#define TELETONE_API_NONSTD(type)		__declspec(dllimport) type __cdecl
+#define TELETONE_API_DATA				__declspec(dllimport)
+#endif
+#else
+#if (defined(__GNUC__) || defined(__SUNPRO_CC) || defined (__SUNPRO_C)) && defined(HAVE_VISIBILITY)
+#define TELETONE_API(type)		__attribute__((visibility("default"))) type
+#define TELETONE_API_NONSTD(type)	__attribute__((visibility("default"))) type
+#define TELETONE_API_DATA		__attribute__((visibility("default")))
+#else
+#define TELETONE_API(type)		type
+#define TELETONE_API_NONSTD(type)	type
+#define TELETONE_API_DATA
+#endif
+#endif
+
+#include <libteletone_generate.h>
+#include <libteletone_detect.h>
+
+#ifdef HAVE_STRING_H
+#include <string.h>
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+/* For Emacs:
+ * Local Variables:
+ * mode:c
+ * indent-tabs-mode:t
+ * tab-width:4
+ * c-basic-offset:4
+ * End:
+ * For VIM:
+ * vim:set softtabstop=4 shiftwidth=4 tabstop=4:
+ */

libs/freetdm/src/include/private/libteletone_detect.h

@@ -0,0 +1,240 @@
+/* 
+ * libteletone
+ * Copyright (C) 2005/2006, Anthony Minessale II <anthmct@yahoo.com>
+ *
+ * libteletone_detect.c Tone Detection Code
+ *
+ * Exception:
+ * The author hereby grants the use of this source code under the 
+ * following license if and only if the source code is distributed
+ * as part of the freetdm library.	Any use or distribution of this
+ * source code outside the scope of the freetdm library will nullify the
+ * following license and reinact the MPL 1.1 as stated above.
+ *
+ * Copyright (c) 2007, Anthony Minessale II
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 
+ * * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 
+ * * Neither the name of the original author; nor the names of any contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ * 
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED.	 IN NO EVENT SHALL THE COPYRIGHT OWNER
+ * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ ********************************************************************************* 
+ *
+ * Derived from tone_detect.h - General telephony tone detection, and specific
+ * detection of DTMF.
+ *
+ * Copyright (C) 2001  Steve Underwood <steveu@coppice.org>
+ *
+ * Despite my general liking of the GPL, I place this code in the
+ * public domain for the benefit of all mankind - even the slimy
+ * ones who might try to proprietize my work and use it to my
+ * detriment.
+ *
+ *
+ */
+
+#ifndef LIBTELETONE_DETECT_H
+#define LIBTELETONE_DETECT_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+#include <libteletone.h>
+
+	/*! \file libteletone_detect.h
+	  \brief Tone Detection Routines
+
+	  This module is responsible for tone detection specifics
+	*/
+
+#ifndef FALSE
+#define FALSE	0
+#ifndef TRUE
+#define TRUE	(!FALSE)
+#endif
+#endif
+
+	/* Basic DTMF specs:
+	 *
+	 * Minimum tone on = 40ms
+	 * Minimum tone off = 50ms
+	 * Maximum digit rate = 10 per second
+	 * Normal twist <= 8dB accepted
+	 * Reverse twist <= 4dB accepted
+	 * S/N >= 15dB will detect OK
+	 * Attenuation <= 26dB will detect OK
+	 * Frequency tolerance +- 1.5% will detect, +-3.5% will reject
+	 */
+
+#define DTMF_THRESHOLD				8.0e7
+#define DTMF_NORMAL_TWIST			6.3		/* 8dB */
+#define DTMF_REVERSE_TWIST			2.5		/* 4dB */
+#define DTMF_RELATIVE_PEAK_ROW		6.3		/* 8dB */
+#define DTMF_RELATIVE_PEAK_COL		6.3		/* 8dB */
+#define DTMF_2ND_HARMONIC_ROW		2.5		/* 4dB */
+#define DTMF_2ND_HARMONIC_COL		63.1	/* 18dB */
+#define GRID_FACTOR 4
+#define BLOCK_LEN 102
+#define M_TWO_PI 2.0*M_PI
+
+	/*! \brief A continer for the elements of a Goertzel Algorithm (The names are from his formula) */
+	typedef struct {
+		float v2;
+		float v3;
+		double fac;
+	} teletone_goertzel_state_t;
+	
+	/*! \brief A container for a DTMF detection state.*/
+	typedef struct {
+		int hit1;
+		int hit2;
+		int hit3;
+		int hit4;
+		int mhit;
+
+		teletone_goertzel_state_t row_out[GRID_FACTOR];
+		teletone_goertzel_state_t col_out[GRID_FACTOR];
+		teletone_goertzel_state_t row_out2nd[GRID_FACTOR];
+		teletone_goertzel_state_t col_out2nd[GRID_FACTOR];
+		float energy;
+	
+		int current_sample;
+		char digits[TELETONE_MAX_DTMF_DIGITS + 1];
+		int current_digits;
+		int detected_digits;
+		int lost_digits;
+		int digit_hits[16];
+	} teletone_dtmf_detect_state_t;
+
+	/*! \brief An abstraction to store the coefficient of a tone frequency */
+	typedef struct {
+		float fac;
+	} teletone_detection_descriptor_t;
+
+	/*! \brief A container for a single multi-tone detection 
+	  TELETONE_MAX_TONES dictates the maximum simultaneous tones that can be present
+	  in a multi-tone representation.
+	*/
+	typedef struct {
+		int sample_rate;
+
+		teletone_detection_descriptor_t tdd[TELETONE_MAX_TONES];
+		teletone_goertzel_state_t gs[TELETONE_MAX_TONES];
+		teletone_goertzel_state_t gs2[TELETONE_MAX_TONES];
+		int tone_count;
+
+		float energy;
+		int current_sample;
+	
+		int min_samples;
+		int total_samples;
+
+		int positives;
+		int negatives;
+		int hits;
+
+		int positive_factor;
+		int negative_factor;
+		int hit_factor;
+
+	} teletone_multi_tone_t;
+
+
+	/*! 
+	  \brief Initilize a multi-frequency tone detector
+	  \param mt the multi-frequency tone descriptor
+	  \param map a representation of the multi-frequency tone
+	*/
+TELETONE_API(void) teletone_multi_tone_init(teletone_multi_tone_t *mt, teletone_tone_map_t *map);
+
+	/*! 
+	  \brief Check a sample buffer for the presence of the mulit-frequency tone described by mt
+	  \param mt the multi-frequency tone descriptor
+	  \param sample_buffer an array aof 16 bit signed linear samples
+	  \param samples the number of samples present in sample_buffer
+	  \return true when the tone was detected or false when it is not
+	*/
+TELETONE_API(int) teletone_multi_tone_detect (teletone_multi_tone_t *mt,
+									int16_t sample_buffer[],
+									int samples);
+
+	/*! 
+	  \brief Initilize a DTMF detection state object
+	  \param dtmf_detect_state the DTMF detection state to initilize
+	  \param sample_rate the desired sample rate
+	*/
+TELETONE_API(void) teletone_dtmf_detect_init (teletone_dtmf_detect_state_t *dtmf_detect_state, int sample_rate);
+
+	/*! 
+	  \brief Check a sample buffer for the presence of DTMF digits
+	  \param dtmf_detect_state the detection state object to check
+	  \param sample_buffer an array aof 16 bit signed linear samples
+	  \param samples the number of samples present in sample_buffer
+	  \return true when DTMF was detected or false when it is not
+	*/
+TELETONE_API(int) teletone_dtmf_detect (teletone_dtmf_detect_state_t *dtmf_detect_state,
+							  int16_t sample_buffer[],
+							  int samples);
+	/*! 
+	  \brief retrieve any collected digits into a string buffer
+	  \param dtmf_detect_state the detection state object to check
+	  \param buf the string buffer to write to
+	  \param max the maximum length of buf
+	  \return the number of characters written to buf
+	*/
+TELETONE_API(int) teletone_dtmf_get (teletone_dtmf_detect_state_t *dtmf_detect_state,
+						   char *buf,
+						   int max);
+
+	/*! 
+	  \brief Step through the Goertzel Algorithm for each sample in a buffer
+	  \param goertzel_state the goertzel state to step the samples through
+	  \param sample_buffer an array aof 16 bit signed linear samples
+	  \param samples the number of samples present in sample_buffer
+	*/
+TELETONE_API(void) teletone_goertzel_update(teletone_goertzel_state_t *goertzel_state,
+								  int16_t sample_buffer[],
+								  int samples);
+
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+/* For Emacs:
+ * Local Variables:
+ * mode:c
+ * indent-tabs-mode:t
+ * tab-width:4
+ * c-basic-offset:4
+ * End:
+ * For VIM:
+ * vim:set softtabstop=4 shiftwidth=4 tabstop=4:
+ */

libs/freetdm/src/include/private/libteletone_generate.h

@@ -0,0 +1,281 @@
+/* 
+ * libteletone
+ * Copyright (C) 2005/2006, Anthony Minessale II <anthmct@yahoo.com>
+ *
+ * Copyright (c) 2007, Anthony Minessale II
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 
+ * * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 
+ * * Neither the name of the original author; nor the names of any contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ * 
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED.	 IN NO EVENT SHALL THE COPYRIGHT OWNER
+ * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef LIBTELETONE_GENERATE_H
+#define LIBTELETONE_GENERATE_H
+#ifdef __cplusplus
+extern "C" {
+#ifdef _doh
+}
+#endif
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#if  defined(__SUNPRO_C) || defined(__SUNPRO_CC)
+#ifndef __inline__
+#define __inline__ inline
+#endif
+#endif
+
+#ifdef _MSC_VER
+#ifndef __inline__
+#define __inline__ __inline
+#endif
+
+typedef unsigned __int64 uint64_t;
+typedef unsigned __int32 uint32_t;
+typedef unsigned __int16 uint16_t;
+typedef unsigned __int8 uint8_t;
+typedef __int64 int64_t;
+typedef __int32 int32_t;
+typedef __int16 int16_t;
+typedef __int8 int8_t;
+#else
+#include <stdint.h>
+#endif
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <math.h>
+#if !defined(powf) && !defined(_WIN64)
+extern float powf (float, float);
+#endif
+#include <string.h>
+#include <errno.h>
+#ifndef _MSC_VER
+#include <unistd.h>
+#endif
+#include <assert.h>
+#include <stdarg.h>
+#include <libteletone.h>
+
+#define TELETONE_VOL_DB_MAX 0
+#define TELETONE_VOL_DB_MIN -63
+#define MAX_PHASE_TONES 4
+
+struct teletone_dds_state {
+	uint32_t phase_rate[MAX_PHASE_TONES];
+	uint32_t scale_factor;
+	uint32_t phase_accumulator;
+	teletone_process_t tx_level;
+};
+typedef struct teletone_dds_state teletone_dds_state_t;
+
+#define SINE_TABLE_MAX 128
+#define SINE_TABLE_LEN (SINE_TABLE_MAX - 1)
+#define MAX_PHASE_ACCUMULATOR 0x10000 * 0x10000
+/* 3.14 == the max power on ulaw (alaw is 3.17) */
+/* 3.02 represents twice the power */
+#define DBM0_MAX_POWER (3.14f + 3.02f)
+
+TELETONE_API_DATA extern int16_t TELETONE_SINES[SINE_TABLE_MAX];
+
+static __inline__ int32_t teletone_dds_phase_rate(teletone_process_t tone, uint32_t rate)
+{
+	return (int32_t) ((tone * MAX_PHASE_ACCUMULATOR) / rate);
+}
+
+static __inline__ int16_t teletone_dds_state_modulate_sample(teletone_dds_state_t *dds, uint32_t pindex)
+{
+	int32_t bitmask = dds->phase_accumulator, sine_index = (bitmask >>= 23) & SINE_TABLE_LEN;
+	int16_t sample;
+
+	if (pindex >= MAX_PHASE_TONES)	{
+		pindex = 0;
+	}
+
+	if (bitmask & SINE_TABLE_MAX) {
+		sine_index = SINE_TABLE_LEN - sine_index;
+	}
+
+	sample = TELETONE_SINES[sine_index];
+	
+	if (bitmask & (SINE_TABLE_MAX * 2)) {
+		sample *= -1;
+	}
+
+	dds->phase_accumulator += dds->phase_rate[pindex];
+	return (int16_t) (sample * dds->scale_factor >> 15);
+}
+
+static __inline__ void teletone_dds_state_set_tx_level(teletone_dds_state_t *dds, float tx_level)
+{
+	dds->scale_factor = (int) (powf(10.0f, (tx_level - DBM0_MAX_POWER) / 20.0f) * (32767.0f * 1.414214f));
+	dds->tx_level = tx_level;
+}
+
+static __inline__ void teletone_dds_state_reset_accum(teletone_dds_state_t *dds)
+{
+	dds->phase_accumulator = 0;
+}
+
+static __inline__ int teletone_dds_state_set_tone(teletone_dds_state_t *dds, teletone_process_t tone, uint32_t rate, uint32_t pindex)
+{
+	if (pindex < MAX_PHASE_TONES)  {
+		dds->phase_rate[pindex] = teletone_dds_phase_rate(tone, rate);
+		return 0;
+	}
+	
+	return -1;
+}
+
+
+
+/*! \file libteletone_generate.h
+  \brief Tone Generation Routines
+
+  This module is responsible for tone generation specifics
+*/
+
+typedef int16_t teletone_audio_t;
+struct teletone_generation_session;
+typedef int (*tone_handler)(struct teletone_generation_session *ts, teletone_tone_map_t *map);
+
+/*! \brief An abstraction to store a tone generation session */
+struct teletone_generation_session {
+	/*! An array of tone mappings to character mappings */
+	teletone_tone_map_t TONES[TELETONE_TONE_RANGE];
+	/*! The number of channels the output audio should be in */
+	int channels;
+	/*! The Rate in hz of the output audio */
+	int rate;
+	/*! The duration (in samples) of the output audio */
+	int duration;
+	/*! The duration of silence to append after the initial audio is generated */
+	int wait;
+	/*! The duration (in samples) of the output audio (takes prescedence over actual duration value) */
+	int tmp_duration;
+	/*! The duration of silence to append after the initial audio is generated (takes prescedence over actual wait value)*/
+	int tmp_wait;
+	/*! Number of loops to repeat a single instruction*/
+	int loops;
+	/*! Number of loops to repeat the entire set of instructions*/
+	int LOOPS;
+	/*! Number to mutiply total samples by to determine when to begin ascent or decent e.g. 0=beginning 4=(last 25%) */
+	float decay_factor;
+	/*! Direction to perform volume increase/decrease 1/-1*/
+	int decay_direction;
+	/*! Number of samples between increase/decrease of volume */
+	int decay_step;
+	/*! Volume factor of the tone */
+	float volume;
+	/*! Debug on/off */
+	int debug;
+	/*! FILE stream to write debug data to */
+	FILE *debug_stream;
+	/*! Extra user data to attach to the session*/
+	void *user_data;
+	/*! Buffer for storing sample data (dynamic) */
+	teletone_audio_t *buffer;
+	/*! Size of the buffer */
+	int datalen;
+	/*! In-Use size of the buffer */
+	int samples;
+	/*! Callback function called during generation */
+	int dynamic;
+	tone_handler handler;
+};
+
+typedef struct teletone_generation_session teletone_generation_session_t;
+
+
+/*! 
+  \brief Assign a set of tones to a tone_session indexed by a paticular index/character
+  \param ts the tone generation session
+  \param index the index to map the tone to
+  \param ... up to TELETONE_MAX_TONES frequencies terminated by 0.0
+  \return 0
+*/
+TELETONE_API(int) teletone_set_tone(teletone_generation_session_t *ts, int index, ...);
+
+/*! 
+  \brief Assign a set of tones to a single tone map
+  \param map the map to assign the tones to
+  \param ... up to TELETONE_MAX_TONES frequencies terminated by 0.0
+  \return 0
+*/
+TELETONE_API(int) teletone_set_map(teletone_tone_map_t *map, ...);
+
+/*! 
+  \brief Initilize a tone generation session
+  \param ts the tone generation session to initilize
+  \param buflen the size of the buffer(in samples) to dynamically allocate
+  \param handler a callback function to execute when a tone generation instruction is complete
+  \param user_data optional user data to send
+  \return 0
+*/
+TELETONE_API(int) teletone_init_session(teletone_generation_session_t *ts, int buflen, tone_handler handler, void *user_data);
+
+/*! 
+  \brief Free the buffer allocated by a tone generation session
+  \param ts the tone generation session to destroy
+  \return 0
+*/
+TELETONE_API(int) teletone_destroy_session(teletone_generation_session_t *ts);
+
+/*! 
+  \brief Execute a single tone generation instruction
+  \param ts the tone generation session to consult for parameters
+  \param map the tone mapping to use for the frequencies
+  \return 0
+*/
+TELETONE_API(int) teletone_mux_tones(teletone_generation_session_t *ts, teletone_tone_map_t *map);
+
+/*! 
+  \brief Execute a tone generation script and call callbacks after each instruction
+  \param ts the tone generation session to execute on
+  \param cmd the script to execute
+  \return 0
+*/
+TELETONE_API(int) teletone_run(teletone_generation_session_t *ts, const char *cmd);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+/* For Emacs:
+ * Local Variables:
+ * mode:c
+ * indent-tabs-mode:t
+ * tab-width:4
+ * c-basic-offset:4
+ * End:
+ * For VIM:
+ * vim:set softtabstop=4 shiftwidth=4 tabstop=4:
+ */

libs/freetdm/src/include/private/sangoma_tdm_api.h

@@ -0,0 +1,321 @@
+/*****************************************************************************
+ * sangoma_tdm_api.h	Sangoma TDM API Portability functions
+ *
+ * Author(s):	Anthony Minessale II <anthmct@yahoo.com>
+ *              Nenad Corbic <ncorbic@sangoma.com>
+ *				Michael Jerris <mike@jerris.com>
+ *				David Rokhvarg <davidr@sangoma.com>
+ *
+ * Copyright:	(c) 2006 Nenad Corbic <ncorbic@sangoma.com>
+ *                       Anthony Minessale II
+ *				(c) 1984-2007 Sangoma Technologies Inc.
+ *
+ * ============================================================================
+ */
+
+#ifndef _SANGOMA_TDM_API_H
+#define _SANGOMA_TDM_API_H
+
+/* This entire block of defines and includes from this line, through #define FNAME_LEN probably dont belong here */
+/* most of them probably belong in wanpipe_defines.h, then each header file listed included below properly included */
+/* in the header files that depend on them, leaving only the include for wanpipe_tdm_api.h left in this file or */
+/* possibly integrating the rest of this file diretly into wanpipe_tdm_api.h */
+#ifndef __WINDOWS__
+#if defined(WIN32) || defined(WIN64) || defined(_MSC_VER) || defined(_WIN32)
+#define __WINDOWS__
+#endif /* defined(WIN32) || defined(WIN64) || defined(_MSC_VER) || defined(_WIN32) */
+#endif /* ndef __WINDOWS__ */
+
+#if defined(__WINDOWS__)
+#if defined(_MSC_VER)
+/* disable some warnings caused by wanpipe headers that will need to be fixed in those headers */
+#pragma warning(disable:4201 4214)
+
+/* sang_api.h(74) : warning C4201: nonstandard extension used : nameless struct/union */
+
+/* wanpipe_defines.h(219) : warning C4214: nonstandard extension used : bit field types other than int */
+/* wanpipe_defines.h(220) : warning C4214: nonstandard extension used : bit field types other than int */
+/* this will break for any compilers that are strict ansi or strict c99 */
+
+/* The following definition for that struct should resolve this warning and work for 32 and 64 bit */
+#if 0
+struct iphdr {
+	
+#if defined(__LITTLE_ENDIAN_BITFIELD)
+	unsigned    ihl:4,
+		version:4;
+#elif defined (__BIG_ENDIAN_BITFIELD)
+	unsigned    version:4,
+		ihl:4;
+#else
+# error  "unknown byteorder!"
+#endif
+	unsigned    tos:8;
+	unsigned		tot_len:16;
+	unsigned		id:16;
+	unsigned		frag_off:16;
+	__u8    ttl;
+	__u8    protocol;
+	__u16   check;
+	__u32   saddr;
+	__u32   daddr;
+	/*The options start here. */
+};
+#endif /* #if 0 */
+
+#define __inline__ __inline
+#endif /* defined(_MSC_VER) */
+#include <windows.h>
+/* do we like the name WP_INVALID_SOCKET or should it be changed? */
+#define WP_INVALID_SOCKET INVALID_HANDLE_VALUE
+#else /* defined(__WINDOWS__) */ 
+#define WP_INVALID_SOCKET -1
+#include <stropts.h>
+#include <poll.h>
+#include <sys/socket.h>
+#endif
+
+#include <wanpipe_defines.h>
+#include <wanpipe_cfg.h>
+#include <wanpipe_tdm_api.h>
+#include <sdla_te1_pmc.h>
+#ifdef __WINDOWS__
+#include <sang_status_defines.h>
+#include <sang_api.h>
+#endif
+#include <sdla_aft_te1.h>
+
+#define FNAME_LEN	50
+
+
+#if defined(__WINDOWS__)
+/* This might be broken on windows, as POLL_EVENT_TELEPHONY seems to be commented out in sang_api.h.. it should be added to POLLPRI */
+#define POLLPRI (POLL_EVENT_LINK_STATE | POLL_EVENT_LINK_CONNECT | POLL_EVENT_LINK_DISCONNECT)
+#endif
+
+/* return -1 for error, 0 for timeout or 1 for success. *flags is set to the poll evetns POLLIN | POLLOUT | POLLPRI based on the result of the poll */
+/* on windows we actually have POLLPRI defined with several events, so we could theoretically poll */
+/* for specific events.  Is there any way to do this on *nix as well? */ 
+
+/* a cross platform way to poll on an actual pollset (span and/or list of spans) will probably also be needed for analog */
+/* so we can have one analong handler thread that will deal with all the idle analog channels for events */
+/* the alternative would be for the driver to provide one socket for all of the oob events for all analog channels */
+static __inline__ int tdmv_api_wait_socket(sng_fd_t fd, int timeout, int *flags)
+{
+#if defined(__WINDOWS__)
+	DWORD ln;
+	API_POLL_STRUCT	api_poll;
+
+	memset(&api_poll, 0x00, sizeof(API_POLL_STRUCT));
+	
+	api_poll.user_flags_bitmap = *flags;
+	api_poll.timeout = timeout;
+
+	if (!DeviceIoControl(
+						 fd,
+						 IoctlApiPoll,
+						 (LPVOID)NULL,
+						 0L,
+						 (LPVOID)&api_poll,
+						 sizeof(API_POLL_STRUCT),
+						 (LPDWORD)(&ln),
+						 (LPOVERLAPPED)NULL)) {
+		return -1;
+	}
+
+	*flags = 0;
+
+	switch(api_poll.operation_status)
+		{
+		case SANG_STATUS_RX_DATA_AVAILABLE:
+			break;
+
+		case SANG_STATUS_RX_DATA_TIMEOUT:
+			return 0;
+
+		default:
+			return -1;
+		}
+
+	if (api_poll.poll_events_bitmap == 0){
+		return -1;
+	}
+
+	if (api_poll.poll_events_bitmap & POLL_EVENT_TIMEOUT) {
+		return 0;
+	}
+
+	*flags = api_poll.poll_events_bitmap;
+
+	return 1;
+#else
+    struct pollfd pfds[1];
+    int res;
+
+    memset(&pfds[0], 0, sizeof(pfds[0]));
+    pfds[0].fd = fd;
+    pfds[0].events = *flags;
+    res = poll(pfds, 1, timeout);
+	*flags = 0;
+
+	if (pfds[0].revents & POLLERR) {
+		res = -1;
+	}
+
+	if (res > 0) {
+		*flags = pfds[0].revents;
+	}
+
+    return res;
+#endif
+}
+
+/* on windows right now, there is no way to specify if we want to read events here or not, we allways get them here */
+/* we need some what to select if we are reading regular tdm msgs or events */
+/* need to either have 2 functions, 1 for events, 1 for regural read, or a flag on this function to choose */
+/* 2 functions preferred.  Need implementation for the event function for both nix and windows that is threadsafe */
+static __inline__ int tdmv_api_readmsg_tdm(sng_fd_t fd, void *hdrbuf, int hdrlen, void *databuf, int datalen)
+{
+	/* What do we need to do here to avoid having to do all */
+	/* the memcpy's on windows and still maintain api compat with nix */
+	int rx_len=0;
+#if defined(__WINDOWS__)
+	static RX_DATA_STRUCT	rx_data;
+	api_header_t			*pri;
+	wp_tdm_api_rx_hdr_t		*tdm_api_rx_hdr;
+	wp_tdm_api_rx_hdr_t		*user_buf = (wp_tdm_api_rx_hdr_t*)hdrbuf;
+	DWORD ln;
+
+	if (hdrlen != sizeof(wp_tdm_api_rx_hdr_t)){
+		return -1;
+	}
+
+	if (!DeviceIoControl(
+						 fd,
+						 IoctlReadCommand,
+						 (LPVOID)NULL,
+						 0L,
+						 (LPVOID)&rx_data,
+						 sizeof(RX_DATA_STRUCT),
+						 (LPDWORD)(&ln),
+						 (LPOVERLAPPED)NULL
+						 )){
+		return -1;
+	}
+
+	pri = &rx_data.api_header;
+	tdm_api_rx_hdr = (wp_tdm_api_rx_hdr_t*)rx_data.data;
+
+	user_buf->wp_tdm_api_event_type = pri->operation_status;
+
+	switch(pri->operation_status)
+		{
+		case SANG_STATUS_RX_DATA_AVAILABLE:
+			if (pri->data_length > datalen){
+				break;
+			}
+			memcpy(databuf, rx_data.data, pri->data_length);
+			rx_len = pri->data_length;
+			break;
+
+		default:
+			break;
+		}
+
+#else
+	struct msghdr msg;
+	struct iovec iov[2];
+
+	memset(&msg,0,sizeof(struct msghdr));
+
+	iov[0].iov_len=hdrlen;
+	iov[0].iov_base=hdrbuf;
+
+	iov[1].iov_len=datalen;
+	iov[1].iov_base=databuf;
+
+	msg.msg_iovlen=2;
+	msg.msg_iov=iov;
+
+	rx_len = read(fd,&msg,datalen+hdrlen);
+
+	if (rx_len <= sizeof(wp_tdm_api_rx_hdr_t)){
+		return -EINVAL;
+	}
+
+	rx_len-=sizeof(wp_tdm_api_rx_hdr_t);
+#endif
+    return rx_len;
+}                    
+
+static __inline__ int tdmv_api_writemsg_tdm(sng_fd_t fd, void *hdrbuf, int hdrlen, void *databuf, unsigned short datalen)
+{
+	/* What do we need to do here to avoid having to do all */
+	/* the memcpy's on windows and still maintain api compat with nix */
+	int bsent = 0;
+#if defined(__WINDOWS__)
+	static TX_DATA_STRUCT	local_tx_data;
+	api_header_t			*pri;
+	DWORD ln;
+
+	/* Are these really not needed or used???  What about for nix?? */
+	(void)hdrbuf;
+	(void)hdrlen;
+
+	pri = &local_tx_data.api_header;
+
+	pri->data_length = datalen;
+	memcpy(local_tx_data.data, databuf, pri->data_length);
+
+	if (!DeviceIoControl(
+						 fd,
+						 IoctlWriteCommand,
+						 (LPVOID)&local_tx_data,
+						 (ULONG)sizeof(TX_DATA_STRUCT),
+						 (LPVOID)&local_tx_data,
+						 sizeof(TX_DATA_STRUCT),
+						 (LPDWORD)(&ln),
+						 (LPOVERLAPPED)NULL
+						 )){
+		return -1;
+	}
+
+	if (local_tx_data.api_header.operation_status == SANG_STATUS_SUCCESS) {
+		bsent = datalen;
+	}
+#else
+	struct msghdr msg;
+	struct iovec iov[2];
+
+	memset(&msg,0,sizeof(struct msghdr));
+
+	iov[0].iov_len = hdrlen;
+	iov[0].iov_base = hdrbuf;
+
+	iov[1].iov_len = datalen;
+	iov[1].iov_base = databuf;
+
+	msg.msg_iovlen = 2;
+	msg.msg_iov = iov;
+
+	bsent = write(fd, &msg, datalen + hdrlen);
+	if (bsent > 0){
+		bsent -= sizeof(wp_tdm_api_tx_hdr_t);
+	}
+#endif
+	return bsent;
+}
+
+#endif /* _SANGOMA_TDM_API_H */
+
+/* For Emacs:
+ * Local Variables:
+ * mode:c
+ * indent-tabs-mode:t
+ * tab-width:4
+ * c-basic-offset:4
+ * End:
+ * For VIM:
+ * vim:set softtabstop=4 shiftwidth=4 tabstop=4:
+ */
+

libs/freetdm/src/include/private/uart.h

@@ -0,0 +1,83 @@
+/*
+ *	uart.h
+ *
+ *	Copyright (c) 2005 Robert Krten.  All Rights Reserved.
+ *
+ *	Redistribution and use in source and binary forms, with or without
+ *	modification, are permitted provided that the following conditions
+ *	are met:
+ *
+ *	1. Redistributions of source code must retain the above copyright
+ *	   notice, this list of conditions and the following disclaimer.
+ *	2. Redistributions in binary form must reproduce the above copyright
+ *	   notice, this list of conditions and the following disclaimer in the
+ *	   documentation and/or other materials provided with the distribution.
+ *
+ *	THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND
+ *	ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ *	IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ *	ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE
+ *	FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ *	DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ *	OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *	HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ *	LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ *	OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ *	SUCH DAMAGE.
+ *
+ *	This module contains the manifest constants and declarations for
+ *	the UART module.
+ *
+ *	2005 06 19	R. Krten		created
+*/
+
+#ifndef	__UART_H__
+#define	__UART_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void (*bytehandler_func_t) (void *, int);
+typedef void (*bithandler_func_t) (void *, int);
+
+
+typedef struct dsp_uart_attr_s
+{
+	bytehandler_func_t	bytehandler;					/* byte handler */
+	void				*bytehandler_arg;				/* arbitrary ID passed to bytehandler as first argument */
+}	dsp_uart_attr_t;
+
+typedef struct
+{
+	dsp_uart_attr_t		attr;
+	int					have_start;						/* wait for start bit to show up */
+	int					data;							/* data buffer */
+	int					nbits;							/* number of bits accumulated so far */
+}	dsp_uart_handle_t;
+
+/*
+ *	Function prototypes
+ *
+ *	General calling order is:
+ *		a) create the attributes structure (dsp_uart_attr_init)
+ *		b) initialize fields in the attributes structure (dsp_uart_attr_set_*)
+ *		c) create a Bell-202 handle (dsp_uart_create)
+ *		d) feed bits through dsp_uart_bit_handler
+*/
+
+void					dsp_uart_attr_init(dsp_uart_attr_t *attributes);
+
+bytehandler_func_t		dsp_uart_attr_get_bytehandler(dsp_uart_attr_t *attributes, void **bytehandler_arg);
+void					dsp_uart_attr_set_bytehandler(dsp_uart_attr_t *attributes, bytehandler_func_t bytehandler, void *bytehandler_arg);
+
+dsp_uart_handle_t *		dsp_uart_create(dsp_uart_attr_t *attributes);
+void					dsp_uart_destroy(dsp_uart_handle_t **handle);
+
+void					dsp_uart_bit_handler(void *handle, int bit);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
+