add some weapons to arsenal

git-svn-id: http://svn.openzap.org/svn/openzap/trunk@13 a93c3328-9c30-0410-af19-c9cd2b2d52af

libs/freetdm/src/Makefile

@@ -29,7 +29,8 @@
 # NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-OBJS=hashtable.o hashtable_itr.o openzap.o zap_config.o
+
+OBJS=hashtable.o hashtable_itr.o openzap.o zap_config.o libteletone_detect.o libteletone_generate.o zap_buffer.o
 CFLAGS=$(ZAP_CFLAGS) -Iinclude 
 MYLIB=libopenzap.a
 
@@ -41,6 +42,9 @@ $(MYLIB): $(OBJS)
 	ar rcs $(MYLIB) $(OBJS)
 	ranlib $(MYLIB)
 
+openzap.o: openzap.c
+	$(CC) $(MOD_CFLAGS) $(CC_CFLAGS) $(CFLAGS) -c $< -o $@
+
 zap_wanpipe.o: zap_wanpipe.c
 	$(CC) $(CFLAGS) $(ZAP_CFLAGS) $(WP_CFLAGS) -c $< -o $@
 

libs/freetdm/src/include/libteletone.h

+/* 
+ * libteletone
+ * Copyright (C) 2005/2006, Anthony Minessale II <anthmct@yahoo.com>
+ *
+ * Version: MPL 1.1
+ *
+ * The contents of this file are subject to the Mozilla 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.mozilla.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 openzap library.  Any use or distribution of this
+ * source code outside the scope of the openzap 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
+#define	TELETONE_MAX_DTMF_DIGITS 128
+#define TELETONE_MAX_TONES 6
+#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
+
+#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 expandtab:
+ */

libs/freetdm/src/include/libteletone_detect.h

+/* 
+ * libteletone
+ * Copyright (C) 2005/2006, Anthony Minessale II <anthmct@yahoo.com>
+ *
+ * Version: MPL 1.1
+ *
+ * The contents of this file are subject to the Mozilla 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.mozilla.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 tone_detect.c - General telephony tone detection, and specific detection of DTMF.
+ *
+ *
+ * The Initial Developer of the Original Code is
+ * Stephen Underwood <steveu@coppice.org>
+ * Portions created by the Initial Developer are Copyright (C)
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ * 
+ * The the original interface designed by Steve Underwood was preserved to retain 
+ *the optimizations when considering DTMF tones though the names were changed in the interest 
+ * of namespace.
+ *
+ * Much less efficient expansion interface was added to allow for the detection of 
+ * a single arbitrary tone combination which may also exceed 2 simultaneous tones.
+ * (controlled by compile time constant TELETONE_MAX_TONES)
+ *
+ * Copyright (C) 2006 Anthony Minessale II <anthmct@yahoo.com>
+ *
+ *
+ * libteletone_detect.c Tone Detection Code
+ *
+ *
+ ********************************************************************************* 
+ *
+ * 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.
+ *
+ *
+ * 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 openzap library.  Any use or distribution of this
+ * source code outside the scope of the openzap 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_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 {
+	teletone_process_t v2;
+	teletone_process_t v3;
+	teletone_process_t 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];
+    teletone_process_t 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 {
+    teletone_process_t 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;
+
+	teletone_process_t 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
+*/
+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
+*/
+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
+*/
+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
+*/
+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
+*/
+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
+*/
+void teletone_goertzel_update(teletone_goertzel_state_t *goertzel_state,
+							  int16_t sample_buffer[],
+							  int samples);
+
+/*! 
+  \brief Compute the result of the last applied step of the Goertzel Algorithm
+  \param goertzel_state the goertzel state to retrieve from
+  \return the computed value for consideration in furthur audio tests
+*/
+teletone_process_t teletone_goertzel_result (teletone_goertzel_state_t *goertzel_state);
+
+
+
+#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 expandtab:
+ */

libs/freetdm/src/include/libteletone_generate.h

