Author: anthm Date: Thu Jul 6 16:12:53 2006 New Revision: 1770 Added: freeswitch/trunk/src/mod/applications/mod_conference/ freeswitch/trunk/src/mod/applications/mod_conference/mod_conference.c freeswitch/trunk/src/mod/applications/mod_conference/mod_conference.vcproj (contents, props changed) Modified: freeswitch/trunk/conf/freeswitch.xml freeswitch/trunk/w32/vsnet/Freeswitch.sln Log: add a new software conference module (mod_conference) Modified: freeswitch/trunk/conf/freeswitch.xml ============================================================================== --- freeswitch/trunk/conf/freeswitch.xml (original) +++ freeswitch/trunk/conf/freeswitch.xml Thu Jul 6 16:12:53 2006 @@ -7,7 +7,7 @@ <load module="mod_console"/> <!-- <load module="mod_syslog"/> --> - <!-- XML Interfaces --> + <!-- XML Interfaces --> <!-- <load module="mod_xml_rpc"/> --> <!-- Event Handlers --> @@ -59,6 +59,10 @@ <!-- ASR /TTS --> <!-- <load module="mod_cepstral"/> --> <!-- <load module="mod_rss"/> --> + + <!-- Conference Bridges --> + <!--<load module="mod_conference"/>--> + </modules> </configuration> @@ -107,12 +111,12 @@ <param name="dialplan" value="XML"/> <param name="dtmf-duration" value="100"/> <param name="codec-prefs" value="PCMU,PCMA"/> - <!-- Payload number to bind DTMF to--> + <!-- Payload number to bind DTMF to--> <param name="rfc2833-pt" value="101"/> - <!-- disable to trade async for more calls --> - <param name="use-rtp-timer" value="true"/> - <!-- auto sense NAT issues and adjust accordingly --> - <param name="use-rtp-auto-adjust" value="true"/> + <!-- disable to trade async for more calls --> + <param name="use-rtp-timer" value="true"/> + <!-- auto sense NAT issues and adjust accordingly --> + <param name="use-rtp-auto-adjust" value="true"/> <!-- pick one (default if not specified is 'guess'); --> <param name="rtp-ip" value="guess"/> <!-- <param name-"rtp-ip" value="10.0.0.1"/> --> @@ -228,8 +232,8 @@ <param name="message" value="Jingle all the way"/> <param name="rtp-ip" value="10.0.0.1"/> <param name="auto-login" value="true"/> - <!-- disable to trade async for more calls --> - <param name="use-rtp-timer" value="true"/> + <!-- disable to trade async for more calls --> + <param name="use-rtp-timer" value="true"/> <!-- or --> <!-- <param name="rtp-ip" value="my_lan_ip"/> --> <!-- <param name="ext-rtp-ip" value="stun:stun.server.com"/> --> @@ -243,16 +247,16 @@ </configuration> <configuration name="xml_rpc.conf" description="XML RPC"> <settings> - <!-- The port where you want to run the http service (default 8080) --> - <param name="http-port" value="8080"/> - <!-- if all 3 of the following params exist all http traffic will require auth --> + <!-- The port where you want to run the http service (default 8080) --> + <param name="http-port" value="8080"/> + <!-- if all 3 of the following params exist all http traffic will require auth --> <param name="auth-realm" value="freeswitch"/> <param name="auth-user" value="freeswitch"/> <param name="auth-pass" value="works"/> <!-- The url to a gateway cgi that can generate xml similar to what's in this file only on-the-fly (leave it commented if you dont need it) --> - <!-- one or more |-delim of configuration|directory|dialplan --> + <!-- one or more |-delim of configuration|directory|dialplan --> <!-- <param name="gateway-url" value="http://www.server.com/gateway.cgi" bindings="configuration"/> --> </settings> </configuration> @@ -265,6 +269,48 @@ </feeds> </configuration> + <!-- None of these paths are real if you want any of these options + you need to really set them up --> + <configuration name="conference.conf" description="Audio Conference"> + <!-- Profiles are collections of settings you can reference by name. --> + <profiles> + <profile name="default"> + <!-- Sample Rate--> + <param name="rate" value="8000"/> + <!-- Number of milliseconds per frame --> + <param name="interval" value="20"/> + <!-- Energy level required for audio to be sent to the other users --> + <param name="energy_level" value="300"/> + <!-- File to play to acknowledge succees --> + <!--<param name="ack_sound" value="/soundfiles/beep.wav"/>--> + <!-- File to play to acknowledge failure --> + <!--<param name="nack_sound" value="/soundfiles/beeperr.wav"/>--> + <!-- File to play to acknowledge muted --> + <!--<param name="muted_sound" value="/soundfiles/muted.wav"/>--> + <!-- File to play to acknowledge unmuted --> + <!--<param name="unmuted_sound" value="/soundfiles/unmuted.wav"/>--> + <!-- File to play if you are alone in the conference --> + <!--<param name="alone_sound" value="/soundfiles/yactopitc.wav"/>--> + <!-- File to play when you join the conference --> + <!--<param name="enter_sound" value="/soundfiles/welcome.wav"/>--> + <!-- File to play when you leave the conference --> + <!--<param name="exit_sound" value="/soundfiles/exit.wav"/>--> + <!-- File to play when you ae ejected from the conference --> + <!--<param name="kicked_sound" value="/soundfiles/kicked.wav"/>--> + <!-- File to play when the conference is locked --> + <!--<param name="locked_sound" value="/soundfiles/locked.wav"/>--> + <!-- File to play to prompt for a pin --> + <!--<param name="pin_sound" value="/soundfiles/pin.wav"/>--> + <!-- File to play to when the pin is invalid --> + <!--<param name="bad_pin_sound" value="/soundfiles/invalid-pin.wav"/>--> + <!-- Conference pin --> + <!--<param name="pin" value="12345"/>--> + </profile> + </profiles> + <rooms> + <room name="freeswitch" profile="default"/> + </rooms> + </configuration> </section> <section name="dialplan" description="Regex/XML Dialplan"> <!-- Valid fields in conditions: @@ -274,18 +320,32 @@ <!-- *NOTE* The special context name 'any' will match any context --> <context name="default"> - <extension name="tollfree"> - <condition field="destination_number" expression="^(18[0{2}8{2}7{2}6{2}]\d{7})"> - <action application="bridge" data="exosip/$1-freeswitch@voip.trxtel.com"/> - </condition> - </extension> + <extension name="tollfree"> + <condition field="destination_number" expression="^(18[0{2}8{2}7{2}6{2}]\d{7})"> + <action application="bridge" data="exosip/$1-freeswitch@voip.trxtel.com"/> + </condition> + </extension> - <extension name="devconf"> - <condition field="destination_number" expression="^888$"> - <action application="bridge" data="exosip/888@66.250.68.194"/> - </condition> - </extension> + <extension name="devconf"> + <condition field="destination_number" expression="^888$"> + <action application="bridge" data="exosip/888@66.250.68.194"/> + </condition> + </extension> + <!-- Enter an existing conference --> + <extension name="1000"> + <condition field="destination_number" expression="^1000$"> + <action application="conference" data="1000"/> + </condition> + </extension> + + <!-- Start a dynamic conference and call someone at the same time --> + <extension name="2000"> + <condition field="destination_number" expression="^2000$"> + <action application="conference" data="bridge:mydynaconf:exosip/1234@66.250.68.194"/> + </condition> + </extension> + <!-- if the destination is an exact match on the extension name you do not need any regex in the condition --> <extension name="999"> @@ -294,30 +354,30 @@ <!-- extensions starting with 4, all the numbers after 4 form a numeric filename continue=true means keep looking for more extensions to match *NOTE* The entire dialplan is parsed ONCE when the call starts - so any call info acquired after the various actions cannot - be taken into consideration. + so any call info acquired after the various actions cannot + be taken into consideration. - The first match will play a beep and the second one plays - the desired file. This is for demo purposes both actions - could have been under the same <extension> tag as well. - --> + The first match will play a beep and the second one plays + the desired file. This is for demo purposes both actions + could have been under the same <extension> tag as well. + --> <extension name="playsound1" continue="true"> <condition field="source" expression="mod_exosip"/> <condition field="destination_number" expression="^4(\d+)"> <action application="playback" data="/var/sounds/beep.gsm"/> - </condition> + </condition> </extension> <extension name="playsound2"> <condition field="source" expression="mod_exosip"/> <condition field="destination_number" expression="^4(\d+)"> <action application="playback" data="/root/$1.raw"/> - </condition> + </condition> </extension> <!-- send everything with a certian RDNIS to Wanpipe ISDN --> <extension name="To PRI"> <condition field="rdnis" expression="8881231234"/> <condition field="destination_number" expression="(.*)"> - <action application="bridge" data="wanpipe/a/a/$1"/> + <action application="bridge" data="wanpipe/a/a/$1"/> </condition> </extension> <!-- Call *MUST* originate from mod_iax and also be dialing ext 9999--> Added: freeswitch/trunk/src/mod/applications/mod_conference/mod_conference.c ============================================================================== --- (empty file) +++ freeswitch/trunk/src/mod/applications/mod_conference/mod_conference.c Thu Jul 6 16:12:53 2006 @@ -0,0 +1,2475 @@ +/* + * FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application + * 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 FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application + * + * 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> + * + * + * mod_conference.c -- Software Conference Bridge + * + */ +#include <switch.h> + +static const char modname[] = "mod_conference"; +static const char global_app_name[] = "conference"; +static char *global_cf_name = "conference.conf"; + +/* Size to allocate for audio buffers */ +#define CONF_BUFFER_SIZE 1024 * 128 +#define CONF_EVENT_MAINT "conference::maintenence" +#define CONF_DEFAULT_LEADIN 20 + +typedef enum { + FILE_STOP_CURRENT, + FILE_STOP_ALL +} file_stop_t; + +/* Global Values */ +static struct { + switch_memory_pool_t *conference_pool; + switch_mutex_t *conference_mutex; + switch_hash_t *conference_hash; + switch_mutex_t *id_mutex; + switch_mutex_t *hash_mutex; + uint32_t id_pool; +} globals; + +struct conference_member; +struct conference_obj; +typedef struct conference_obj conference_obj_t; +typedef struct conference_member conference_member_t; + +typedef enum { + MFLAG_RUNNING = (1 << 0), + MFLAG_CAN_SPEAK = (1 << 1), + MFLAG_CAN_HEAR = (1 << 2), + MFLAG_KICKED = (1 << 3), + MFLAG_ITHREAD = (1 << 4) +} member_flag_t; + + +typedef enum { + CFLAG_RUNNING = (1 << 0), + CFLAG_DYNAMIC = (1 << 1), + CFLAG_ENFORCE_MIN = (1 << 2), + CFLAG_DESTRUCT = (1 << 3), + CFLAG_LOCKED = (1 << 4) +} conf_flag_t; + +typedef enum { + RFLAG_CAN_SPEAK = (1 << 0), + RFLAG_CAN_HEAR = (1 << 1) +} relation_flag_t; + +typedef enum { + NODE_TYPE_FILE, + NODE_TYPE_SPEECH +} node_type_t; + +struct confernce_file_node { + switch_file_handle_t fh; + switch_speech_handle_t sh; + node_type_t type; + uint8_t done; + switch_memory_pool_t *pool; + uint32_t leadin; + struct confernce_file_node *next; +}; + +typedef struct confernce_file_node confernce_file_node_t; + +/* Conference Object */ +struct conference_obj { + char *name; + char *timer_name; + char *tts_engine; + char *tts_voice; + char *enter_sound; + char *exit_sound; + char *alone_sound; + char *ack_sound; + char *nack_sound; + char *muted_sound; + char *unmuted_sound; + char *locked_sound; + char *kicked_sound; + char *caller_id_name; + char *caller_id_number; + char *pin; + char *pin_sound; + char *bad_pin_sound; + uint32_t flags; + switch_mutex_t *flag_mutex; + uint32_t rate; + uint32_t interval; + switch_mutex_t *mutex; + conference_member_t *members; + switch_mutex_t *member_mutex; + confernce_file_node_t *fnode; + switch_memory_pool_t *pool; + switch_thread_rwlock_t *rwlock; + uint32_t count; + uint32_t energy_level; + uint8_t min; +}; + +/* Relationship with another member */ +struct conference_relationship { + uint32_t id; + uint32_t flags; + struct conference_relationship *next; +}; +typedef struct conference_relationship conference_relationship_t; + +/* Conference Member Object */ +struct conference_member { + uint32_t id; + switch_core_session_t *session; + conference_obj_t *conference; + conference_obj_t *last_conference; + switch_memory_pool_t *pool; + switch_buffer_t *audio_buffer; + switch_buffer_t *mux_buffer; + uint32_t flags; + switch_mutex_t *flag_mutex; + switch_mutex_t *audio_in_mutex; + switch_mutex_t *audio_out_mutex; + switch_codec_t read_codec; + switch_codec_t write_codec; + uint8_t *frame; + uint8_t *mux_frame; + uint32_t buflen; + uint32_t read; + uint32_t len; + confernce_file_node_t *fnode; + conference_relationship_t *relationships; + struct conference_member *next; +}; + +/* Function Prototypes */ +static uint32_t next_member_id(void); +static conference_relationship_t *member_get_relationship(conference_member_t *member, conference_member_t *other_member); +static conference_member_t *conference_member_get(conference_obj_t *conference, uint32_t id); +static conference_relationship_t *member_add_relationship(conference_member_t *member, uint32_t id); +static void member_del_relationship(conference_member_t *member, uint32_t id); +static switch_status_t conference_add_member(conference_obj_t *conference, conference_member_t *member); +static void conference_del_member(conference_obj_t *conference, conference_member_t *member); +static void *SWITCH_THREAD_FUNC conference_thread_run(switch_thread_t *thread, void *obj); +static void conference_loop(conference_member_t *member); +static uint32_t conference_stop_file(conference_obj_t *conference, file_stop_t stop); +static switch_status_t conference_play_file(conference_obj_t *conference, char *file, uint32_t leadin); +static switch_status_t conference_say(conference_obj_t *conference, char *text, uint32_t leadin); +static void conference_list(conference_obj_t *conference, switch_stream_handle_t *stream, char *delim); +static switch_status_t conf_function(char *buf, switch_stream_handle_t *stream); +static switch_status_t audio_bridge_on_ring(switch_core_session_t *session); +static switch_status_t conference_outcall(conference_obj_t *conference, switch_core_session_t *session, char *bridgeto, char *cid_name, char *cid_num); +static void conference_function(switch_core_session_t *session, char *data); +static void launch_conference_thread(conference_obj_t *conference); +static void *SWITCH_THREAD_FUNC input_thread_run(switch_thread_t *thread, void *obj); +static void launch_input_thread(conference_member_t *member, switch_memory_pool_t *pool); +static switch_status_t conference_local_play_file(switch_core_session_t *session, char *path, uint32_t leadin, char *buf, switch_size_t len); +static switch_status_t conference_member_play_file(conference_member_t *member, char *file, uint32_t leadin); +static switch_status_t conference_member_say(conference_obj_t *conference, conference_member_t *member, char *text, uint32_t leadin); +static uint32_t conference_member_stop_file(conference_member_t *member, file_stop_t stop); +static conference_obj_t *conference_new(char *name, switch_xml_t profile, switch_memory_pool_t *pool); + +/* Return a Distinct ID # */ +static uint32_t next_member_id(void) +{ + uint32_t id; + + switch_mutex_lock(globals.id_mutex); + id = ++globals.id_pool; + switch_mutex_unlock(globals.id_mutex); + + return id; +} + +/* if other_member has a relationship with member, produce it */ +static conference_relationship_t *member_get_relationship(conference_member_t *member, conference_member_t *other_member) +{ + conference_relationship_t *rel = NULL, *global = NULL; + + switch_mutex_lock(member->flag_mutex); + switch_mutex_lock(other_member->flag_mutex); + + if (member->relationships) { + for (rel = member->relationships; rel; rel = rel->next) { + if (rel->id == other_member->id) { + break; + } + + /* 0 matches everyone. + (We will still test the others brcause a real match carries more clout) */ + + if (rel->id == 0) { + global = rel; + } + } + } + + switch_mutex_unlock(other_member->flag_mutex); + switch_mutex_unlock(member->flag_mutex); + + if (!rel && global) { + rel = global; + } + + return rel; +} + +static conference_member_t *conference_member_get(conference_obj_t *conference, uint32_t id) +{ + conference_member_t *member = NULL; + + for(member = conference->members; member; member = member->next) { + if (member->id == id) { + break; + } + } + + return member; +} + +/* Add a custom relationship to a member */ +static conference_relationship_t *member_add_relationship(conference_member_t *member, uint32_t id) +{ + conference_relationship_t *rel = NULL; + + if ((rel = switch_core_alloc(member->pool, sizeof(*rel)))) { + rel->id = id; + + switch_mutex_lock(member->flag_mutex); + rel->next = member->relationships; + member->relationships = rel; + switch_mutex_unlock(member->flag_mutex); + } + + return rel; +} + +/* Remove a custom relationship from a member */ +static void member_del_relationship(conference_member_t *member, uint32_t id) +{ + conference_relationship_t *rel, *last = NULL; + + switch_mutex_lock(member->flag_mutex); + for (rel = member->relationships; rel; rel = rel->next) { + if (rel->id == id) { + /* we just forget about rel here cos it was allocated by the member's pool + it will be freed when the member is */ + if (last) { + last->next = rel->next; + } else { + member->relationships = rel->next; + } + } + last = rel; + } + switch_mutex_unlock(member->flag_mutex); +} + +/* Gain exclusive access and add the member to the list */ +static switch_status_t conference_add_member(conference_obj_t *conference, conference_member_t *member) +{ + switch_event_t *event; + + if (switch_thread_rwlock_tryrdlock(conference->rwlock) != SWITCH_STATUS_SUCCESS) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Read Lock Fail\n"); + return SWITCH_STATUS_FALSE; + } + + switch_mutex_lock(conference->mutex); + switch_mutex_lock(conference->member_mutex); + switch_mutex_lock(member->audio_in_mutex); + switch_mutex_lock(member->audio_out_mutex); + switch_mutex_lock(member->flag_mutex); + member->conference = member->last_conference = conference; + member->next = conference->members; + conference->members = member; + conference->count++; + + if (conference->enter_sound) { + conference_play_file(conference, conference->enter_sound, CONF_DEFAULT_LEADIN); + } + + if (conference->count == 1 && conference->alone_sound) { + conference_play_file(conference, conference->alone_sound, CONF_DEFAULT_LEADIN); + } + + if (conference->min && conference->count >= conference->min) { + switch_set_flag(conference, CFLAG_ENFORCE_MIN); + } + + if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) { + switch_channel_t *channel = switch_core_session_get_channel(member->session); + switch_channel_event_set_data(channel, event); + + switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Conference-Name", conference->name); + switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Action", "add-member"); + switch_event_fire(&event); + } + + switch_mutex_unlock(member->flag_mutex); + switch_mutex_unlock(member->audio_out_mutex); + switch_mutex_unlock(member->audio_in_mutex); + switch_mutex_unlock(conference->member_mutex); + switch_mutex_unlock(conference->mutex); + + return SWITCH_STATUS_SUCCESS; +} + +/* Gain exclusive access and remove the member from the list */ +static void conference_del_member(conference_obj_t *conference, conference_member_t *member) +{ + conference_member_t *imember, *last = NULL; + switch_event_t *event; + + switch_mutex_lock(conference->mutex); + switch_mutex_lock(conference->member_mutex); + switch_mutex_lock(member->audio_in_mutex); + switch_mutex_lock(member->audio_out_mutex); + switch_mutex_lock(member->flag_mutex); + + for (imember = conference->members; imember; imember = imember->next) { + if (imember == member ) { + if (last) { + last->next = imember->next; + } else { + conference->members = imember->next; + } + break; + } + last = imember; + } + conference->count--; + member->conference = NULL; + + if (conference->min && switch_test_flag(conference, CFLAG_ENFORCE_MIN) && conference->count < conference->min) { + switch_set_flag(conference, CFLAG_DESTRUCT); + } else { + if (conference->exit_sound) { + conference_play_file(conference, conference->exit_sound, 0); + } + if (conference->count == 1 && conference->alone_sound) { + conference_play_file(conference, conference->alone_sound, 0); + } + } + + if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) { + switch_channel_t *channel = switch_core_session_get_channel(member->session); + switch_channel_event_set_data(channel, event); + + switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Conference-Name", conference->name); + switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Action", "del-member"); + switch_event_fire(&event); + } + + switch_mutex_unlock(member->flag_mutex); + switch_mutex_unlock(member->audio_out_mutex); + switch_mutex_unlock(member->audio_in_mutex); + switch_mutex_unlock(conference->member_mutex); + switch_mutex_unlock(conference->mutex); + + + switch_thread_rwlock_unlock(conference->rwlock); + +} + +/* Main monitor thread (1 per distinct conference room) */ +static void *SWITCH_THREAD_FUNC conference_thread_run(switch_thread_t *thread, void *obj) +{ + conference_obj_t *conference = (conference_obj_t *) obj; + conference_member_t *imember, *omember; + uint32_t divider = 1000 / conference->interval; + uint32_t samples = (conference->rate / divider); + uint32_t bytes = samples * 2; + uint8_t ready = 0; + switch_timer_t timer = {0}; + + if (switch_core_timer_init(&timer, conference->timer_name, conference->interval, samples, conference->pool) == SWITCH_STATUS_SUCCESS) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "setup timer success interval: %u samples: %u\n", conference->interval, samples); + } else { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Timer Setup Failed. Conference Cannot Start\n"); + return NULL; + } + + while(!switch_test_flag(conference, CFLAG_DESTRUCT)) { + uint8_t file_frame[CONF_BUFFER_SIZE] = {0}; + switch_size_t file_sample_len = samples; + switch_size_t file_data_len = samples * 2; + + /* Sync the conference to a single timing source */ + switch_core_timer_next(&timer); + + switch_mutex_lock(conference->mutex); + ready = 0; + + /* Read one frame of audio from each member channel and save it for redistribution */ + for (imember = conference->members; imember; imember = imember->next) { + if (imember->buflen) { + memset(imember->frame, 255, bytes); + } else { + imember->frame = switch_core_alloc(imember->pool, bytes); + imember->mux_frame = switch_core_alloc(imember->pool, bytes); + imember->buflen = bytes; + } + + switch_mutex_lock(imember->audio_in_mutex); + if ((imember->read = (uint32_t)switch_buffer_read(imember->audio_buffer, imember->frame, imember->buflen))) { + ready++; /* Tally of how many channels had data */ + } + switch_mutex_unlock(imember->audio_in_mutex); + } + + /* If a file or speech event is being played */ + if (conference->fnode) { + /* Lead in time */ + if (conference->fnode->leadin) { + conference->fnode->leadin--; + } else { + ready++; + if (conference->fnode->type == NODE_TYPE_SPEECH) { + switch_speech_flag_t flags = SWITCH_SPEECH_FLAG_BLOCKING; + uint32_t rate = conference->rate; + + if (switch_core_speech_read_tts(&conference->fnode->sh, + file_frame, + &file_data_len, + &rate, + &flags) == SWITCH_STATUS_SUCCESS) { + file_sample_len = file_data_len / 2; + } else { + file_sample_len = file_data_len = 0; + } + } else if (conference->fnode->type == NODE_TYPE_FILE) { + switch_core_file_read(&conference->fnode->fh, file_frame, &file_sample_len); + } + + if (file_sample_len <= 0) { + conference->fnode->done++; + } + } + } + + if (ready) { + /* Build a muxed frame for every member that contains the mixed audio of everyone else */ + for (omember = conference->members; omember; omember = omember->next) { + if (conference->fnode) { + memcpy(omember->mux_frame, file_frame, file_sample_len * 2); + omember->len = bytes; + } else { + memset(omember->mux_frame, 255, bytes); + } + for (imember = conference->members; imember; imember = imember->next) { + + if (imember == omember) { + /* Don't add audio from yourself */ + continue; + } + + if (imember->read) { /* mux the frame with the collective */ + uint32_t x; + int16_t *bptr, *muxed; + + /* If they are not supposed to talk to us then don't let them */ + if (omember->relationships) { + conference_relationship_t *rel; + + if ((rel = member_get_relationship(omember, imember))) { + if (! switch_test_flag(rel, RFLAG_CAN_HEAR)) { + continue; + } + } + } + + /* If we are not supposed to hear them then don't let it happen */ + if (imember->relationships) { + conference_relationship_t *rel; + + if ((rel = member_get_relationship(imember, omember))) { + if (! switch_test_flag(rel, RFLAG_CAN_SPEAK)) { + continue; + } + } + } + + if (imember->read > imember->len) { + imember->len = imember->read; + } + + bptr = (int16_t *) imember->frame; + muxed = (int16_t *) omember->mux_frame; + + for (x = 0; x < imember->read / 2; x++) { + muxed[x] = muxed[x] + bptr[x]; + } + + ready++; + } + } + } + + /* Go back and write each member his dedicated copy of the audio frame that does not contain his own audio. */ + for (imember = conference->members; imember; imember = imember->next) { + switch_mutex_lock(imember->audio_out_mutex); + switch_buffer_write(imember->mux_buffer, imember->mux_frame, imember->len); + switch_mutex_unlock(imember->audio_out_mutex); + } + } + + + if (conference->fnode && conference->fnode->done) { + confernce_file_node_t *fnode; + switch_memory_pool_t *pool; + + if (conference->fnode->type == NODE_TYPE_SPEECH) { + switch_speech_flag_t flags = SWITCH_SPEECH_FLAG_TTS; + switch_core_speech_close(&conference->fnode->sh, &flags); + } else { + switch_core_file_close(&conference->fnode->fh); + } + + fnode = conference->fnode; + conference->fnode = conference->fnode->next; + + pool = fnode->pool; + fnode = NULL; + switch_core_destroy_memory_pool(&pool); + + } + + switch_mutex_unlock(conference->mutex); + } /* Rinse ... Repeat */ + + switch_core_timer_destroy(&timer); + + if (switch_test_flag(conference, CFLAG_DESTRUCT)) { + + switch_mutex_lock(conference->mutex); + + for(imember = conference->members; imember; imember = imember->next) { + switch_channel_t *channel = switch_core_session_get_channel(imember->session); + switch_channel_hangup(channel, SWITCH_CAUSE_NORMAL_CLEARING); + switch_clear_flag_locked(imember, MFLAG_RUNNING); + } + + switch_mutex_unlock(conference->mutex); + + /* Wait till everybody is out */ + + switch_thread_rwlock_wrlock(conference->rwlock); + switch_thread_rwlock_unlock(conference->rwlock); + + switch_mutex_lock(globals.hash_mutex); + switch_core_hash_delete(globals.conference_hash, conference->name); + switch_mutex_unlock(globals.hash_mutex); + + if (conference->pool) { + switch_memory_pool_t *pool = conference->pool; + switch_core_destroy_memory_pool(&pool); + } + } + + return NULL; +} + +/* Sub-Routine called by a channel inside a conference */ +static void conference_loop(conference_member_t *member) +{ + switch_channel_t *channel; + switch_frame_t write_frame = {0}; + uint8_t data[SWITCH_RECCOMMENDED_BUFFER_SIZE]; + switch_timer_t timer = {0}; + uint32_t divider = 1000 / member->conference->interval; + uint32_t samples = (member->conference->rate / divider); + uint32_t bytes = samples * 2; + + channel = switch_core_session_get_channel(member->session); + + assert(channel != NULL); + assert(member->conference != NULL); + + if (switch_core_timer_init(&timer, + member->conference->timer_name, + member->conference->interval, + samples, + NULL) == SWITCH_STATUS_SUCCESS) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "XXXsetup timer %s success interval: %u samples: %u\n", + member->conference->timer_name, member->conference->interval, samples); + } else { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Timer Setup Failed. Conference Cannot Start\n"); + return; + } + + /* Answer the channel */ + switch_channel_answer(channel); + + /* Prepare the write frame */ + write_frame.data = data; + write_frame.buflen = sizeof(data); + write_frame.codec = &member->write_codec; + + /* Start a thread to read data and feed it into the buffer and use this thread to generate output */ + launch_input_thread(member, switch_core_session_get_pool(member->session)); + + while(switch_test_flag(member, MFLAG_RUNNING) && switch_test_flag(member, MFLAG_ITHREAD) && switch_channel_ready(channel)) { + char dtmf[128] = ""; + uint8_t file_frame[CONF_BUFFER_SIZE] = {0}; + switch_size_t file_data_len = samples * 2; + switch_size_t file_sample_len = samples; + char *digit; + + switch_core_timer_next(&timer); + + if (switch_channel_has_dtmf(channel)) { + switch_channel_dequeue_dtmf(channel, dtmf, sizeof(dtmf)); + } + + for (digit = dtmf; *digit; digit++) { + switch(*digit) { + case '1': + if (switch_test_flag(member, MFLAG_CAN_SPEAK)) { + switch_clear_flag_locked(member, MFLAG_CAN_SPEAK); + if (member->conference->muted_sound) { + conference_member_play_file(member, member->conference->muted_sound, 0); + } + } else { + switch_set_flag_locked(member, MFLAG_CAN_SPEAK); + if (member->conference->unmuted_sound) { + conference_member_play_file(member, member->conference->unmuted_sound, 0); + } + } + + break; + case '#': + switch_clear_flag_locked(member, MFLAG_RUNNING); + break; + default: + break; + } + } + + if (member->fnode) { + if (member->fnode->done) { + confernce_file_node_t *fnode; + switch_memory_pool_t *pool; + + if (member->fnode->type == NODE_TYPE_SPEECH) { + switch_speech_flag_t flags = SWITCH_SPEECH_FLAG_TTS; + switch_core_speech_close(&member->fnode->sh, &flags); + } else { + switch_core_file_close(&member->fnode->fh); + } + + switch_mutex_lock(member->flag_mutex); + fnode = member->fnode; + member->fnode = member->fnode->next; + switch_mutex_unlock(member->flag_mutex); + + pool = fnode->pool; + fnode = NULL; + switch_core_destroy_memory_pool(&pool); + + } else { + if (member->fnode->leadin) { + member->fnode->leadin--; + } else { + if (member->fnode->type == NODE_TYPE_SPEECH) { + switch_speech_flag_t flags = SWITCH_SPEECH_FLAG_BLOCKING; + uint32_t rate = member->conference->rate; + + if (switch_core_speech_read_tts(&member->fnode->sh, + file_frame, + &file_data_len, + &rate, + &flags) == SWITCH_STATUS_SUCCESS) { + file_sample_len = file_data_len / 2; + } else { + file_sample_len = file_data_len = 0; + } + } else if (member->fnode->type == NODE_TYPE_FILE) { + switch_core_file_read(&member->fnode->fh, file_frame, &file_sample_len); + file_data_len = file_sample_len * 2; + } + + if (file_sample_len <= 0) { + member->fnode->done++; + } else { /* there is file node data to deliver */ + write_frame.data = file_frame; + write_frame.datalen = (uint32_t)file_data_len; + write_frame.samples = (uint32_t)file_sample_len; + switch_core_session_write_frame(member->session, &write_frame, -1, 0); + + /* forget the conference data we played file node data instead */ + switch_mutex_lock(member->audio_out_mutex); + switch_buffer_zero(member->mux_buffer); + switch_mutex_unlock(member->audio_out_mutex); + } + } + } + } else { + /* Flush the output buffer and write all the data (presumably muxed) back to the channel */ + switch_mutex_lock(member->audio_out_mutex); + write_frame.data = data; + while ((write_frame.datalen = (uint32_t)switch_buffer_read(member->mux_buffer, write_frame.data, bytes))) { + if (write_frame.datalen && switch_test_flag(member, MFLAG_CAN_HEAR)) { + write_frame.samples = write_frame.datalen / 2; + switch_core_session_write_frame(member->session, &write_frame, -1, 0); + } + } + switch_mutex_unlock(member->audio_out_mutex); + } + } /* Rinse ... Repeat */ + + switch_clear_flag_locked(member, MFLAG_RUNNING); + switch_core_timer_destroy(&timer); + + /* Wait for the input thead to end */ + while(switch_test_flag(member, MFLAG_ITHREAD)) { + switch_yield(1000); + } +} + +/* Make files stop playing in a conference either the current one or all of them */ +static uint32_t conference_stop_file(conference_obj_t *conference, file_stop_t stop) +{ + confernce_file_node_t *nptr; + uint32_t count = 0; + + switch_mutex_lock(conference->mutex); + + if (stop == FILE_STOP_ALL) { + for (nptr = conference->fnode; nptr; nptr = nptr->next) { + nptr->done++; + count++; + } + } else { + if (conference->fnode) { + conference->fnode->done++; + count++; + } + } + + switch_mutex_unlock(conference->mutex); + + return count; +} + +static uint32_t conference_member_stop_file(conference_member_t *member, file_stop_t stop) +{ + confernce_file_node_t *nptr; + uint32_t count = 0; + + switch_mutex_lock(member->flag_mutex); + + if (stop == FILE_STOP_ALL) { + for (nptr = member->fnode; nptr; nptr = nptr->next) { + nptr->done++; + count++; + } + } else { + if (member->fnode) { + member->fnode->done++; + count++; + } + } + + switch_mutex_unlock(member->flag_mutex); + + return count; +} + +/* Play a file in the conference rooom */ +static switch_status_t conference_play_file(conference_obj_t *conference, char *file, uint32_t leadin) +{ + confernce_file_node_t *fnode, *nptr; + switch_memory_pool_t *pool; + + /* Setup a memory pool to use. */ + if (switch_core_new_memory_pool(&pool) != SWITCH_STATUS_SUCCESS) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Pool Failure\n"); + return SWITCH_STATUS_MEMERR; + } + + /* Create a node object*/ + if (!(fnode = switch_core_alloc(pool, sizeof(*fnode)))) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Alloc Failure\n"); + switch_core_destroy_memory_pool(&pool); + return SWITCH_STATUS_MEMERR; + } + + fnode->type = NODE_TYPE_FILE; + fnode->leadin = leadin; + + /* Open the file */ + if (switch_core_file_open(&fnode->fh, + file, + SWITCH_FILE_FLAG_READ | SWITCH_FILE_DATA_SHORT, + pool) != SWITCH_STATUS_SUCCESS) { + switch_core_destroy_memory_pool(&pool); + return SWITCH_STATUS_NOTFOUND; + } + + fnode->pool = pool; + + /* Queue the node */ + switch_mutex_lock(conference->mutex); + for (nptr = conference->fnode; nptr && nptr->next; nptr = nptr->next); + + if (nptr) { + nptr->next = fnode; + } else { + conference->fnode = fnode; + } + switch_mutex_unlock(conference->mutex); + + return SWITCH_STATUS_SUCCESS; +} + + +/* Play a file in the conference rooom to a member */ +static switch_status_t conference_member_play_file(conference_member_t *member, char *file, uint32_t leadin) +{ + confernce_file_node_t *fnode, *nptr; + switch_memory_pool_t *pool; + + /* Setup a memory pool to use. */ + if (switch_core_new_memory_pool(&pool) != SWITCH_STATUS_SUCCESS) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Pool Failure\n"); + return SWITCH_STATUS_MEMERR; + } + + /* Create a node object*/ + if (!(fnode = switch_core_alloc(pool, sizeof(*fnode)))) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Alloc Failure\n"); + switch_core_destroy_memory_pool(&pool); + return SWITCH_STATUS_MEMERR; + } + + fnode->type = NODE_TYPE_FILE; + fnode->leadin = leadin; + + /* Open the file */ + if (switch_core_file_open(&fnode->fh, + file, + SWITCH_FILE_FLAG_READ | SWITCH_FILE_DATA_SHORT, + pool) != SWITCH_STATUS_SUCCESS) { + switch_core_destroy_memory_pool(&pool); + return SWITCH_STATUS_NOTFOUND; + } + + fnode->pool = pool; + + /* Queue the node */ + switch_mutex_lock(member->flag_mutex); + for (nptr = member->fnode; nptr && nptr->next; nptr = nptr->next); + + if (nptr) { + nptr->next = fnode; + } else { + member->fnode = fnode; + } + switch_mutex_unlock(member->flag_mutex); + + return SWITCH_STATUS_SUCCESS; +} + +/* Say some thing with TTS in the conference rooom */ +static switch_status_t conference_member_say(conference_obj_t *conference, conference_member_t *member, char *text, uint32_t leadin) +{ + confernce_file_node_t *fnode, *nptr; + switch_memory_pool_t *pool; + switch_speech_flag_t flags = SWITCH_SPEECH_FLAG_TTS; + + /* Setup a memory pool to use. */ + if (switch_core_new_memory_pool(&pool) != SWITCH_STATUS_SUCCESS) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Pool Failure\n"); + return SWITCH_STATUS_MEMERR; + } + + /* Create a node object*/ + if (!(fnode = switch_core_alloc(pool, sizeof(*fnode)))) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Alloc Failure\n"); + switch_core_destroy_memory_pool(&pool); + return SWITCH_STATUS_MEMERR; + } + + fnode->type = NODE_TYPE_SPEECH; + fnode->leadin = leadin; + + memset(&fnode->sh, 0, sizeof(fnode->sh)); + if (switch_core_speech_open(&fnode->sh, + conference->tts_engine, + conference->tts_voice, + conference->rate, + &flags, + conference->pool) != SWITCH_STATUS_SUCCESS) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invalid TTS module [%s]!\n", conference->tts_engine); + return SWITCH_STATUS_FALSE; + } + + + fnode->pool = pool; + + /* Queue the node */ + switch_mutex_lock(member->flag_mutex); + for (nptr = member->fnode; nptr && nptr->next; nptr = nptr->next); + + if (nptr) { + nptr->next = fnode; + } else { + member->fnode = fnode; + } + switch_mutex_unlock(member->flag_mutex); + + /* Begin Generation */ + switch_sleep(200000); + switch_core_speech_feed_tts(&fnode->sh, text, &flags); + + return SWITCH_STATUS_SUCCESS; +} + +/* Say some thing with TTS in the conference rooom */ +static switch_status_t conference_say(conference_obj_t *conference, char *text, uint32_t leadin) +{ + confernce_file_node_t *fnode, *nptr; + switch_memory_pool_t *pool; + switch_speech_flag_t flags = SWITCH_SPEECH_FLAG_TTS; + + /* Setup a memory pool to use. */ + if (switch_core_new_memory_pool(&pool) != SWITCH_STATUS_SUCCESS) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Pool Failure\n"); + return SWITCH_STATUS_MEMERR; + } + + /* Create a node object*/ + if (!(fnode = switch_core_alloc(pool, sizeof(*fnode)))) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Alloc Failure\n"); + switch_core_destroy_memory_pool(&pool); + return SWITCH_STATUS_MEMERR; + } + + fnode->type = NODE_TYPE_SPEECH; + fnode->leadin = leadin; + + memset(&fnode->sh, 0, sizeof(fnode->sh)); + if (switch_core_speech_open(&fnode->sh, + conference->tts_engine, + conference->tts_voice, + conference->rate, + &flags, + conference->pool) != SWITCH_STATUS_SUCCESS) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invalid TTS module [%s]!\n", conference->tts_engine); + return SWITCH_STATUS_FALSE; + } + + + fnode->pool = pool; + + /* Queue the node */ + switch_mutex_lock(conference->mutex); + for (nptr = conference->fnode; nptr && nptr->next; nptr = nptr->next); + + if (nptr) { + nptr->next = fnode; + } else { + conference->fnode = fnode; + } + switch_mutex_unlock(conference->mutex); + + /* Begin Generation */ + switch_sleep(200000); + switch_core_speech_feed_tts(&fnode->sh, text, &flags); + + return SWITCH_STATUS_SUCCESS; +} + +static void conference_list(conference_obj_t *conference, switch_stream_handle_t *stream, char *delim) +{ + conference_member_t *member = NULL; + switch_mutex_lock(conference->member_mutex); + + for (member = conference->members; member; member = member->next) { + switch_channel_t *channel = switch_core_session_get_channel(member->session); + switch_caller_profile_t *profile = switch_channel_get_caller_profile(channel); + char *uuid = switch_core_session_get_uuid(member->session); + char *name = switch_channel_get_name(channel); + uint32_t count = 0; + + stream->write_function(stream, "%u%s%s%s%s%s%s%s%s%s", + member->id,delim, + name,delim, + uuid,delim, + profile->caller_id_name,delim, + profile->caller_id_number, delim); + + if (switch_test_flag(member, MFLAG_CAN_HEAR)) { + stream->write_function(stream, "hear"); + count++; + } + + if (switch_test_flag(member, MFLAG_CAN_SPEAK)) { + stream->write_function(stream, "%s%s", count ? "|" : "", "speak"); + count++; + } + + stream->write_function(stream, "\n"); + } + switch_mutex_unlock(conference->member_mutex); +} + +/* API Interface Function */ +static switch_status_t conf_function(char *buf, switch_stream_handle_t *stream) +{ + char *lbuf = NULL; + switch_status_t status = SWITCH_STATUS_SUCCESS; + char *http = NULL; + char *topusage = "Available Commands:\n" + "--------------------------------------------------------------------------------\n" + "conference commands\n" + "conference list [delim <string>]\n" + "conference <confname> list [delim <string>]\n" + "conference <confname> play <file_path> [<member_id>]\n" + "conference <confname> say <text>\n" + "conference <confname> saymember <member_id><text>\n" + "conference <confname> stop <[current|all]> [<member_id>]\n" + "conference <confname> kick <member_id>\n" + "conference <confname> mute <member_id>\n" + "conference <confname> unmute <member_id>\n" + "conference <confname> deaf <member_id>\n" + "conference <confname> undef <member_id>\n" + "conference <confname> relate <member_id> <other_member_id> [nospeak|nohear]\n" + "conference <confname> lock\n" + "conference <confname> unlock\n" + "conference <confname> dial <endpoint_module_name>/<destination>\n" + "conference <confname> transfer <member_id> <conference_name>\n" + ; + + if (stream->event) { + http = switch_event_get_header(stream->event, "http-host"); + } + + if (http) { + /* Output must be to a web browser */ + stream->write_function(stream, "<pre>\n"); + } + + if (!buf) { + stream->write_function(stream, topusage); + return status; + } + + if ((lbuf = strdup(buf))) { + conference_obj_t *conference = NULL; + int argc; + char *argv[25]; + switch_event_t *event; + + argc = switch_separate_string(lbuf, ' ', argv, (sizeof(argv) / sizeof(argv[0]))); + + /* Figure out what conference */ + if (argc) { + if (!strcasecmp(argv[0], "commands")) { + stream->write_function(stream, topusage); + goto done; + } else if (!strcasecmp(argv[0], "list")) { + switch_hash_index_t *hi; + void *val; + char *d = ";"; + + if (argv[1]) { + if (argv[2] && !strcasecmp(argv[1], "delim")) { + d = argv[2]; + + if (*d == '"') { + if (++d) { + char *p; + if ((p = strchr(d, '"'))) { + *p = '\0'; + } + } else { + d = ";"; + } + } + } + } + + for (hi = switch_hash_first(globals.conference_pool, globals.conference_hash); hi; hi = switch_hash_next(hi)) { + switch_hash_this(hi, NULL, NULL, &val); + conference = (conference_obj_t *) val; + + stream->write_function(stream, "Conference %s (%u members)\n", conference->name, conference->count); + conference_list(conference, stream, d); + stream->write_function(stream, "\n"); + } + goto done; + } else if (!(conference = (conference_obj_t *) switch_core_hash_find(globals.conference_hash, argv[0]))) { + stream->write_function(stream, "No Conference called %s found.\n", argv[0]); + goto done; + } + + if (argc > 1) { + if (!strcasecmp(argv[1], "lock")) { + switch_set_flag_locked(conference, CFLAG_LOCKED); + stream->write_function(stream, "OK %s locked\n", argv[0]); + if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) { + switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Conference-Name", conference->name); + switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Action", "lock"); + switch_event_fire(&event); + } + goto done; + } else if (!strcasecmp(argv[1], "unlock")) { + switch_clear_flag_locked(conference, CFLAG_LOCKED); + stream->write_function(stream, "OK %s unlocked\n", argv[0]); + if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) { + switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Conference-Name", conference->name); + switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Action", "lock"); + switch_event_fire(&event); + } + goto done; + } else if (!strcasecmp(argv[1], "dial")) { + if (argc > 2) { + conference_outcall(conference, NULL, argv[2], argv[3], argv[4]); + stream->write_function(stream, "OK\n"); + goto done; + } else { + stream->write_function(stream, "Error!\n"); + goto done; + } + } else if (!strcasecmp(argv[1], "play")) { + if (argc == 3) { + if (conference_play_file(conference, argv[2], 0) == SWITCH_STATUS_SUCCESS) { + stream->write_function(stream, "(play) Playing file %s\n", argv[2]); + if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) { + switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Conference-Name", conference->name); + switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Action", "play-file"); + switch_event_add_header(event, SWITCH_STACK_BOTTOM, "File", argv[2]); + switch_event_fire(&event); + } + goto done; + } else { + stream->write_function(stream, "(play) File: %s not found.\n", argv[2] ? argv[2] : "(unspecified)"); + goto done; + } + } else if (argc == 4) { + uint32_t id = atoi(argv[3]); + conference_member_t *member; + + if ((member = conference_member_get(conference, id))) { + if (conference_member_play_file(member, argv[2], 0) == SWITCH_STATUS_SUCCESS) { + stream->write_function(stream, "(play) Playing file %s to member %u\n", argv[2], id); + if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) { + switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Conference-Name", conference->name); + switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Member-ID", "%u", id); + switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Action", "play-file-member"); + switch_event_add_header(event, SWITCH_STACK_BOTTOM, "File", argv[2]); + switch_event_fire(&event); + } + goto done; + } else { + stream->write_function(stream, "(play) File: %s not found.\n", argv[2] ? argv[2] : "(unspecified)"); + goto done; + } + } else { + stream->write_function(stream, "Member: %u not found.\n", id); + goto done; + } + } + } else if (!strcasecmp(argv[1], "say")) { + char *tbuf = NULL; + char *text; + + if ((tbuf = strdup(buf))) { + if ((text = strstr(tbuf, "say "))) { + text += 4; + if (text && conference_say(conference, text, 0) == SWITCH_STATUS_SUCCESS) { + stream->write_function(stream, "(say) OK\n"); + if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) { + switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Conference-Name", conference->name); + switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Action", "speak-text"); + switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Text", text); + switch_event_fire(&event); + } + goto done; + } else { + stream->write_function(stream, "(say) Error!"); + goto done; + } + } + + free(tbuf); + } + } else if (!strcasecmp(argv[1], "saymember")) { + char *tbuf = NULL, *text, *name; + uint32_t id = atoi(argv[3]); + conference_member_t *member; + + if ((tbuf = strdup(buf))) { + if ((name = strstr(tbuf, "saymember "))) { + name += 10; + text = strchr(name, ' '); + id = atoi(name); + + if ((member = conference_member_get(conference, id))) { + if (text && conference_member_say(conference, member, text, 0) == SWITCH_STATUS_SUCCESS) { + stream->write_function(stream, "(saymember) OK\n"); + if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) { + switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Conference-Name", conference->name); + switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Action", "speak-text-member"); + switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Member-ID", "%u", id); + switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Text", text); + switch_event_fire(&event); + } + } else { + stream->write_function(stream, "(saymember) Error!"); + } + } else { + stream->write_function(stream, "(saymember) Unknown Member %u!", id); + } + } else { + stream->write_function(stream, "(saymember) Syntax Error!"); + } + + free(tbuf); + goto done; + } + } else if (!strcasecmp(argv[1], "stop")) { + uint8_t current = 0, all = 0; + + if (argc > 2) { + current = strcasecmp(argv[2], "current") ? 0 : 1; + all = strcasecmp(argv[2], "all") ? 0 : 1; + } + + if (current || all) { + if (argc == 4) { + uint32_t id = atoi(argv[3]); + conference_member_t *member; + if ((member = conference_member_get(conference, id))) { + uint32_t stopped = conference_member_stop_file(member, current ? FILE_STOP_CURRENT : FILE_STOP_ALL); + stream->write_function(stream, "Stopped %u files.\n", stopped); + } else { + stream->write_function(stream, "Member: %u not found.\n", id); + goto done; + } + } else { + uint32_t stopped = conference_stop_file(conference, current ? FILE_STOP_CURRENT : FILE_STOP_ALL); + stream->write_function(stream, "Stopped %u files.\n", stopped); + } + } else { + stream->write_function(stream, "Usage stop [current/all]\n"); + goto done; + } + + } else if (!strcasecmp(argv[1], "mute")) { + if (argc > 2) { + uint32_t id = atoi(argv[2]); + conference_member_t *member; + + if ((member = conference_member_get(conference, id))) { + switch_clear_flag_locked(member, MFLAG_CAN_SPEAK); + if (member->conference->muted_sound) { + conference_member_play_file(member, member->conference->muted_sound, 0); + } + stream->write_function(stream, "OK mute %u\n", id); + if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) { + switch_channel_t *channel = switch_core_session_get_channel(member->session); + switch_channel_event_set_data(channel, event); + + switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Conference-Name", conference->name); + switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Member-ID", "%u", id); + switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Action", "mute-member"); + switch_event_fire(&event); + } + goto done; + } else { + stream->write_function(stream, "Non-Existant ID %u\n", id); + goto done; + } + } else { + stream->write_function(stream, "usage mute <id>\n"); + goto done; + } + } else if (!strcasecmp(argv[1], "unmute")) { + if (argc > 2) { + uint32_t id = atoi(argv[2]); + conference_member_t *member; + + if ((member = conference_member_get(conference, id))) { + switch_set_flag_locked(member, MFLAG_CAN_SPEAK); + stream->write_function(stream, "OK unmute %u\n", id); + if (member->conference->unmuted_sound) { + conference_member_play_file(member, member->conference->unmuted_sound, 0); + } + if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) { + switch_channel_t *channel = switch_core_session_get_channel(member->session); + switch_channel_event_set_data(channel, event); + + switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Conference-Name", conference->name); + switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Member-ID", "%u", id); + switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Action", "unmute-member"); + switch_event_fire(&event); + } + goto done; + } else { + stream->write_function(stream, "Non-Existant ID %u\n", id); + goto done; + } + } else { + stream->write_function(stream, "usage unmute <id>\n"); + goto done; + } + } else if (!strcasecmp(argv[1], "deaf")) { + if (argc > 2) { + uint32_t id = atoi(argv[2]); + conference_member_t *member; + + if ((member = conference_member_get(conference, id))) { + switch_clear_flag_locked(member, MFLAG_CAN_HEAR); + stream->write_function(stream, "OK deaf %u\n", id); + if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) { + switch_channel_t *channel = switch_core_session_get_channel(member->session); + switch_channel_event_set_data(channel, event); + + switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Conference-Name", conference->name); + switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Member-ID", "%u", id); + switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Action", "deaf-member"); + switch_event_fire(&event); + } + goto done; + } else { + stream->write_function(stream, "Non-Existant ID %u\n", id); + goto done; + } + } else { + stream->write_function(stream, "usage deaf <id>\n"); + goto done; + } + } else if (!strcasecmp(argv[1], "undeaf")) { + if (argc > 2) { + uint32_t id = atoi(argv[2]); + conference_member_t *member; + + if ((member = conference_member_get(conference, id))) { + switch_set_flag_locked(member, MFLAG_CAN_HEAR); + stream->write_function(stream, "OK undeaf %u\n", id); + if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) { + switch_channel_t *channel = switch_core_session_get_channel(member->session); + switch_channel_event_set_data(channel, event); + + switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Conference-Name", conference->name); + switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Member-ID", "%u", id); + switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Action", "undeaf-member"); + switch_event_fire(&event); + } + goto done; + } else { + stream->write_function(stream, "Non-Existant ID %u\n", id); + goto done; + } + } else { + stream->write_function(stream, "usage undeaf <id>\n"); + goto done; + } + } else if (!strcasecmp(argv[1], "kick")) { + if (argc > 2) { + uint32_t id = atoi(argv[2]); + conference_member_t *member; + + if ((member = conference_member_get(conference, id))) { + switch_mutex_lock(member->flag_mutex); + switch_clear_flag(member, MFLAG_RUNNING); + switch_set_flag(member, MFLAG_KICKED); + switch_mutex_unlock(member->flag_mutex); + + stream->write_function(stream, "OK kicked %u\n", id); + + if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) { + switch_channel_t *channel = switch_core_session_get_channel(member->session); + switch_channel_event_set_data(channel, event); + + switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Conference-Name", conference->name); + switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Member-ID", "%u", id); + switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Action", "kick-member"); + switch_event_fire(&event); + } + goto done; + } else { + stream->write_function(stream, "Non-Existant ID %u\n", id); + goto done; + } + } else { + stream->write_function(stream, "usage kick <id>\n"); + goto done; + } + } else if (!strcasecmp(argv[1], "transfer")) { + char *transfer_usage = "Usage transfer <id> <confname>\n"; + if (argc > 3) { + conference_member_t *member = NULL; + uint32_t id = atoi(argv[2]); + conference_obj_t *new_conference = NULL; + + if ((new_conference = (conference_obj_t *) switch_core_hash_find(globals.conference_hash, argv[3]))) { + if ((member = conference_member_get(conference, id))) { + switch_channel_t *channel = switch_core_session_get_channel(member->session); + switch_event_t *event; + + conference_del_member(member->last_conference, member); + conference_add_member(new_conference, member); + stream->write_function(stream, "OK Member %u sent to conference %s.\n", id, argv[3]); + + if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) { + switch_channel_event_set_data(channel, event); + switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Member-ID", "%u", member->id); + switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Old-Conference-Name", conference->name); + switch_event_add_header(event, SWITCH_STACK_BOTTOM, "New-Conference-Name", argv[3]); + switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Action", "transfer"); + switch_event_fire(&event); + } + goto done; + } else { + stream->write_function(stream, "No Member %u in conference %s.\n", id, conference->name); + goto done; + } + } else { + stream->write_function(stream, "No Conference called %s found.\n", argv[3]); + goto done; + } + + } else { + stream->write_function(stream, transfer_usage); + goto done; + } + } else if (!strcasecmp(argv[1], "relate")) { + char *relate_usage = "Usage relate <id> <id> [nospeak|nohear|clear]\n"; + if (argc > 4) { + uint8_t nospeak = 0, nohear = 0, clear = 0; + nospeak = strstr(argv[4], "nospeak") ? 1 : 0; + nohear = strstr(argv[4], "nohear") ? 1 : 0; + + if (!strcasecmp(argv[4], "clear")) { + clear = 1; + } + + if (!(clear || nospeak || nohear)) { + stream->write_function(stream, relate_usage); + goto done; + } + + if (clear) { + conference_member_t *member = NULL; + uint32_t id = atoi(argv[2]); + uint32_t oid = atoi(argv[3]); + + switch_mutex_lock(conference->mutex); + switch_mutex_lock(conference->member_mutex); + if ((member = conference_member_get(conference, id))) { + member_del_relationship(member, oid); + stream->write_function(stream, "relationship %u->%u cleared.", id, oid); + } else { + stream->write_function(stream, "relationship %u->%u not found", id, oid); + } + switch_mutex_unlock(conference->member_mutex); + switch_mutex_unlock(conference->mutex); + } else if (nospeak || nohear) { + conference_member_t *member = NULL, *other_member = NULL; + uint32_t id = atoi(argv[2]); + uint32_t oid = atoi(argv[3]); + + switch_mutex_lock(conference->mutex); + switch_mutex_lock(conference->member_mutex); + if ((member = conference_member_get(conference, id)) && (other_member = conference_member_get(conference, oid))) { + conference_relationship_t *rel = NULL; + if ((rel = member_get_relationship(member, other_member))) { + rel->flags = 0; + } else { + rel = member_add_relationship(member, oid); + } + + if (rel) { + switch_set_flag(rel, RFLAG_CAN_SPEAK | RFLAG_CAN_HEAR); + if (nospeak) { + switch_clear_flag(rel, RFLAG_CAN_SPEAK); + } + if (nohear) { + switch_clear_flag(rel, RFLAG_CAN_HEAR); + } + stream->write_function(stream, "ok %u->%u set\n", id, oid); + } else { + stream->write_function(stream, "error!\n"); + } + + } else { + stream->write_function(stream, "relationship %u->%u not found", id, oid); + } + switch_mutex_unlock(conference->member_mutex); + switch_mutex_unlock(conference->mutex); + } + + + } else { + stream->write_function(stream, relate_usage); + } + } else if (!strcasecmp(argv[1], "list")) { + char *d = ";"; + + if (argv[2]) { + if (argv[3] && !strcasecmp(argv[2], "delim")) { + d = argv[3]; + + if (*d == '"') { + if (++d) { + char *p; + if ((p = strchr(d, '"'))) { + *p = '\0'; + } + } else { + d = ";"; + } + } + } + } + conference_list(conference, stream, d); + } else { + stream->write_function(stream, "Command: %s not found.\n", argv[1]); + goto done; + } + + } else { + stream->write_function(stream, "Command not specified.\n"); + goto done; + } + } else { + stream->write_function(stream, topusage); + } + } else { + stream->write_function(stream, "Memory Error!\n"); + } + + done: + + if (lbuf) { + free(lbuf); + } + + return status; + +} + +static switch_status_t audio_bridge_on_ring(switch_core_session_t *session) +{ + switch_channel_t *channel = NULL; + + channel = switch_core_session_get_channel(session); + assert(channel != NULL); + + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "CUSTOM RING\n"); + + /* put the channel in a passive state so we can loop audio to it */ + return SWITCH_STATUS_FALSE; +} + +static const switch_state_handler_table_t audio_bridge_peer_state_handlers = { + /*.on_init */ NULL, + /*.on_ring */ audio_bridge_on_ring, + /*.on_execute */ NULL, + /*.on_hangup */ NULL, + /*.on_loopback */ NULL, + /*.on_transmit */ NULL, + /*.on_hold */ NULL, +}; + +static switch_status_t conference_outcall(conference_obj_t *conference, switch_core_session_t *session, char *bridgeto, char *cid_name, char *cid_num) +{ + switch_core_session_t *peer_session; + switch_caller_profile_t *caller_profile, *caller_caller_profile; + char *chan_type, *chan_data; + unsigned int timelimit = 60; + switch_channel_t *peer_channel; + time_t start; + switch_frame_t *read_frame = NULL; + switch_status_t status = SWITCH_STATUS_SUCCESS; + switch_channel_t *caller_channel = NULL; + + chan_type = strdup(bridgeto); + + if ((chan_data = strchr(chan_type, '/')) != 0) { + *chan_data = '\0'; + chan_data++; + } + + if (session) { + caller_channel = switch_core_session_get_channel(session); + assert(caller_channel != NULL); + caller_caller_profile = switch_channel_get_caller_profile(caller_channel); + + if (!cid_name) { + cid_name = caller_caller_profile->caller_id_name; + } + + if (!cid_num) { + cid_num = caller_caller_profile->caller_id_number; + } + + caller_profile = switch_caller_profile_new(switch_core_session_get_pool(session), + caller_caller_profile->username, + caller_caller_profile->dialplan, + cid_name, + cid_num, + caller_caller_profile->network_addr, + NULL, + NULL, + caller_caller_profile->rdnis, + caller_caller_profile->source, + caller_caller_profile->context, + chan_data); + } else { + + if (!cid_name) { + cid_name = conference->caller_id_name; + } + + if (!cid_num) { + cid_num = conference->caller_id_number; + } + + caller_profile = switch_caller_profile_new(conference->pool, + NULL, + NULL, + cid_name, + cid_num, + NULL, + NULL, + NULL, + NULL, + (char *) global_app_name, + NULL, + chan_data); + } + + + + if (switch_core_session_outgoing_channel(session, chan_type, caller_profile, &peer_session, NULL) != + SWITCH_STATUS_SUCCESS) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Cannot Create Outgoing Channel!\n"); + if (caller_channel) { + switch_channel_hangup(caller_channel, SWITCH_CAUSE_REQUESTED_CHAN_UNAVAIL); + } + status = SWITCH_STATUS_FALSE; + goto done; + } + + peer_channel = switch_core_session_get_channel(peer_session); + assert(peer_channel != NULL); + + switch_channel_add_state_handler(peer_channel, &audio_bridge_peer_state_handlers); + + if (switch_core_session_runing(peer_session)) { + switch_channel_set_state(peer_channel, CS_RING); + } else { + switch_core_session_thread_launch(peer_session); + } + + time(&start); + + for (;;) { + int state = switch_channel_get_state(peer_channel); + if (state >= CS_RING) { + break; + } + + if (caller_channel && !switch_channel_ready(caller_channel)) { + break; + } + + if ((time(NULL) - start) > timelimit) { + break; + } + switch_yield(1000); + } + + if (caller_channel) { + switch_channel_pre_answer(caller_channel); + } + + while ((!caller_channel || switch_channel_ready(caller_channel)) && + switch_channel_ready(peer_channel) && + !switch_channel_test_flag(peer_channel, CF_ANSWERED) && + !switch_channel_test_flag(peer_channel, CF_EARLY_MEDIA) && + ((time(NULL) - start) < timelimit)) { + + /* read from the channel while we wait if the audio is up on it */ + if (session && (switch_channel_test_flag(caller_channel, CF_ANSWERED) || switch_channel_test_flag(caller_channel, CF_EARLY_MEDIA))) { + switch_status_t status = switch_core_session_read_frame(session, &read_frame, 1000, 0); + + if (!SWITCH_READ_ACCEPTABLE(status)) { + break; + } + if (read_frame) { + if (switch_core_session_write_frame(session, read_frame, 1000, 0) != SWITCH_STATUS_SUCCESS) { + break; + } + } + + } else { + switch_yield(1000); + } + + } + + if (caller_channel && switch_channel_test_flag(peer_channel, CF_ANSWERED)) { + switch_channel_answer(caller_channel); + } + + if (switch_channel_test_flag(peer_channel, CF_ANSWERED) || switch_channel_test_flag(peer_channel, CF_EARLY_MEDIA)) { + switch_caller_extension_t *extension = NULL; + if ((extension = switch_caller_extension_new(peer_session, caller_profile->destination_number, + caller_profile->destination_number)) == 0) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "memory error!\n"); + status = SWITCH_STATUS_MEMERR; + goto done; + } + /* add them to the conference */ + switch_caller_extension_add_application(peer_session, extension, (char *) global_app_name, conference->name); + switch_channel_set_caller_extension(peer_channel, extension); + switch_channel_set_state(peer_channel, CS_EXECUTE); + + } else { + switch_channel_hangup(peer_channel, SWITCH_CAUSE_NO_ANSWER); + status = SWITCH_STATUS_FALSE; + goto done; + } + + done: + free(chan_type); + return status; +} + +/* Play a file */ +static switch_status_t conference_local_play_file(switch_core_session_t *session, char *path, uint32_t leadin, char *buf, switch_size_t len) +{ + uint32_t x = 0; + switch_status_t status = SWITCH_STATUS_SUCCESS; + + for (x = 0; x < leadin; x++) { + switch_frame_t *read_frame; + switch_status_t status = switch_core_session_read_frame(session, &read_frame, 1000, 0); + + if (!SWITCH_READ_ACCEPTABLE(status)) { + break; + } + } + + if (status == SWITCH_STATUS_SUCCESS) { + status = switch_ivr_play_file(session, NULL, path, NULL, NULL, NULL, 0); + } + + return status; +} + +/* Application interface function that is called from the dialplan to join the channel to a conference */ +static void conference_function(switch_core_session_t *session, char *data) +{ + switch_codec_t *read_codec = NULL; + switch_memory_pool_t *pool = NULL, *freepool = NULL; + uint32_t flags = 0; + conference_member_t member = {0}; + conference_obj_t *conference = NULL; + switch_channel_t *channel = NULL; + char *mydata = switch_core_session_strdup(session, data); + char *conf_name = NULL; + char *bridge_prefix = "bridge:"; + char *bridgeto = NULL; + char *profile_name = NULL; + switch_xml_t cxml = NULL, cfg = NULL, profile = NULL, profiles = NULL; + + channel = switch_core_session_get_channel(session); + assert(channel != NULL); + + if (!mydata) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Pool Failure\n"); + return; + } + + /* Setup a memory pool to use. */ + if (switch_core_new_memory_pool(&pool) != SWITCH_STATUS_SUCCESS) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Pool Failure\n"); + return; + } + + if (!strncasecmp(mydata, bridge_prefix, strlen(bridge_prefix))) { + char *uuid = switch_core_session_get_uuid(session); + + mydata += strlen(bridge_prefix); + conf_name = mydata; + + if ((bridgeto = strchr(conf_name, ':'))) { + *bridgeto++ = '\0'; + } else { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Config Error!\n"); + goto done; + } + + if ((profile_name = strchr(conf_name, '@'))) { + *profile_name++ = '\0'; + + /* Open the config from the xml registry */ + if (!(cxml = switch_xml_open_cfg(global_cf_name, &cfg, NULL))) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "open of %s failed\n", global_cf_name); + goto done; + } + + if ((profiles = switch_xml_child(cfg, "profiles"))) { + profile = switch_xml_find_child(profiles, "profile", "name", profile_name); + } + } + + if (!strcmp(conf_name, "_uuid_")) { + conf_name = uuid; + } + + if ((conference = (conference_obj_t *) switch_core_hash_find(globals.conference_hash, conf_name))) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Conference %s already exists!\n", conf_name); + goto done; + } + + /* Create the conference object. */ + conference = conference_new(conf_name, profile, pool); + + /* Release the config registry handle */ + switch_xml_free(cxml); + cxml = NULL; + + if (!conference) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Memory Error!\n"); + goto done; + } + + /* Set the minimum number of members (once you go above it you cannot go below it) */ + conference->min = 2; + + /* Indicate the conference is dynamic */ + switch_set_flag_locked(conference, CFLAG_DYNAMIC); + + /* Start the conference thread for this conference */ + launch_conference_thread(conference); + + } else { + conf_name = mydata; + freepool = pool; + /* Figure out what conference to call. */ + if (!(conference = (conference_obj_t *) switch_core_hash_find(globals.conference_hash, conf_name))) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "No Conference called %s found.\n", conf_name); + goto done; + } + + if (conference->pin) { + char term = '\0'; + char pin[80] = ""; + char *buf; + + /* Answer the channel */ + switch_channel_answer(channel); + + if (conference->pin_sound) { + conference_local_play_file(session, conference->pin_sound, 20, pin, sizeof(pin)); + } + + if (strlen(pin) < strlen(conference->pin)) { + buf = pin + strlen(pin); + switch_ivr_collect_digits_count(session, buf, sizeof(pin) - (unsigned int)strlen(pin), (unsigned int)strlen(conference->pin) - (unsigned int)strlen(pin), "#", &term, 10000); + } + + if (strcmp(pin, conference->pin)) { + if (conference->bad_pin_sound) { + conference_local_play_file(session, conference->bad_pin_sound, 20, NULL, 0); + } + goto done; + } + } + + if (switch_test_flag(conference, CFLAG_LOCKED)) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Conference %s is locked.\n", conf_name); + if (conference->locked_sound) { + /* Answer the channel */ + switch_channel_answer(channel); + conference_local_play_file(session, conference->locked_sound, 20, NULL, 0); + } + goto done; + } + + } + + if (bridgeto) { + if (conference_outcall(conference, session, bridgeto, NULL, NULL) != SWITCH_STATUS_SUCCESS) { + goto done; + } + } + + /* Save the original read codec. */ + read_codec = switch_core_session_get_read_codec(session); + + /* Setup a Signed Linear codec for reading audio. */ + if (switch_core_codec_init(&member.read_codec, + "L16", + read_codec->implementation->samples_per_second, + conference->interval, + 1, + SWITCH_CODEC_FLAG_ENCODE | SWITCH_CODEC_FLAG_DECODE, + NULL, + pool) == SWITCH_STATUS_SUCCESS) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Raw Codec Activation Success L16@%uhz 1 channel %dms\n", + conference->rate, conference->interval); + } else { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Raw Codec Activation Failed L16@%uhz 1 channel %dms\n", + conference->rate, conference->interval); + flags = 0; + goto done; + } + + /* Setup a Signed Linear codec for writing audio. */ + if (switch_core_codec_init(&member.write_codec, + "L16", + read_codec->implementation->samples_per_second, + conference->interval, + 1, + SWITCH_CODEC_FLAG_ENCODE | SWITCH_CODEC_FLAG_DECODE, + NULL, + pool) == SWITCH_STATUS_SUCCESS) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Raw Codec Activation Success L16@%uhz 1 channel %dms\n", + conference->rate, conference->interval); + } else { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Raw Codec Activation Failed L16@%uhz 1 channel %dms\n", + conference->rate, conference->interval); + flags = 0; + goto codec_done2; + } + + /* Setup an audio buffer for the incoming audio */ + if (switch_buffer_create(pool, &member.audio_buffer, CONF_BUFFER_SIZE) != SWITCH_STATUS_SUCCESS) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Memory Error Creating Audio Buffer!\n"); + goto codec_done1; + } + + /* Setup an audio buffer for the outgoing audio */ + if (switch_buffer_create(pool, &member.mux_buffer, CONF_BUFFER_SIZE) != SWITCH_STATUS_SUCCESS) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Memory Error Creating Audio Buffer!\n"); + goto codec_done1; + } + + /* Prepare MUTEXS */ + member.id = next_member_id(); + member.pool = pool; + member.session = session; + switch_mutex_init(&member.flag_mutex, SWITCH_MUTEX_NESTED, pool); + switch_mutex_init(&member.audio_in_mutex, SWITCH_MUTEX_NESTED, pool); + switch_mutex_init(&member.audio_out_mutex, SWITCH_MUTEX_NESTED, pool); + + /* Install our Signed Linear codec so we get the audio in that format */ + switch_core_session_set_read_codec(member.session, &member.read_codec); + + /* Add the caller to the conference */ + if (conference_add_member(conference, &member) != SWITCH_STATUS_SUCCESS) { + goto codec_done1; + } + switch_set_flag_locked((&member), MFLAG_RUNNING | MFLAG_CAN_SPEAK | MFLAG_CAN_HEAR); + + /* Run the confernece loop */ + conference_loop(&member); + + /* Remove the caller from the conference */ + conference_del_member(member.last_conference, &member); + + /* Put the original codec back */ + switch_core_session_set_read_codec(member.session, read_codec); + + /* Clean Up. codec_done(X): is for error situations after the codecs were setup and done: is for situations before */ + codec_done1: + switch_core_codec_destroy(&member.read_codec); + codec_done2: + switch_core_codec_destroy(&member.write_codec); + done: + + /* Release the config registry handle */ + if (cxml) { + switch_xml_free(cxml); + } + + if (freepool) { + switch_core_destroy_memory_pool(&freepool); + } + + if (switch_test_flag(&member, MFLAG_KICKED) && conference->kicked_sound) { + switch_ivr_play_file(session, NULL, conference->kicked_sound, NULL, NULL, NULL, 0); + } + + switch_core_session_reset(session); + +} + +/* Create a thread for the conference and launch it */ +static void launch_conference_thread(conference_obj_t *conference) +{ + switch_thread_t *thread; + switch_threadattr_t *thd_attr = NULL; + + switch_set_flag_locked(conference, CFLAG_RUNNING); + switch_threadattr_create(&thd_attr, conference->pool); + switch_threadattr_detach_set(thd_attr, 1); + switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE); + switch_mutex_lock(globals.hash_mutex); + switch_core_hash_insert(globals.conference_hash, conference->name, conference); + switch_mutex_unlock(globals.hash_mutex); + switch_thread_create(&thread, thd_attr, conference_thread_run, conference, conference->pool); +} + +static void *SWITCH_THREAD_FUNC input_thread_run(switch_thread_t *thread, void *obj) +{ + conference_member_t *member = obj; + switch_channel_t *channel; + switch_status_t status; + switch_frame_t *read_frame = NULL; + switch_codec_t *read_codec; + uint32_t hangover = 40, + hangunder = 15, + hangover_hits = 0, + hangunder_hits = 0, + energy_level = 0, + diff_level = 400; + uint8_t talking = 0; + + assert(member != NULL); + + energy_level = member->conference->energy_level; + + channel = switch_core_session_get_channel(member->session); + assert(channel != NULL); + + read_codec = switch_core_session_get_read_codec(member->session); + assert(read_codec != NULL); + + /* As long as we have a valid read, feed that data into an input buffer where the conference thread will take it + and mux it with any audio from other channels. */ + + while(switch_test_flag(member, MFLAG_RUNNING) && switch_channel_ready(channel)) { + /* Read a frame. */ + status = switch_core_session_read_frame(member->session, &read_frame, -1, 0); + + /* end the loop, if appropriate */ + if (!SWITCH_READ_ACCEPTABLE(status) || !switch_test_flag(member, MFLAG_RUNNING)) { + break; + } + + if (switch_test_flag(read_frame, SFF_CNG)) { + continue; + } + + if (switch_test_flag(member, MFLAG_CAN_SPEAK) && energy_level) { + uint32_t energy = 0, i = 0, samples = 0, j = 0, score = 0; + int16_t *data; + + data = read_frame->data; + samples = read_frame->datalen / sizeof(*data); + + for (i = 0; i < samples; i++) { + energy += abs(data[j]); + j += read_codec->implementation->number_of_channels; + } + + score = energy / samples; + + if (score > energy_level) { + uint32_t diff = score - energy_level; + if (hangover_hits) { + hangover_hits--; + } + + if (diff >= diff_level || ++hangunder_hits >= hangunder) { + hangover_hits = hangunder_hits = 0; + + if (!talking) { + switch_event_t *event; + talking = 1; + if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) { + switch_channel_event_set_data(channel, event); + switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Conference-Name", member->conference->name); + switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Member-ID", "%u", member->id); + switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Action", "start-talking"); + switch_event_fire(&event); + } + } + + } + } else { + if (hangunder_hits) { + hangunder_hits--; + } + if (talking) { + switch_event_t *event; + if (++hangover_hits >= hangover) { + hangover_hits = hangunder_hits = 0; + talking = 0; + + if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) { + switch_channel_event_set_data(channel, event); + switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Conference-Name", member->conference->name); + switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Member-ID", "%u", member->id); + switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Action", "stop-talking"); + switch_event_fire(&event); + } + } + } + } + } + + /* skip frames that are not actual media or when we are muted or silent */ + if (talking && switch_test_flag(member, MFLAG_CAN_SPEAK)) { + /* Write the audio into the input buffer */ + switch_mutex_lock(member->audio_in_mutex); + switch_buffer_write(member->audio_buffer, read_frame->data, read_frame->datalen); + switch_mutex_unlock(member->audio_in_mutex); + } + } + + switch_clear_flag_locked(member, MFLAG_ITHREAD); + + return NULL; +} + +/* Create a thread for the conference and launch it */ +static void launch_input_thread(conference_member_t *member, switch_memory_pool_t *pool) +{ + switch_thread_t *thread; + switch_threadattr_t *thd_attr = NULL; + + switch_threadattr_create(&thd_attr, pool); + switch_threadattr_detach_set(thd_attr, 1); + switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE); + switch_set_flag_locked(member, MFLAG_ITHREAD); + switch_thread_create(&thread, thd_attr, input_thread_run, member, pool); +} + +static const switch_application_interface_t conference_application_interface = { + /*.interface_name */ global_app_name, + /*.application_function */ conference_function, + NULL, NULL, NULL, + /*.next*/ NULL +}; + +static switch_api_interface_t conf_api_interface = { + /*.interface_name */ "conference", + /*.desc */ "Conference", + /*.function */ conf_function + /*.next */ +}; + +static switch_loadable_module_interface_t conference_module_interface = { + /*.module_name */ modname, + /*.endpoint_interface */ NULL, + /*.timer_interface */ NULL, + /*.dialplan_interface */ NULL, + /*.codec_interface */ NULL, + /*.application_interface */ &conference_application_interface, + /*.api_interface */ &conf_api_interface, + /*.file_interface */ NULL, + /*.speech_interface */ NULL, + /*.directory_interface */ NULL +}; + +/* create a new conferene with a specific profile */ +static conference_obj_t *conference_new(char *name, switch_xml_t profile, switch_memory_pool_t *pool) +{ + conference_obj_t *conference; + switch_xml_t param; + char *rate_name = NULL; + char *interval_name = NULL; + char *timer_name = NULL; + char *tts_engine = NULL; + char *tts_voice = NULL; + char *enter_sound = NULL; + char *exit_sound = NULL; + char *alone_sound = NULL; + char *ack_sound = NULL; + char *nack_sound = NULL; + char *muted_sound = NULL; + char *unmuted_sound = NULL; + char *locked_sound = NULL; + char *kicked_sound = NULL; + char *pin = NULL; + char *pin_sound = NULL; + char *bad_pin_sound = NULL; + char *energy_level = NULL; + char *caller_id_name = NULL; + char *caller_id_number = NULL; + uint32_t rate = 8000, interval = 20; + switch_status_t status; + + /* Conference Name */ + if (switch_strlen_zero(name)) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invalid Record! no name.\n"); + return NULL; + } + + + for (param = switch_xml_child(profile, "param"); param; param = param->next) { + char *var = (char *) switch_xml_attr_soft(param, "name"); + char *val = (char *) switch_xml_attr_soft(param, "value"); + + if (!strcasecmp(var, "rate")) { + rate_name = val; + } else if (!strcasecmp(var, "interval")) { + interval_name= val; + } else if (!strcasecmp(var, "timer_name")) { + timer_name= val; + } else if (!strcasecmp(var, "tts_engine")) { + tts_engine= val; + } else if (!strcasecmp(var, "tts_voice")) { + tts_voice= val; + } else if (!strcasecmp(var, "enter_sound")) { + enter_sound = val; + } else if (!strcasecmp(var, "exit_sound")) { + exit_sound = val; + } else if (!strcasecmp(var, "alone_sound")) { + alone_sound = val; + } else if (!strcasecmp(var, "ack_sound")) { + ack_sound = val; + } else if (!strcasecmp(var, "nack_sound")) { + nack_sound = val; + } else if (!strcasecmp(var, "muted_sound")) { + muted_sound = val; + } else if (!strcasecmp(var, "unmuted_sound")) { + unmuted_sound = val; + } else if (!strcasecmp(var, "locked_sound")) { + locked_sound= val; + } else if (!strcasecmp(var, "kicked_sound")) { + kicked_sound = val; + } else if (!strcasecmp(var, "pin")) { + pin = val; + } else if (!strcasecmp(var, "pin_sound")) { + pin_sound = val; + } else if (!strcasecmp(var, "bad_pin_sound")) { + bad_pin_sound = val; + } else if (!strcasecmp(var, "energy_level")) { + energy_level = val; + } else if (!strcasecmp(var, "caller_id_name")) { + caller_id_name = val; + } else if (!strcasecmp(var, "caller_id_number")) { + caller_id_number = val; + } + } + + /* Set defaults and various paramaters */ + + /* Speed in hertz */ + if (!switch_strlen_zero(rate_name)) { + uint32_t r = atoi(rate_name); + if (r) { + rate = r; + } + } + + /* Packet Interval in milliseconds */ + if (!switch_strlen_zero(interval_name)) { + uint32_t i = atoi(interval_name); + if (i) { + interval = i; + } + } + + /* Timer module to use */ + if (switch_strlen_zero(timer_name)) { + timer_name = "soft"; + } + + /* TTS engine to use */ + if (switch_strlen_zero(tts_engine)) { + tts_engine = "cepstral"; + } + + /* TTS voice to use */ + if (switch_strlen_zero(tts_voice)) { + tts_voice = "david"; + } + + /* Caller ID Name */ + if (switch_strlen_zero(caller_id_name)) { + caller_id_name = (char *) global_app_name; + } + + /* Caller ID Number */ + if (switch_strlen_zero(caller_id_number)) { + caller_id_number = "0000000000"; + } + + if (!pool) { + /* Setup a memory pool to use. */ + if (switch_core_new_memory_pool(&pool) != SWITCH_STATUS_SUCCESS) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Pool Failure\n"); + status = SWITCH_STATUS_TERM; + return NULL; + } + } + + /* Create the conference object. */ + if (!(conference = switch_core_alloc(pool, sizeof(*conference)))) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Memory Error!\n"); + status = SWITCH_STATUS_TERM; + return NULL; + } + + /* Initilize the object with some settings */ + conference->pool = pool; + conference->timer_name = switch_core_strdup(conference->pool, timer_name); + conference->tts_engine = switch_core_strdup(conference->pool, tts_engine); + conference->tts_voice = switch_core_strdup(conference->pool, tts_voice); + + conference->caller_id_name = switch_core_strdup(conference->pool, caller_id_name); + conference->caller_id_number = switch_core_strdup(conference->pool, caller_id_number); + + if (!switch_strlen_zero(enter_sound)) { + conference->enter_sound = switch_core_strdup(conference->pool, enter_sound); + } + + if (!switch_strlen_zero(exit_sound)) { + conference->exit_sound = switch_core_strdup(conference->pool, exit_sound); + } + + if (!switch_strlen_zero(ack_sound)) { + conference->ack_sound = switch_core_strdup(conference->pool, ack_sound); + } + + if (!switch_strlen_zero(nack_sound)) { + conference->nack_sound = switch_core_strdup(conference->pool, nack_sound); + } + + if (!switch_strlen_zero(muted_sound)) { + conference->muted_sound = switch_core_strdup(conference->pool, muted_sound); + } + + if (!switch_strlen_zero(unmuted_sound)) { + conference->unmuted_sound = switch_core_strdup(conference->pool, unmuted_sound); + } + + if (!switch_strlen_zero(kicked_sound)) { + conference->kicked_sound = switch_core_strdup(conference->pool, kicked_sound); + } + + if (!switch_strlen_zero(pin_sound)) { + conference->pin_sound = switch_core_strdup(conference->pool, pin_sound); + } + + if (!switch_strlen_zero(bad_pin_sound)) { + conference->bad_pin_sound = switch_core_strdup(conference->pool, bad_pin_sound); + } + + if (!switch_strlen_zero(pin)) { + conference->pin = switch_core_strdup(conference->pool, pin); + } + + if (!switch_strlen_zero(alone_sound)) { + conference->alone_sound = switch_core_strdup(conference->pool, alone_sound); + } + + if (!switch_strlen_zero(locked_sound)) { + conference->locked_sound = switch_core_strdup(conference->pool, locked_sound); + } + + if (!switch_strlen_zero(energy_level)) { + conference->energy_level = atoi(energy_level); + } + + conference->name = switch_core_strdup(conference->pool, name); + conference->rate = rate; + conference->interval = interval; + + + /* Activate the conference mutex for exclusivity */ + switch_mutex_init(&conference->mutex, SWITCH_MUTEX_NESTED, conference->pool); + switch_mutex_init(&conference->member_mutex, SWITCH_MUTEX_NESTED, conference->pool); + switch_mutex_init(&conference->flag_mutex, SWITCH_MUTEX_NESTED, conference->pool); + switch_thread_rwlock_create(&conference->rwlock, conference->pool); + + return conference; +} + +/* Called by FreeSWITCH when the module loads */ +SWITCH_MOD_DECLARE(switch_status_t) switch_module_load(const switch_loadable_module_interface_t **module_interface, char *filename) +{ + switch_xml_t cfg, cxml, room, rooms, profiles, profile = NULL; + conference_obj_t *conference; + switch_status_t status = SWITCH_STATUS_SUCCESS; + + memset(&globals, 0, sizeof(globals)); + + /* Connect my internal structure to the blank pointer passed to me */ + *module_interface = &conference_module_interface; + + if (switch_event_reserve_subclass(CONF_EVENT_MAINT) != SWITCH_STATUS_SUCCESS) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Couldn't register subclass %s!", CONF_EVENT_MAINT); + return SWITCH_STATUS_TERM; + } + + /* Setup the pool */ + if (switch_core_new_memory_pool(&globals.conference_pool) != SWITCH_STATUS_SUCCESS) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "OH OH no conference pool\n"); + return SWITCH_STATUS_TERM; + } + + /* Open the config from the xml registry */ + if (!(cxml = switch_xml_open_cfg(global_cf_name, &cfg, NULL))) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "open of %s failed\n", global_cf_name); + return SWITCH_STATUS_TERM; + } + + /* Setup a hash to store conferences by name */ + switch_core_hash_init(&globals.conference_hash, globals.conference_pool); + switch_mutex_init(&globals.conference_mutex, SWITCH_MUTEX_NESTED, globals.conference_pool); + switch_mutex_init(&globals.id_mutex, SWITCH_MUTEX_NESTED, globals.conference_pool); + switch_mutex_init(&globals.hash_mutex, SWITCH_MUTEX_NESTED, globals.conference_pool); + + /* Itterate the config */ + if ((rooms = switch_xml_child(cfg, "rooms"))) { + /* Parse various rooms. */ + for (room = switch_xml_child(rooms, "room"); room; room = room->next) { + char *name = (char *) switch_xml_attr_soft(room, "name"); + char *pname = (char *) switch_xml_attr_soft(room, "profile"); + + if ((profiles = switch_xml_child(cfg, "profiles"))) { + profile = switch_xml_find_child(profiles, "profile", "name", pname); + } + + if ((conference = conference_new(name, profile, NULL))) { + /* Start the conference thread for this conference */ + launch_conference_thread(conference); + } + } + } + + /* Release the config registry handle */ + switch_xml_free(cxml); + + /* indicate that the module should continue to be loaded */ + return status; +} Added: freeswitch/trunk/src/mod/applications/mod_conference/mod_conference.vcproj ============================================================================== --- (empty file) +++ freeswitch/trunk/src/mod/applications/mod_conference/mod_conference.vcproj Thu Jul 6 16:12:53 2006 @@ -0,0 +1,209 @@ +<?xml version="1.0" encoding="Windows-1252"?> +<VisualStudioProject + ProjectType="Visual C++" + Version="8.00" + Name="mod_conference" + ProjectGUID="{C24FB505-05D7-4319-8485-7540B44C8603}" + RootNamespace="mod_conference" + Keyword="Win32Proj" + > + <Platforms> + <Platform + Name="Win32" + /> + </Platforms> + <ToolFiles> + </ToolFiles> + <Configurations> + <Configuration + Name="Debug|Win32" + OutputDirectory="Debug" + IntermediateDirectory="Debug" + ConfigurationType="2" + InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops" + CharacterSet="2" + > + <Tool + Name="VCPreBuildEventTool" + /> + <Tool + Name="VCCustomBuildTool" + /> + <Tool + Name="VCXMLDataGeneratorTool" + /> + <Tool + Name="VCWebServiceProxyGeneratorTool" + /> + <Tool + Name="VCMIDLTool" + /> + <Tool + Name="VCCLCompilerTool" + Optimization="0" + AdditionalIncludeDirectories=""$(InputDir)..\..\..\include";"$(InputDir)include";"$(InputDir)..\..\..\..\libs\include"" + PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_USRDLL;MOD_EXPORTS" + MinimalRebuild="true" + BasicRuntimeChecks="3" + RuntimeLibrary="1" + UsePrecompiledHeader="0" + WarningLevel="4" + WarnAsError="true" + Detect64BitPortabilityProblems="true" + DebugInformationFormat="4" + /> + <Tool + Name="VCManagedResourceCompilerTool" + /> + <Tool + Name="VCResourceCompilerTool" + /> + <Tool + Name="VCPreLinkEventTool" + /> + <Tool + Name="VCLinkerTool" + OutputFile="..\..\..\..\w32\vsnet\$(OutDir)/mod/mod_conference.dll" + LinkIncremental="2" + AdditionalLibraryDirectories="..\..\..\..\w32\vsnet\$(OutDir)" + GenerateDebugInformation="true" + ProgramDatabaseFile="$(OutDir)/mod_conference.pdb" + SubSystem="2" + ImportLibrary="$(OutDir)/mod_conference.lib" + TargetMachine="1" + /> + <Tool + Name="VCALinkTool" + /> + <Tool + Name="VCManifestTool" + /> + <Tool + Name="VCXDCMakeTool" + /> + <Tool + Name="VCBscMakeTool" + /> + <Tool + Name="VCFxCopTool" + /> + <Tool + Name="VCAppVerifierTool" + /> + <Tool + Name="VCWebDeploymentTool" + /> + <Tool + Name="VCPostBuildEventTool" + /> + </Configuration> + <Configuration + Name="Release|Win32" + OutputDirectory="Release" + IntermediateDirectory="Release" + ConfigurationType="2" + InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops" + CharacterSet="2" + > + <Tool + Name="VCPreBuildEventTool" + /> + <Tool + Name="VCCustomBuildTool" + /> + <Tool + Name="VCXMLDataGeneratorTool" + /> + <Tool + Name="VCWebServiceProxyGeneratorTool" + /> + <Tool + Name="VCMIDLTool" + /> + <Tool + Name="VCCLCompilerTool" + AdditionalIncludeDirectories=""$(InputDir)..\..\..\include";"$(InputDir)include";"$(InputDir)..\..\..\..\libs\include"" + PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_USRDLL;MOD_EXPORTS" + RuntimeLibrary="0" + UsePrecompiledHeader="0" + WarningLevel="4" + WarnAsError="true" + Detect64BitPortabilityProblems="true" + DebugInformationFormat="3" + /> + <Tool + Name="VCManagedResourceCompilerTool" + /> + <Tool + Name="VCResourceCompilerTool" + /> + <Tool + Name="VCPreLinkEventTool" + /> + <Tool + Name="VCLinkerTool" + OutputFile="..\..\..\..\w32\vsnet\$(OutDir)/mod/mod_conference.dll" + LinkIncremental="1" + AdditionalLibraryDirectories="..\..\..\..\w32\vsnet\$(OutDir)" + GenerateDebugInformation="true" + SubSystem="2" + OptimizeReferences="2" + EnableCOMDATFolding="2" + ImportLibrary="$(OutDir)/mod_conference.lib" + TargetMachine="1" + /> + <Tool + Name="VCALinkTool" + /> + <Tool + Name="VCManifestTool" + /> + <Tool + Name="VCXDCMakeTool" + /> + <Tool + Name="VCBscMakeTool" + /> + <Tool + Name="VCFxCopTool" + /> + <Tool + Name="VCAppVerifierTool" + /> + <Tool + Name="VCWebDeploymentTool" + /> + <Tool + Name="VCPostBuildEventTool" + /> + </Configuration> + </Configurations> + <References> + </References> + <Files> + <Filter + Name="Source Files" + Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx" + UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}" + > + <File + RelativePath=".\mod_conference.c" + > + </File> + </Filter> + <Filter + Name="Header Files" + Filter="h;hpp;hxx;hm;inl;inc;xsd" + UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}" + > + </Filter> + <Filter + Name="Resource Files" + Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx" + UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}" + > + </Filter> + </Files> + <Globals> + </Globals> +</VisualStudioProject> Modified: freeswitch/trunk/w32/vsnet/Freeswitch.sln ============================================================================== --- freeswitch/trunk/w32/vsnet/Freeswitch.sln (original) +++ freeswitch/trunk/w32/vsnet/Freeswitch.sln Thu Jul 6 16:12:53 2006 @@ -208,6 +208,11 @@ {202D7A4E-760D-4D0E-AFA1-D7459CED30FF} = {202D7A4E-760D-4D0E-AFA1-D7459CED30FF} EndProjectSection EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "mod_conference", "..\..\src\mod\applications\mod_conference\mod_conference.vcproj", "{C24FB505-05D7-4319-8485-7540B44C8603}" + ProjectSection(ProjectDependencies) = postProject + {202D7A4E-760D-4D0E-AFA1-D7459CED30FF} = {202D7A4E-760D-4D0E-AFA1-D7459CED30FF} + EndProjectSection +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Win32 = Debug|Win32 @@ -354,6 +359,10 @@ {B69247FA-ECD6-40ED-8E44-5CA6C3BAF9A4}.Debug|Win32.Build.0 = Debug|Win32 {B69247FA-ECD6-40ED-8E44-5CA6C3BAF9A4}.Release|Win32.ActiveCfg = Release|Win32 {B69247FA-ECD6-40ED-8E44-5CA6C3BAF9A4}.Release|Win32.Build.0 = Release|Win32 + {C24FB505-05D7-4319-8485-7540B44C8603}.Debug|Win32.ActiveCfg = Debug|Win32 + {C24FB505-05D7-4319-8485-7540B44C8603}.Debug|Win32.Build.0 = Debug|Win32 + {C24FB505-05D7-4319-8485-7540B44C8603}.Release|Win32.ActiveCfg = Release|Win32 + {C24FB505-05D7-4319-8485-7540B44C8603}.Release|Win32.Build.0 = Release|Win32 EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE @@ -376,6 +385,7 @@ {0E2C6395-13B9-46E5-9264-8859D346018D} = {E72B5BCB-6462-4D23-B419-3AF1A4AC3D78} {30A5B29C-983E-4580-9FD0-D647CCDCC7EB} = {E72B5BCB-6462-4D23-B419-3AF1A4AC3D78} {B69247FA-ECD6-40ED-8E44-5CA6C3BAF9A4} = {E72B5BCB-6462-4D23-B419-3AF1A4AC3D78} + {C24FB505-05D7-4319-8485-7540B44C8603} = {E72B5BCB-6462-4D23-B419-3AF1A4AC3D78} {3A5B9131-F20C-4A85-9447-6C1610941CEE} = {9460B5F1-0A95-41C4-BEB7-9C2C96459A7C} {5FD31A25-5D83-4794-8BEE-904DAD84CE71} = {9460B5F1-0A95-41C4-BEB7-9C2C96459A7C} {FE3540C5-3303-46E0-A69E-D92F775687F1} = {9460B5F1-0A95-41C4-BEB7-9C2C96459A7C}