+/* 
+ * libteletone
+ * Copyright (C) 2005/2006, Anthony Minessale II <anthmct@yahoo.com>
+ *
+ * Version: MPL 1.1
+ *
+ * The contents of this file are subject to the Mozilla 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.mozilla.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
+ *
+ *
+ *
+ * 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 openzap library.  Any use or distribution of this
+ * source code outside the scope of the openzap 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_GENERATE_H
+#define LIBTELETONE_GENERATE_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+#ifndef _MSC_VER
+#include <unistd.h>
+#endif
+#include <fcntl.h>
+#include <sys/types.h>
+#include <errno.h>
+#include <assert.h>
+#include <stdarg.h>
+#include <libteletone.h>
+
+
+
+/*! \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%) */
+	int 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 */
+	int 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
+*/
+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
+*/
+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
+*/
+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
+*/
+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
+*/
+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
+*/
+int teletone_run(teletone_generation_session_t *ts, 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 expandtab:
+ */

libs/freetdm/src/include/openzap.h

@@ -62,6 +62,8 @@
 #include <assert.h>
 #include "hashtable.h"
 #include "zap_config.h"
+#include "g711.h"
+#include "libteletone.h"
 
 #ifdef  NDEBUG
 #undef assert
@@ -115,7 +117,8 @@ struct zap_software_interface;
 
 typedef enum {
 	ZAP_SUCCESS,
-	ZAP_FAIL
+	ZAP_FAIL,
+	ZAP_MEMERR
 } zap_status_t;
 
 typedef enum {
@@ -205,6 +208,20 @@ typedef zap_status_t (*zint_write_t) ZINT_WRITE_ARGS ;
 #define ZINT_READ_MUZZLE assert(zchan != NULL); assert(data != NULL); assert(datalen != NULL)
 #define ZINT_WRITE_MUZZLE assert(zchan != NULL); assert(data != NULL); assert(datalen != NULL)
 
+#define ZAP_PRE __FILE__, __FUNCTION__, __LINE__
+#define ZAP_LOG_DEBUG ZAP_PRE, 7
+#define ZAP_LOG_INFO ZAP_PRE, 6
+#define ZAP_LOG_NOTICE ZAP_PRE, 5
+#define ZAP_LOG_WARNING ZAP_PRE, 4
+#define ZAP_LOG_ERROR ZAP_PRE, 3
+#define ZAP_LOG_CRIT ZAP_PRE, 2
+#define ZAP_LOG_ALERT ZAP_PRE, 1
+#define ZAP_LOG_EMERG ZAP_PRE, 0
+
+typedef void (*zap_logger_t)(char *file, const char *func, int line, int level, char *fmt, ...);
+extern zap_logger_t global_logger;
+#define zap_log global_logger;
+
 struct zap_software_interface {
 	const char *name;
 	zint_configure_t configure;
@@ -220,6 +237,7 @@ struct zap_software_interface {
 };
 typedef struct zap_software_interface zap_software_interface_t;
 
+
 zap_status_t zap_span_create(zap_software_interface_t *zint, zap_span_t **span);
 zap_status_t zap_span_add_channel(zap_span_t *span, zap_socket_t sockfd, zap_chan_type_t type, zap_channel_t **chan);
 zap_status_t zap_span_destroy(zap_span_t **span);
@@ -233,6 +251,8 @@ zap_status_t zap_channel_read(zap_channel_t *zchan, void *data, zap_size_t *data
 zap_status_t zap_channel_write(zap_channel_t *zchan, void *data, zap_size_t *datalen);
 zap_status_t zap_global_init(void);
 zap_status_t zap_global_destroy(void);
+void zap_global_set_logger(zap_logger_t logger);
+void zap_global_set_default_logger(void);
 
 typedef struct hashtable zap_hash_t;
 

libs/freetdm/src/include/zap_buffer.h

+/*
+ * 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 ZAP_BUFFER_H
+#define ZAP_BUFFER_H
+
+#include "openzap.h"
+
+/**
+ * @defgroup zap_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 zap_buffer;
+typedef struct zap_buffer zap_buffer_t;
+
+/*! \brief Allocate a new dynamic zap_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
+ */
+zap_status_t zap_buffer_create(zap_buffer_t **buffer, zap_size_t blocksize, zap_size_t start_len, zap_size_t max_len);
+
+/*! \brief Get the length of a zap_buffer_t 
+ * \param buffer any buffer of type zap_buffer_t
+ * \return int size of the buffer.
+ */
+zap_size_t zap_buffer_len(zap_buffer_t *buffer);
+
+/*! \brief Get the freespace of a zap_buffer_t 
+ * \param buffer any buffer of type zap_buffer_t
+ * \return int freespace in the buffer.
+ */
+zap_size_t zap_buffer_freespace(zap_buffer_t *buffer);
+
+/*! \brief Get the in use amount of a zap_buffer_t 
+ * \param buffer any buffer of type zap_buffer_t
+ * \return int ammount of buffer curently in use
+ */
+zap_size_t zap_buffer_inuse(zap_buffer_t *buffer);
+
+/*! \brief Read data from a zap_buffer_t up to the ammount of datalen if it is available.  Remove read data from buffer. 
+ * \param buffer any buffer of type zap_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
+ */
+zap_size_t zap_buffer_read(zap_buffer_t *buffer, void *data, zap_size_t datalen);
+
+/*! \brief Read data endlessly from a zap_buffer_t 
+ * \param buffer any buffer of type zap_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.
+ */
+zap_size_t zap_buffer_read_loop(zap_buffer_t *buffer, void *data, zap_size_t datalen);
+
+/*! \brief Assign a number of loops to read
+ * \param buffer any buffer of type zap_buffer_t
+ * \param loops the number of loops (-1 for infinite)
+ */
+void zap_buffer_set_loops(zap_buffer_t *buffer, int32_t loops);
+
+/*! \brief Write data into a zap_buffer_t up to the length of datalen
+ * \param buffer any buffer of type zap_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
+ */
+zap_size_t zap_buffer_write(zap_buffer_t *buffer, const void *data, zap_size_t datalen);
+
+/*! \brief Remove data from the buffer
+ * \param buffer any buffer of type zap_buffer_t
+ * \param datalen amount of data to be removed
+ * \return int size of buffer, or 0 if unable to toss that much data
+ */
+zap_size_t zap_buffer_toss(zap_buffer_t *buffer, zap_size_t datalen);
+
+/*! \brief Remove all data from the buffer
+ * \param buffer any buffer of type zap_buffer_t
+ */
+void zap_buffer_zero(zap_buffer_t *buffer);
+
+/*! \brief Destroy the buffer
+ * \param buffer buffer to destroy
+ * \note only neccessary on dynamic buffers (noop on pooled ones)
+ */
+void zap_buffer_destroy(zap_buffer_t **buffer);
+
+/** @} */
+
+
+#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 expandtab:
+ */

libs/freetdm/src/openzap.c

@@ -33,6 +33,7 @@
 
 
 #include "openzap.h"
+#include <stdarg.h>
 #ifdef ZAP_WANPIPE_SUPPORT
 #include "zap_wanpipe.h"
 #endif
@@ -44,6 +45,78 @@ static struct {
 	zap_hash_t *interface_hash;
 } globals;
 
+static char *LEVEL_NAMES[] = {
+	"EMERG",
+	"ALERT",
+	"CRIT",
+	"ERROR",
+	"WARNING",
+	"NOTICE",
+	"INFO",
+	"DEBUG",
+	NULL
+};
+
+static char *cut_path(char *in)
+{
+	char *p, *ret = in;
+	char delims[] = "/\\";
+	char *i;
+
+	for (i = delims; *i; i++) {
+		p = in;
+		while ((p = strchr(p, *i)) != 0) {
+			ret = ++p;
+		}
+	}
+	return ret;
+}
+
+static void null_logger(char *file, const char *func, int line, int level, char *fmt, ...)
+{
+	if (0) {
+		null_logger(file, func, line, level, fmt);
+	}
+}
+
+static void default_logger(char *file, const char *func, int line, int level, char *fmt, ...)
+{
+	char *fp;
+	char data[1024];
+
+	va_list ap;
+	
+	fp = cut_path(file);
+
+	va_start(ap, fmt);
+
+	vsnprintf(data, sizeof(data), fmt, ap);
+
+	if (level < 0 || level > 7) {
+		level = 7;
+	}
+
+	fprintf(stderr, "[%s] %s:%d %s() %s", LEVEL_NAMES[level], file, line, func, data);
+
+	va_end(ap);
+
+}
+
+zap_logger_t global_logger = null_logger;
+
+void zap_global_set_logger(zap_logger_t logger)
+{
+	if (logger) {
+		global_logger = logger;
+	} else {
+		global_logger = null_logger;
+	}
+}
+
+void zap_global_set_default_logger(void)
+{
+	global_logger = default_logger;
+}
 
 static int equalkeys(const void *k1, const void *k2)
 {

libs/freetdm/src/wanpipe

-CFLAGS +=-DZAP_WANPIPE_SUPPORT
+MOD_CFLAGS +=-DZAP_WANPIPE_SUPPORT
 OBJS += zap_wanpipe.o
 WANPIPE_INCLUDE=/usr/include/wanpipe
-#WANPIPE_INCLUDE=../../wanpipe-3.1.0.p18/patches/kdrivers/include
 
 WP_CFLAGS =-I$(WANPIPE_INCLUDE) -I/usr/local/include -I/usr/src/linux/include -I. -I/usr/include 
 WP_CFLAGS +=-D__LINUX__ -D_REENTRANT -D_GNU_SOURCE -DAFT_A104 -DWANPIPE_TDM_API -D_GNUC_ -DWANPIPE_TDM_API

libs/freetdm/src/zap_buffer.c

+/*
+ * 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.
+ */
+
+#include "openzap.h"
+#include "zap_buffer.h"
+
+static unsigned buffer_id = 0;
+
+struct zap_buffer {
+	unsigned char *data;
+	unsigned char *head;
+	zap_size_t used;
+	zap_size_t actually_used;
+	zap_size_t datalen;
+	zap_size_t max_len;
+	zap_size_t blocksize;
+	unsigned id;
+	int loops;
+};
+
+
+zap_status_t zap_buffer_create(zap_buffer_t **buffer, zap_size_t blocksize, zap_size_t start_len, zap_size_t max_len)
+{
+	zap_buffer_t *new_buffer;
+
+	if ((new_buffer = malloc(sizeof(*new_buffer)))) {
+		memset(new_buffer, 0, sizeof(*new_buffer));
+
+		if (start_len) {
+			if (!(new_buffer->data = malloc(start_len))) {
+				free(new_buffer);
+				return ZAP_MEMERR;
+			}
+			memset(new_buffer->data, 0, start_len);
+		}
+
+		new_buffer->max_len = max_len;
+		new_buffer->datalen = start_len;
+		new_buffer->id = buffer_id++;
+		new_buffer->blocksize = blocksize;
+		new_buffer->head = new_buffer->data;
+
+		*buffer = new_buffer;
+		return ZAP_SUCCESS;
+	}
+
+	return ZAP_MEMERR;
+}
+
+zap_size_t zap_buffer_len(zap_buffer_t *buffer)
+{
+
+	assert(buffer != NULL);
+
+	return buffer->datalen;
+
+}
+
+
+zap_size_t zap_buffer_freespace(zap_buffer_t *buffer)
+{
+	assert(buffer != NULL);
+
+
+	if (buffer->max_len) {
+		return (zap_size_t) (buffer->max_len - buffer->used);
+	}
+	return 1000000;
+
+}
+
+zap_size_t zap_buffer_inuse(zap_buffer_t *buffer)
+{
+	assert(buffer != NULL);
+
+	return buffer->used;
+}
+
+zap_size_t zap_buffer_toss(zap_buffer_t *buffer, zap_size_t datalen)
+{
+	zap_size_t reading = 0;
+
+	assert(buffer != NULL);
+
+	if (buffer->used < 1) {
+		buffer->used = 0;
+		return 0;
+	} else if (buffer->used >= datalen) {
+		reading = datalen;
+	} else {
+		reading = buffer->used;
+	}
+
+	buffer->used -= reading;
+	buffer->head += reading;
+
+	return buffer->used;
+}
+
+void zap_buffer_set_loops(zap_buffer_t *buffer, int loops)
+{
+	buffer->loops = loops;
+}
+
+zap_size_t zap_buffer_read_loop(zap_buffer_t *buffer, void *data, zap_size_t datalen)
+{
+	zap_size_t len;
+	if ((len = zap_buffer_read(buffer, data, datalen)) == 0) {
+		if (buffer->loops == 0) {
+			return 0;
+		}
+		buffer->head = buffer->data;
+		buffer->used = buffer->actually_used;
+		len = zap_buffer_read(buffer, data, datalen);
+		buffer->loops--;
+	}
+	return len;
+}
+
+zap_size_t zap_buffer_read(zap_buffer_t *buffer, void *data, zap_size_t datalen)
+{
+	zap_size_t reading = 0;
+
+	assert(buffer != NULL);
+	assert(data != NULL);
+
+
+	if (buffer->used < 1) {
+		buffer->used = 0;
+		return 0;
+	} else if (buffer->used >= datalen) {
+		reading = datalen;
+	} else {
+		reading = buffer->used;
+	}
+
+	memcpy(data, buffer->head, reading);
+	buffer->used -= reading;
+	buffer->head += reading;
+
+	/* if (buffer->id == 4) printf("%u o %d = %d\n", buffer->id, (unsigned)reading, (unsigned)buffer->used); */
+	return reading;
+}
+
+zap_size_t zap_buffer_write(zap_buffer_t *buffer, const void *data, zap_size_t datalen)
+{
+	zap_size_t freespace, actual_freespace;
+
+	assert(buffer != NULL);
+	assert(data != NULL);
+	assert(buffer->data != NULL);
+
+	if (!datalen) {
+		return buffer->used;
+	}
+
+	actual_freespace = buffer->datalen - buffer->actually_used;
+
+	if (actual_freespace < datalen) {
+		memmove(buffer->data, buffer->head, buffer->used);
+		buffer->head = buffer->data;
+		buffer->actually_used = buffer->used;
+	}
+
+	freespace = buffer->datalen - buffer->used;
+
+	/*
+	   if (buffer->data != buffer->head) {
+	   memmove(buffer->data, buffer->head, buffer->used);
+	   buffer->head = buffer->data;
+	   }
+	 */
+	
+	if (freespace < datalen) {
+		zap_size_t new_size, new_block_size;
+		
+		new_size = buffer->datalen + datalen;
+		new_block_size = buffer->datalen + buffer->blocksize;
+
+		if (new_block_size > new_size) {
+			new_size = new_block_size;
+		}
+		buffer->head = buffer->data;
+		if (!(buffer->data = realloc(buffer->data, new_size))) {
+			return 0;
+		}
+		buffer->head = buffer->data;
+		buffer->datalen = new_size;
+	}
+	
+
+	freespace = buffer->datalen - buffer->used;
+
+	if (freespace < datalen) {
+		return 0;
+	} else {
+		memcpy(buffer->head + buffer->used, data, datalen);
+		buffer->used += datalen;
+		buffer->actually_used += datalen;
+	}
+	/* if (buffer->id == 4) printf("%u i %d = %d\n", buffer->id, (unsigned)datalen, (unsigned)buffer->used); */
+
+	return buffer->used;
+}
+
+void zap_buffer_zero(zap_buffer_t *buffer)
+{
+	assert(buffer != NULL);
+	assert(buffer->data != NULL);
+
+	buffer->used = 0;
+	buffer->head = buffer->data;
+}
+
+void zap_buffer_destroy(zap_buffer_t **buffer)
+{
+	if (*buffer) {
+		free((*buffer)->data);
+		free(*buffer);
+	}
+
+	*buffer = NULL;
+}
+
+/* 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 expandtab:
+ */

libs/freetdm/src/zt

-CFLAGS +=-DZAP_ZT_SUPPORT
+MOD_CFLAGS +=-DZAP_ZT_SUPPORT
 OBJS += zap_zt.o