located in.
const char *mod_conference_app_name = "conference";
char *mod_conference_cf_name = "conference.conf";
-mod_conference_globals_t mod_conference_globals = {0};
+conf_globals_t conf_globals = {0};
int EC = 0;
char *api_syntax = NULL;
{
uint32_t id;
- switch_mutex_lock(mod_conference_globals.id_mutex);
- id = ++mod_conference_globals.id_pool;
- switch_mutex_unlock(mod_conference_globals.id_mutex);
+ switch_mutex_lock(conf_globals.id_mutex);
+ id = ++conf_globals.id_pool;
+ switch_mutex_unlock(conf_globals.id_mutex);
return id;
}
+void conference_list(conference_obj_t *conference, switch_stream_handle_t *stream, char *delim)
+{
+ conf_member_t *member = NULL;
+
+ switch_assert(conference != NULL);
+ switch_assert(stream != NULL);
+ switch_assert(delim != NULL);
+
+ switch_mutex_lock(conference->member_mutex);
+
+ for (member = conference->members; member; member = member->next) {
+ switch_channel_t *channel;
+ switch_caller_profile_t *profile;
+ char *uuid;
+ char *name;
+ uint32_t count = 0;
+
+ if (conf_utils_member_test_flag(member, MFLAG_NOCHANNEL)) {
+ continue;
+ }
+
+ uuid = switch_core_session_get_uuid(member->session);
+ channel = switch_core_session_get_channel(member->session);
+ profile = switch_channel_get_caller_profile(channel);
+ name = switch_channel_get_name(channel);
+
+ 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 (conf_utils_member_test_flag(member, MFLAG_CAN_HEAR)) {
+ stream->write_function(stream, "hear");
+ count++;
+ }
+
+ if (conf_utils_member_test_flag(member, MFLAG_CAN_SPEAK)) {
+ stream->write_function(stream, "%s%s", count ? "|" : "", "speak");
+ count++;
+ }
+
+ if (conf_utils_member_test_flag(member, MFLAG_TALKING)) {
+ stream->write_function(stream, "%s%s", count ? "|" : "", "talking");
+ count++;
+ }
+
+ if (switch_channel_test_flag(switch_core_session_get_channel(member->session), CF_VIDEO)) {
+ stream->write_function(stream, "%s%s", count ? "|" : "", "video");
+ count++;
+ }
+
+ if (member == member->conference->floor_holder) {
+ stream->write_function(stream, "%s%s", count ? "|" : "", "floor");
+ count++;
+ }
+
+ if (member->id == member->conference->video_floor_holder) {
+ stream->write_function(stream, "%s%s", count ? "|" : "", "vid-floor");
+ count++;
+ }
-void send_conference_notify(conference_obj_t *conference, const char *status, const char *call_id, switch_bool_t final)
+ if (conf_utils_member_test_flag(member, MFLAG_MOD)) {
+ stream->write_function(stream, "%s%s", count ? "|" : "", "moderator");
+ count++;
+ }
+
+ if (conf_utils_member_test_flag(member, MFLAG_GHOST)) {
+ stream->write_function(stream, "%s%s", count ? "|" : "", "ghost");
+ count++;
+ }
+
+ stream->write_function(stream, "%s%d%s%d%s%d%s%d\n", delim,
+ member->volume_in_level,
+ delim,
+ member->agc_volume_in_level,
+ delim, member->volume_out_level, delim, member->energy_level);
+ }
+
+ switch_mutex_unlock(conference->member_mutex);
+}
+
+void conf_send_notify(conference_obj_t *conference, const char *status, const char *call_id, switch_bool_t final)
{
switch_event_t *event;
char *name = NULL, *domain = NULL, *dup_domain = NULL;
- if (!conference_test_flag(conference, CFLAG_RFC4579)) {
+ if (!conf_utils_test_flag(conference, CFLAG_RFC4579)) {
return;
}
/* Main monitor thread (1 per distinct conference room) */
-void *SWITCH_THREAD_FUNC conference_thread_run(switch_thread_t *thread, void *obj)
+void *SWITCH_THREAD_FUNC conf_thread_run(switch_thread_t *thread, void *obj)
{
conference_obj_t *conference = (conference_obj_t *) obj;
- conference_member_t *imember, *omember;
+ conf_member_t *imember, *omember;
uint32_t samples = switch_samples_per_packet(conference->rate, conference->interval);
uint32_t bytes = samples * 2 * conference->channels;
uint8_t ready = 0, total = 0;
int32_t z = 0;
int member_score_sum = 0;
int divisor = 0;
- conference_cdr_node_t *np;
+ conf_cdr_node_t *np;
if (!(divisor = conference->rate / 8000)) {
divisor = 1;
return NULL;
}
- switch_mutex_lock(mod_conference_globals.hash_mutex);
- mod_conference_globals.threads++;
- switch_mutex_unlock(mod_conference_globals.hash_mutex);
+ switch_mutex_lock(conf_globals.hash_mutex);
+ conf_globals.threads++;
+ switch_mutex_unlock(conf_globals.hash_mutex);
conference->auto_recording = 0;
conference->record_count = 0;
switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT);
- conference_add_event_data(conference, event);
+ conf_event_add_data(conference, event);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "conference-create");
switch_event_fire(&event);
- if (conference_test_flag(conference, CFLAG_LIVEARRAY_SYNC)) {
+ if (conf_utils_test_flag(conference, CFLAG_LIVEARRAY_SYNC)) {
char *p;
if (strchr(conference->name, '@')) {
*p = '\0';
}
- switch_live_array_create(conference->la_event_channel, conference->la_name, mod_conference_globals.event_channel_id, &conference->la);
+ switch_live_array_create(conference->la_event_channel, conference->la_name, conf_globals.event_channel_id, &conference->la);
switch_live_array_set_user_data(conference->la, conference);
- switch_live_array_set_command_handler(conference->la, conference_command_handler);
+ switch_live_array_set_command_handler(conference->la, conf_event_la_command_handler);
}
- while (mod_conference_globals.running && !conference_test_flag(conference, CFLAG_DESTRUCT)) {
+ while (conf_globals.running && !conf_utils_test_flag(conference, CFLAG_DESTRUCT)) {
switch_size_t file_sample_len = samples;
switch_size_t file_data_len = samples * 2 * conference->channels;
int has_file_data = 0, members_with_video = 0, members_with_avatar = 0;
uint32_t conf_energy = 0;
int nomoh = 0;
- conference_member_t *floor_holder;
+ conf_member_t *floor_holder;
/* Sync the conference to a single timing source */
if (switch_core_timer_next(&timer) != SWITCH_STATUS_SUCCESS) {
- conference_set_flag(conference, CFLAG_DESTRUCT);
+ conf_utils_set_flag(conference, CFLAG_DESTRUCT);
break;
}
total++;
imember->read = 0;
- if (member_test_flag(imember, MFLAG_RUNNING) && imember->session) {
+ if (conf_utils_member_test_flag(imember, MFLAG_RUNNING) && imember->session) {
switch_channel_t *channel = switch_core_session_get_channel(imember->session);
if ((!floor_holder || (imember->score_iir > SCORE_IIR_SPEAKING_MAX && (floor_holder->score_iir < SCORE_IIR_SPEAKING_MIN)))) {// &&
- //(!conference_test_flag(conference, CFLAG_VID_FLOOR) || switch_channel_test_flag(channel, CF_VIDEO))) {
+ //(!conf_utils_test_flag(conference, CFLAG_VID_FLOOR) || switch_channel_test_flag(channel, CF_VIDEO))) {
floor_holder = imember;
}
members_with_avatar++;
}
- if (member_test_flag(imember, MFLAG_NOMOH)) {
+ if (conf_utils_member_test_flag(imember, MFLAG_NOMOH)) {
nomoh++;
}
}
- member_clear_flag_locked(imember, MFLAG_HAS_AUDIO);
+ conf_utils_member_clear_flag_locked(imember, MFLAG_HAS_AUDIO);
switch_mutex_lock(imember->audio_in_mutex);
if (switch_buffer_inuse(imember->audio_buffer) >= bytes
&& (buf_read = (uint32_t) switch_buffer_read(imember->audio_buffer, imember->frame, bytes))) {
imember->read = buf_read;
- member_set_flag_locked(imember, MFLAG_HAS_AUDIO);
+ conf_utils_member_set_flag_locked(imember, MFLAG_HAS_AUDIO);
ready++;
}
switch_mutex_unlock(imember->audio_in_mutex);
conference->members_with_avatar = members_with_avatar;
if (floor_holder != conference->floor_holder) {
- conference_set_floor_holder(conference, floor_holder);
+ conf_member_set_floor_holder(conference, floor_holder);
}
if (conference->perpetual_sound && !conference->async_fnode) {
- conference_play_file(conference, conference->perpetual_sound, CONF_DEFAULT_LEADIN, NULL, 1);
+ conference_file_play(conference, conference->perpetual_sound, CONF_DEFAULT_LEADIN, NULL, 1);
} else if (conference->moh_sound && ((nomoh == 0 && conference->count == 1)
- || conference_test_flag(conference, CFLAG_WAIT_MOD)) && !conference->async_fnode && !conference->fnode) {
- conference_play_file(conference, conference->moh_sound, CONF_DEFAULT_LEADIN, NULL, 1);
+ || conf_utils_test_flag(conference, CFLAG_WAIT_MOD)) && !conference->async_fnode && !conference->fnode) {
+ conference_file_play(conference, conference->moh_sound, CONF_DEFAULT_LEADIN, NULL, 1);
}
}
if (is_talking == 0) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Conference has been idle for over %d seconds, terminating\n", conference->terminate_on_silence);
- conference_set_flag(conference, CFLAG_DESTRUCT);
+ conf_utils_set_flag(conference, CFLAG_DESTRUCT);
}
}
switch_channel_t *channel = switch_core_session_get_channel(imember->session);
char *rfile = switch_channel_expand_variables(channel, conference->auto_record);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Auto recording file: %s\n", rfile);
- launch_conference_record_thread(conference, rfile, SWITCH_TRUE);
+ conf_record_launch_thread(conference, rfile, SWITCH_TRUE);
if (rfile != conference->auto_record) {
conference->record_filename = switch_core_strdup(conference->pool, rfile);
if (switch_core_speech_read_tts(conference->fnode->sh, file_frame, &speech_len, &flags) == SWITCH_STATUS_SUCCESS) {
if (conference->fnode->al) {
- process_al(conference->fnode->al, file_frame, speech_len, conference->rate);
+ conf_al_process(conference->fnode->al, file_frame, speech_len, conference->rate);
}
file_sample_len = file_data_len / 2 / conference->fnode->sh->channels;
conference->fnode->fh.vol);
}
if (conference->fnode->al) {
- process_al(conference->fnode->al, file_frame, file_sample_len * 2, conference->fnode->fh.samplerate);
+ conf_al_process(conference->fnode->al, file_frame, file_sample_len * 2, conference->fnode->fh.samplerate);
}
}
file_sample_len = samples;
switch_core_file_read(&conference->async_fnode->fh, async_file_frame, &file_sample_len);
if (conference->async_fnode->al) {
- process_al(conference->async_fnode->al, file_frame, file_sample_len * 2, conference->async_fnode->fh.samplerate);
+ conf_al_process(conference->async_fnode->al, file_frame, file_sample_len * 2, conference->async_fnode->fh.samplerate);
}
if (file_sample_len <= 0) {
conference->async_fnode->done++;
for (omember = conference->members; omember; omember = omember->next) {
conference->member_loop_count++;
- if (!(member_test_flag(omember, MFLAG_RUNNING) && member_test_flag(omember, MFLAG_HAS_AUDIO))) {
+ if (!(conf_utils_member_test_flag(omember, MFLAG_RUNNING) && conf_utils_member_test_flag(omember, MFLAG_HAS_AUDIO))) {
continue;
}
if (conference->agc_level) {
- if (member_test_flag(omember, MFLAG_TALKING) && member_test_flag(omember, MFLAG_CAN_SPEAK)) {
+ if (conf_utils_member_test_flag(omember, MFLAG_TALKING) && conf_utils_member_test_flag(omember, MFLAG_CAN_SPEAK)) {
member_score_sum += omember->score;
conference->mux_loop_count++;
}
for (omember = conference->members; omember; omember = omember->next) {
switch_size_t ok = 1;
- if (!member_test_flag(omember, MFLAG_RUNNING)) {
+ if (!conf_utils_member_test_flag(omember, MFLAG_RUNNING)) {
continue;
}
- if (!member_test_flag(omember, MFLAG_CAN_HEAR)) {
+ if (!conf_utils_member_test_flag(omember, MFLAG_CAN_HEAR)) {
switch_mutex_lock(omember->audio_out_mutex);
memset(write_frame, 255, bytes);
ok = switch_buffer_write(omember->mux_buffer, write_frame, bytes);
z = main_frame[x];
/* bptr[x] represents my own contribution to this audio sample */
- if (member_test_flag(omember, MFLAG_HAS_AUDIO) && x <= omember->read / 2) {
+ if (conf_utils_member_test_flag(omember, MFLAG_HAS_AUDIO) && x <= omember->read / 2) {
z -= (int32_t) bptr[x];
}
*/
if (conference->relationship_total) {
for (imember = conference->members; imember; imember = imember->next) {
- if (imember != omember && member_test_flag(imember, MFLAG_HAS_AUDIO)) {
+ if (imember != omember && conf_utils_member_test_flag(imember, MFLAG_HAS_AUDIO)) {
conference_relationship_t *rel;
switch_size_t found = 0;
int16_t *rptr = (int16_t *) imember->frame;
for (omember = conference->members; omember; omember = omember->next) {
switch_size_t ok = 1;
- if (!member_test_flag(omember, MFLAG_RUNNING)) {
+ if (!conf_utils_member_test_flag(omember, MFLAG_RUNNING)) {
continue;
}
switch_memory_pool_t *pool;
if (conference->canvas && conference->async_fnode->layer_id > -1 ) {
- canvas_del_fnode_layer(conference, conference->async_fnode);
+ conf_video_canvas_del_fnode_layer(conference, conference->async_fnode);
}
conference_file_close(conference, conference->async_fnode);
switch_memory_pool_t *pool;
if (conference->canvas && conference->fnode->layer_id > -1 ) {
- canvas_del_fnode_layer(conference, conference->fnode);
+ conf_video_canvas_del_fnode_layer(conference, conference->fnode);
}
if (conference->fnode->type != NODE_TYPE_SPEECH) {
conference->fnode = conference->fnode->next;
if (conference->fnode) {
- fnode_check_video(conference->fnode);
+ conf_video_fnode_check(conference->fnode);
}
switch_epoch_time_now(NULL) - conference->endconf_time > conference->endconf_grace_time) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Conference %s: endconf grace time exceeded (%u)\n",
conference->name, conference->endconf_grace_time);
- conference_set_flag(conference, CFLAG_DESTRUCT | CFLAG_ENDCONF_FORCED);
+ conf_utils_set_flag(conference, CFLAG_DESTRUCT | CFLAG_ENDCONF_FORCED);
}
switch_mutex_unlock(conference->mutex);
/* Rinse ... Repeat */
end:
- if (conference_test_flag(conference, CFLAG_OUTCALL)) {
+ if (conf_utils_test_flag(conference, CFLAG_OUTCALL)) {
conference->cancel_cause = SWITCH_CAUSE_ORIGINATOR_CANCEL;
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Ending pending outcall channels for Conference: '%s'\n", conference->name);
while(conference->originating) {
}
}
- conference_send_presence(conference);
+ conf_send_presence(conference);
switch_mutex_lock(conference->mutex);
- conference_stop_file(conference, FILE_STOP_ASYNC);
- conference_stop_file(conference, FILE_STOP_ALL);
+ conference_file_stop(conference, FILE_STOP_ASYNC);
+ conference_file_stop(conference, FILE_STOP_ALL);
for (np = conference->cdr_nodes; np; np = np->next) {
if (np->var_event) {
for (imember = conference->members; imember; imember = imember->next) {
switch_channel_t *channel;
- if (!member_test_flag(imember, MFLAG_NOCHANNEL)) {
+ if (!conf_utils_member_test_flag(imember, MFLAG_NOCHANNEL)) {
channel = switch_core_session_get_channel(imember->session);
if (!switch_false(switch_channel_get_variable(channel, "hangup_after_conference"))) {
/* add this little bit to preserve the bridge cause code in case of an early media call that */
/* never answers */
- if (conference_test_flag(conference, CFLAG_ANSWERED)) {
+ if (conf_utils_test_flag(conference, CFLAG_ANSWERED)) {
switch_channel_hangup(channel, SWITCH_CAUSE_NORMAL_CLEARING);
} else {
/* put actual cause code from outbound channel hangup here */
}
}
- member_clear_flag_locked(imember, MFLAG_RUNNING);
+ conf_utils_member_clear_flag_locked(imember, MFLAG_RUNNING);
}
switch_mutex_unlock(conference->member_mutex);
switch_mutex_unlock(conference->mutex);
}
switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT);
- conference_add_event_data(conference, event);
+ conf_event_add_data(conference, event);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "conference-destroy");
switch_event_fire(&event);
switch_core_timer_destroy(&timer);
- switch_mutex_lock(mod_conference_globals.hash_mutex);
- if (conference_test_flag(conference, CFLAG_INHASH)) {
- switch_core_hash_delete(mod_conference_globals.conference_hash, conference->name);
+ switch_mutex_lock(conf_globals.hash_mutex);
+ if (conf_utils_test_flag(conference, CFLAG_INHASH)) {
+ switch_core_hash_delete(conf_globals.conference_hash, conference->name);
}
- switch_mutex_unlock(mod_conference_globals.hash_mutex);
+ switch_mutex_unlock(conf_globals.hash_mutex);
- conference_clear_flag(conference, CFLAG_VIDEO_MUXING);
+ conf_utils_clear_flag(conference, CFLAG_VIDEO_MUXING);
for (x = 0; x <= conference->canvas_count; x++) {
if (conference->canvases[x] && conference->canvases[x]->video_muxing_thread) {
}
/* Wait till everybody is out */
- conference_clear_flag_locked(conference, CFLAG_RUNNING);
+ conf_utils_clear_flag_locked(conference, CFLAG_RUNNING);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Write Lock ON\n");
switch_thread_rwlock_wrlock(conference->rwlock);
switch_thread_rwlock_unlock(conference->rwlock);
}
conference->end_time = switch_epoch_time_now(NULL);
- conference_cdr_render(conference);
+ conf_cdr_render(conference);
- switch_mutex_lock(mod_conference_globals.setup_mutex);
+ switch_mutex_lock(conf_globals.setup_mutex);
if (conference->layout_hash) {
switch_core_hash_destroy(&conference->layout_hash);
}
- switch_mutex_unlock(mod_conference_globals.setup_mutex);
+ switch_mutex_unlock(conf_globals.setup_mutex);
if (conference->layout_group_hash) {
switch_core_hash_destroy(&conference->layout_group_hash);
switch_core_destroy_memory_pool(&pool);
}
- switch_mutex_lock(mod_conference_globals.hash_mutex);
- mod_conference_globals.threads--;
- switch_mutex_unlock(mod_conference_globals.hash_mutex);
+ switch_mutex_lock(conf_globals.hash_mutex);
+ conf_globals.threads--;
+ switch_mutex_unlock(conf_globals.hash_mutex);
return NULL;
}
/* Say some thing with TTS in the conference room */
-switch_status_t conference_say(conference_obj_t *conference, const char *text, uint32_t leadin)
+switch_status_t conf_say(conference_obj_t *conference, const char *text, uint32_t leadin)
{
switch_status_t status = SWITCH_STATUS_FALSE;
conference_file_node_t *fnode, *nptr;
position = NULL;
} else {
channels = 1;
- fnode->al = create_al(pool);
- if (parse_position(fnode->al, position) != SWITCH_STATUS_SUCCESS) {
+ fnode->al = conf_al_create(pool);
+ if (conf_al_parse_position(fnode->al, position) != SWITCH_STATUS_SUCCESS) {
fnode->al = NULL;
channels = conference->channels;
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invalid Position Data.\n");
}
-switch_status_t list_conferences(const char *line, const char *cursor, switch_console_callback_match_t **matches)
+switch_status_t conf_list_conferences(const char *line, const char *cursor, switch_console_callback_match_t **matches)
{
switch_console_callback_match_t *my_matches = NULL;
switch_status_t status = SWITCH_STATUS_FALSE;
void *val;
const void *vvar;
- switch_mutex_lock(mod_conference_globals.hash_mutex);
- for (hi = switch_core_hash_first(mod_conference_globals.conference_hash); hi; hi = switch_core_hash_next(&hi)) {
+ switch_mutex_lock(conf_globals.hash_mutex);
+ for (hi = switch_core_hash_first(conf_globals.conference_hash); hi; hi = switch_core_hash_next(&hi)) {
switch_core_hash_this(hi, &vvar, NULL, &val);
switch_console_push_match(&my_matches, (const char *) vvar);
}
- switch_mutex_unlock(mod_conference_globals.hash_mutex);
+ switch_mutex_unlock(conf_globals.hash_mutex);
if (my_matches) {
*matches = my_matches;
return status;
}
-void conference_list_pretty(conference_obj_t *conference, switch_stream_handle_t *stream)
+void conf_list_pretty(conference_obj_t *conference, switch_stream_handle_t *stream)
{
- conference_member_t *member = NULL;
+ conf_member_t *member = NULL;
switch_assert(conference != NULL);
switch_assert(stream != NULL);
switch_channel_t *channel;
switch_caller_profile_t *profile;
- if (member_test_flag(member, MFLAG_NOCHANNEL)) {
+ if (conf_utils_member_test_flag(member, MFLAG_NOCHANNEL)) {
continue;
}
channel = switch_core_session_get_channel(member->session);
}
-void conference_list_count_only(conference_obj_t *conference, switch_stream_handle_t *stream)
+void conf_list_count_only(conference_obj_t *conference, switch_stream_handle_t *stream)
{
switch_assert(conference != NULL);
switch_assert(stream != NULL);
return x_tag;
}
-void conference_xlist(conference_obj_t *conference, switch_xml_t x_conference, int off)
+void conf_xlist(conference_obj_t *conference, switch_xml_t x_conference, int off)
{
- conference_member_t *member = NULL;
+ conf_member_t *member = NULL;
switch_xml_t x_member = NULL, x_members = NULL, x_flags;
int moff = 0;
char i[30] = "";
switch_xml_set_attr_d(x_conference, "rate", ival);
switch_xml_set_attr_d(x_conference, "uuid", conference->uuid_str);
- if (conference_test_flag(conference, CFLAG_LOCKED)) {
+ if (conf_utils_test_flag(conference, CFLAG_LOCKED)) {
switch_xml_set_attr_d(x_conference, "locked", "true");
}
- if (conference_test_flag(conference, CFLAG_DESTRUCT)) {
+ if (conf_utils_test_flag(conference, CFLAG_DESTRUCT)) {
switch_xml_set_attr_d(x_conference, "destruct", "true");
}
- if (conference_test_flag(conference, CFLAG_WAIT_MOD)) {
+ if (conf_utils_test_flag(conference, CFLAG_WAIT_MOD)) {
switch_xml_set_attr_d(x_conference, "wait_mod", "true");
}
- if (conference_test_flag(conference, CFLAG_AUDIO_ALWAYS)) {
+ if (conf_utils_test_flag(conference, CFLAG_AUDIO_ALWAYS)) {
switch_xml_set_attr_d(x_conference, "audio_always", "true");
}
- if (conference_test_flag(conference, CFLAG_RUNNING)) {
+ if (conf_utils_test_flag(conference, CFLAG_RUNNING)) {
switch_xml_set_attr_d(x_conference, "running", "true");
}
- if (conference_test_flag(conference, CFLAG_ANSWERED)) {
+ if (conf_utils_test_flag(conference, CFLAG_ANSWERED)) {
switch_xml_set_attr_d(x_conference, "answered", "true");
}
- if (conference_test_flag(conference, CFLAG_ENFORCE_MIN)) {
+ if (conf_utils_test_flag(conference, CFLAG_ENFORCE_MIN)) {
switch_xml_set_attr_d(x_conference, "enforce_min", "true");
}
- if (conference_test_flag(conference, CFLAG_BRIDGE_TO)) {
+ if (conf_utils_test_flag(conference, CFLAG_BRIDGE_TO)) {
switch_xml_set_attr_d(x_conference, "bridge_to", "true");
}
- if (conference_test_flag(conference, CFLAG_DYNAMIC)) {
+ if (conf_utils_test_flag(conference, CFLAG_DYNAMIC)) {
switch_xml_set_attr_d(x_conference, "dynamic", "true");
}
- if (conference_test_flag(conference, CFLAG_EXIT_SOUND)) {
+ if (conf_utils_test_flag(conference, CFLAG_EXIT_SOUND)) {
switch_xml_set_attr_d(x_conference, "exit_sound", "true");
}
- if (conference_test_flag(conference, CFLAG_ENTER_SOUND)) {
+ if (conf_utils_test_flag(conference, CFLAG_ENTER_SOUND)) {
switch_xml_set_attr_d(x_conference, "enter_sound", "true");
}
switch_xml_set_attr_d(x_conference, "endconf_grace_time", ival);
}
- if (conference_test_flag(conference, CFLAG_VID_FLOOR)) {
+ if (conf_utils_test_flag(conference, CFLAG_VID_FLOOR)) {
switch_xml_set_attr_d(x_conference, "video_floor_only", "true");
}
- if (conference_test_flag(conference, CFLAG_RFC4579)) {
+ if (conf_utils_test_flag(conference, CFLAG_RFC4579)) {
switch_xml_set_attr_d(x_conference, "video_rfc4579", "true");
}
int toff = 0;
char tmp[50] = "";
- if (member_test_flag(member, MFLAG_NOCHANNEL)) {
+ if (conf_utils_member_test_flag(member, MFLAG_NOCHANNEL)) {
if (member->rec_path) {
x_member = switch_xml_add_child_d(x_members, "member", moff++);
switch_assert(x_member);
*/
x_tag = switch_xml_add_child_d(x_member, "record_path", count++);
- if (member_test_flag(member, MFLAG_PAUSE_RECORDING)) {
+ if (conf_utils_member_test_flag(member, MFLAG_PAUSE_RECORDING)) {
switch_xml_set_attr_d(x_tag, "status", "paused");
}
switch_xml_set_txt_d(x_tag, member->rec_path);
switch_assert(x_flags);
x_tag = switch_xml_add_child_d(x_flags, "can_hear", count++);
- switch_xml_set_txt_d(x_tag, member_test_flag(member, MFLAG_CAN_HEAR) ? "true" : "false");
+ switch_xml_set_txt_d(x_tag, conf_utils_member_test_flag(member, MFLAG_CAN_HEAR) ? "true" : "false");
x_tag = switch_xml_add_child_d(x_flags, "can_speak", count++);
- switch_xml_set_txt_d(x_tag, member_test_flag(member, MFLAG_CAN_SPEAK) ? "true" : "false");
+ switch_xml_set_txt_d(x_tag, conf_utils_member_test_flag(member, MFLAG_CAN_SPEAK) ? "true" : "false");
x_tag = switch_xml_add_child_d(x_flags, "mute_detect", count++);
- switch_xml_set_txt_d(x_tag, member_test_flag(member, MFLAG_MUTE_DETECT) ? "true" : "false");
+ switch_xml_set_txt_d(x_tag, conf_utils_member_test_flag(member, MFLAG_MUTE_DETECT) ? "true" : "false");
x_tag = switch_xml_add_child_d(x_flags, "talking", count++);
- switch_xml_set_txt_d(x_tag, member_test_flag(member, MFLAG_TALKING) ? "true" : "false");
+ switch_xml_set_txt_d(x_tag, conf_utils_member_test_flag(member, MFLAG_TALKING) ? "true" : "false");
x_tag = switch_xml_add_child_d(x_flags, "has_video", count++);
switch_xml_set_txt_d(x_tag, switch_channel_test_flag(switch_core_session_get_channel(member->session), CF_VIDEO) ? "true" : "false");
x_tag = switch_xml_add_child_d(x_flags, "video_bridge", count++);
- switch_xml_set_txt_d(x_tag, member_test_flag(member, MFLAG_VIDEO_BRIDGE) ? "true" : "false");
+ switch_xml_set_txt_d(x_tag, conf_utils_member_test_flag(member, MFLAG_VIDEO_BRIDGE) ? "true" : "false");
x_tag = switch_xml_add_child_d(x_flags, "has_floor", count++);
switch_xml_set_txt_d(x_tag, (member == member->conference->floor_holder) ? "true" : "false");
x_tag = switch_xml_add_child_d(x_flags, "is_moderator", count++);
- switch_xml_set_txt_d(x_tag, member_test_flag(member, MFLAG_MOD) ? "true" : "false");
+ switch_xml_set_txt_d(x_tag, conf_utils_member_test_flag(member, MFLAG_MOD) ? "true" : "false");
x_tag = switch_xml_add_child_d(x_flags, "end_conference", count++);
- switch_xml_set_txt_d(x_tag, member_test_flag(member, MFLAG_ENDCONF) ? "true" : "false");
+ switch_xml_set_txt_d(x_tag, conf_utils_member_test_flag(member, MFLAG_ENDCONF) ? "true" : "false");
x_tag = switch_xml_add_child_d(x_flags, "is_ghost", count++);
- switch_xml_set_txt_d(x_tag, member_test_flag(member, MFLAG_GHOST) ? "true" : "false");
+ switch_xml_set_txt_d(x_tag, conf_utils_member_test_flag(member, MFLAG_GHOST) ? "true" : "false");
switch_snprintf(tmp, sizeof(tmp), "%d", member->volume_out_level);
add_x_tag(x_member, "output-volume", tmp, toff++);
switch_mutex_unlock(conference->member_mutex);
}
-void switch_fnode_toggle_pause(conference_file_node_t *fnode, switch_stream_handle_t *stream)
+void conf_fnode_toggle_pause(conference_file_node_t *fnode, switch_stream_handle_t *stream)
{
if (fnode) {
if (switch_test_flag(fnode, NFLAG_PAUSE)) {
}
-void switch_fnode_seek(conference_file_node_t *fnode, switch_stream_handle_t *stream, char *arg)
+void conf_fnode_seek(conference_file_node_t *fnode, switch_stream_handle_t *stream, char *arg)
{
if (fnode && fnode->type == NODE_TYPE_FILE) {
unsigned int samps = 0;
/* generate an outbound call from the conference */
-switch_status_t conference_outcall(conference_obj_t *conference,
+switch_status_t conf_outcall(conference_obj_t *conference,
char *conference_name,
switch_core_session_t *session,
char *bridgeto, uint32_t timeout,
switch_mutex_unlock(conference->mutex);
if (track) {
- send_conference_notify(conference, "SIP/2.0 100 Trying\r\n", call_id, SWITCH_FALSE);
+ conf_send_notify(conference, "SIP/2.0 100 Trying\r\n", call_id, SWITCH_FALSE);
}
}
if (track) {
- send_conference_notify(conference, "SIP/2.0 481 Failure\r\n", call_id, SWITCH_TRUE);
+ conf_send_notify(conference, "SIP/2.0 481 Failure\r\n", call_id, SWITCH_TRUE);
}
goto done;
}
if (track) {
- send_conference_notify(conference, "SIP/2.0 200 OK\r\n", call_id, SWITCH_TRUE);
+ conf_send_notify(conference, "SIP/2.0 200 OK\r\n", call_id, SWITCH_TRUE);
}
rdlock = 1;
peer_channel = switch_core_session_get_channel(peer_session);
/* make sure the conference still exists */
- if (!conference_test_flag(conference, CFLAG_RUNNING)) {
+ if (!conf_utils_test_flag(conference, CFLAG_RUNNING)) {
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Conference is gone now, nevermind..\n");
if (caller_channel) {
switch_channel_hangup(caller_channel, SWITCH_CAUSE_NO_ROUTE_DESTINATION);
return status;
}
-void *SWITCH_THREAD_FUNC conference_outcall_run(switch_thread_t *thread, void *obj)
+void *SWITCH_THREAD_FUNC conf_outcall_run(switch_thread_t *thread, void *obj)
{
struct bg_call *call = (struct bg_call *) obj;
switch_event_t *event;
- conference_outcall(call->conference, call->conference_name,
+ conf_outcall(call->conference, call->conference_name,
call->session, call->bridgeto, call->timeout,
call->flags, call->cid_name, call->cid_num, call->profile, &cause, call->cancel_cause, call->var_event);
if (call->conference && test_eflag(call->conference, EFLAG_BGDIAL_RESULT) &&
switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
- conference_add_event_data(call->conference, event);
+ conf_event_add_data(call->conference, event);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "bgdial-result");
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Result", switch_channel_cause2str(cause));
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Job-UUID", call->uuid);
return NULL;
}
-switch_status_t conference_outcall_bg(conference_obj_t *conference,
+switch_status_t conf_outcall_bg(conference_obj_t *conference,
char *conference_name,
switch_core_session_t *session, char *bridgeto, uint32_t timeout, const char *flags, const char *cid_name,
const char *cid_num, const char *call_uuid, const char *profile, switch_call_cause_t *cancel_cause, switch_event_t **var_event)
switch_threadattr_create(&thd_attr, pool);
switch_threadattr_detach_set(thd_attr, 1);
switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE);
- switch_thread_create(&thread, thd_attr, conference_outcall_run, call, pool);
+ switch_thread_create(&thread, thd_attr, conf_outcall_run, call, pool);
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Launching BG Thread for outcall\n");
return SWITCH_STATUS_SUCCESS;
-SWITCH_STANDARD_APP(conference_auto_function)
+SWITCH_STANDARD_APP(conf_auto_function)
{
switch_channel_t *channel = switch_core_session_get_channel(session);
call_list_t *call_list, *np;
}
-const char *combine_flag_var(switch_core_session_t *session, const char *var_name)
-{
- switch_event_header_t *hp;
- switch_event_t *event, *cevent;
- char *ret = NULL;
- switch_channel_t *channel = switch_core_session_get_channel(session);
-
- switch_core_get_variables(&event);
- switch_channel_get_variables(channel, &cevent);
- switch_event_merge(event, cevent);
-
-
- for (hp = event->headers; hp; hp = hp->next) {
- char *var = hp->name;
- char *val = hp->value;
-
- if (!strcasecmp(var, var_name)) {
- if (hp->idx) {
- int i;
- for (i = 0; i < hp->idx; i++) {
- if (zstr(ret)) {
- ret = switch_core_session_sprintf(session, "%s", hp->array[i]);
- } else {
- ret = switch_core_session_sprintf(session, "%s|%s", ret, hp->array[i]);
- }
- }
- } else {
- if (zstr(ret)) {
- ret = switch_core_session_sprintf(session, "%s", val);
- } else {
- ret = switch_core_session_sprintf(session, "%s|%s", ret, val);
- }
- }
- }
- }
-
-
- switch_event_destroy(&event);
- switch_event_destroy(&cevent);
-
- return ret;
-
-}
-
/* Application interface function that is called from the dialplan to join the channel to a conference */
SWITCH_STANDARD_APP(conference_function)
{
switch_codec_t *read_codec = NULL;
//uint32_t flags = 0;
- conference_member_t member = { 0 };
+ conf_member_t member = { 0 };
conference_obj_t *conference = NULL;
switch_channel_t *channel = switch_core_session_get_channel(session);
char *mydata = NULL;
}
}
- //if ((v_flags_str = switch_channel_get_variable(channel, "conference_member_flags"))) {
- if ((v_flags_str = combine_flag_var(session, "conference_member_flags"))) {
+ //if ((v_flags_str = switch_channel_get_variable(channel, "conf_member_flags"))) {
+ if ((v_flags_str = conf_utils_combine_flag_var(session, "conf_member_flags"))) {
if (zstr(flags_str)) {
flags_str = v_flags_str;
} else {
cflags_str = flags_str;
//if ((v_cflags_str = switch_channel_get_variable(channel, "conference_flags"))) {
- if ((v_cflags_str = combine_flag_var(session, "conference_flags"))) {
+ if ((v_cflags_str = conf_utils_combine_flag_var(session, "conference_flags"))) {
if (zstr(cflags_str)) {
cflags_str = v_cflags_str;
} else {
/* conference object, and skip pin handling, and locked checking */
if (!locked) {
- switch_mutex_lock(mod_conference_globals.setup_mutex);
+ switch_mutex_lock(conf_globals.setup_mutex);
locked = 1;
}
conf_name = uuid;
}
- if ((conference = conference_find(conf_name, NULL))) {
+ if ((conference = conf_find(conf_name, NULL))) {
switch_thread_rwlock_unlock(conference->rwlock);
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Conference %s already exists!\n", conf_name);
goto done;
}
/* Create the conference object. */
- conference = conference_new(conf_name, xml_cfg, session, NULL);
+ conference = conf_new(conf_name, xml_cfg, session, NULL);
if (!conference) {
goto done;
}
- set_cflags(cflags_str, conference->flags);
+ conf_utils_set_cflags(cflags_str, conference->flags);
if (locked) {
- switch_mutex_unlock(mod_conference_globals.setup_mutex);
+ switch_mutex_unlock(conf_globals.setup_mutex);
locked = 0;
}
conference->min = 2;
/* Indicate the conference is dynamic */
- conference_set_flag_locked(conference, CFLAG_DYNAMIC);
+ conf_utils_set_flag_locked(conference, CFLAG_DYNAMIC);
/* Indicate the conference has a bridgeto party */
- conference_set_flag_locked(conference, CFLAG_BRIDGE_TO);
+ conf_utils_set_flag_locked(conference, CFLAG_BRIDGE_TO);
/* Start the conference thread for this conference */
- launch_conference_thread(conference);
+ conf_launch_thread(conference);
} else {
int enforce_security = switch_channel_direction(channel) == SWITCH_CALL_DIRECTION_INBOUND;
enforce_security = switch_true(pvar);
}
- if ((conference = conference_find(conf_name, NULL))) {
+ if ((conference = conf_find(conf_name, NULL))) {
if (locked) {
- switch_mutex_unlock(mod_conference_globals.setup_mutex);
+ switch_mutex_unlock(conf_globals.setup_mutex);
locked = 0;
}
}
/* no conference yet, so check for join-only flag */
if (flags_str) {
- set_mflags(flags_str, mflags);
+ conf_utils_set_mflags(flags_str, mflags);
if (!(mflags[MFLAG_CAN_SPEAK])) {
if (!(mflags[MFLAG_MUTE_DETECT])) {
}
/* couldn't find the conference, create one */
- conference = conference_new(conf_name, xml_cfg, session, NULL);
+ conference = conf_new(conf_name, xml_cfg, session, NULL);
if (!conference) {
goto done;
}
- set_cflags(cflags_str, conference->flags);
+ conf_utils_set_cflags(cflags_str, conference->flags);
if (locked) {
- switch_mutex_unlock(mod_conference_globals.setup_mutex);
+ switch_mutex_unlock(conf_globals.setup_mutex);
locked = 0;
}
}
/* Indicate the conference is dynamic */
- conference_set_flag_locked(conference, CFLAG_DYNAMIC);
+ conf_utils_set_flag_locked(conference, CFLAG_DYNAMIC);
/* acquire a read lock on the thread so it can't leave without us */
if (switch_thread_rwlock_tryrdlock(conference->rwlock) != SWITCH_STATUS_SUCCESS) {
rl++;
/* Start the conference thread for this conference */
- launch_conference_thread(conference);
+ conf_launch_thread(conference);
} else { /* setup user variable */
switch_channel_set_variable(channel, "conference_name", conference->name);
rl++;
/* be friendly */
if (conference->pin_sound) {
- pstatus = conference_local_play_file(conference, session, conference->pin_sound, 20, pin_buf, sizeof(pin_buf));
+ pstatus = conference_file_local_play(conference, session, conference->pin_sound, 20, pin_buf, sizeof(pin_buf));
} else if (conference->tts_engine && conference->tts_voice) {
pstatus =
switch_ivr_speak_text(session, conference->tts_engine, conference->tts_voice, "please enter the conference pin number", NULL);
/* more friendliness */
if (conference->bad_pin_sound) {
- conference_local_play_file(conference, session, conference->bad_pin_sound, 20, NULL, 0);
+ conference_file_local_play(conference, session, conference->bad_pin_sound, 20, NULL, 0);
}
switch_channel_flush_dtmf(channel);
}
}
if (!pin_valid) {
- conference_cdr_rejected(conference, channel, CDRR_PIN);
+ conf_cdr_rejected(conference, channel, CDRR_PIN);
goto done;
}
}
if (conference->special_announce && !switch_channel_test_app_flag_key("conf_silent", channel, CONF_SILENT_REQ)) {
- conference_local_play_file(conference, session, conference->special_announce, CONF_DEFAULT_LEADIN, NULL, 0);
+ conference_file_local_play(conference, session, conference->special_announce, CONF_DEFAULT_LEADIN, NULL, 0);
}
/* don't allow more callers if the conference is locked, unless we invited them */
- if (conference_test_flag(conference, CFLAG_LOCKED) && enforce_security) {
+ if (conf_utils_test_flag(conference, CFLAG_LOCKED) && enforce_security) {
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_NOTICE, "Conference %s is locked.\n", conf_name);
- conference_cdr_rejected(conference, channel, CDRR_LOCKED);
+ conf_cdr_rejected(conference, channel, CDRR_LOCKED);
if (conference->locked_sound) {
/* Answer the channel */
switch_channel_answer(channel);
- conference_local_play_file(conference, session, conference->locked_sound, 20, NULL, 0);
+ conference_file_local_play(conference, session, conference->locked_sound, 20, NULL, 0);
}
goto done;
}
*/
if ((conference->max_members > 0) && (conference->count >= conference->max_members)) {
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_NOTICE, "Conference %s is full.\n", conf_name);
- conference_cdr_rejected(conference, channel, CDRR_MAXMEMBERS);
+ conf_cdr_rejected(conference, channel, CDRR_MAXMEMBERS);
if (conference->maxmember_sound) {
/* Answer the channel */
switch_channel_answer(channel);
- conference_local_play_file(conference, session, conference->maxmember_sound, 20, NULL, 0);
+ conference_file_local_play(conference, session, conference->maxmember_sound, 20, NULL, 0);
}
goto done;
}
/* if we're using "bridge:" make an outbound call and bridge it in */
if (!zstr(bridgeto) && strcasecmp(bridgeto, "none")) {
switch_call_cause_t cause;
- if (conference_outcall(conference, NULL, session, bridgeto, 60, NULL, NULL, NULL, NULL, &cause, NULL, NULL) != SWITCH_STATUS_SUCCESS) {
+ if (conf_outcall(conference, NULL, session, bridgeto, 60, NULL, NULL, NULL, NULL, &cause, NULL, NULL) != SWITCH_STATUS_SUCCESS) {
goto done;
}
} else {
/* if we're not using "bridge:" set the conference answered flag */
/* and this isn't an outbound channel, answer the call */
if (switch_channel_direction(channel) == SWITCH_CALL_DIRECTION_INBOUND)
- conference_set_flag(conference, CFLAG_ANSWERED);
+ conf_utils_set_flag(conference, CFLAG_ANSWERED);
}
member.session = session;
switch_mutex_init(&member.audio_out_mutex, SWITCH_MUTEX_NESTED, member.pool);
switch_thread_rwlock_create(&member.rwlock, member.pool);
- if (setup_media(&member, conference)) {
+ if (conf_member_setup_media(&member, conference)) {
//flags = 0;
goto done;
}
switch_channel_set_private(channel, "__confmid", mid);
}
- switch_channel_set_variable_printf(channel, "conference_member_id", "%u", *mid);
+ switch_channel_set_variable_printf(channel, "conf_member_id", "%u", *mid);
member.id = *mid;
memcpy(mflags, conference->mflags, sizeof(mflags));
- set_mflags(flags_str, mflags);
+ conf_utils_set_mflags(flags_str, mflags);
mflags[MFLAG_RUNNING] = 1;
if (!(mflags[MFLAG_CAN_SPEAK])) {
mflags[MFLAG_MOD] = 1;
}
- merge_mflags(member.flags, mflags);
+ conf_utils_merge_mflags(member.flags, mflags);
if (mflags[MFLAG_MINTWO]) {
}
/* Add the caller to the conference */
- if (conference_add_member(conference, &member) != SWITCH_STATUS_SUCCESS) {
+ if (conf_member_add(conference, &member) != SWITCH_STATUS_SUCCESS) {
switch_core_codec_destroy(&member.read_codec);
goto done;
}
if (conference->conf_video_mode == CONF_VIDEO_MODE_MUX) {
- launch_conference_video_muxing_write_thread(&member);
+ conf_video_launch_muxing_write_thread(&member);
}
msg.from = __FILE__;
msg.message_id = SWITCH_MESSAGE_INDICATE_BRIDGE;
switch_core_session_receive_message(session, &msg);
- if (conference_test_flag(conference, CFLAG_TRANSCODE_VIDEO)) {
+ if (conf_utils_test_flag(conference, CFLAG_TRANSCODE_VIDEO)) {
switch_channel_set_flag(channel, CF_VIDEO_DECODED_READ);
switch_core_media_gen_key_frame(session);
}
/* Chime in the core video thread */
- switch_core_session_set_video_read_callback(session, video_thread_callback, (void *)&member);
+ switch_core_session_set_video_read_callback(session, conf_video_thread_callback, (void *)&member);
if (switch_channel_test_flag(channel, CF_VIDEO_ONLY)) {
- while(member_test_flag((&member), MFLAG_RUNNING) && switch_channel_ready(channel)) {
+ while(conf_utils_member_test_flag((&member), MFLAG_RUNNING) && switch_channel_ready(channel)) {
switch_yield(100000);
}
} else {
/* Run the conference loop */
do {
- conference_loop_output(&member);
+ conf_loop_output(&member);
} while (member.loop_loop);
}
switch_core_session_receive_message(session, &msg);
/* Remove the caller from the conference */
- conference_del_member(member.conference, &member);
+ conf_member_del(member.conference, &member);
/* Put the original codec back */
switch_core_session_set_read_codec(member.session, NULL);
if (locked) {
- switch_mutex_unlock(mod_conference_globals.setup_mutex);
+ switch_mutex_unlock(conf_globals.setup_mutex);
}
if (member.read_resampler) {
if (conference) {
switch_mutex_lock(conference->mutex);
- if (conference_test_flag(conference, CFLAG_DYNAMIC) && conference->count == 0) {
- conference_set_flag_locked(conference, CFLAG_DESTRUCT);
+ if (conf_utils_test_flag(conference, CFLAG_DYNAMIC) && conference->count == 0) {
+ conf_utils_set_flag_locked(conference, CFLAG_DESTRUCT);
}
switch_mutex_unlock(conference->mutex);
}
switch_xml_free(cxml);
}
- if (conference && member_test_flag(&member, MFLAG_KICKED) && conference->kicked_sound) {
+ if (conference && conf_utils_member_test_flag(&member, MFLAG_KICKED) && conference->kicked_sound) {
char *toplay = NULL;
char *dfile = NULL;
char *expanded = NULL;
/* Create a thread for the conference and launch it */
-void launch_conference_thread(conference_obj_t *conference)
+void conf_launch_thread(conference_obj_t *conference)
{
switch_thread_t *thread;
switch_threadattr_t *thd_attr = NULL;
- conference_set_flag_locked(conference, CFLAG_RUNNING);
+ conf_utils_set_flag_locked(conference, CFLAG_RUNNING);
switch_threadattr_create(&thd_attr, conference->pool);
switch_threadattr_detach_set(thd_attr, 1);
switch_threadattr_priority_set(thd_attr, SWITCH_PRI_REALTIME);
switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE);
- switch_mutex_lock(mod_conference_globals.hash_mutex);
- switch_mutex_unlock(mod_conference_globals.hash_mutex);
- switch_thread_create(&thread, thd_attr, conference_thread_run, conference, conference->pool);
-}
-
-void launch_conference_record_thread(conference_obj_t *conference, char *path, switch_bool_t autorec)
-{
- switch_thread_t *thread;
- switch_threadattr_t *thd_attr = NULL;
- switch_memory_pool_t *pool;
- conference_record_t *rec;
-
- /* 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");
- }
-
- /* Create a node object */
- if (!(rec = switch_core_alloc(pool, sizeof(*rec)))) {
- switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Alloc Failure\n");
- switch_core_destroy_memory_pool(&pool);
- return;
- }
-
- rec->conference = conference;
- rec->path = switch_core_strdup(pool, path);
- rec->pool = pool;
- rec->autorec = autorec;
-
- switch_mutex_lock(conference->flag_mutex);
- rec->next = conference->rec_node_head;
- conference->rec_node_head = rec;
- switch_mutex_unlock(conference->flag_mutex);
-
- switch_threadattr_create(&thd_attr, rec->pool);
- switch_threadattr_detach_set(thd_attr, 1);
- switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE);
- switch_thread_create(&thread, thd_attr, conference_record_thread_run, rec, rec->pool);
+ switch_mutex_lock(conf_globals.hash_mutex);
+ switch_mutex_unlock(conf_globals.hash_mutex);
+ switch_thread_create(&thread, thd_attr, conf_thread_run, conference, conference->pool);
}
-conference_obj_t *conference_find(char *name, char *domain)
+conference_obj_t *conf_find(char *name, char *domain)
{
conference_obj_t *conference;
- switch_mutex_lock(mod_conference_globals.hash_mutex);
- if ((conference = switch_core_hash_find(mod_conference_globals.conference_hash, name))) {
- if (conference_test_flag(conference, CFLAG_DESTRUCT)) {
- switch_core_hash_delete(mod_conference_globals.conference_hash, conference->name);
- conference_clear_flag(conference, CFLAG_INHASH);
+ switch_mutex_lock(conf_globals.hash_mutex);
+ if ((conference = switch_core_hash_find(conf_globals.conference_hash, name))) {
+ if (conf_utils_test_flag(conference, CFLAG_DESTRUCT)) {
+ switch_core_hash_delete(conf_globals.conference_hash, conference->name);
+ conf_utils_clear_flag(conference, CFLAG_INHASH);
conference = NULL;
} else if (!zstr(domain) && conference->domain && strcasecmp(domain, conference->domain)) {
conference = NULL;
conference = NULL;
}
}
- switch_mutex_unlock(mod_conference_globals.hash_mutex);
+ switch_mutex_unlock(conf_globals.hash_mutex);
return conference;
}
/* create a new conferene with a specific profile */
-conference_obj_t *conference_new(char *name, conf_xml_cfg_t cfg, switch_core_session_t *session, switch_memory_pool_t *pool)
+conference_obj_t *conf_new(char *name, conf_xml_cfg_t cfg, switch_core_session_t *session, switch_memory_pool_t *pool)
{
conference_obj_t *conference;
switch_xml_t xml_kvp;
}
}
- switch_mutex_lock(mod_conference_globals.hash_mutex);
+ switch_mutex_lock(conf_globals.hash_mutex);
/* parse the profile tree for param values */
if (cfg.profile)
}
- conference_parse_layouts(conference, canvas_w, canvas_h);
+ conf_video_parse_layouts(conference, canvas_w, canvas_h);
if (!video_canvas_bgcolor) {
video_canvas_bgcolor = "#333333";
conference->video_letterbox_bgcolor = switch_core_strdup(conference->pool, video_letterbox_bgcolor);
if (fps) {
- conference_set_fps(conference, fps);
+ conf_video_set_fps(conference, fps);
}
if (!conference->video_fps.ms) {
- conference_set_fps(conference, 30);
+ conf_video_set_fps(conference, 30);
}
if (video_codec_bandwidth) {
conference->video_layout_group = switch_core_strdup(conference->pool, video_layout_group);
}
- if (!get_layout(conference, video_layout_name, video_layout_group)) {
+ if (!conf_video_get_layout(conference, video_layout_name, video_layout_group)) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Invalid video-layout-name specified, using " CONFERENCE_MUX_DEFAULT_LAYOUT "\n");
video_layout_name = CONFERENCE_MUX_DEFAULT_LAYOUT;
video_layout_group = video_layout_name + 6;
conference->video_layout_group = switch_core_strdup(conference->pool, video_layout_group);
}
- if (!get_layout(conference, video_layout_name, video_layout_group)) {
+ if (!conf_video_get_layout(conference, video_layout_name, video_layout_group)) {
conference->video_layout_name = conference->video_layout_group = video_layout_group = video_layout_name = NULL;
conference->conf_video_mode = CONF_VIDEO_MODE_TRANSCODE;
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Invalid conference layout settings, falling back to transcode mode\n");
}
if (conference->conf_video_mode == CONF_VIDEO_MODE_TRANSCODE || conference->conf_video_mode == CONF_VIDEO_MODE_MUX) {
- conference_set_flag(conference, CFLAG_TRANSCODE_VIDEO);
+ conf_utils_set_flag(conference, CFLAG_TRANSCODE_VIDEO);
}
if (outcall_templ) {
}
if (member_flags) {
- set_mflags(member_flags, conference->mflags);
+ conf_utils_set_mflags(member_flags, conference->mflags);
}
if (conference_flags) {
- set_cflags(conference_flags, conference->flags);
+ conf_utils_set_cflags(conference_flags, conference->flags);
}
if (!zstr(sound_prefix)) {
conference->eflags = 0xFFFFFFFF;
if (!zstr(suppress_events)) {
- clear_eflags(suppress_events, &conference->eflags);
+ conf_utils_clear_eflags(suppress_events, &conference->eflags);
}
if (!zstr(auto_record)) {
conference->uuid_str = switch_core_strdup(conference->pool, uuid_str);
/* Set enter sound and exit sound flags so that default is on */
- conference_set_flag(conference, CFLAG_ENTER_SOUND);
- conference_set_flag(conference, CFLAG_EXIT_SOUND);
+ conf_utils_set_flag(conference, CFLAG_ENTER_SOUND);
+ conf_utils_set_flag(conference, CFLAG_EXIT_SOUND);
/* 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->canvas_mutex, SWITCH_MUTEX_NESTED, conference->pool);
- switch_mutex_lock(mod_conference_globals.hash_mutex);
- conference_set_flag(conference, CFLAG_INHASH);
- switch_core_hash_insert(mod_conference_globals.conference_hash, conference->name, conference);
- switch_mutex_unlock(mod_conference_globals.hash_mutex);
+ switch_mutex_lock(conf_globals.hash_mutex);
+ conf_utils_set_flag(conference, CFLAG_INHASH);
+ switch_core_hash_insert(conf_globals.conference_hash, conference->name, conference);
+ switch_mutex_unlock(conf_globals.hash_mutex);
conference->super_canvas_label_layers = video_super_canvas_label_layers;
conference->super_canvas_show_all_layers = video_super_canvas_show_all_layers;
if (video_canvas_count < 1) video_canvas_count = 1;
if (conference->conf_video_mode == CONF_VIDEO_MODE_MUX) {
- video_layout_t *vlayout = get_layout(conference, conference->video_layout_name, conference->video_layout_group);
+ video_layout_t *vlayout = conf_video_get_layout(conference, conference->video_layout_name, conference->video_layout_group);
if (!vlayout) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Cannot find layout\n");
conference->video_layout_name = conference->video_layout_group = NULL;
- conference_clear_flag(conference, CFLAG_VIDEO_MUXING);
+ conf_utils_clear_flag(conference, CFLAG_VIDEO_MUXING);
} else {
int j;
mcu_canvas_t *canvas = NULL;
switch_mutex_lock(conference->canvas_mutex);
- init_canvas(conference, vlayout, &canvas);
- attach_canvas(conference, canvas, 0);
- launch_conference_video_muxing_thread(conference, canvas, 0);
+ conf_video_init_canvas(conference, vlayout, &canvas);
+ conf_video_attach_canvas(conference, canvas, 0);
+ conf_video_launch_muxing_thread(conference, canvas, 0);
switch_mutex_unlock(conference->canvas_mutex);
}
if (conference->canvas_count > 1) {
- video_layout_t *svlayout = get_layout(conference, NULL, CONFERENCE_MUX_DEFAULT_SUPER_LAYOUT);
+ video_layout_t *svlayout = conf_video_get_layout(conference, NULL, CONFERENCE_MUX_DEFAULT_SUPER_LAYOUT);
mcu_canvas_t *canvas = NULL;
if (svlayout) {
switch_mutex_lock(conference->canvas_mutex);
- init_canvas(conference, svlayout, &canvas);
- set_canvas_bgcolor(canvas, conference->video_super_canvas_bgcolor);
- attach_canvas(conference, canvas, 1);
- launch_conference_video_muxing_thread(conference, canvas, 1);
+ conf_video_init_canvas(conference, svlayout, &canvas);
+ conf_video_set_canvas_bgcolor(canvas, conference->video_super_canvas_bgcolor);
+ conf_video_attach_canvas(conference, canvas, 1);
+ conf_video_launch_muxing_thread(conference, canvas, 1);
switch_mutex_unlock(conference->canvas_mutex);
}
}
end:
- switch_mutex_unlock(mod_conference_globals.hash_mutex);
+ switch_mutex_unlock(conf_globals.hash_mutex);
return conference;
}
-void conference_send_presence(conference_obj_t *conference)
+void conf_send_presence(conference_obj_t *conference)
{
switch_event_t *event;
}
#if 0
-uint32_t kickall_matching_var(conference_obj_t *conference, const char *var, const char *val)
+uint32_t conf_kickall_matching_var(conference_obj_t *conference, const char *var, const char *val)
{
- conference_member_t *member = NULL;
+ conf_member_t *member = NULL;
const char *vval = NULL;
uint32_t r = 0;
for (member = conference->members; member; member = member->next) {
switch_channel_t *channel = NULL;
- if (member_test_flag(member, MFLAG_NOCHANNEL)) {
+ if (conf_utils_member_test_flag(member, MFLAG_NOCHANNEL)) {
continue;
}
vval = switch_channel_get_variable(channel, var);
if (vval && !strcmp(vval, val)) {
- member_set_flag_locked(member, MFLAG_KICKED);
- member_clear_flag_locked(member, MFLAG_RUNNING);
+ conf_utils_member_set_flag_locked(member, MFLAG_KICKED);
+ conf_utils_member_clear_flag_locked(member, MFLAG_RUNNING);
switch_core_session_kill_channel(member->session, SWITCH_SIG_BREAK);
r++;
}
switch_application_interface_t *app_interface;
switch_status_t status = SWITCH_STATUS_SUCCESS;
- memset(&mod_conference_globals, 0, sizeof(mod_conference_globals));
+ memset(&conf_globals, 0, sizeof(conf_globals));
/* Connect my internal structure to the blank pointer passed to me */
*module_interface = switch_loadable_module_create_module_interface(pool, modname);
- switch_console_add_complete_func("::conference::list_conferences", list_conferences);
+ switch_console_add_complete_func("::conference::conf_list_conferences", conf_list_conferences);
- switch_event_channel_bind("conference", conference_event_channel_handler, &mod_conference_globals.event_channel_id);
- switch_event_channel_bind("conference-liveArray", conference_la_event_channel_handler, &mod_conference_globals.event_channel_id);
- switch_event_channel_bind("conference-mod", conference_mod_event_channel_handler, &mod_conference_globals.event_channel_id);
+ switch_event_channel_bind("conference", conf_event_channel_handler, &conf_globals.event_channel_id);
+ switch_event_channel_bind("conference-liveArray", conf_event_la_channel_handler, &conf_globals.event_channel_id);
+ switch_event_channel_bind("conference-mod", conf_event_mod_channel_handler, &conf_globals.event_channel_id);
if ( conf_api_sub_syntax(&api_syntax) != SWITCH_STATUS_SUCCESS) {
return SWITCH_STATUS_TERM;
}
/* Setup the pool */
- mod_conference_globals.conference_pool = pool;
+ conf_globals.conference_pool = pool;
/* Setup a hash to store conferences by name */
- switch_core_hash_init(&mod_conference_globals.conference_hash);
- switch_mutex_init(&mod_conference_globals.conference_mutex, SWITCH_MUTEX_NESTED, mod_conference_globals.conference_pool);
- switch_mutex_init(&mod_conference_globals.id_mutex, SWITCH_MUTEX_NESTED, mod_conference_globals.conference_pool);
- switch_mutex_init(&mod_conference_globals.hash_mutex, SWITCH_MUTEX_NESTED, mod_conference_globals.conference_pool);
- switch_mutex_init(&mod_conference_globals.setup_mutex, SWITCH_MUTEX_NESTED, mod_conference_globals.conference_pool);
+ switch_core_hash_init(&conf_globals.conference_hash);
+ switch_mutex_init(&conf_globals.conference_mutex, SWITCH_MUTEX_NESTED, conf_globals.conference_pool);
+ switch_mutex_init(&conf_globals.id_mutex, SWITCH_MUTEX_NESTED, conf_globals.conference_pool);
+ switch_mutex_init(&conf_globals.hash_mutex, SWITCH_MUTEX_NESTED, conf_globals.conference_pool);
+ switch_mutex_init(&conf_globals.setup_mutex, SWITCH_MUTEX_NESTED, conf_globals.conference_pool);
/* Subscribe to presence request events */
- if (switch_event_bind(modname, SWITCH_EVENT_PRESENCE_PROBE, SWITCH_EVENT_SUBCLASS_ANY, pres_event_handler, NULL) != SWITCH_STATUS_SUCCESS) {
+ if (switch_event_bind(modname, SWITCH_EVENT_PRESENCE_PROBE, SWITCH_EVENT_SUBCLASS_ANY, conf_event_pres_handler, NULL) != SWITCH_STATUS_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Couldn't subscribe to presence request events!\n");
}
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Couldn't subscribe to conference data query events!\n");
}
- if (switch_event_bind(modname, SWITCH_EVENT_CALL_SETUP_REQ, SWITCH_EVENT_SUBCLASS_ANY, call_setup_event_handler, NULL) != SWITCH_STATUS_SUCCESS) {
+ if (switch_event_bind(modname, SWITCH_EVENT_CALL_SETUP_REQ, SWITCH_EVENT_SUBCLASS_ANY, conf_event_call_setup_handler, NULL) != SWITCH_STATUS_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Couldn't subscribe to conference data query events!\n");
}
SWITCH_ADD_API(api_interface, "conference", "Conference module commands", conf_api_main, p);
SWITCH_ADD_APP(app_interface, mod_conference_app_name, mod_conference_app_name, NULL, conference_function, NULL, SAF_NONE);
- SWITCH_ADD_APP(app_interface, "conference_set_auto_outcall", "conference_set_auto_outcall", NULL, conference_auto_function, NULL, SAF_NONE);
+ SWITCH_ADD_APP(app_interface, "conference_set_auto_outcall", "conference_set_auto_outcall", NULL, conf_auto_function, NULL, SAF_NONE);
SWITCH_ADD_CHAT(chat_interface, CONF_CHAT_PROTO, chat_send);
send_presence(SWITCH_EVENT_PRESENCE_IN);
- mod_conference_globals.running = 1;
+ conf_globals.running = 1;
/* indicate that the module should continue to be loaded */
return status;
}
SWITCH_MODULE_SHUTDOWN_FUNCTION(mod_conference_shutdown)
{
- if (mod_conference_globals.running) {
+ if (conf_globals.running) {
/* signal all threads to shutdown */
- mod_conference_globals.running = 0;
+ conf_globals.running = 0;
- switch_event_channel_unbind(NULL, conference_event_channel_handler);
- switch_event_channel_unbind(NULL, conference_la_event_channel_handler);
+ switch_event_channel_unbind(NULL, conf_event_channel_handler);
+ switch_event_channel_unbind(NULL, conf_event_la_channel_handler);
- switch_console_del_complete_func("::conference::list_conferences");
+ switch_console_del_complete_func("::conference::conf_list_conferences");
/* wait for all threads */
- while (mod_conference_globals.threads) {
- switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Waiting for %d threads\n", mod_conference_globals.threads);
+ while (conf_globals.threads) {
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Waiting for %d threads\n", conf_globals.threads);
switch_yield(100000);
}
- switch_event_unbind_callback(pres_event_handler);
+ switch_event_unbind_callback(conf_event_pres_handler);
switch_event_unbind_callback(conf_data_event_handler);
- switch_event_unbind_callback(call_setup_event_handler);
+ switch_event_unbind_callback(conf_event_call_setup_handler);
switch_event_free_subclass(CONF_EVENT_MAINT);
/* free api interface help ".syntax" field string */
switch_safe_free(api_syntax);
}
- switch_core_hash_destroy(&mod_conference_globals.conference_hash);
+ switch_core_hash_destroy(&conf_globals.conference_hash);
return SWITCH_STATUS_SUCCESS;
}
CONF_SILENT_DONE = (1 << 1)
} conf_app_flag_t;
-extern char *mod_conference_cf_name;
extern char *mod_conference_cf_name;
extern char *api_syntax;
extern int EC;
} file_stop_t;
/* Global Values */
-typedef struct mod_conference_globals_s {
+typedef struct conf_globals_s {
switch_memory_pool_t *conference_pool;
switch_mutex_t *conference_mutex;
switch_hash_t *conference_hash;
int32_t running;
uint32_t threads;
switch_event_channel_id_t event_channel_id;
-} mod_conference_globals_t;
+} conf_globals_t;
-extern mod_conference_globals_t mod_conference_globals;
+extern conf_globals_t conf_globals;
/* forward declaration for conference_obj and caller_control */
struct conference_member;
-typedef struct conference_member conference_member_t;
+typedef struct conference_member conf_member_t;
struct caller_control_actions;
CFLAG_MAX
} conference_flag_t;
-typedef struct conference_cdr_node_s {
+typedef struct conf_cdr_node_s {
switch_caller_profile_t *cp;
char *record_path;
switch_time_t join_time;
switch_time_t leave_time;
member_flag_t mflags[MFLAG_MAX];
uint32_t id;
- conference_member_t *member;
+ conf_member_t *member;
switch_event_t *var_event;
- struct conference_cdr_node_s *next;
-} conference_cdr_node_t;
+ struct conf_cdr_node_s *next;
+} conf_cdr_node_t;
typedef enum {
CDRR_LOCKED = 1,
CDRR_MAXMEMBERS
} cdr_reject_reason_t;
-typedef struct conference_cdr_reject_s {
+typedef struct conf_cdr_reject_s {
switch_caller_profile_t *cp;
switch_time_t reject_time;
cdr_reject_reason_t reason;
- struct conference_cdr_reject_s *next;
-} conference_cdr_reject_t;
+ struct conf_cdr_reject_s *next;
+} conf_cdr_reject_t;
typedef enum {
CDRE_NONE,
ALfloat pos_z;
} al_handle_t;
-void close_al(al_handle_t *al);
+void conf_al_close(al_handle_t *al);
#else
typedef struct al_handle_s {
int unsupported;
} conf_xml_cfg_t;
struct vid_helper {
- conference_member_t *member_a;
- conference_member_t *member_b;
+ conf_member_t *member_a;
+ conf_member_t *member_b;
int up;
};
switch_bool_t autorec;
struct conference_record *next;
switch_file_handle_t fh;
-} conference_record_t;
+} conf_record_t;
typedef enum {
CONF_VIDEO_MODE_PASSTHROUGH,
uint32_t interval;
uint32_t channels;
switch_mutex_t *mutex;
- conference_member_t *members;
- conference_member_t *floor_holder;
+ conf_member_t *members;
+ conf_member_t *floor_holder;
uint32_t video_floor_holder;
uint32_t last_video_floor_holder;
switch_mutex_t *member_mutex;
char *uuid_str;
uint32_t originating;
switch_call_cause_t cancel_cause;
- conference_cdr_node_t *cdr_nodes;
- conference_cdr_reject_t *cdr_rejected;
+ conf_cdr_node_t *cdr_nodes;
+ conf_cdr_reject_t *cdr_rejected;
switch_time_t start_time;
switch_time_t end_time;
char *log_dir;
cdr_event_mode_t cdr_event_mode;
struct vid_helper vh[2];
struct vid_helper mh;
- conference_record_t *rec_node_head;
+ conf_record_t *rec_node_head;
int last_speech_channels;
mcu_canvas_t *canvas;
mcu_canvas_t *canvases[MAX_CANVASES+1];
switch_codec_t write_codec;
char *rec_path;
switch_time_t rec_time;
- conference_record_t *rec;
+ conf_record_t *rec;
uint8_t *frame;
uint8_t *last_frame;
uint32_t frame_size;
uint32_t avg_tally;
struct conference_member *next;
switch_ivr_dmachine_t *dmachine;
- conference_cdr_node_t *cdr_node;
+ conf_cdr_node_t *cdr_node;
char *kicked_sound;
switch_queue_t *dtmf_queue;
switch_queue_t *video_queue;
uint8_t *packet;
} codec_set_t;
-typedef void (*conf_key_callback_t) (conference_member_t *, struct caller_control_actions *);
+typedef void (*conf_key_callback_t) (conf_member_t *, struct caller_control_actions *);
typedef struct {
- conference_member_t *member;
+ conf_member_t *member;
caller_control_action_t action;
conf_key_callback_t handler;
} key_binding_t;
/* FUNCTION DEFINITIONS */
-switch_bool_t conference_test_flag(conference_obj_t *conference, conference_flag_t flag);
+switch_bool_t conf_utils_test_flag(conference_obj_t *conference, conference_flag_t flag);
+conference_relationship_t *conf_member_get_relationship(conf_member_t *member, conf_member_t *other_member);
uint32_t next_member_id(void);
-void set_cflags(const char *flags, conference_flag_t *f);
-void set_mflags(const char *flags, member_flag_t *f);
-void merge_mflags(member_flag_t *a, member_flag_t *b);
-void clear_eflags(char *events, uint32_t *f);
-void pres_event_handler(switch_event_t *event);
+void conf_utils_set_cflags(const char *flags, conference_flag_t *f);
+void conf_utils_set_mflags(const char *flags, member_flag_t *f);
+void conf_utils_merge_mflags(member_flag_t *a, member_flag_t *b);
+void conf_utils_clear_eflags(char *events, uint32_t *f);
+void conf_event_pres_handler(switch_event_t *event);
void conf_data_event_handler(switch_event_t *event);
-void call_setup_event_handler(switch_event_t *event);
-void member_add_file_data(conference_member_t *member, int16_t *data, switch_size_t file_data_len);
-void send_conference_notify(conference_obj_t *conference, const char *status, const char *call_id, switch_bool_t final);
+void conf_event_call_setup_handler(switch_event_t *event);
+void conf_member_add_file_data(conf_member_t *member, int16_t *data, switch_size_t file_data_len);
+void conf_send_notify(conference_obj_t *conference, const char *status, const char *call_id, switch_bool_t final);
switch_status_t conference_file_close(conference_obj_t *conference, conference_file_node_t *node);
-void *SWITCH_THREAD_FUNC conference_record_thread_run(switch_thread_t *thread, void *obj);
-
-void gen_arc(conference_obj_t *conference, switch_stream_handle_t *stream);
-void process_al(al_handle_t *al, void *data, switch_size_t datalen, int rate);
-
-void member_set_flag_locked(conference_member_t *member, member_flag_t flag);
-void member_set_flag(conference_member_t *member, member_flag_t flag);
-
-void member_update_status_field(conference_member_t *member);
-void vmute_snap(conference_member_t *member, switch_bool_t clear);
-void reset_video_bitrate_counters(conference_member_t *member);
-void clear_layer(mcu_layer_t *layer);
-int get_canvas_id(conference_member_t *member, const char *val, switch_bool_t watching);
-void reset_member_codec_index(conference_member_t *member);
-void detach_video_layer(conference_member_t *member);
-void conference_set_flag(conference_obj_t *conference, conference_flag_t flag);
-void conference_set_flag_locked(conference_obj_t *conference, conference_flag_t flag);
-void conference_clear_flag(conference_obj_t *conference, conference_flag_t flag);
-void conference_clear_flag_locked(conference_obj_t *conference, conference_flag_t flag);
-
-int setup_media(conference_member_t *member, conference_obj_t *conference);
-
-al_handle_t *create_al(switch_memory_pool_t *pool);
-switch_status_t member_parse_position(conference_member_t *member, const char *data);
-video_layout_t *find_best_layout(conference_obj_t *conference, layout_group_t *lg, uint32_t count);
-void conference_list_count_only(conference_obj_t *conference, switch_stream_handle_t *stream);
-void conference_set_floor_holder(conference_obj_t *conference, conference_member_t *member);
-void member_clear_flag(conference_member_t *member, member_flag_t flag);
-void member_clear_flag_locked(conference_member_t *member, member_flag_t flag);
-switch_status_t attach_video_layer(conference_member_t *member, mcu_canvas_t *canvas, int idx);
-int conference_set_fps(conference_obj_t *conference, float fps);
-void layer_set_logo(conference_member_t *member, mcu_layer_t *layer, const char *path);
-void layer_set_banner(conference_member_t *member, mcu_layer_t *layer, const char *text);
-void switch_fnode_seek(conference_file_node_t *fnode, switch_stream_handle_t *stream, char *arg);
-uint32_t conference_member_stop_file(conference_member_t *member, file_stop_t stop);
-switch_bool_t member_test_flag(conference_member_t *member, member_flag_t flag);
-void conference_list_pretty(conference_obj_t *conference, switch_stream_handle_t *stream);
-switch_status_t conference_record_stop(conference_obj_t *conference, switch_stream_handle_t *stream, char *path);
-switch_status_t conference_record_action(conference_obj_t *conference, char *path, recording_action_type_t action);
-void conference_xlist(conference_obj_t *conference, switch_xml_t x_conference, int off);
-void send_json_event(conference_obj_t *conference);
-void send_rfc_event(conference_obj_t *conference);
-void member_update_status_field(conference_member_t *member);
-void conference_command_handler(switch_live_array_t *la, const char *cmd, const char *sessid, cJSON *jla, void *user_data);
-void adv_la(conference_obj_t *conference, conference_member_t *member, switch_bool_t join);
-switch_status_t init_canvas(conference_obj_t *conference, video_layout_t *vlayout, mcu_canvas_t **canvasP);
-switch_status_t attach_canvas(conference_obj_t *conference, mcu_canvas_t *canvas, int super);
-void init_canvas_layers(conference_obj_t *conference, mcu_canvas_t *canvas, video_layout_t *vlayout);
-switch_status_t attach_video_layer(conference_member_t *member, mcu_canvas_t *canvas, int idx);
-void reset_video_bitrate_counters(conference_member_t *member);
-void layer_set_banner(conference_member_t *member, mcu_layer_t *layer, const char *text);
-void layer_set_logo(conference_member_t *member, mcu_layer_t *layer, const char *path);
-void detach_video_layer(conference_member_t *member);
-void check_used_layers(mcu_canvas_t *canvas);
-void set_canvas_letterbox_bgcolor(mcu_canvas_t *canvas, char *color);
-void set_canvas_bgcolor(mcu_canvas_t *canvas, char *color);
-void scale_and_patch(mcu_layer_t *layer, switch_image_t *ximg, switch_bool_t freeze);
-void reset_layer(mcu_layer_t *layer);
-void clear_layer(mcu_layer_t *layer);
-void reset_image(switch_image_t *img, switch_rgb_color_t *color);
-void conference_parse_layouts(conference_obj_t *conference, int WIDTH, int HEIGHT);
-int conference_set_fps(conference_obj_t *conference, float fps);
-video_layout_t *get_layout(conference_obj_t *conference, const char *video_layout_name, const char *video_layout_group);
-void check_avatar(conference_member_t *member, switch_bool_t force);
-void find_video_floor(conference_member_t *member, switch_bool_t entering);
-void destroy_canvas(mcu_canvas_t **canvasP);
-void fnode_check_video(conference_file_node_t *fnode);
-switch_status_t parse_position(al_handle_t *al, const char *data);
-switch_status_t video_thread_callback(switch_core_session_t *session, switch_frame_t *frame, void *user_data);
-void *SWITCH_THREAD_FUNC conference_video_muxing_write_thread_run(switch_thread_t *thread, void *obj);
-void check_agc_levels(conference_member_t *member);
-void clear_avg(conference_member_t *member);
-int noise_gate_check(conference_member_t *member);
-void member_check_channels(switch_frame_t *frame, conference_member_t *member, switch_bool_t in);
-
-void switch_fnode_toggle_pause(conference_file_node_t *fnode, switch_stream_handle_t *stream);
-
-// static conference_relationship_t *member_get_relationship(conference_member_t *member, conference_member_t *other_member);
+void *SWITCH_THREAD_FUNC conf_record_thread_run(switch_thread_t *thread, void *obj);
+
+void conf_al_gen_arc(conference_obj_t *conference, switch_stream_handle_t *stream);
+void conf_al_process(al_handle_t *al, void *data, switch_size_t datalen, int rate);
+
+void conf_utils_member_set_flag_locked(conf_member_t *member, member_flag_t flag);
+void conf_utils_member_set_flag(conf_member_t *member, member_flag_t flag);
+
+void conf_member_update_status_field(conf_member_t *member);
+void conf_video_vmute_snap(conf_member_t *member, switch_bool_t clear);
+void conf_video_reset_video_bitrate_counters(conf_member_t *member);
+void conf_video_clear_layer(mcu_layer_t *layer);
+int conf_member_get_canvas_id(conf_member_t *member, const char *val, switch_bool_t watching);
+void conf_video_reset_member_codec_index(conf_member_t *member);
+void conf_video_detach_video_layer(conf_member_t *member);
+void conf_utils_set_flag(conference_obj_t *conference, conference_flag_t flag);
+void conf_utils_set_flag_locked(conference_obj_t *conference, conference_flag_t flag);
+void conf_utils_clear_flag(conference_obj_t *conference, conference_flag_t flag);
+void conf_utils_clear_flag_locked(conference_obj_t *conference, conference_flag_t flag);
+switch_status_t conf_loop_dmachine_dispatcher(switch_ivr_dmachine_match_t *match);
+
+int conf_member_setup_media(conf_member_t *member, conference_obj_t *conference);
+
+al_handle_t *conf_al_create(switch_memory_pool_t *pool);
+switch_status_t conf_member_parse_position(conf_member_t *member, const char *data);
+video_layout_t *conf_video_find_best_layout(conference_obj_t *conference, layout_group_t *lg, uint32_t count);
+void conf_list_count_only(conference_obj_t *conference, switch_stream_handle_t *stream);
+void conf_member_set_floor_holder(conference_obj_t *conference, conf_member_t *member);
+void conf_utils_member_clear_flag(conf_member_t *member, member_flag_t flag);
+void conf_utils_member_clear_flag_locked(conf_member_t *member, member_flag_t flag);
+switch_status_t conf_video_attach_video_layer(conf_member_t *member, mcu_canvas_t *canvas, int idx);
+int conf_video_set_fps(conference_obj_t *conference, float fps);
+void conf_video_layer_set_logo(conf_member_t *member, mcu_layer_t *layer, const char *path);
+void conf_video_layer_set_banner(conf_member_t *member, mcu_layer_t *layer, const char *text);
+void conf_fnode_seek(conference_file_node_t *fnode, switch_stream_handle_t *stream, char *arg);
+uint32_t conf_member_stop_file(conf_member_t *member, file_stop_t stop);
+switch_bool_t conf_utils_member_test_flag(conf_member_t *member, member_flag_t flag);
+void conf_list_pretty(conference_obj_t *conference, switch_stream_handle_t *stream);
+switch_status_t conf_record_stop(conference_obj_t *conference, switch_stream_handle_t *stream, char *path);
+switch_status_t conf_record_action(conference_obj_t *conference, char *path, recording_action_type_t action);
+void conf_xlist(conference_obj_t *conference, switch_xml_t x_conference, int off);
+void conf_event_send_json(conference_obj_t *conference);
+void conf_event_send_rfc(conference_obj_t *conference);
+void conf_member_update_status_field(conf_member_t *member);
+void conf_event_la_command_handler(switch_live_array_t *la, const char *cmd, const char *sessid, cJSON *jla, void *user_data);
+void conf_event_adv_la(conference_obj_t *conference, conf_member_t *member, switch_bool_t join);
+switch_status_t conf_video_init_canvas(conference_obj_t *conference, video_layout_t *vlayout, mcu_canvas_t **canvasP);
+switch_status_t conf_video_attach_canvas(conference_obj_t *conference, mcu_canvas_t *canvas, int super);
+void conf_video_init_canvas_layers(conference_obj_t *conference, mcu_canvas_t *canvas, video_layout_t *vlayout);
+switch_status_t conf_video_attach_video_layer(conf_member_t *member, mcu_canvas_t *canvas, int idx);
+void conf_video_reset_video_bitrate_counters(conf_member_t *member);
+void conf_video_layer_set_banner(conf_member_t *member, mcu_layer_t *layer, const char *text);
+void conf_video_layer_set_logo(conf_member_t *member, mcu_layer_t *layer, const char *path);
+void conf_video_detach_video_layer(conf_member_t *member);
+void conf_video_check_used_layers(mcu_canvas_t *canvas);
+void conf_video_set_canvas_letterbox_bgcolor(mcu_canvas_t *canvas, char *color);
+void conf_video_set_canvas_bgcolor(mcu_canvas_t *canvas, char *color);
+void conf_video_scale_and_patch(mcu_layer_t *layer, switch_image_t *ximg, switch_bool_t freeze);
+void conf_video_reset_layer(mcu_layer_t *layer);
+void conf_video_clear_layer(mcu_layer_t *layer);
+void conf_video_reset_image(switch_image_t *img, switch_rgb_color_t *color);
+void conf_video_parse_layouts(conference_obj_t *conference, int WIDTH, int HEIGHT);
+int conf_video_set_fps(conference_obj_t *conference, float fps);
+video_layout_t *conf_video_get_layout(conference_obj_t *conference, const char *video_layout_name, const char *video_layout_group);
+void conf_video_check_avatar(conf_member_t *member, switch_bool_t force);
+void conf_video_find_floor(conf_member_t *member, switch_bool_t entering);
+void conf_video_destroy_canvas(mcu_canvas_t **canvasP);
+void conf_video_fnode_check(conference_file_node_t *fnode);
+switch_status_t conf_al_parse_position(al_handle_t *al, const char *data);
+switch_status_t conf_video_thread_callback(switch_core_session_t *session, switch_frame_t *frame, void *user_data);
+void *SWITCH_THREAD_FUNC conf_video_muxing_write_thread_run(switch_thread_t *thread, void *obj);
+void conf_member_check_agc_levels(conf_member_t *member);
+void conf_member_clear_avg(conf_member_t *member);
+int conf_member_noise_gate_check(conf_member_t *member);
+void conf_member_check_channels(switch_frame_t *frame, conf_member_t *member, switch_bool_t in);
+
+void conf_fnode_toggle_pause(conference_file_node_t *fnode, switch_stream_handle_t *stream);
+
+// static conference_relationship_t *conf_member_get_relationship(conf_member_t *member, conf_member_t *other_member);
// static void conference_list(conference_obj_t *conference, switch_stream_handle_t *stream, char *delim);
-conference_relationship_t *member_add_relationship(conference_member_t *member, uint32_t id);
-conference_member_t *conference_member_get(conference_obj_t *conference, uint32_t id);
-
-switch_status_t member_del_relationship(conference_member_t *member, uint32_t id);
-switch_status_t conference_add_member(conference_obj_t *conference, conference_member_t *member);
-switch_status_t conference_del_member(conference_obj_t *conference, conference_member_t *member);
-void *SWITCH_THREAD_FUNC conference_thread_run(switch_thread_t *thread, void *obj);
-void *SWITCH_THREAD_FUNC conference_video_muxing_thread_run(switch_thread_t *thread, void *obj);
-void *SWITCH_THREAD_FUNC conference_super_video_muxing_thread_run(switch_thread_t *thread, void *obj);
-void conference_loop_output(conference_member_t *member);
-uint32_t conference_stop_file(conference_obj_t *conference, file_stop_t stop);
-switch_status_t conference_play_file(conference_obj_t *conference, char *file, uint32_t leadin, switch_channel_t *channel, uint8_t async);
-void conference_send_all_dtmf(conference_member_t *member, conference_obj_t *conference, const char *dtmf);
-switch_status_t conference_say(conference_obj_t *conference, const char *text, uint32_t leadin);
-conference_obj_t *conference_find(char *name, char *domain);
-void member_bind_controls(conference_member_t *member, const char *controls);
-void conference_send_presence(conference_obj_t *conference);
-void conference_set_video_floor_holder(conference_obj_t *conference, conference_member_t *member, switch_bool_t force);
-void canvas_del_fnode_layer(conference_obj_t *conference, conference_file_node_t *fnode);
-void canvas_set_fnode_layer(mcu_canvas_t *canvas, conference_file_node_t *fnode, int idx);
-
-switch_status_t conference_outcall(conference_obj_t *conference,
+conference_relationship_t *conf_member_add_relationship(conf_member_t *member, uint32_t id);
+conf_member_t *conf_member_get(conference_obj_t *conference, uint32_t id);
+
+switch_status_t conf_member_del_relationship(conf_member_t *member, uint32_t id);
+switch_status_t conf_member_add(conference_obj_t *conference, conf_member_t *member);
+switch_status_t conf_member_del(conference_obj_t *conference, conf_member_t *member);
+void *SWITCH_THREAD_FUNC conf_thread_run(switch_thread_t *thread, void *obj);
+void *SWITCH_THREAD_FUNC conf_video_muxing_thread_run(switch_thread_t *thread, void *obj);
+void *SWITCH_THREAD_FUNC conf_video_super_muxing_thread_run(switch_thread_t *thread, void *obj);
+void conf_loop_output(conf_member_t *member);
+uint32_t conference_file_stop(conference_obj_t *conference, file_stop_t stop);
+switch_status_t conference_file_play(conference_obj_t *conference, char *file, uint32_t leadin, switch_channel_t *channel, uint8_t async);
+void conf_member_send_all_dtmf(conf_member_t *member, conference_obj_t *conference, const char *dtmf);
+switch_status_t conf_say(conference_obj_t *conference, const char *text, uint32_t leadin);
+conference_obj_t *conf_find(char *name, char *domain);
+void conf_member_bind_controls(conf_member_t *member, const char *controls);
+void conf_send_presence(conference_obj_t *conference);
+void conf_video_set_floor_holder(conference_obj_t *conference, conf_member_t *member, switch_bool_t force);
+void conf_video_canvas_del_fnode_layer(conference_obj_t *conference, conference_file_node_t *fnode);
+void conf_video_canvas_set_fnode_layer(mcu_canvas_t *canvas, conference_file_node_t *fnode, int idx);
+void conference_list(conference_obj_t *conference, switch_stream_handle_t *stream, char *delim);
+const char *conf_utils_combine_flag_var(switch_core_session_t *session, const char *var_name);
+int conf_loop_mapping_len();
+
+switch_status_t conf_outcall(conference_obj_t *conference,
char *conference_name,
switch_core_session_t *session,
char *bridgeto, uint32_t timeout,
char *profile,
switch_call_cause_t *cause,
switch_call_cause_t *cancel_cause, switch_event_t *var_event);
-switch_status_t conference_outcall_bg(conference_obj_t *conference,
+switch_status_t conf_outcall_bg(conference_obj_t *conference,
char *conference_name,
switch_core_session_t *session, char *bridgeto, uint32_t timeout, const char *flags, const char *cid_name,
const char *cid_num, const char *call_uuid, const char *profile, switch_call_cause_t *cancel_cause,
switch_event_t **var_event);
-void launch_conference_video_muxing_thread(conference_obj_t *conference, mcu_canvas_t *canvas, int super);
-void launch_conference_thread(conference_obj_t *conference);
-void launch_conference_video_muxing_write_thread(conference_member_t *member);
-void *SWITCH_THREAD_FUNC conference_loop_input(switch_thread_t *thread, void *obj);
-switch_status_t conference_local_play_file(conference_obj_t *conference, switch_core_session_t *session, char *path, uint32_t leadin, void *buf,
+void conf_video_launch_muxing_thread(conference_obj_t *conference, mcu_canvas_t *canvas, int super);
+void conf_launch_thread(conference_obj_t *conference);
+void conf_video_launch_muxing_write_thread(conf_member_t *member);
+void *SWITCH_THREAD_FUNC conf_loop_input(switch_thread_t *thread, void *obj);
+switch_status_t conference_file_local_play(conference_obj_t *conference, switch_core_session_t *session, char *path, uint32_t leadin, void *buf,
uint32_t buflen);
-switch_status_t conference_member_play_file(conference_member_t *member, char *file, uint32_t leadin, switch_bool_t mux);
-switch_status_t conference_member_say(conference_member_t *member, char *text, uint32_t leadin);
-uint32_t conference_member_stop_file(conference_member_t *member, file_stop_t stop);
-conference_obj_t *conference_new(char *name, conf_xml_cfg_t cfg, switch_core_session_t *session, switch_memory_pool_t *pool);
+switch_status_t conf_member_play_file(conf_member_t *member, char *file, uint32_t leadin, switch_bool_t mux);
+switch_status_t conf_member_say(conf_member_t *member, char *text, uint32_t leadin);
+uint32_t conf_member_stop_file(conf_member_t *member, file_stop_t stop);
+conference_obj_t *conf_new(char *name, conf_xml_cfg_t cfg, switch_core_session_t *session, switch_memory_pool_t *pool);
switch_status_t chat_send(switch_event_t *message_event);
-void launch_conference_record_thread(conference_obj_t *conference, char *path, switch_bool_t autorec);
+void conf_record_launch_thread(conference_obj_t *conference, char *path, switch_bool_t autorec);
typedef switch_status_t (*conf_api_args_cmd_t) (conference_obj_t *, switch_stream_handle_t *, int, char **);
-typedef switch_status_t (*conf_api_member_cmd_t) (conference_member_t *, switch_stream_handle_t *, void *);
+typedef switch_status_t (*conf_api_member_cmd_t) (conf_member_t *, switch_stream_handle_t *, void *);
typedef switch_status_t (*conf_api_text_cmd_t) (conference_obj_t *, switch_stream_handle_t *, const char *);
-switch_status_t conference_add_event_data(conference_obj_t *conference, switch_event_t *event);
-switch_status_t conference_add_event_member_data(conference_member_t *member, switch_event_t *event);
-
-cJSON *conference_json_render(conference_obj_t *conference, cJSON *req);
-char *conference_rfc4579_render(conference_obj_t *conference, switch_event_t *event, switch_event_t *revent);
-void conference_cdr_del(conference_member_t *member);
-void conference_cdr_add(conference_member_t *member);
-void conference_cdr_rejected(conference_obj_t *conference, switch_channel_t *channel, cdr_reject_reason_t reason);
-void conference_cdr_render(conference_obj_t *conference);
-void conference_event_channel_handler(const char *event_channel, cJSON *json, const char *key, switch_event_channel_id_t id);
-void conference_la_event_channel_handler(const char *event_channel, cJSON *json, const char *key, switch_event_channel_id_t id);
-void conference_mod_event_channel_handler(const char *event_channel, cJSON *json, const char *key, switch_event_channel_id_t id);
-
-
-void conference_member_itterator(conference_obj_t *conference, switch_stream_handle_t *stream, uint8_t non_mod, conf_api_member_cmd_t pfncallback, void *data);
-
-switch_status_t conf_api_sub_mute(conference_member_t *member, switch_stream_handle_t *stream, void *data);
-switch_status_t conf_api_sub_tmute(conference_member_t *member, switch_stream_handle_t *stream, void *data);
-switch_status_t conf_api_sub_unmute(conference_member_t *member, switch_stream_handle_t *stream, void *data);
-switch_status_t conf_api_sub_vmute(conference_member_t *member, switch_stream_handle_t *stream, void *data);
-switch_status_t conf_api_sub_tvmute(conference_member_t *member, switch_stream_handle_t *stream, void *data);
-switch_status_t conf_api_sub_unvmute(conference_member_t *member, switch_stream_handle_t *stream, void *data);
-switch_status_t conf_api_sub_deaf(conference_member_t *member, switch_stream_handle_t *stream, void *data);
-switch_status_t conf_api_sub_undeaf(conference_member_t *member, switch_stream_handle_t *stream, void *data);
-switch_status_t conf_api_sub_floor(conference_member_t *member, switch_stream_handle_t *stream, void *data);
-switch_status_t conf_api_sub_vid_floor(conference_member_t *member, switch_stream_handle_t *stream, void *data);
+switch_status_t conf_event_add_data(conference_obj_t *conference, switch_event_t *event);
+switch_status_t conf_member_add_event_data(conf_member_t *member, switch_event_t *event);
+
+cJSON *conf_cdr_json_render(conference_obj_t *conference, cJSON *req);
+char *conf_cdr_rfc4579_render(conference_obj_t *conference, switch_event_t *event, switch_event_t *revent);
+void conf_cdr_del(conf_member_t *member);
+void conf_cdr_add(conf_member_t *member);
+void conf_cdr_rejected(conference_obj_t *conference, switch_channel_t *channel, cdr_reject_reason_t reason);
+void conf_cdr_render(conference_obj_t *conference);
+void conf_event_channel_handler(const char *event_channel, cJSON *json, const char *key, switch_event_channel_id_t id);
+void conf_event_la_channel_handler(const char *event_channel, cJSON *json, const char *key, switch_event_channel_id_t id);
+void conf_event_mod_channel_handler(const char *event_channel, cJSON *json, const char *key, switch_event_channel_id_t id);
+
+
+void conf_member_itterator(conference_obj_t *conference, switch_stream_handle_t *stream, uint8_t non_mod, conf_api_member_cmd_t pfncallback, void *data);
+
+switch_status_t conf_api_sub_mute(conf_member_t *member, switch_stream_handle_t *stream, void *data);
+switch_status_t conf_api_sub_tmute(conf_member_t *member, switch_stream_handle_t *stream, void *data);
+switch_status_t conf_api_sub_unmute(conf_member_t *member, switch_stream_handle_t *stream, void *data);
+switch_status_t conf_api_sub_vmute(conf_member_t *member, switch_stream_handle_t *stream, void *data);
+switch_status_t conf_api_sub_tvmute(conf_member_t *member, switch_stream_handle_t *stream, void *data);
+switch_status_t conf_api_sub_unvmute(conf_member_t *member, switch_stream_handle_t *stream, void *data);
+switch_status_t conf_api_sub_deaf(conf_member_t *member, switch_stream_handle_t *stream, void *data);
+switch_status_t conf_api_sub_undeaf(conf_member_t *member, switch_stream_handle_t *stream, void *data);
+switch_status_t conf_api_sub_floor(conf_member_t *member, switch_stream_handle_t *stream, void *data);
+switch_status_t conf_api_sub_vid_floor(conf_member_t *member, switch_stream_handle_t *stream, void *data);
switch_status_t conf_api_sub_clear_vid_floor(conference_obj_t *conference, switch_stream_handle_t *stream, void *data);
-switch_status_t conf_api_sub_position(conference_member_t *member, switch_stream_handle_t *stream, void *data);
-switch_status_t conf_api_sub_vmute_snap(conference_member_t *member, switch_stream_handle_t *stream, void *data);
-switch_status_t conf_api_sub_dtmf(conference_member_t *member, switch_stream_handle_t *stream, void *data);
+switch_status_t conf_api_sub_position(conf_member_t *member, switch_stream_handle_t *stream, void *data);
+switch_status_t conf_api_sub_conf_video_vmute_snap(conf_member_t *member, switch_stream_handle_t *stream, void *data);
+switch_status_t conf_api_sub_dtmf(conf_member_t *member, switch_stream_handle_t *stream, void *data);
switch_status_t conf_api_sub_pause_play(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv);
switch_status_t conf_api_sub_play(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv);
switch_status_t conf_api_sub_say(conference_obj_t *conference, switch_stream_handle_t *stream, const char *text);
switch_status_t conf_api_sub_saymember(conference_obj_t *conference, switch_stream_handle_t *stream, const char *text);
switch_status_t conf_api_sub_check_record(conference_obj_t *conference, switch_stream_handle_t *stream, int arc, char **argv);
switch_status_t conf_api_sub_check_record(conference_obj_t *conference, switch_stream_handle_t *stream, int arc, char **argv);
-switch_status_t conf_api_sub_volume_in(conference_member_t *member, switch_stream_handle_t *stream, void *data);
+switch_status_t conf_api_sub_volume_in(conf_member_t *member, switch_stream_handle_t *stream, void *data);
switch_status_t conf_api_sub_file_seek(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv);
switch_status_t conf_api_sub_stop(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv);
-switch_status_t conf_api_sub_hup(conference_member_t *member, switch_stream_handle_t *stream, void *data);
+switch_status_t conf_api_sub_hup(conf_member_t *member, switch_stream_handle_t *stream, void *data);
switch_status_t conf_api_sub_pauserec(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv);
-switch_status_t conf_api_sub_volume_out(conference_member_t *member, switch_stream_handle_t *stream, void *data);
+switch_status_t conf_api_sub_volume_out(conf_member_t *member, switch_stream_handle_t *stream, void *data);
switch_status_t conf_api_sub_lock(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv);
switch_status_t conf_api_sub_unlock(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv);
switch_status_t conf_api_sub_relate(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv);
switch_status_t conf_api_sub_pin(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv);
switch_status_t conf_api_sub_exit_sound(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv);
-switch_status_t conf_api_sub_vid_banner(conference_member_t *member, switch_stream_handle_t *stream, void *data);
+switch_status_t conf_api_sub_vid_banner(conf_member_t *member, switch_stream_handle_t *stream, void *data);
switch_status_t conf_api_sub_enter_sound(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv);
switch_status_t conf_api_sub_set(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv);
-switch_status_t conf_api_sub_vid_res_id(conference_member_t *member, switch_stream_handle_t *stream, void *data);
+switch_status_t conf_api_sub_vid_res_id(conf_member_t *member, switch_stream_handle_t *stream, void *data);
switch_status_t conf_api_sub_get(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv);
-switch_status_t conf_api_sub_vid_mute_img(conference_member_t *member, switch_stream_handle_t *stream, void *data);
-switch_status_t conf_api_sub_vid_logo_img(conference_member_t *member, switch_stream_handle_t *stream, void *data);
+switch_status_t conf_api_sub_vid_mute_img(conf_member_t *member, switch_stream_handle_t *stream, void *data);
+switch_status_t conf_api_sub_vid_logo_img(conf_member_t *member, switch_stream_handle_t *stream, void *data);
switch_status_t conf_api_sub_vid_fps(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv);
switch_status_t conf_api_sub_write_png(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv);
switch_status_t conf_api_sub_file_vol(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv);
switch_status_t conf_api_sub_vid_layout(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv);
switch_status_t conf_api_sub_list(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv);
switch_status_t conf_api_sub_xml_list(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv);
-switch_status_t conf_api_sub_energy(conference_member_t *member, switch_stream_handle_t *stream, void *data);
-switch_status_t conf_api_sub_watching_canvas(conference_member_t *member, switch_stream_handle_t *stream, void *data);
-switch_status_t conf_api_sub_canvas(conference_member_t *member, switch_stream_handle_t *stream, void *data);
-switch_status_t conf_api_sub_layer(conference_member_t *member, switch_stream_handle_t *stream, void *data);
-switch_status_t conf_api_sub_kick(conference_member_t *member, switch_stream_handle_t *stream, void *data);
+switch_status_t conf_api_sub_energy(conf_member_t *member, switch_stream_handle_t *stream, void *data);
+switch_status_t conf_api_sub_watching_canvas(conf_member_t *member, switch_stream_handle_t *stream, void *data);
+switch_status_t conf_api_sub_canvas(conf_member_t *member, switch_stream_handle_t *stream, void *data);
+switch_status_t conf_api_sub_layer(conf_member_t *member, switch_stream_handle_t *stream, void *data);
+switch_status_t conf_api_sub_kick(conf_member_t *member, switch_stream_handle_t *stream, void *data);
switch_status_t conf_api_sub_transfer(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv);
switch_status_t conf_api_sub_record(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv);
switch_status_t conf_api_sub_norecord(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv);
switch_status_t conf_api_main_real(const char *cmd, switch_core_session_t *session, switch_stream_handle_t *stream);
-void conference_loop_fn_mute_on(conference_member_t *member, caller_control_action_t *action);
-void conference_loop_fn_mute_toggle(conference_member_t *member, caller_control_action_t *action);
-void conference_loop_fn_energy_dn(conference_member_t *member, caller_control_action_t *action);
-void conference_loop_fn_energy_equ_conf(conference_member_t *member, caller_control_action_t *action);
-void conference_loop_fn_volume_talk_zero(conference_member_t *member, caller_control_action_t *action);
-void conference_loop_fn_volume_talk_up(conference_member_t *member, caller_control_action_t *action);
-void conference_loop_fn_volume_listen_dn(conference_member_t *member, caller_control_action_t *action);
-void conference_loop_fn_lock_toggle(conference_member_t *member, caller_control_action_t *action);
-void conference_loop_fn_volume_listen_up(conference_member_t *member, caller_control_action_t *action);
-void conference_loop_fn_volume_listen_zero(conference_member_t *member, caller_control_action_t *action);
-void conference_loop_fn_volume_talk_dn(conference_member_t *member, caller_control_action_t *action);
-void conference_loop_fn_energy_up(conference_member_t *member, caller_control_action_t *action);
-void conference_loop_fn_floor_toggle(conference_member_t *member, caller_control_action_t *action);
-void conference_loop_fn_vid_floor_toggle(conference_member_t *member, caller_control_action_t *action);
-void conference_loop_fn_energy_up(conference_member_t *member, caller_control_action_t *action);
-void conference_loop_fn_floor_toggle(conference_member_t *member, caller_control_action_t *action);
-void conference_loop_fn_vid_floor_force(conference_member_t *member, caller_control_action_t *action);
-void conference_loop_fn_vmute_off(conference_member_t *member, caller_control_action_t *action);
-void conference_loop_fn_vmute_snap(conference_member_t *member, caller_control_action_t *action);
-void conference_loop_fn_vmute_snapoff(conference_member_t *member, caller_control_action_t *action);
-void conference_loop_fn_vmute_toggle(conference_member_t *member, caller_control_action_t *action);
-void conference_loop_fn_vmute_on(conference_member_t *member, caller_control_action_t *action);
-void conference_loop_fn_deafmute_toggle(conference_member_t *member, caller_control_action_t *action);
-void conference_loop_fn_hangup(conference_member_t *member, caller_control_action_t *action);
-void conference_loop_fn_transfer(conference_member_t *member, caller_control_action_t *action);
-void conference_loop_fn_mute_off(conference_member_t *member, caller_control_action_t *action);
-void conference_loop_fn_event(conference_member_t *member, caller_control_action_t *action);
-void conference_loop_fn_transfer(conference_member_t *member, caller_control_action_t *action);
-void conference_loop_fn_exec_app(conference_member_t *member, caller_control_action_t *action);
+void conf_loop_mute_on(conf_member_t *member, caller_control_action_t *action);
+void conf_loop_mute_toggle(conf_member_t *member, caller_control_action_t *action);
+void conf_loop_energy_dn(conf_member_t *member, caller_control_action_t *action);
+void conf_loop_energy_equ_conf(conf_member_t *member, caller_control_action_t *action);
+void conf_loop_volume_talk_zero(conf_member_t *member, caller_control_action_t *action);
+void conf_loop_volume_talk_up(conf_member_t *member, caller_control_action_t *action);
+void conf_loop_volume_listen_dn(conf_member_t *member, caller_control_action_t *action);
+void conf_loop_lock_toggle(conf_member_t *member, caller_control_action_t *action);
+void conf_loop_volume_listen_up(conf_member_t *member, caller_control_action_t *action);
+void conf_loop_volume_listen_zero(conf_member_t *member, caller_control_action_t *action);
+void conf_loop_volume_talk_dn(conf_member_t *member, caller_control_action_t *action);
+void conf_loop_energy_up(conf_member_t *member, caller_control_action_t *action);
+void conf_loop_floor_toggle(conf_member_t *member, caller_control_action_t *action);
+void conf_loop_vid_floor_toggle(conf_member_t *member, caller_control_action_t *action);
+void conf_loop_energy_up(conf_member_t *member, caller_control_action_t *action);
+void conf_loop_floor_toggle(conf_member_t *member, caller_control_action_t *action);
+void conf_loop_vid_floor_force(conf_member_t *member, caller_control_action_t *action);
+void conf_loop_vmute_off(conf_member_t *member, caller_control_action_t *action);
+void conf_loop_conf_video_vmute_snap(conf_member_t *member, caller_control_action_t *action);
+void conf_loop_conf_video_vmute_snapoff(conf_member_t *member, caller_control_action_t *action);
+void conf_loop_vmute_toggle(conf_member_t *member, caller_control_action_t *action);
+void conf_loop_vmute_on(conf_member_t *member, caller_control_action_t *action);
+void conf_loop_deafmute_toggle(conf_member_t *member, caller_control_action_t *action);
+void conf_loop_hangup(conf_member_t *member, caller_control_action_t *action);
+void conf_loop_transfer(conf_member_t *member, caller_control_action_t *action);
+void conf_loop_mute_off(conf_member_t *member, caller_control_action_t *action);
+void conf_loop_event(conf_member_t *member, caller_control_action_t *action);
+void conf_loop_transfer(conf_member_t *member, caller_control_action_t *action);
+void conf_loop_exec_app(conf_member_t *member, caller_control_action_t *action);
-al_handle_t *create_al(switch_memory_pool_t *pool)
+al_handle_t *conf_al_create(switch_memory_pool_t *pool)
{
al_handle_t *al;
}
#ifndef OPENAL_POSITIONING
-void gen_arc(conference_obj_t *conference, switch_stream_handle_t *stream)
+void conf_al_gen_arc(conference_obj_t *conference, switch_stream_handle_t *stream)
{
}
-void process_al(al_handle_t *al, void *data, switch_size_t datalen, int rate)
+void conf_al_process(al_handle_t *al, void *data, switch_size_t datalen, int rate)
{
}
#else
-void gen_arc(conference_obj_t *conference, switch_stream_handle_t *stream)
+void conf_al_gen_arc(conference_obj_t *conference, switch_stream_handle_t *stream)
{
float offset;
float pos;
float radius;
float x, z;
float div = 3.14159f / 180;
- conference_member_t *member;
+ conf_member_t *member;
uint32_t count = 0;
if (!conference->count) {
switch_mutex_lock(conference->member_mutex);
for (member = conference->members; member; member = member->next) {
- if (member->channel && member_test_flag(member, MFLAG_CAN_SPEAK) && !member_test_flag(member, MFLAG_NO_POSITIONAL)) {
+ if (member->channel && conf_utils_member_test_flag(member, MFLAG_CAN_SPEAK) && !conf_utils_member_test_flag(member, MFLAG_NO_POSITIONAL)) {
count++;
}
}
if (count < 3) {
for (member = conference->members; member; member = member->next) {
- if (member->channel && !member_test_flag(member, MFLAG_NO_POSITIONAL) && member->al) {
+ if (member->channel && !conf_utils_member_test_flag(member, MFLAG_NO_POSITIONAL) && member->al) {
member->al->pos_x = 0;
member->al->pos_y = 0;
for (member = conference->members; member; member = member->next) {
- if (!member->channel || member_test_flag(member, MFLAG_NO_POSITIONAL) || !member_test_flag(member, MFLAG_CAN_SPEAK)) {
+ if (!member->channel || conf_utils_member_test_flag(member, MFLAG_NO_POSITIONAL) || !conf_utils_member_test_flag(member, MFLAG_CAN_SPEAK)) {
continue;
}
if (!member->al) {
- member->al = create_al(member->pool);
+ member->al = conf_al_create(member->pool);
}
- member_set_flag(member, MFLAG_POSITIONAL);
+ conf_utils_member_set_flag(member, MFLAG_POSITIONAL);
if (pos == 0) {
x = 0;
-void process_al(al_handle_t *al, void *data, switch_size_t datalen, int rate)
+void conf_al_process(al_handle_t *al, void *data, switch_size_t datalen, int rate)
{
if (rate != 48000) {
0
};
- switch_mutex_lock(mod_conference_globals.setup_mutex);
+ switch_mutex_lock(conf_globals.setup_mutex);
if ((al->device = alcLoopbackOpenDeviceSOFT(NULL))) {
const ALshort silence[16] = { 0 };
float orient[6] = { /*fwd:*/ 0., 0., -1., /*up:*/ 0., 1., 0. };
alSourceQueueBuffers(al->source, 2, al->buffer_in);
alSourcePlay(al->source);
}
- switch_mutex_unlock(mod_conference_globals.setup_mutex);
+ switch_mutex_unlock(conf_globals.setup_mutex);
}
if (al->device) {
}
#endif
-void check_agc_levels(conference_member_t *member)
-{
- int x = 0;
-
- if (!member->avg_score) return;
-
- if ((int)member->avg_score < member->conference->agc_level - 100) {
- member->agc_volume_in_level++;
- switch_normalize_volume_granular(member->agc_volume_in_level);
- x = 1;
- } else if ((int)member->avg_score > member->conference->agc_level + 100) {
- member->agc_volume_in_level--;
- switch_normalize_volume_granular(member->agc_volume_in_level);
- x = -1;
- }
-
- if (x) {
- switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG7,
- "AGC %s:%d diff:%d level:%d cur:%d avg:%d vol:%d %s\n",
- member->conference->name,
- member->id, member->conference->agc_level - member->avg_score, member->conference->agc_level,
- member->score, member->avg_score, member->agc_volume_in_level, x > 0 ? "+++" : "---");
-
- clear_avg(member);
- }
-}
-
-
#ifndef OPENAL_POSITIONING
-switch_status_t parse_position(al_handle_t *al, const char *data)
+switch_status_t conf_al_parse_position(al_handle_t *al, const char *data)
{
return SWITCH_STATUS_FALSE;
}
#else
-switch_status_t parse_position(al_handle_t *al, const char *data)
+switch_status_t conf_al_parse_position(al_handle_t *al, const char *data)
{
char *args[3];
int num;
}
#endif
-#ifndef OPENAL_POSITIONING
-switch_status_t member_parse_position(conference_member_t *member, const char *data)
-{
- return SWITCH_STATUS_FALSE;
-}
-#else
-switch_status_t member_parse_position(conference_member_t *member, const char *data)
-{
- switch_status_t status = SWITCH_STATUS_FALSE;
-
- if (member->al) {
- status = parse_position(member->al, data);
- }
-
- return status;
-
-}
-#endif
-
#ifdef OPENAL_POSITIONING
-void close_al(al_handle_t *al)
+void conf_al_close(al_handle_t *al)
{
if (!al) return;
- switch_mutex_lock(mod_conference_globals.setup_mutex);
+ switch_mutex_lock(conf_globals.setup_mutex);
if (al->source) {
alDeleteSources(1, &al->source);
al->source = 0;
alcCloseDevice(al->device);
al->device = NULL;
}
- switch_mutex_unlock(mod_conference_globals.setup_mutex);
+ switch_mutex_unlock(conf_globals.setup_mutex);
}
#endif
{"unmute", (void_fn_t) & conf_api_sub_unmute, CONF_API_SUB_MEMBER_TARGET, "unmute", "<[member_id|all]|last|non_moderator> [<quiet>]"},
{"vmute", (void_fn_t) & conf_api_sub_vmute, CONF_API_SUB_MEMBER_TARGET, "vmute", "<[member_id|all]|last|non_moderator> [<quiet>]"},
{"tvmute", (void_fn_t) & conf_api_sub_tvmute, CONF_API_SUB_MEMBER_TARGET, "tvmute", "<[member_id|all]|last|non_moderator> [<quiet>]"},
- {"vmute-snap", (void_fn_t) & conf_api_sub_vmute_snap, CONF_API_SUB_MEMBER_TARGET, "vmute-snap", "<[member_id|all]|last|non_moderator>"},
+ {"vmute-snap", (void_fn_t) & conf_api_sub_conf_video_vmute_snap, CONF_API_SUB_MEMBER_TARGET, "vmute-snap", "<[member_id|all]|last|non_moderator>"},
{"unvmute", (void_fn_t) & conf_api_sub_unvmute, CONF_API_SUB_MEMBER_TARGET, "unvmute", "<[member_id|all]|last|non_moderator> [<quiet>]"},
{"deaf", (void_fn_t) & conf_api_sub_deaf, CONF_API_SUB_MEMBER_TARGET, "deaf", "<[member_id|all]|last|non_moderator>"},
{"undeaf", (void_fn_t) & conf_api_sub_undeaf, CONF_API_SUB_MEMBER_TARGET, "undeaf", "<[member_id|all]|last|non_moderator>"},
{"vid-bandwidth", (void_fn_t) & conf_api_sub_vid_bandwidth, CONF_API_SUB_ARGS_SPLIT, "vid-bandwidth", "<BW>"}
};
-/* 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;
-
- if (member == NULL || other_member == NULL || member->relationships == NULL)
- return NULL;
-
- lock_member(member);
- lock_member(other_member);
-
- for (rel = member->relationships; rel; rel = rel->next) {
- if (rel->id == other_member->id) {
- break;
- }
-
- /* 0 matches everyone. (We will still test the others because a real match carries more clout) */
- if (rel->id == 0) {
- global = rel;
- }
- }
-
- unlock_member(other_member);
- unlock_member(member);
-
- return rel ? rel : global;
-}
-
switch_status_t conf_api_sub_pause_play(conference_obj_t *conference, switch_stream_handle_t *stream, int argc, char **argv)
{
if (argc == 2) {
switch_mutex_lock(conference->mutex);
- switch_fnode_toggle_pause(conference->fnode, stream);
+ conf_fnode_toggle_pause(conference->fnode, stream);
switch_mutex_unlock(conference->mutex);
return SWITCH_STATUS_SUCCESS;
if (argc == 3) {
uint32_t id = atoi(argv[2]);
- conference_member_t *member;
+ conf_member_t *member;
- if ((member = conference_member_get(conference, id))) {
+ if ((member = conf_member_get(conference, id))) {
switch_mutex_lock(member->fnode_mutex);
- switch_fnode_toggle_pause(member->fnode, stream);
+ conf_fnode_toggle_pause(member->fnode, stream);
switch_mutex_unlock(member->fnode_mutex);
switch_thread_rwlock_unlock(member->rwlock);
return SWITCH_STATUS_SUCCESS;
return SWITCH_STATUS_GENERR;
}
-/* stop playing a file for the member of the conference */
-uint32_t conference_member_stop_file(conference_member_t *member, file_stop_t stop)
-{
- conference_file_node_t *nptr;
- uint32_t count = 0;
-
- if (member == NULL)
- return count;
-
-
- switch_mutex_lock(member->fnode_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->fnode_mutex);
-
- return count;
-}
-
-
-
-/* traverse the conference member list for the specified member id and return it's pointer */
-conference_member_t *conference_member_get(conference_obj_t *conference, uint32_t id)
-{
- conference_member_t *member = NULL;
-
- switch_assert(conference != NULL);
- if (!id) {
- return NULL;
- }
-
- switch_mutex_lock(conference->member_mutex);
- for (member = conference->members; member; member = member->next) {
-
- if (member_test_flag(member, MFLAG_NOCHANNEL)) {
- continue;
- }
-
- if (member->id == id) {
- break;
- }
- }
-
- if (member) {
- if (!member_test_flag(member, MFLAG_INTREE) ||
- member_test_flag(member, MFLAG_KICKED) ||
- (member->session && !switch_channel_up(switch_core_session_get_channel(member->session)))) {
-
- /* member is kicked or hanging up so forget it */
- member = NULL;
- }
- }
-
- if (member) {
- if (switch_thread_rwlock_tryrdlock(member->rwlock) != SWITCH_STATUS_SUCCESS) {
- /* if you cant readlock it's way to late to do anything */
- member = NULL;
- }
- }
-
- switch_mutex_unlock(conference->member_mutex);
-
- return member;
-}
-
-static void conference_list(conference_obj_t *conference, switch_stream_handle_t *stream, char *delim)
-{
- conference_member_t *member = NULL;
-
- switch_assert(conference != NULL);
- switch_assert(stream != NULL);
- switch_assert(delim != NULL);
-
- switch_mutex_lock(conference->member_mutex);
-
- for (member = conference->members; member; member = member->next) {
- switch_channel_t *channel;
- switch_caller_profile_t *profile;
- char *uuid;
- char *name;
- uint32_t count = 0;
-
- if (member_test_flag(member, MFLAG_NOCHANNEL)) {
- continue;
- }
-
- uuid = switch_core_session_get_uuid(member->session);
- channel = switch_core_session_get_channel(member->session);
- profile = switch_channel_get_caller_profile(channel);
- name = switch_channel_get_name(channel);
-
- 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 (member_test_flag(member, MFLAG_CAN_HEAR)) {
- stream->write_function(stream, "hear");
- count++;
- }
-
- if (member_test_flag(member, MFLAG_CAN_SPEAK)) {
- stream->write_function(stream, "%s%s", count ? "|" : "", "speak");
- count++;
- }
-
- if (member_test_flag(member, MFLAG_TALKING)) {
- stream->write_function(stream, "%s%s", count ? "|" : "", "talking");
- count++;
- }
-
- if (switch_channel_test_flag(switch_core_session_get_channel(member->session), CF_VIDEO)) {
- stream->write_function(stream, "%s%s", count ? "|" : "", "video");
- count++;
- }
-
- if (member == member->conference->floor_holder) {
- stream->write_function(stream, "%s%s", count ? "|" : "", "floor");
- count++;
- }
-
- if (member->id == member->conference->video_floor_holder) {
- stream->write_function(stream, "%s%s", count ? "|" : "", "vid-floor");
- count++;
- }
-
- if (member_test_flag(member, MFLAG_MOD)) {
- stream->write_function(stream, "%s%s", count ? "|" : "", "moderator");
- count++;
- }
-
- if (member_test_flag(member, MFLAG_GHOST)) {
- stream->write_function(stream, "%s%s", count ? "|" : "", "ghost");
- count++;
- }
-
- stream->write_function(stream, "%s%d%s%d%s%d%s%d\n", delim,
- member->volume_in_level,
- delim,
- member->agc_volume_in_level,
- delim, member->volume_out_level, delim, member->energy_level);
- }
-
- switch_mutex_unlock(conference->member_mutex);
-}
-
-
/* _In_opt_z_ const char *cmd, _In_opt_ switch_core_session_t *session, _In_ switch_stream_handle_t *stream */
switch_status_t conf_api_main_real(const char *cmd, switch_core_session_t *session, switch_stream_handle_t *stream)
{
if (argc && argv[0]) {
conference_obj_t *conference = NULL;
- if ((conference = conference_find(argv[0], NULL))) {
+ if ((conference = conf_find(argv[0], NULL))) {
if (argc >= 2) {
conf_api_dispatch(conference, stream, argc, argv, cmd, 1);
} else {
for (i = 0; i < CONFFUNCAPISIZE; i++) {
nl = strlen(conf_api_sub_commands[i].pcommand) + strlen(conf_api_sub_commands[i].psyntax) + 5;
- switch_snprintf(cmd_str, sizeof(cmd_str), "add conference ::conference::list_conferences %s", conf_api_sub_commands[i].pcommand);
+ switch_snprintf(cmd_str, sizeof(cmd_str), "add conference ::conference::conf_list_conferences %s", conf_api_sub_commands[i].pcommand);
switch_console_set_complete(cmd_str);
if (p != NULL) {
}
-switch_status_t conf_api_sub_mute(conference_member_t *member, switch_stream_handle_t *stream, void *data)
+switch_status_t conf_api_sub_mute(conf_member_t *member, switch_stream_handle_t *stream, void *data)
{
switch_event_t *event;
if (member == NULL)
return SWITCH_STATUS_GENERR;
- member_clear_flag_locked(member, MFLAG_CAN_SPEAK);
- member_clear_flag_locked(member, MFLAG_TALKING);
+ conf_utils_member_clear_flag_locked(member, MFLAG_CAN_SPEAK);
+ conf_utils_member_clear_flag_locked(member, MFLAG_TALKING);
- if (member->session && !member_test_flag(member, MFLAG_MUTE_DETECT)) {
+ if (member->session && !conf_utils_member_test_flag(member, MFLAG_MUTE_DETECT)) {
switch_core_media_hard_mute(member->session, SWITCH_TRUE);
}
if (!(data) || !strstr((char *) data, "quiet")) {
- member_set_flag(member, MFLAG_INDICATE_MUTE);
+ conf_utils_member_set_flag(member, MFLAG_INDICATE_MUTE);
}
member->score_iir = 0;
if (test_eflag(member->conference, EFLAG_MUTE_MEMBER) &&
switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
- conference_add_event_member_data(member, event);
+ conf_member_add_event_data(member, event);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "mute-member");
switch_event_fire(&event);
}
- if (conference_test_flag(member->conference, CFLAG_POSITIONAL)) {
- gen_arc(member->conference, NULL);
+ if (conf_utils_test_flag(member->conference, CFLAG_POSITIONAL)) {
+ conf_al_gen_arc(member->conference, NULL);
}
- member_update_status_field(member);
+ conf_member_update_status_field(member);
return SWITCH_STATUS_SUCCESS;
}
-switch_status_t conf_api_sub_tmute(conference_member_t *member, switch_stream_handle_t *stream, void *data)
+switch_status_t conf_api_sub_tmute(conf_member_t *member, switch_stream_handle_t *stream, void *data)
{
if (member == NULL)
return SWITCH_STATUS_GENERR;
- if (member_test_flag(member, MFLAG_CAN_SPEAK)) {
+ if (conf_utils_member_test_flag(member, MFLAG_CAN_SPEAK)) {
return conf_api_sub_mute(member, stream, data);
}
}
-switch_status_t conf_api_sub_unmute(conference_member_t *member, switch_stream_handle_t *stream, void *data)
+switch_status_t conf_api_sub_unmute(conf_member_t *member, switch_stream_handle_t *stream, void *data)
{
switch_event_t *event;
if (member == NULL)
return SWITCH_STATUS_GENERR;
- member_set_flag_locked(member, MFLAG_CAN_SPEAK);
+ conf_utils_member_set_flag_locked(member, MFLAG_CAN_SPEAK);
- if (member->session && !member_test_flag(member, MFLAG_MUTE_DETECT)) {
+ if (member->session && !conf_utils_member_test_flag(member, MFLAG_MUTE_DETECT)) {
switch_core_media_hard_mute(member->session, SWITCH_FALSE);
}
if (!(data) || !strstr((char *) data, "quiet")) {
- member_set_flag(member, MFLAG_INDICATE_UNMUTE);
+ conf_utils_member_set_flag(member, MFLAG_INDICATE_UNMUTE);
}
if (stream != NULL) {
if (test_eflag(member->conference, EFLAG_UNMUTE_MEMBER) &&
switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
- conference_add_event_member_data(member, event);
+ conf_member_add_event_data(member, event);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "unmute-member");
switch_event_fire(&event);
}
- if (conference_test_flag(member->conference, CFLAG_POSITIONAL)) {
- gen_arc(member->conference, NULL);
+ if (conf_utils_test_flag(member->conference, CFLAG_POSITIONAL)) {
+ conf_al_gen_arc(member->conference, NULL);
}
- member_update_status_field(member);
+ conf_member_update_status_field(member);
return SWITCH_STATUS_SUCCESS;
}
-switch_status_t conf_api_sub_vmute_snap(conference_member_t *member, switch_stream_handle_t *stream, void *data)
+switch_status_t conf_api_sub_conf_video_vmute_snap(conf_member_t *member, switch_stream_handle_t *stream, void *data)
{
switch_bool_t clear = SWITCH_FALSE;
clear = SWITCH_TRUE;
}
- vmute_snap(member, clear);
+ conf_video_vmute_snap(member, clear);
return SWITCH_STATUS_SUCCESS;
}
-switch_status_t conf_api_sub_vmute(conference_member_t *member, switch_stream_handle_t *stream, void *data)
+switch_status_t conf_api_sub_vmute(conf_member_t *member, switch_stream_handle_t *stream, void *data)
{
switch_event_t *event;
return SWITCH_STATUS_SUCCESS;
}
- member_clear_flag_locked(member, MFLAG_CAN_BE_SEEN);
- reset_video_bitrate_counters(member);
+ conf_utils_member_clear_flag_locked(member, MFLAG_CAN_BE_SEEN);
+ conf_video_reset_video_bitrate_counters(member);
if (member->channel) {
switch_channel_set_flag(member->channel, CF_VIDEO_PAUSE_READ);
}
if (!(data) || !strstr((char *) data, "quiet")) {
- member_set_flag(member, MFLAG_INDICATE_MUTE);
+ conf_utils_member_set_flag(member, MFLAG_INDICATE_MUTE);
}
if (stream != NULL) {
if (test_eflag(member->conference, EFLAG_MUTE_MEMBER) &&
switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
- conference_add_event_member_data(member, event);
+ conf_member_add_event_data(member, event);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "vmute-member");
switch_event_fire(&event);
}
- member_update_status_field(member);
+ conf_member_update_status_field(member);
return SWITCH_STATUS_SUCCESS;
}
-switch_status_t conf_api_sub_tvmute(conference_member_t *member, switch_stream_handle_t *stream, void *data)
+switch_status_t conf_api_sub_tvmute(conf_member_t *member, switch_stream_handle_t *stream, void *data)
{
if (member == NULL)
return SWITCH_STATUS_GENERR;
- if (member_test_flag(member, MFLAG_CAN_BE_SEEN)) {
+ if (conf_utils_member_test_flag(member, MFLAG_CAN_BE_SEEN)) {
return conf_api_sub_vmute(member, stream, data);
}
}
-switch_status_t conf_api_sub_unvmute(conference_member_t *member, switch_stream_handle_t *stream, void *data)
+switch_status_t conf_api_sub_unvmute(conf_member_t *member, switch_stream_handle_t *stream, void *data)
{
switch_event_t *event;
mcu_layer_t *layer = NULL;
if (member->conference->canvas) {
switch_mutex_lock(member->conference->canvas->mutex);
layer = &member->conference->canvas->layers[member->video_layer_id];
- clear_layer(layer);
+ conf_video_clear_layer(layer);
switch_mutex_unlock(member->conference->canvas->mutex);
}
- member_set_flag_locked(member, MFLAG_CAN_BE_SEEN);
- reset_video_bitrate_counters(member);
+ conf_utils_member_set_flag_locked(member, MFLAG_CAN_BE_SEEN);
+ conf_video_reset_video_bitrate_counters(member);
if (member->channel) {
switch_channel_clear_flag(member->channel, CF_VIDEO_PAUSE_READ);
}
if (!(data) || !strstr((char *) data, "quiet")) {
- member_set_flag(member, MFLAG_INDICATE_UNMUTE);
+ conf_utils_member_set_flag(member, MFLAG_INDICATE_UNMUTE);
}
if (stream != NULL) {
if (test_eflag(member->conference, EFLAG_UNMUTE_MEMBER) &&
switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
- conference_add_event_member_data(member, event);
+ conf_member_add_event_data(member, event);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "unvmute-member");
switch_event_fire(&event);
}
- member_update_status_field(member);
+ conf_member_update_status_field(member);
return SWITCH_STATUS_SUCCESS;
}
-switch_status_t conf_api_sub_deaf(conference_member_t *member, switch_stream_handle_t *stream, void *data)
+switch_status_t conf_api_sub_deaf(conf_member_t *member, switch_stream_handle_t *stream, void *data)
{
switch_event_t *event;
if (member == NULL)
return SWITCH_STATUS_GENERR;
- member_clear_flag_locked(member, MFLAG_CAN_HEAR);
+ conf_utils_member_clear_flag_locked(member, MFLAG_CAN_HEAR);
if (stream != NULL) {
stream->write_function(stream, "OK deaf %u\n", member->id);
}
if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
- conference_add_event_member_data(member, event);
+ conf_member_add_event_data(member, event);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "deaf-member");
switch_event_fire(&event);
}
- if (conference_test_flag(member->conference, CFLAG_POSITIONAL)) {
- gen_arc(member->conference, NULL);
+ if (conf_utils_test_flag(member->conference, CFLAG_POSITIONAL)) {
+ conf_al_gen_arc(member->conference, NULL);
}
return SWITCH_STATUS_SUCCESS;
}
-switch_status_t conf_api_sub_undeaf(conference_member_t *member, switch_stream_handle_t *stream, void *data)
+switch_status_t conf_api_sub_undeaf(conf_member_t *member, switch_stream_handle_t *stream, void *data)
{
switch_event_t *event;
if (member == NULL)
return SWITCH_STATUS_GENERR;
- member_set_flag_locked(member, MFLAG_CAN_HEAR);
+ conf_utils_member_set_flag_locked(member, MFLAG_CAN_HEAR);
if (stream != NULL) {
stream->write_function(stream, "OK undeaf %u\n", member->id);
}
if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
- conference_add_event_member_data(member, event);
+ conf_member_add_event_data(member, event);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "undeaf-member");
switch_event_fire(&event);
}
- if (conference_test_flag(member->conference, CFLAG_POSITIONAL)) {
- gen_arc(member->conference, NULL);
+ if (conf_utils_test_flag(member->conference, CFLAG_POSITIONAL)) {
+ conf_al_gen_arc(member->conference, NULL);
}
return SWITCH_STATUS_SUCCESS;
}
-switch_status_t conf_api_sub_hup(conference_member_t *member, switch_stream_handle_t *stream, void *data)
+switch_status_t conf_api_sub_hup(conf_member_t *member, switch_stream_handle_t *stream, void *data)
{
switch_event_t *event;
return SWITCH_STATUS_GENERR;
}
- member_clear_flag(member, MFLAG_RUNNING);
+ conf_utils_member_clear_flag(member, MFLAG_RUNNING);
if (member->conference && test_eflag(member->conference, EFLAG_HUP_MEMBER)) {
if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
- conference_add_event_member_data(member, event);
+ conf_member_add_event_data(member, event);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "hup-member");
switch_event_fire(&event);
}
return SWITCH_STATUS_SUCCESS;
}
-switch_status_t conf_api_sub_kick(conference_member_t *member, switch_stream_handle_t *stream, void *data)
+switch_status_t conf_api_sub_kick(conf_member_t *member, switch_stream_handle_t *stream, void *data)
{
switch_event_t *event;
return SWITCH_STATUS_GENERR;
}
- member_clear_flag(member, MFLAG_RUNNING);
- member_set_flag_locked(member, MFLAG_KICKED);
+ conf_utils_member_clear_flag(member, MFLAG_RUNNING);
+ conf_utils_member_set_flag_locked(member, MFLAG_KICKED);
switch_core_session_kill_channel(member->session, SWITCH_SIG_BREAK);
if (data && member->session) {
if (member->conference && test_eflag(member->conference, EFLAG_KICK_MEMBER)) {
if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
- conference_add_event_member_data(member, event);
+ conf_member_add_event_data(member, event);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "kick-member");
switch_event_fire(&event);
}
}
-switch_status_t conf_api_sub_dtmf(conference_member_t *member, switch_stream_handle_t *stream, void *data)
+switch_status_t conf_api_sub_dtmf(conf_member_t *member, switch_stream_handle_t *stream, void *data)
{
switch_event_t *event;
char *dtmf = (char *) data;
if (test_eflag(member->conference, EFLAG_DTMF_MEMBER) &&
switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
- conference_add_event_member_data(member, event);
+ conf_member_add_event_data(member, event);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "dtmf-member");
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Digits", dtmf);
switch_event_fire(&event);
return SWITCH_STATUS_SUCCESS;
}
-switch_status_t conf_api_sub_watching_canvas(conference_member_t *member, switch_stream_handle_t *stream, void *data)
+switch_status_t conf_api_sub_watching_canvas(conf_member_t *member, switch_stream_handle_t *stream, void *data)
{
int index;
char *val = (char *) data;
return SWITCH_STATUS_SUCCESS;
}
- index = get_canvas_id(member, val, SWITCH_TRUE);
+ index = conf_member_get_canvas_id(member, val, SWITCH_TRUE);
if (index < 0) {
stream->write_function(stream, "-ERR Invalid DATA\n");
}
member->watching_canvas_id = index;
- reset_member_codec_index(member);
+ conf_video_reset_member_codec_index(member);
switch_core_session_request_video_refresh(member->session);
switch_core_media_gen_key_frame(member->session);
member->conference->canvases[index]->send_keyframe = 10;
return SWITCH_STATUS_SUCCESS;
}
-switch_status_t conf_api_sub_canvas(conference_member_t *member, switch_stream_handle_t *stream, void *data)
+switch_status_t conf_api_sub_canvas(conf_member_t *member, switch_stream_handle_t *stream, void *data)
{
int index;
char *val = (char *) data;
switch_mutex_lock(member->conference->canvas_mutex);
- index = get_canvas_id(member, val, SWITCH_FALSE);
+ index = conf_member_get_canvas_id(member, val, SWITCH_FALSE);
if (index < 0) {
stream->write_function(stream, "-ERR Invalid DATA\n");
return SWITCH_STATUS_SUCCESS;
}
- detach_video_layer(member);
+ conf_video_detach_video_layer(member);
member->canvas_id = index;
member->layer_timeout = DEFAULT_LAYER_TIMEOUT;
canvas = member->conference->canvases[member->canvas_id];
- attach_video_layer(member, canvas, index);
- reset_member_codec_index(member);
+ conf_video_attach_video_layer(member, canvas, index);
+ conf_video_reset_member_codec_index(member);
switch_mutex_unlock(member->conference->canvas_mutex);
switch_core_session_request_video_refresh(member->session);
-switch_status_t conf_api_sub_layer(conference_member_t *member, switch_stream_handle_t *stream, void *data)
+switch_status_t conf_api_sub_layer(conf_member_t *member, switch_stream_handle_t *stream, void *data)
{
int index = -1;
mcu_canvas_t *canvas = NULL;
index = canvas->total_layers - 1;
}
- attach_video_layer(member, canvas, index);
+ conf_video_attach_video_layer(member, canvas, index);
switch_mutex_unlock(member->conference->canvas_mutex);
switch_core_session_request_video_refresh(member->session);
}
-switch_status_t conf_api_sub_energy(conference_member_t *member, switch_stream_handle_t *stream, void *data)
+switch_status_t conf_api_sub_energy(conf_member_t *member, switch_stream_handle_t *stream, void *data)
{
switch_event_t *event;
}
if (test_eflag(member->conference, EFLAG_ENERGY_LEVEL_MEMBER) &&
data && switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
- conference_add_event_member_data(member, event);
+ conf_member_add_event_data(member, event);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "energy-level-member");
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Energy-Level", "%d", member->energy_level);
switch_event_fire(&event);
if (!zstr(arg)) {
if (!strcasecmp(arg, "on")) {
- conference_set_flag(conference, CFLAG_POSITIONAL);
+ conf_utils_set_flag(conference, CFLAG_POSITIONAL);
set = 1;
} else if (!strcasecmp(arg, "off")) {
- conference_clear_flag(conference, CFLAG_POSITIONAL);
+ conf_utils_clear_flag(conference, CFLAG_POSITIONAL);
}
}
- if (set && conference_test_flag(conference, CFLAG_POSITIONAL)) {
- gen_arc(conference, stream);
+ if (set && conf_utils_test_flag(conference, CFLAG_POSITIONAL)) {
+ conf_al_gen_arc(conference, stream);
}
- stream->write_function(stream, "+OK positioning %s\n", conference_test_flag(conference, CFLAG_POSITIONAL) ? "on" : "off");
+ stream->write_function(stream, "+OK positioning %s\n", conf_utils_test_flag(conference, CFLAG_POSITIONAL) ? "on" : "off");
#else
stream->write_function(stream, "-ERR not supported\n");
return SWITCH_STATUS_SUCCESS;
}
-switch_status_t conf_api_sub_position(conference_member_t *member, switch_stream_handle_t *stream, void *data)
+switch_status_t conf_api_sub_position(conf_member_t *member, switch_stream_handle_t *stream, void *data)
{
#ifndef OPENAL_POSITIONING
if (stream) stream->write_function(stream, "-ERR not supported\n");
return SWITCH_STATUS_GENERR;
}
- if (member_test_flag(member, MFLAG_NO_POSITIONAL)) {
+ if (conf_utils_member_test_flag(member, MFLAG_NO_POSITIONAL)) {
if (stream) stream->write_function(stream,
"%s has positional audio blocked.\n", switch_channel_get_name(member->channel));
return SWITCH_STATUS_SUCCESS;
}
if (!member->al) {
- if (!member_test_flag(member, MFLAG_POSITIONAL) && member->conference->channels == 2) {
- member_set_flag(member, MFLAG_POSITIONAL);
- member->al = create_al(member->pool);
+ if (!conf_utils_member_test_flag(member, MFLAG_POSITIONAL) && member->conference->channels == 2) {
+ conf_utils_member_set_flag(member, MFLAG_POSITIONAL);
+ member->al = conf_al_create(member->pool);
} else {
if (stream) {
if (data) {
- if (member_parse_position(member, data) != SWITCH_STATUS_SUCCESS) {
+ if (conf_member_parse_position(member, data) != SWITCH_STATUS_SUCCESS) {
if (stream) {
stream->write_function(stream, "invalid input!\n");
}
if (test_eflag(member->conference, EFLAG_SET_POSITION_MEMBER) &&
data && switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
- conference_add_event_member_data(member, event);
+ conf_member_add_event_data(member, event);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "set-position-member");
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Position", "%0.2f:%0.2f:%0.2f", member->al->pos_x, member->al->pos_y, member->al->pos_z);
switch_event_fire(&event);
return SWITCH_STATUS_SUCCESS;
}
-switch_status_t conf_api_sub_volume_in(conference_member_t *member, switch_stream_handle_t *stream, void *data)
+switch_status_t conf_api_sub_volume_in(conf_member_t *member, switch_stream_handle_t *stream, void *data)
{
switch_event_t *event;
}
if (test_eflag(member->conference, EFLAG_VOLUME_IN_MEMBER) &&
data && switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
- conference_add_event_member_data(member, event);
+ conf_member_add_event_data(member, event);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "volume-in-member");
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Volume-Level", "%d", member->volume_in_level);
switch_event_fire(&event);
return SWITCH_STATUS_SUCCESS;
}
-switch_status_t conf_api_sub_volume_out(conference_member_t *member, switch_stream_handle_t *stream, void *data)
+switch_status_t conf_api_sub_volume_out(conf_member_t *member, switch_stream_handle_t *stream, void *data)
{
switch_event_t *event;
}
if (test_eflag(member->conference, EFLAG_VOLUME_OUT_MEMBER) && data &&
switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
- conference_add_event_member_data(member, event);
+ conf_member_add_event_data(member, event);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "volume-out-member");
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Volume-Level", "%d", member->volume_out_level);
switch_event_fire(&event);
{
int32_t i, video_write_bandwidth;
- if (!conference_test_flag(conference, CFLAG_MINIMIZE_VIDEO_ENCODING)) {
+ if (!conf_utils_test_flag(conference, CFLAG_MINIMIZE_VIDEO_ENCODING)) {
stream->write_function(stream, "Bandwidth control not available.\n");
return SWITCH_STATUS_SUCCESS;
}
fps = atof(argv[2]);
- if (conference_set_fps(conference, fps)) {
+ if (conf_video_set_fps(conference, fps)) {
stream->write_function(stream, "FPS set to [%s]\n", argv[2]);
} else {
stream->write_function(stream, "Invalid FPS [%s]\n", argv[2]);
return SWITCH_STATUS_SUCCESS;
} else {
if (((lg = switch_core_hash_find(conference->layout_group_hash, group_name)))) {
- vlayout = find_best_layout(conference, lg, 0);
+ vlayout = conf_video_find_best_layout(conference, lg, 0);
}
if (!vlayout) {
}
if (conference == NULL) {
- switch_mutex_lock(mod_conference_globals.hash_mutex);
- for (hi = switch_core_hash_first(mod_conference_globals.conference_hash); hi; hi = switch_core_hash_next(&hi)) {
+ switch_mutex_lock(conf_globals.hash_mutex);
+ for (hi = switch_core_hash_first(conf_globals.conference_hash); hi; hi = switch_core_hash_next(&hi)) {
int fcount = 0;
switch_core_hash_this(hi, NULL, NULL, &val);
conference = (conference_obj_t *) val;
stream->write_function(stream, "Conference %s (%u member%s rate: %u%s flags: ",
conference->name,
conference->count,
- conference->count == 1 ? "" : "s", conference->rate, conference_test_flag(conference, CFLAG_LOCKED) ? " locked" : "");
+ conference->count == 1 ? "" : "s", conference->rate, conf_utils_test_flag(conference, CFLAG_LOCKED) ? " locked" : "");
- if (conference_test_flag(conference, CFLAG_LOCKED)) {
+ if (conf_utils_test_flag(conference, CFLAG_LOCKED)) {
stream->write_function(stream, "%slocked", fcount ? "|" : "");
fcount++;
}
- if (conference_test_flag(conference, CFLAG_DESTRUCT)) {
+ if (conf_utils_test_flag(conference, CFLAG_DESTRUCT)) {
stream->write_function(stream, "%sdestruct", fcount ? "|" : "");
fcount++;
}
- if (conference_test_flag(conference, CFLAG_WAIT_MOD)) {
+ if (conf_utils_test_flag(conference, CFLAG_WAIT_MOD)) {
stream->write_function(stream, "%swait_mod", fcount ? "|" : "");
fcount++;
}
- if (conference_test_flag(conference, CFLAG_AUDIO_ALWAYS)) {
+ if (conf_utils_test_flag(conference, CFLAG_AUDIO_ALWAYS)) {
stream->write_function(stream, "%saudio_always", fcount ? "|" : "");
fcount++;
}
- if (conference_test_flag(conference, CFLAG_RUNNING)) {
+ if (conf_utils_test_flag(conference, CFLAG_RUNNING)) {
stream->write_function(stream, "%srunning", fcount ? "|" : "");
fcount++;
}
- if (conference_test_flag(conference, CFLAG_ANSWERED)) {
+ if (conf_utils_test_flag(conference, CFLAG_ANSWERED)) {
stream->write_function(stream, "%sanswered", fcount ? "|" : "");
fcount++;
}
- if (conference_test_flag(conference, CFLAG_ENFORCE_MIN)) {
+ if (conf_utils_test_flag(conference, CFLAG_ENFORCE_MIN)) {
stream->write_function(stream, "%senforce_min", fcount ? "|" : "");
fcount++;
}
- if (conference_test_flag(conference, CFLAG_BRIDGE_TO)) {
+ if (conf_utils_test_flag(conference, CFLAG_BRIDGE_TO)) {
stream->write_function(stream, "%sbridge_to", fcount ? "|" : "");
fcount++;
}
- if (conference_test_flag(conference, CFLAG_DYNAMIC)) {
+ if (conf_utils_test_flag(conference, CFLAG_DYNAMIC)) {
stream->write_function(stream, "%sdynamic", fcount ? "|" : "");
fcount++;
}
- if (conference_test_flag(conference, CFLAG_EXIT_SOUND)) {
+ if (conf_utils_test_flag(conference, CFLAG_EXIT_SOUND)) {
stream->write_function(stream, "%sexit_sound", fcount ? "|" : "");
fcount++;
}
- if (conference_test_flag(conference, CFLAG_ENTER_SOUND)) {
+ if (conf_utils_test_flag(conference, CFLAG_ENTER_SOUND)) {
stream->write_function(stream, "%senter_sound", fcount ? "|" : "");
fcount++;
}
fcount++;
}
- if (conference_test_flag(conference, CFLAG_VID_FLOOR)) {
+ if (conf_utils_test_flag(conference, CFLAG_VID_FLOOR)) {
stream->write_function(stream, "%svideo_floor_only", fcount ? "|" : "");
fcount++;
}
- if (conference_test_flag(conference, CFLAG_RFC4579)) {
+ if (conf_utils_test_flag(conference, CFLAG_RFC4579)) {
stream->write_function(stream, "%svideo_rfc4579", fcount ? "|" : "");
fcount++;
}
- if (conference_test_flag(conference, CFLAG_LIVEARRAY_SYNC)) {
+ if (conf_utils_test_flag(conference, CFLAG_LIVEARRAY_SYNC)) {
stream->write_function(stream, "%slivearray_sync", fcount ? "|" : "");
fcount++;
}
- if (conference_test_flag(conference, CFLAG_VID_FLOOR_LOCK)) {
+ if (conf_utils_test_flag(conference, CFLAG_VID_FLOOR_LOCK)) {
stream->write_function(stream, "%svideo_floor_lock", fcount ? "|" : "");
fcount++;
}
- if (conference_test_flag(conference, CFLAG_TRANSCODE_VIDEO)) {
+ if (conf_utils_test_flag(conference, CFLAG_TRANSCODE_VIDEO)) {
stream->write_function(stream, "%stranscode_video", fcount ? "|" : "");
fcount++;
}
- if (conference_test_flag(conference, CFLAG_VIDEO_MUXING)) {
+ if (conf_utils_test_flag(conference, CFLAG_VIDEO_MUXING)) {
stream->write_function(stream, "%svideo_muxing", fcount ? "|" : "");
fcount++;
}
- if (conference_test_flag(conference, CFLAG_MINIMIZE_VIDEO_ENCODING)) {
+ if (conf_utils_test_flag(conference, CFLAG_MINIMIZE_VIDEO_ENCODING)) {
stream->write_function(stream, "%sminimize_video_encoding", fcount ? "|" : "");
fcount++;
}
- if (conference_test_flag(conference, CFLAG_MANAGE_INBOUND_VIDEO_BITRATE)) {
+ if (conf_utils_test_flag(conference, CFLAG_MANAGE_INBOUND_VIDEO_BITRATE)) {
stream->write_function(stream, "%smanage_inbound_bitrate", fcount ? "|" : "");
fcount++;
}
- if (conference_test_flag(conference, CFLAG_JSON_STATUS)) {
+ if (conf_utils_test_flag(conference, CFLAG_JSON_STATUS)) {
stream->write_function(stream, "%sjson_status", fcount ? "|" : "");
fcount++;
}
- if (conference_test_flag(conference, CFLAG_VIDEO_BRIDGE_FIRST_TWO)) {
+ if (conf_utils_test_flag(conference, CFLAG_VIDEO_BRIDGE_FIRST_TWO)) {
stream->write_function(stream, "%svideo_bridge_first_two", fcount ? "|" : "");
fcount++;
}
- if (conference_test_flag(conference, CFLAG_VIDEO_REQUIRED_FOR_CANVAS)) {
+ if (conf_utils_test_flag(conference, CFLAG_VIDEO_REQUIRED_FOR_CANVAS)) {
stream->write_function(stream, "%svideo_required_for_canvas", fcount ? "|" : "");
fcount++;
}
- if (conference_test_flag(conference, CFLAG_PERSONAL_CANVAS)) {
+ if (conf_utils_test_flag(conference, CFLAG_PERSONAL_CANVAS)) {
stream->write_function(stream, "%spersonal_canvas", fcount ? "|" : "");
fcount++;
}
count++;
if (!summary) {
if (pretty) {
- conference_list_pretty(conference, stream);
+ conf_list_pretty(conference, stream);
} else {
conference_list(conference, stream, d);
}
}
}
- switch_mutex_unlock(mod_conference_globals.hash_mutex);
+ switch_mutex_unlock(conf_globals.hash_mutex);
} else {
count++;
if (countonly) {
- conference_list_count_only(conference, stream);
+ conf_list_count_only(conference, stream);
} else if (pretty) {
- conference_list_pretty(conference, stream);
+ conf_list_pretty(conference, stream);
} else {
conference_list(conference, stream, d);
}
return ret_status;
}
-switch_status_t conf_api_sub_floor(conference_member_t *member, switch_stream_handle_t *stream, void *data)
+switch_status_t conf_api_sub_floor(conf_member_t *member, switch_stream_handle_t *stream, void *data)
{
if (member == NULL)
switch_mutex_lock(member->conference->mutex);
if (member->conference->floor_holder == member) {
- conference_set_floor_holder(member->conference, NULL);
+ conf_member_set_floor_holder(member->conference, NULL);
if (stream != NULL) {
stream->write_function(stream, "OK floor none\n");
}
} else if (member->conference->floor_holder == NULL) {
- conference_set_floor_holder(member->conference, member);
+ conf_member_set_floor_holder(member->conference, member);
if (stream != NULL) {
stream->write_function(stream, "OK floor %u\n", member->id);
}
{
switch_mutex_lock(conference->mutex);
- conference_clear_flag(conference, CFLAG_VID_FLOOR_LOCK);
- //conference_set_video_floor_holder(conference, NULL);
+ conf_utils_clear_flag(conference, CFLAG_VID_FLOOR_LOCK);
+ //conf_video_set_floor_holder(conference, NULL);
switch_mutex_unlock(conference->mutex);
return SWITCH_STATUS_SUCCESS;
}
-switch_status_t conf_api_sub_vid_mute_img(conference_member_t *member, switch_stream_handle_t *stream, void *data)
+switch_status_t conf_api_sub_vid_mute_img(conf_member_t *member, switch_stream_handle_t *stream, void *data)
{
char *text = (char *) data;
mcu_layer_t *layer = NULL;
}
-switch_status_t conf_api_sub_vid_logo_img(conference_member_t *member, switch_stream_handle_t *stream, void *data)
+switch_status_t conf_api_sub_vid_logo_img(conf_member_t *member, switch_stream_handle_t *stream, void *data)
{
char *text = (char *) data;
mcu_layer_t *layer = NULL;
member->video_logo = switch_core_strdup(member->pool, text);
}
- layer_set_logo(member, layer, text);
+ conf_video_layer_set_logo(member, layer, text);
end:
}
-switch_status_t conf_api_sub_vid_res_id(conference_member_t *member, switch_stream_handle_t *stream, void *data)
+switch_status_t conf_api_sub_vid_res_id(conf_member_t *member, switch_stream_handle_t *stream, void *data)
{
char *text = (char *) data;
//mcu_layer_t *layer = NULL;
stream->write_function(stream, "+OK reservation_id %s\n", text);
}
- detach_video_layer(member);
+ conf_video_detach_video_layer(member);
switch_mutex_unlock(member->conference->canvas->mutex);
}
-switch_status_t conf_api_sub_vid_banner(conference_member_t *member, switch_stream_handle_t *stream, void *data)
+switch_status_t conf_api_sub_vid_banner(conf_member_t *member, switch_stream_handle_t *stream, void *data)
{
mcu_layer_t *layer = NULL;
char *text = (char *) data;
member->video_banner_text = switch_core_strdup(member->pool, text);
- layer_set_banner(member, layer, NULL);
+ conf_video_layer_set_banner(member, layer, NULL);
stream->write_function(stream, "+OK\n");
return SWITCH_STATUS_SUCCESS;
}
-switch_status_t conf_api_sub_vid_floor(conference_member_t *member, switch_stream_handle_t *stream, void *data)
+switch_status_t conf_api_sub_vid_floor(conf_member_t *member, switch_stream_handle_t *stream, void *data)
{
int force = 0;
force = 1;
}
- if (member->conference->video_floor_holder == member->id && conference_test_flag(member->conference, CFLAG_VID_FLOOR_LOCK)) {
- conference_clear_flag(member->conference, CFLAG_VID_FLOOR_LOCK);
+ if (member->conference->video_floor_holder == member->id && conf_utils_test_flag(member->conference, CFLAG_VID_FLOOR_LOCK)) {
+ conf_utils_clear_flag(member->conference, CFLAG_VID_FLOOR_LOCK);
- conference_set_floor_holder(member->conference, member);
+ conf_member_set_floor_holder(member->conference, member);
if (stream == NULL) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "conference %s OK video floor auto\n", member->conference->name);
} else {
}
} else if (force || member->conference->video_floor_holder == 0) {
- conference_set_flag(member->conference, CFLAG_VID_FLOOR_LOCK);
- conference_set_video_floor_holder(member->conference, member, SWITCH_TRUE);
+ conf_utils_set_flag(member->conference, CFLAG_VID_FLOOR_LOCK);
+ conf_video_set_floor_holder(member->conference, member, SWITCH_TRUE);
if (test_eflag(member->conference, EFLAG_FLOOR_CHANGE)) {
if (stream == NULL) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "conference %s OK video floor %d %s\n",
{
if (argc == 3) {
switch_mutex_lock(conference->mutex);
- switch_fnode_seek(conference->fnode, stream, argv[2]);
+ conf_fnode_seek(conference->fnode, stream, argv[2]);
switch_mutex_unlock(conference->mutex);
return SWITCH_STATUS_SUCCESS;
if (argc == 4) {
uint32_t id = atoi(argv[3]);
- conference_member_t *member = conference_member_get(conference, id);
+ conf_member_t *member = conf_member_get(conference, id);
if (member == NULL) {
stream->write_function(stream, "Member: %u not found.\n", id);
return SWITCH_STATUS_GENERR;
}
switch_mutex_lock(member->fnode_mutex);
- switch_fnode_seek(member->fnode, stream, argv[2]);
+ conf_fnode_seek(member->fnode, stream, argv[2]);
switch_mutex_unlock(member->fnode_mutex);
switch_thread_rwlock_unlock(member->rwlock);
return SWITCH_STATUS_SUCCESS;
}
if (argc == 3) {
- if (conference_play_file(conference, argv[2], 0, NULL, async) == SWITCH_STATUS_SUCCESS) {
+ if (conference_file_play(conference, argv[2], 0, NULL, async) == SWITCH_STATUS_SUCCESS) {
stream->write_function(stream, "(play) Playing file %s\n", argv[2]);
if (test_eflag(conference, EFLAG_PLAY_FILE) &&
switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
- conference_add_event_data(conference, event);
+ conf_event_add_data(conference, event);
if (conference->fnode && conference->fnode->fh.params) {
switch_event_merge(event, conference->fnode->fh.params);
ret_status = SWITCH_STATUS_SUCCESS;
} else if (argc >= 4) {
uint32_t id = atoi(argv[3]);
- conference_member_t *member;
+ conf_member_t *member;
switch_bool_t mux = SWITCH_TRUE;
if (argc > 4 && !strcasecmp(argv[4], "nomux")) {
mux = SWITCH_FALSE;
}
- if ((member = conference_member_get(conference, id))) {
- if (conference_member_play_file(member, argv[2], 0, mux) == SWITCH_STATUS_SUCCESS) {
+ if ((member = conf_member_get(conference, id))) {
+ if (conf_member_play_file(member, argv[2], 0, mux) == SWITCH_STATUS_SUCCESS) {
stream->write_function(stream, "(play) Playing file %s to member %u\n", argv[2], id);
if (test_eflag(conference, EFLAG_PLAY_FILE_MEMBER) &&
switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
- conference_add_event_member_data(member, event);
+ conf_member_add_event_data(member, event);
if (member->fnode->fh.params) {
switch_event_merge(event, member->fnode->fh.params);
return SWITCH_STATUS_GENERR;
}
- if (conference_say(conference, text, 0) != SWITCH_STATUS_SUCCESS) {
+ if (conf_say(conference, text, 0) != SWITCH_STATUS_SUCCESS) {
stream->write_function(stream, "(say) Error!\n");
return SWITCH_STATUS_GENERR;
}
stream->write_function(stream, "(say) OK\n");
if (test_eflag(conference, EFLAG_SPEAK_TEXT) && switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
- conference_add_event_data(conference, event);
+ conf_event_add_data(conference, event);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "speak-text");
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Text", text);
switch_event_fire(&event);
char *start_text = NULL;
char *workspace = NULL;
uint32_t id = 0;
- conference_member_t *member = NULL;
+ conf_member_t *member = NULL;
switch_event_t *event;
if (zstr(text)) {
goto done;
}
- if (!(member = conference_member_get(conference, id))) {
+ if (!(member = conf_member_get(conference, id))) {
stream->write_function(stream, "(saymember) Unknown Member %u!\n", id);
goto done;
}
expanded = NULL;
}
- if (!text || conference_member_say(member, (char *) text, 0) != SWITCH_STATUS_SUCCESS) {
+ if (!text || conf_member_say(member, (char *) text, 0) != SWITCH_STATUS_SUCCESS) {
stream->write_function(stream, "(saymember) Error!\n");
goto done;
}
stream->write_function(stream, "(saymember) OK\n");
if (test_eflag(member->conference, EFLAG_SPEAK_TEXT_MEMBER) &&
switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
- conference_add_event_member_data(member, event);
+ conf_member_add_event_data(member, event);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "speak-text-member");
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Text", text);
switch_event_fire(&event);
if (argc == 4) {
uint32_t id = atoi(argv[3]);
- conference_member_t *member;
+ conf_member_t *member;
- if ((member = conference_member_get(conference, id))) {
- uint32_t stopped = conference_member_stop_file(member, async ? FILE_STOP_ASYNC : current ? FILE_STOP_CURRENT : FILE_STOP_ALL);
+ if ((member = conf_member_get(conference, id))) {
+ uint32_t stopped = conf_member_stop_file(member, async ? FILE_STOP_ASYNC : current ? FILE_STOP_CURRENT : FILE_STOP_ALL);
stream->write_function(stream, "Stopped %u files.\n", stopped);
switch_thread_rwlock_unlock(member->rwlock);
} else {
stream->write_function(stream, "Member: %u not found.\n", id);
}
} else {
- uint32_t stopped = conference_stop_file(conference, async ? FILE_STOP_ASYNC : current ? FILE_STOP_CURRENT : FILE_STOP_ALL);
+ uint32_t stopped = conference_file_stop(conference, async ? FILE_STOP_ASYNC : current ? FILE_STOP_CURRENT : FILE_STOP_ALL);
stream->write_function(stream, "Stopped %u files.\n", stopped);
}
return SWITCH_STATUS_SUCCESS;
switch_assert(stream != NULL);
if (argc <= 3) {
- conference_member_t *member;
+ conf_member_t *member;
switch_mutex_lock(conference->mutex);
}
if (clear) {
- conference_member_t *member = NULL, *other_member = NULL;
+ conf_member_t *member = NULL, *other_member = NULL;
uint32_t id = atoi(argv[2]);
uint32_t oid = atoi(argv[3]);
- if ((member = conference_member_get(conference, id))) {
- member_del_relationship(member, oid);
- other_member = conference_member_get(conference, oid);
+ if ((member = conf_member_get(conference, id))) {
+ conf_member_del_relationship(member, oid);
+ other_member = conf_member_get(conference, oid);
if (other_member) {
- if (member_test_flag(other_member, MFLAG_RECEIVING_VIDEO)) {
- member_clear_flag(other_member, MFLAG_RECEIVING_VIDEO);
+ if (conf_utils_member_test_flag(other_member, MFLAG_RECEIVING_VIDEO)) {
+ conf_utils_member_clear_flag(other_member, MFLAG_RECEIVING_VIDEO);
if (conference->floor_holder) {
switch_core_session_request_video_refresh(conference->floor_holder->session);
}
}
if (nospeak || nohear || sendvideo) {
- conference_member_t *member = NULL, *other_member = NULL;
+ conf_member_t *member = NULL, *other_member = NULL;
uint32_t id = atoi(argv[2]);
uint32_t oid = atoi(argv[3]);
- if ((member = conference_member_get(conference, id))) {
- other_member = conference_member_get(conference, oid);
+ if ((member = conf_member_get(conference, id))) {
+ other_member = conf_member_get(conference, oid);
}
if (member && other_member) {
conference_relationship_t *rel = NULL;
- if (sendvideo && member_test_flag(other_member, MFLAG_RECEIVING_VIDEO) && (! (nospeak || nohear))) {
+ if (sendvideo && conf_utils_member_test_flag(other_member, MFLAG_RECEIVING_VIDEO) && (! (nospeak || nohear))) {
stream->write_function(stream, "member %d already receiving video", oid);
goto skip;
}
- if ((rel = member_get_relationship(member, other_member))) {
+ if ((rel = conf_member_get_relationship(member, other_member))) {
rel->flags = 0;
} else {
- rel = member_add_relationship(member, oid);
+ rel = conf_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);
- member_clear_flag_locked(member, MFLAG_TALKING);
+ conf_utils_member_clear_flag_locked(member, MFLAG_TALKING);
}
if (nohear) {
switch_clear_flag(rel, RFLAG_CAN_HEAR);
}
if (sendvideo) {
switch_set_flag(rel, RFLAG_CAN_SEND_VIDEO);
- member_set_flag(other_member, MFLAG_RECEIVING_VIDEO);
+ conf_utils_member_set_flag(other_member, MFLAG_RECEIVING_VIDEO);
switch_core_session_request_video_refresh(member->session);
}
switch_assert(stream != NULL);
if (conference->is_locked_sound) {
- conference_play_file(conference, conference->is_locked_sound, CONF_DEFAULT_LEADIN, NULL, 0);
+ conference_file_play(conference, conference->is_locked_sound, CONF_DEFAULT_LEADIN, NULL, 0);
}
- conference_set_flag_locked(conference, CFLAG_LOCKED);
+ conf_utils_set_flag_locked(conference, CFLAG_LOCKED);
stream->write_function(stream, "OK %s locked\n", argv[0]);
if (test_eflag(conference, EFLAG_LOCK) && switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
- conference_add_event_data(conference, event);
+ conf_event_add_data(conference, event);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "lock");
switch_event_fire(&event);
}
switch_assert(stream != NULL);
if (conference->is_unlocked_sound) {
- conference_play_file(conference, conference->is_unlocked_sound, CONF_DEFAULT_LEADIN, NULL, 0);
+ conference_file_play(conference, conference->is_unlocked_sound, CONF_DEFAULT_LEADIN, NULL, 0);
}
- conference_clear_flag_locked(conference, CFLAG_LOCKED);
+ conf_utils_clear_flag_locked(conference, CFLAG_LOCKED);
stream->write_function(stream, "OK %s unlocked\n", argv[0]);
if (test_eflag(conference, EFLAG_UNLOCK) && switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
- conference_add_event_data(conference, event);
+ conf_event_add_data(conference, event);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "unlock");
switch_event_fire(&event);
}
}
if ( !strcasecmp(argv[2], "on") ) {
- conference_set_flag_locked(conference, CFLAG_EXIT_SOUND);
+ conf_utils_set_flag_locked(conference, CFLAG_EXIT_SOUND);
stream->write_function(stream, "OK %s exit sounds on (%s)\n", argv[0], conference->exit_sound);
if (test_eflag(conference, EFLAG_LOCK) && switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
- conference_add_event_data(conference, event);
+ conf_event_add_data(conference, event);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "exit-sounds-on");
switch_event_fire(&event);
}
} else if ( !strcasecmp(argv[2], "off") || !strcasecmp(argv[2], "none") ) {
- conference_clear_flag_locked(conference, CFLAG_EXIT_SOUND);
+ conf_utils_clear_flag_locked(conference, CFLAG_EXIT_SOUND);
stream->write_function(stream, "OK %s exit sounds off (%s)\n", argv[0], conference->exit_sound);
if (test_eflag(conference, EFLAG_LOCK) && switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
- conference_add_event_data(conference, event);
+ conf_event_add_data(conference, event);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "exit-sounds-off");
switch_event_fire(&event);
}
conference->exit_sound = switch_core_strdup(conference->pool, argv[3]);
stream->write_function(stream, "OK %s exit sound file set to %s\n", argv[0], conference->exit_sound);
if (test_eflag(conference, EFLAG_LOCK) && switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
- conference_add_event_data(conference, event);
+ conf_event_add_data(conference, event);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "exit-sound-file-changed");
switch_event_fire(&event);
}
}
if ( !strcasecmp(argv[2], "on") ) {
- conference_set_flag_locked(conference, CFLAG_ENTER_SOUND);
+ conf_utils_set_flag_locked(conference, CFLAG_ENTER_SOUND);
stream->write_function(stream, "OK %s enter sounds on (%s)\n", argv[0], conference->enter_sound);
if (test_eflag(conference, EFLAG_LOCK) && switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
- conference_add_event_data(conference, event);
+ conf_event_add_data(conference, event);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "enter-sounds-on");
switch_event_fire(&event);
}
} else if ( !strcasecmp(argv[2], "off") || !strcasecmp(argv[2], "none") ) {
- conference_clear_flag_locked(conference, CFLAG_ENTER_SOUND);
+ conf_utils_clear_flag_locked(conference, CFLAG_ENTER_SOUND);
stream->write_function(stream, "OK %s enter sounds off (%s)\n", argv[0], conference->enter_sound);
if (test_eflag(conference, EFLAG_LOCK) && switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
- conference_add_event_data(conference, event);
+ conf_event_add_data(conference, event);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "enter-sounds-off");
switch_event_fire(&event);
}
conference->enter_sound = switch_core_strdup(conference->pool, argv[3]);
stream->write_function(stream, "OK %s enter sound file set to %s\n", argv[0], conference->enter_sound);
if (test_eflag(conference, EFLAG_LOCK) && switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
- conference_add_event_data(conference, event);
+ conf_event_add_data(conference, event);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "enter-sound-file-changed");
switch_event_fire(&event);
}
}
if (conference) {
- conference_outcall(conference, NULL, NULL, argv[2], 60, NULL, argv[4], argv[3], NULL, &cause, NULL, NULL);
+ conf_outcall(conference, NULL, NULL, argv[2], 60, NULL, argv[4], argv[3], NULL, &cause, NULL, NULL);
} else {
- conference_outcall(NULL, argv[0], NULL, argv[2], 60, NULL, argv[4], argv[3], NULL, &cause, NULL, NULL);
+ conf_outcall(NULL, argv[0], NULL, argv[2], 60, NULL, argv[4], argv[3], NULL, &cause, NULL, NULL);
}
stream->write_function(stream, "Call Requested: result: [%s]\n", switch_channel_cause2str(cause));
switch_uuid_format(uuid_str, &uuid);
if (conference) {
- conference_outcall_bg(conference, NULL, NULL, argv[2], 60, NULL, argv[4], argv[3], uuid_str, NULL, NULL, NULL);
+ conf_outcall_bg(conference, NULL, NULL, argv[2], 60, NULL, argv[4], argv[3], uuid_str, NULL, NULL, NULL);
} else {
- conference_outcall_bg(NULL, argv[0], NULL, argv[2], 60, NULL, argv[4], argv[3], uuid_str, NULL, NULL, NULL);
+ conf_outcall_bg(NULL, argv[0], NULL, argv[2], 60, NULL, argv[4], argv[3], uuid_str, NULL, NULL, NULL);
}
stream->write_function(stream, "OK Job-UUID: %s\n", uuid_str);
}
for (x = 3; x < argc; x++) {
- conference_member_t *member = NULL;
+ conf_member_t *member = NULL;
uint32_t id = atoi(argv[x]);
switch_channel_t *channel;
switch_event_t *event;
char *xdest = NULL;
- if (!id || !(member = conference_member_get(conference, id))) {
+ if (!id || !(member = conf_member_get(conference, id))) {
stream->write_function(stream, "No Member %u in conference %s.\n", id, conference->name);
continue;
}
/* tell them what happened */
if (test_eflag(conference, EFLAG_TRANSFER) &&
switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
- conference_add_event_member_data(member, event);
+ conf_member_add_event_data(member, event);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Old-Conference-Name", conference->name);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "New-Conference-Name", argv[3]);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "transfer");
switch_status_t conf_api_sub_check_record(conference_obj_t *conference, switch_stream_handle_t *stream, int arc, char **argv)
{
- conference_record_t *rec;
+ conf_record_t *rec;
int x = 0;
switch_mutex_lock(conference->flag_mutex);
stream->write_function(stream, "Record file %s\n", argv[2]);
conference->record_filename = switch_core_strdup(conference->pool, argv[2]);
conference->record_count++;
- launch_conference_record_thread(conference, argv[2], SWITCH_FALSE);
+ conf_record_launch_thread(conference, argv[2], SWITCH_FALSE);
return SWITCH_STATUS_SUCCESS;
}
all = (strcasecmp(argv[2], "all") == 0);
- if (!conference_record_stop(conference, stream, all ? NULL : argv[2]) && !all) {
+ if (!conf_record_stop(conference, stream, all ? NULL : argv[2]) && !all) {
stream->write_function(stream, "non-existant recording '%s'\n", argv[2]);
} else {
if (test_eflag(conference, EFLAG_RECORD) &&
switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
- conference_add_event_data(conference, event);
+ conf_event_add_data(conference, event);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "stop-recording");
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Path", all ? "all" : argv[2]);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Other-Recordings", conference->record_count ? "true" : "false");
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s recording file %s\n",
action == REC_ACTION_PAUSE ? "Pause" : "Resume", argv[2]);
- if (!conference_record_action(conference, argv[2], action)) {
+ if (!conf_record_action(conference, argv[2], action)) {
stream->write_function(stream, "non-existant recording '%s'\n", argv[2]);
} else {
if (test_eflag(conference, EFLAG_RECORD) && switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS)
{
- conference_add_event_data(conference, event);
+ conf_event_add_data(conference, event);
if (action == REC_ACTION_PAUSE) {
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "pause-recording");
} else {
conference->caller_id_number);
} else if (strcasecmp(argv[2], "is_locked") == 0) {
stream->write_function(stream, "%s",
- conference_test_flag(conference, CFLAG_LOCKED) ? "locked" : "");
+ conf_utils_test_flag(conference, CFLAG_LOCKED) ? "locked" : "");
} else if (strcasecmp(argv[2], "endconf_grace_time") == 0) {
stream->write_function(stream, "%d",
conference->endconf_grace_time);
conference->uuid_str);
} else if (strcasecmp(argv[2], "wait_mod") == 0) {
stream->write_function(stream, "%s",
- conference_test_flag(conference, CFLAG_WAIT_MOD) ? "true" : "");
+ conf_utils_test_flag(conference, CFLAG_WAIT_MOD) ? "true" : "");
} else {
ret_status = SWITCH_STATUS_FALSE;
}
switch_assert(x_conferences);
if (conference == NULL) {
- switch_mutex_lock(mod_conference_globals.hash_mutex);
- for (hi = switch_core_hash_first(mod_conference_globals.conference_hash); hi; hi = switch_core_hash_next(&hi)) {
+ switch_mutex_lock(conf_globals.hash_mutex);
+ for (hi = switch_core_hash_first(conf_globals.conference_hash); hi; hi = switch_core_hash_next(&hi)) {
switch_core_hash_this(hi, NULL, NULL, &val);
conference = (conference_obj_t *) val;
switch_assert(conference);
count++;
- conference_xlist(conference, x_conference, off);
+ conf_xlist(conference, x_conference, off);
}
- switch_mutex_unlock(mod_conference_globals.hash_mutex);
+ switch_mutex_unlock(conf_globals.hash_mutex);
} else {
x_conference = switch_xml_add_child_d(x_conferences, "conference", off++);
switch_assert(conference);
count++;
- conference_xlist(conference, x_conference, off);
+ conf_xlist(conference, x_conference, off);
}
}
if (all || non_mod) {
- conference_member_itterator(conference, stream, non_mod, (conf_api_member_cmd_t) conf_api_sub_commands[i].pfnapicmd, argv[argn + 2]);
+ conf_member_itterator(conference, stream, non_mod, (conf_api_member_cmd_t) conf_api_sub_commands[i].pfnapicmd, argv[argn + 2]);
} else if (last) {
- conference_member_t *member = NULL;
- conference_member_t *last_member = NULL;
+ conf_member_t *member = NULL;
+ conf_member_t *last_member = NULL;
switch_mutex_lock(conference->member_mutex);
}
/* exec functio on last (oldest) member */
- if (last_member != NULL && last_member->session && !member_test_flag(last_member, MFLAG_NOCHANNEL)) {
+ if (last_member != NULL && last_member->session && !conf_utils_member_test_flag(last_member, MFLAG_NOCHANNEL)) {
conf_api_member_cmd_t pfn = (conf_api_member_cmd_t) conf_api_sub_commands[i].pfnapicmd;
pfn(last_member, stream, argv[argn + 2]);
}
switch_mutex_unlock(conference->member_mutex);
} else if (id) {
conf_api_member_cmd_t pfn = (conf_api_member_cmd_t) conf_api_sub_commands[i].pfnapicmd;
- conference_member_t *member = conference_member_get(conference, id);
+ conf_member_t *member = conf_member_get(conference, id);
if (member != NULL) {
pfn(member, stream, argv[argn + 2]);
#include <mod_conference.h>
-inline switch_bool_t cdr_test_mflag(conference_cdr_node_t *np, member_flag_t mflag)
+inline switch_bool_t conf_cdr_test_mflag(conf_cdr_node_t *np, member_flag_t mflag)
{
return !!np->mflags[mflag];
}
-const char *audio_flow(conference_member_t *member)
+const char *conf_cdr_audio_flow(conf_member_t *member)
{
const char *flow = "sendrecv";
- if (!member_test_flag(member, MFLAG_CAN_SPEAK)) {
+ if (!conf_utils_member_test_flag(member, MFLAG_CAN_SPEAK)) {
flow = "recvonly";
}
if (member->channel && switch_channel_test_flag(member->channel, CF_HOLD)) {
- flow = member_test_flag(member, MFLAG_CAN_SPEAK) ? "sendonly" : "inactive";
+ flow = conf_utils_member_test_flag(member, MFLAG_CAN_SPEAK) ? "sendonly" : "inactive";
}
return flow;
}
-char *conference_rfc4579_render(conference_obj_t *conference, switch_event_t *event, switch_event_t *revent)
+char *conf_cdr_rfc4579_render(conference_obj_t *conference, switch_event_t *event, switch_event_t *revent)
{
switch_xml_t xml, x_tag, x_tag1, x_tag2, x_tag3, x_tag4;
char tmp[30];
char *dup_domain = NULL;
char *uri;
int off = 0, off1 = 0, off2 = 0, off3 = 0, off4 = 0;
- conference_cdr_node_t *np;
+ conf_cdr_node_t *np;
char *tmpp = tmp;
char *xml_text = NULL;
if (!(x_tag4 = switch_xml_add_child_d(x_tag3, "status", off4++))) {
abort();
}
- switch_xml_set_txt_d(x_tag4, audio_flow(np->member));
+ switch_xml_set_txt_d(x_tag4, conf_cdr_audio_flow(np->member));
if (switch_channel_test_flag(channel, CF_VIDEO)) {
}
-cJSON *conference_json_render(conference_obj_t *conference, cJSON *req)
+cJSON *conf_cdr_json_render(conference_obj_t *conference, cJSON *req)
{
char tmp[30];
const char *domain; const char *name;
char *dup_domain = NULL;
char *uri;
- conference_cdr_node_t *np;
+ conf_cdr_node_t *np;
char *tmpp = tmp;
cJSON *json = cJSON_CreateObject(), *jusers = NULL, *jold_users = NULL, *juser = NULL, *jvars = NULL;
json_add_child_string(juser, "rtpAudioSSRC", var);
}
- json_add_child_string(juser, "rtpAudioDirection", audio_flow(np->member));
+ json_add_child_string(juser, "rtpAudioDirection", conf_cdr_audio_flow(np->member));
if (switch_channel_test_flag(channel, CF_VIDEO)) {
return json;
}
-void conference_cdr_del(conference_member_t *member)
+void conf_cdr_del(conf_member_t *member)
{
if (member->channel) {
switch_channel_get_variables(member->channel, &member->cdr_node->var_event);
}
}
-void conference_cdr_add(conference_member_t *member)
+void conf_cdr_add(conf_member_t *member)
{
- conference_cdr_node_t *np;
+ conf_cdr_node_t *np;
switch_caller_profile_t *cp;
switch_channel_t *channel;
}
-void conference_cdr_rejected(conference_obj_t *conference, switch_channel_t *channel, cdr_reject_reason_t reason)
+void conf_cdr_rejected(conference_obj_t *conference, switch_channel_t *channel, cdr_reject_reason_t reason)
{
- conference_cdr_reject_t *rp;
+ conf_cdr_reject_t *rp;
switch_caller_profile_t *cp;
rp = switch_core_alloc(conference->pool, sizeof(*rp));
rp->cp = switch_caller_profile_dup(conference->pool, cp);
}
-void conference_cdr_render(conference_obj_t *conference)
+void conf_cdr_render(conference_obj_t *conference)
{
switch_xml_t cdr, x_ptr, x_member, x_members, x_conference, x_cp, x_flags, x_tag, x_rejected, x_attempt;
- conference_cdr_node_t *np;
- conference_cdr_reject_t *rp;
+ conf_cdr_node_t *np;
+ conf_cdr_reject_t *rp;
int cdr_off = 0, conf_off = 0;
char str[512];
char *path = NULL, *xml_text;
if (!(x_ptr = switch_xml_add_child_d(x_conference, "end_time", conf_off++))) {
abort();
}
- switch_xml_set_attr_d(x_ptr, "endconf_forced", conference_test_flag(conference, CFLAG_ENDCONF_FORCED) ? "true" : "false");
+ switch_xml_set_attr_d(x_ptr, "endconf_forced", conf_utils_test_flag(conference, CFLAG_ENDCONF_FORCED) ? "true" : "false");
switch_xml_set_attr_d(x_ptr, "type", "UNIX-epoch");
switch_snprintf(str, sizeof(str), "%ld", (long)conference->end_time);
switch_xml_set_txt_d(x_ptr, str);
switch_assert(x_flags);
x_tag = switch_xml_add_child_d(x_flags, "is_moderator", flag_off++);
- switch_xml_set_txt_d(x_tag, cdr_test_mflag(np, MFLAG_MOD) ? "true" : "false");
+ switch_xml_set_txt_d(x_tag, conf_cdr_test_mflag(np, MFLAG_MOD) ? "true" : "false");
x_tag = switch_xml_add_child_d(x_flags, "end_conference", flag_off++);
- switch_xml_set_txt_d(x_tag, cdr_test_mflag(np, MFLAG_ENDCONF) ? "true" : "false");
+ switch_xml_set_txt_d(x_tag, conf_cdr_test_mflag(np, MFLAG_ENDCONF) ? "true" : "false");
x_tag = switch_xml_add_child_d(x_flags, "was_kicked", flag_off++);
- switch_xml_set_txt_d(x_tag, cdr_test_mflag(np, MFLAG_KICKED) ? "true" : "false");
+ switch_xml_set_txt_d(x_tag, conf_cdr_test_mflag(np, MFLAG_KICKED) ? "true" : "false");
x_tag = switch_xml_add_child_d(x_flags, "is_ghost", flag_off++);
- switch_xml_set_txt_d(x_tag, cdr_test_mflag(np, MFLAG_GHOST) ? "true" : "false");
+ switch_xml_set_txt_d(x_tag, conf_cdr_test_mflag(np, MFLAG_GHOST) ? "true" : "false");
if (!(x_cp = switch_xml_add_child_d(x_member, "caller_profile", member_off++))) {
abort();
#include <mod_conference.h>
-void conference_mod_event_channel_handler(const char *event_channel, cJSON *json, const char *key, switch_event_channel_id_t id)
+void conf_event_mod_channel_handler(const char *event_channel, cJSON *json, const char *key, switch_event_channel_id_t id)
{
cJSON *data, *addobj = NULL;
const char *action = NULL;
exec = switch_mprintf("%s %s %s %s", conf_name, action, argv[0], argv[1]);
} else if (!strcasecmp(action, "transfer") && cid) {
- conference_member_t *member;
+ conf_member_t *member;
conference_obj_t *conference;
exec = switch_mprintf("%s %s %s", argv[0], switch_str_nil(argv[1]), switch_str_nil(argv[2]));
stream.write_function(&stream, "+OK Call transferred to %s", argv[0]);
- if ((conference = conference_find(conf_name, NULL))) {
- if ((member = conference_member_get(conference, cid))) {
+ if ((conference = conf_find(conf_name, NULL))) {
+ if ((member = conf_member_get(conference, cid))) {
switch_ivr_session_transfer(member->session, argv[0], argv[1], argv[2]);
switch_thread_rwlock_unlock(member->rwlock);
}
const void *vvar;
cJSON *array = cJSON_CreateArray();
conference_obj_t *conference = NULL;
- if ((conference = conference_find(conf_name, NULL))) {
- switch_mutex_lock(mod_conference_globals.setup_mutex);
+ if ((conference = conf_find(conf_name, NULL))) {
+ switch_mutex_lock(conf_globals.setup_mutex);
if (conference->layout_hash) {
for (hi = switch_core_hash_first(conference->layout_hash); hi; hi = switch_core_hash_next(&hi)) {
switch_core_hash_this(hi, &vvar, NULL, &val);
}
}
- switch_mutex_unlock(mod_conference_globals.setup_mutex);
+ switch_mutex_unlock(conf_globals.setup_mutex);
switch_thread_rwlock_unlock(conference->rwlock);
}
addobj = array;
cJSON_AddItemToObject(jdata, "error", cJSON_CreateString("Invalid Command"));
}
- switch_event_channel_broadcast(event_channel, &msg, __FILE__, mod_conference_globals.event_channel_id);
+ switch_event_channel_broadcast(event_channel, &msg, __FILE__, conf_globals.event_channel_id);
switch_safe_free(stream.data);
}
-void conference_la_event_channel_handler(const char *event_channel, cJSON *json, const char *key, switch_event_channel_id_t id)
+void conf_event_la_channel_handler(const char *event_channel, cJSON *json, const char *key, switch_event_channel_id_t id)
{
- switch_live_array_parse_json(json, mod_conference_globals.event_channel_id);
+ switch_live_array_parse_json(json, conf_globals.event_channel_id);
}
-void conference_event_channel_handler(const char *event_channel, cJSON *json, const char *key, switch_event_channel_id_t id)
+void conf_event_channel_handler(const char *event_channel, cJSON *json, const char *key, switch_event_channel_id_t id)
{
char *domain = NULL, *name = NULL;
conference_obj_t *conference = NULL;
}
if (!strcasecmp(action, "bootstrap")) {
- if (!zstr(name) && (conference = conference_find(name, domain))) {
- conf_desc = conference_json_render(conference, json);
+ if (!zstr(name) && (conference = conf_find(name, domain))) {
+ conf_desc = conf_cdr_json_render(conference, json);
} else {
conf_desc = cJSON_CreateObject();
json_add_child_string(conf_desc, "conferenceDescription", "FreeSWITCH Conference");
switch_safe_free(dup);
- switch_event_channel_broadcast(event_channel, &reply, "mod_conference", mod_conference_globals.event_channel_id);
+ switch_event_channel_broadcast(event_channel, &reply, "mod_conference", conf_globals.event_channel_id);
}
-void send_json_event(conference_obj_t *conference)
+void conf_event_send_json(conference_obj_t *conference)
{
cJSON *event, *conf_desc = NULL;
char *name = NULL, *domain = NULL, *dup_domain = NULL;
char *event_channel = NULL;
- if (!conference_test_flag(conference, CFLAG_JSON_EVENTS)) {
+ if (!conf_utils_test_flag(conference, CFLAG_JSON_EVENTS)) {
return;
}
- conf_desc = conference_json_render(conference, NULL);
+ conf_desc = conf_cdr_json_render(conference, NULL);
if (!(name = conference->name)) {
name = "conference";
json_add_child_string(event, "eventChannel", event_channel);
cJSON_AddItemToObject(event, "data", conf_desc);
- switch_event_channel_broadcast(event_channel, &event, "mod_conference", mod_conference_globals.event_channel_id);
+ switch_event_channel_broadcast(event_channel, &event, "mod_conference", conf_globals.event_channel_id);
switch_safe_free(dup_domain);
switch_safe_free(event_channel);
}
-void conference_command_handler(switch_live_array_t *la, const char *cmd, const char *sessid, cJSON *jla, void *user_data)
+void conf_event_la_command_handler(switch_live_array_t *la, const char *cmd, const char *sessid, cJSON *jla, void *user_data)
{
}
-void member_update_status_field(conference_member_t *member)
-{
- char *str, *vstr = "", display[128] = "", *json_display = NULL;
- cJSON *json, *audio, *video;
-
- if (!member->conference->la || !member->json ||
- !member->status_field || switch_channel_test_flag(member->channel, CF_VIDEO_ONLY) || member_test_flag(member, MFLAG_SECOND_SCREEN)) {
- return;
- }
-
- switch_live_array_lock(member->conference->la);
-
- if (conference_test_flag(member->conference, CFLAG_JSON_STATUS)) {
- json = cJSON_CreateObject();
- audio = cJSON_CreateObject();
- cJSON_AddItemToObject(audio, "muted", cJSON_CreateBool(!member_test_flag(member, MFLAG_CAN_SPEAK)));
- cJSON_AddItemToObject(audio, "onHold", cJSON_CreateBool(switch_channel_test_flag(member->channel, CF_HOLD)));
- cJSON_AddItemToObject(audio, "talking", cJSON_CreateBool(member_test_flag(member, MFLAG_TALKING)));
- cJSON_AddItemToObject(audio, "floor", cJSON_CreateBool(member == member->conference->floor_holder));
- cJSON_AddItemToObject(audio, "energyScore", cJSON_CreateNumber(member->score));
- cJSON_AddItemToObject(json, "audio", audio);
-
- if (switch_channel_test_flag(member->channel, CF_VIDEO) || member->avatar_png_img) {
- video = cJSON_CreateObject();
- cJSON_AddItemToObject(video, "avatarPresented", cJSON_CreateBool(!!member->avatar_png_img));
- cJSON_AddItemToObject(video, "mediaFlow", cJSON_CreateString(member->video_flow == SWITCH_MEDIA_FLOW_SENDONLY ? "sendOnly" : "sendRecv"));
- cJSON_AddItemToObject(video, "muted", cJSON_CreateBool(!member_test_flag(member, MFLAG_CAN_BE_SEEN)));
- cJSON_AddItemToObject(video, "floor", cJSON_CreateBool(member && member->id == member->conference->video_floor_holder));
- if (member && member->id == member->conference->video_floor_holder && conference_test_flag(member->conference, CFLAG_VID_FLOOR_LOCK)) {
- cJSON_AddItemToObject(video, "floorLocked", cJSON_CreateTrue());
- }
- cJSON_AddItemToObject(video, "reservationID", member->video_reservation_id ?
- cJSON_CreateString(member->video_reservation_id) : cJSON_CreateNull());
-
- cJSON_AddItemToObject(video, "videoLayerID", cJSON_CreateNumber(member->video_layer_id));
-
- cJSON_AddItemToObject(json, "video", video);
- } else {
- cJSON_AddItemToObject(json, "video", cJSON_CreateFalse());
- }
-
- json_display = cJSON_PrintUnformatted(json);
- cJSON_Delete(json);
- } else {
- if (!member_test_flag(member, MFLAG_CAN_SPEAK)) {
- str = "MUTE";
- } else if (switch_channel_test_flag(member->channel, CF_HOLD)) {
- str = "HOLD";
- } else if (member == member->conference->floor_holder) {
- if (member_test_flag(member, MFLAG_TALKING)) {
- str = "TALKING (FLOOR)";
- } else {
- str = "FLOOR";
- }
- } else if (member_test_flag(member, MFLAG_TALKING)) {
- str = "TALKING";
- } else {
- str = "ACTIVE";
- }
-
- if (switch_channel_test_flag(member->channel, CF_VIDEO)) {
- if (!member_test_flag(member, MFLAG_CAN_BE_SEEN)) {
- vstr = " VIDEO (BLIND)";
- } else {
- vstr = " VIDEO";
- if (member && member->id == member->conference->video_floor_holder) {
- vstr = " VIDEO (FLOOR)";
- }
- }
- }
-
- switch_snprintf(display, sizeof(display), "%s%s", str, vstr);
- }
-
- if (json_display) {
- member->status_field->valuestring = json_display;
- } else {
- free(member->status_field->valuestring);
- member->status_field->valuestring = strdup(display);
- }
-
- switch_live_array_add(member->conference->la, switch_core_session_get_uuid(member->session), -1, &member->json, SWITCH_FALSE);
- switch_live_array_unlock(member->conference->la);
-}
-
-void adv_la(conference_obj_t *conference, conference_member_t *member, switch_bool_t join)
+void conf_event_adv_la(conference_obj_t *conference, conf_member_t *member, switch_bool_t join)
{
//if (member->video_flow == SWITCH_MEDIA_FLOW_SENDONLY) {
cJSON_AddItemToObject(data, "action", cJSON_CreateString(join ? "conference-liveArray-join" : "conference-liveArray-part"));
cJSON_AddItemToObject(data, "laChannel", cJSON_CreateString(conference->la_event_channel));
cJSON_AddItemToObject(data, "laName", cJSON_CreateString(conference->la_name));
- cJSON_AddItemToObject(data, "role", cJSON_CreateString(member_test_flag(member, MFLAG_MOD) ? "moderator" : "participant"));
+ cJSON_AddItemToObject(data, "role", cJSON_CreateString(conf_utils_member_test_flag(member, MFLAG_MOD) ? "moderator" : "participant"));
cJSON_AddItemToObject(data, "chatID", cJSON_CreateString(conference->chat_id));
cJSON_AddItemToObject(data, "canvasCount", cJSON_CreateNumber(conference->canvas_count));
- if (member_test_flag(member, MFLAG_SECOND_SCREEN)) {
+ if (conf_utils_member_test_flag(member, MFLAG_SECOND_SCREEN)) {
cJSON_AddItemToObject(data, "secondScreen", cJSON_CreateTrue());
}
- if (member_test_flag(member, MFLAG_MOD)) {
+ if (conf_utils_member_test_flag(member, MFLAG_MOD)) {
cJSON_AddItemToObject(data, "modChannel", cJSON_CreateString(conference->mod_event_channel));
}
}
switch_event_destroy(&variables);
- switch_event_channel_broadcast(event_channel, &msg, "mod_conference", mod_conference_globals.event_channel_id);
+ switch_event_channel_broadcast(event_channel, &msg, "mod_conference", conf_globals.event_channel_id);
if (cookie) {
switch_event_channel_permission_modify(cookie, conference->la_event_channel, join);
}
}
-void send_rfc_event(conference_obj_t *conference)
+void conf_event_send_rfc(conference_obj_t *conference)
{
switch_event_t *event;
char *body;
char *name = NULL, *domain = NULL, *dup_domain = NULL;
- if (!conference_test_flag(conference, CFLAG_RFC4579)) {
+ if (!conf_utils_test_flag(conference, CFLAG_RFC4579)) {
return;
}
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "conference-name", name);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "conference-domain", domain);
- body = conference_rfc4579_render(conference, NULL, event);
+ body = conf_cdr_rfc4579_render(conference, NULL, event);
switch_event_add_body(event, "%s", body);
free(body);
switch_event_fire(&event);
}
-switch_status_t conference_add_event_data(conference_obj_t *conference, switch_event_t *event)
+switch_status_t conf_event_add_data(conference_obj_t *conference, switch_event_t *event)
{
switch_status_t status = SWITCH_STATUS_SUCCESS;
return status;
}
-switch_status_t conference_add_event_member_data(conference_member_t *member, switch_event_t *event)
-{
- switch_status_t status = SWITCH_STATUS_SUCCESS;
-
- if (!member)
- return status;
-
- if (member->conference) {
- status = conference_add_event_data(member->conference, event);
- switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Floor", "%s", (member == member->conference->floor_holder) ? "true" : "false" );
- }
-
- if (member->session) {
- switch_channel_t *channel = switch_core_session_get_channel(member->session);
-
- if (member->verbose_events) {
- switch_channel_event_set_data(channel, event);
- } else {
- switch_channel_event_set_basic_data(channel, event);
- }
- switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Video", "%s",
- switch_channel_test_flag(switch_core_session_get_channel(member->session), CF_VIDEO) ? "true" : "false" );
-
- }
-
- switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Hear", "%s", member_test_flag(member, MFLAG_CAN_HEAR) ? "true" : "false" );
- switch_event_add_header(event, SWITCH_STACK_BOTTOM, "See", "%s", member_test_flag(member, MFLAG_CAN_BE_SEEN) ? "true" : "false" );
- switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Speak", "%s", member_test_flag(member, MFLAG_CAN_SPEAK) ? "true" : "false" );
- switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Talking", "%s", member_test_flag(member, MFLAG_TALKING) ? "true" : "false" );
- switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Mute-Detect", "%s", member_test_flag(member, MFLAG_MUTE_DETECT) ? "true" : "false" );
- switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Member-ID", "%u", member->id);
- switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Member-Type", "%s", member_test_flag(member, MFLAG_MOD) ? "moderator" : "member");
- switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Member-Ghost", "%s", member_test_flag(member, MFLAG_GHOST) ? "true" : "false");
- switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Energy-Level", "%d", member->energy_level);
- switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Current-Energy", "%d", member->score);
-
- return status;
-}
-
/* send a message to every member of the conference */
-void chat_message_broadcast(conference_obj_t *conference, switch_event_t *event)
+void conf_event_chat_message_broadcast(conference_obj_t *conference, switch_event_t *event)
{
- conference_member_t *member = NULL;
+ conf_member_t *member = NULL;
switch_event_t *processed;
switch_assert(conference != NULL);
switch_mutex_lock(conference->member_mutex);
for (member = conference->members; member; member = member->next) {
- if (member->session && !member_test_flag(member, MFLAG_NOCHANNEL)) {
+ if (member->session && !conf_utils_member_test_flag(member, MFLAG_NOCHANNEL)) {
const char *presence_id = switch_channel_get_variable(member->channel, "presence_id");
const char *chat_proto = switch_channel_get_variable(member->channel, "chat_proto");
switch_event_t *reply = NULL;
switch_mutex_unlock(conference->member_mutex);
}
-void call_setup_event_handler(switch_event_t *event)
+void conf_event_call_setup_handler(switch_event_t *event)
{
switch_status_t status = SWITCH_STATUS_FALSE;
conference_obj_t *conference = NULL;
if (!ext) ext = dial_str;
- if (!zstr(conf) && !zstr(dial_str) && !zstr(action) && (conference = conference_find(conf, domain))) {
+ if (!zstr(conf) && !zstr(dial_str) && !zstr(action) && (conference = conf_find(conf, domain))) {
switch_event_t *var_event;
switch_event_header_t *hp;
- if (conference_test_flag(conference, CFLAG_RFC4579)) {
+ if (conf_utils_test_flag(conference, CFLAG_RFC4579)) {
char *key = switch_mprintf("conf_%s_%s_%s_%s", conference->name, conference->domain, ext, ext_domain);
char *expanded = NULL, *ostr = dial_str;;
}
}
- status = conference_outcall_bg(conference, NULL, NULL, ostr, 60, NULL, NULL, NULL, NULL, NULL, NULL, &var_event);
+ status = conf_outcall_bg(conference, NULL, NULL, ostr, 60, NULL, NULL, NULL, NULL, NULL, NULL, &var_event);
if (expanded && expanded != conference->outcall_templ) {
switch_safe_free(expanded);
} else if (!strcasecmp(action, "end")) {
if (switch_core_session_hupall_matching_var("conference_call_key", key, SWITCH_CAUSE_NORMAL_CLEARING)) {
- send_conference_notify(conference, "SIP/2.0 200 OK\r\n", call_id, SWITCH_TRUE);
+ conf_send_notify(conference, "SIP/2.0 200 OK\r\n", call_id, SWITCH_TRUE);
} else {
- send_conference_notify(conference, "SIP/2.0 481 Failure\r\n", call_id, SWITCH_TRUE);
+ conf_send_notify(conference, "SIP/2.0 481 Failure\r\n", call_id, SWITCH_TRUE);
}
status = SWITCH_STATUS_SUCCESS;
}
conference_obj_t *conference = NULL;
char *body = NULL;
- if (!zstr(name) && (conference = conference_find(name, domain))) {
- if (conference_test_flag(conference, CFLAG_RFC4579)) {
+ if (!zstr(name) && (conference = conf_find(name, domain))) {
+ if (conf_utils_test_flag(conference, CFLAG_RFC4579)) {
switch_event_dup(&revent, event);
revent->event_id = SWITCH_EVENT_CONFERENCE_DATA;
revent->flags |= EF_UNIQ_HEADERS;
switch_event_add_header(revent, SWITCH_STACK_TOP, "Event-Name", "CONFERENCE_DATA");
- body = conference_rfc4579_render(conference, event, revent);
+ body = conf_cdr_rfc4579_render(conference, event, revent);
switch_event_add_body(revent, "%s", body);
switch_event_fire(&revent);
switch_safe_free(body);
}
-void pres_event_handler(switch_event_t *event)
+void conf_event_pres_handler(switch_event_t *event)
{
char *to = switch_event_get_header(event, "to");
char *domain_name = NULL;
dup_conf_name = switch_mprintf("%q@%q", conf_name, domain_name);
- if ((conference = conference_find(conf_name, NULL)) || (conference = conference_find(dup_conf_name, NULL))) {
+ if ((conference = conf_find(conf_name, NULL)) || (conference = conf_find(dup_conf_name, NULL))) {
if (switch_event_create(&event, SWITCH_EVENT_PRESENCE_IN) == SWITCH_STATUS_SUCCESS) {
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "proto", CONF_CHAT_PROTO);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "login", conference->name);
switch_copy_string(name, to, sizeof(name));
}
- if (!(conference = conference_find(name, NULL))) {
+ if (!(conference = conf_find(name, NULL))) {
switch_core_chat_send_args(proto, CONF_CHAT_PROTO, to, hint && strchr(hint, '/') ? hint : from, "",
"Conference not active.", NULL, NULL, SWITCH_FALSE);
return SWITCH_STATUS_FALSE;
if (body != NULL && (lbuf = strdup(body))) {
/* special case list */
if (conference->broadcast_chat_messages) {
- chat_message_broadcast(conference, message_event);
+ conf_event_chat_message_broadcast(conference, message_event);
} else if (switch_stristr("list", lbuf)) {
- conference_list_pretty(conference, &stream);
+ conf_list_pretty(conference, &stream);
/* provide help */
} else {
return SWITCH_STATUS_SUCCESS;
switch_status_t conference_file_close(conference_obj_t *conference, conference_file_node_t *node)
{
switch_event_t *event;
- conference_member_t *member = NULL;
+ conf_member_t *member = NULL;
if (test_eflag(conference, EFLAG_PLAY_FILE_DONE) &&
switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
- conference_add_event_data(conference, event);
+ conf_event_add_data(conference, event);
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "seconds", "%ld", (long) node->fh.samples_in / node->fh.native_rate);
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "milliseconds", "%ld", (long) node->fh.samples_in / (node->fh.native_rate / 1000));
if (node->member_id) {
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "play-file-member-done");
- if ((member = conference_member_get(conference, node->member_id))) {
- conference_add_event_member_data(member, event);
+ if ((member = conf_member_get(conference, node->member_id))) {
+ conf_member_add_event_data(member, event);
switch_thread_rwlock_unlock(member->rwlock);
}
#ifdef OPENAL_POSITIONING
if (node->al && node->al->device) {
- close_al(node->al);
+ conf_al_close(node->al);
}
#endif
if (switch_core_file_has_video(&node->fh) && conference->canvas) {
/* Make files stop playing in a conference either the current one or all of them */
-uint32_t conference_stop_file(conference_obj_t *conference, file_stop_t stop)
+uint32_t conference_file_stop(conference_obj_t *conference, file_stop_t stop)
{
uint32_t count = 0;
conference_file_node_t *nptr;
}
/* Play a file in the conference room */
-switch_status_t conference_play_file(conference_obj_t *conference, char *file, uint32_t leadin, switch_channel_t *channel, uint8_t async)
+switch_status_t conference_file_play(conference_obj_t *conference, char *file, uint32_t leadin, switch_channel_t *channel, uint8_t async)
{
switch_status_t status = SWITCH_STATUS_SUCCESS;
conference_file_node_t *fnode, *nptr = NULL;
}
if (!async && say) {
- status = conference_say(conference, file + 4, leadin);
+ status = conf_say(conference, file + 4, leadin);
goto done;
}
switch_safe_free(params_portion);
} else if (!async) {
- status = conference_say(conference, file, leadin);
+ status = conf_say(conference, file, leadin);
goto done;
} else {
goto done;
flags = SWITCH_FILE_FLAG_READ | SWITCH_FILE_DATA_SHORT;
- if (conference->members_with_video && conference_test_flag(conference, CFLAG_TRANSCODE_VIDEO)) {
+ if (conference->members_with_video && conf_utils_test_flag(conference, CFLAG_TRANSCODE_VIDEO)) {
flags |= SWITCH_FILE_FLAG_VIDEO;
}
if (test_eflag(conference, EFLAG_PLAY_FILE) &&
switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
- conference_add_event_data(conference, event);
+ conf_event_add_data(conference, event);
if (fnode->fh.params) {
switch_event_merge(event, conference->fnode->fh.params);
}
if (!bad_params && !zstr(position) && conference->channels == 2) {
- fnode->al = create_al(pool);
- if (parse_position(fnode->al, position) != SWITCH_STATUS_SUCCESS) {
+ fnode->al = conf_al_create(pool);
+ if (conf_al_parse_position(fnode->al, position) != SWITCH_STATUS_SUCCESS) {
switch_core_file_close(&fnode->fh);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invalid Position Data.\n");
fnode->al = NULL;
fnode->file = switch_core_strdup(fnode->pool, file);
if (!conference->fnode || (async && !conference->async_fnode)) {
- fnode_check_video(fnode);
+ conf_video_fnode_check(fnode);
}
/* Queue the node */
}
/* Play a file */
-switch_status_t conference_local_play_file(conference_obj_t *conference, switch_core_session_t *session, char *path, uint32_t leadin, void *buf,
+switch_status_t conference_file_local_play(conference_obj_t *conference, switch_core_session_t *session, char *path, uint32_t leadin, void *buf,
uint32_t buflen)
{
uint32_t x = 0;
#include <mod_conference.h>
struct _mapping control_mappings[] = {
- {"mute", conference_loop_fn_mute_toggle},
- {"mute on", conference_loop_fn_mute_on},
- {"mute off", conference_loop_fn_mute_off},
- {"vmute", conference_loop_fn_vmute_toggle},
- {"vmute on", conference_loop_fn_vmute_on},
- {"vmute off", conference_loop_fn_vmute_off},
- {"vmute snap", conference_loop_fn_vmute_snap},
- {"vmute snapoff", conference_loop_fn_vmute_snapoff},
- {"deaf mute", conference_loop_fn_deafmute_toggle},
- {"energy up", conference_loop_fn_energy_up},
- {"energy equ", conference_loop_fn_energy_equ_conf},
- {"energy dn", conference_loop_fn_energy_dn},
- {"vol talk up", conference_loop_fn_volume_talk_up},
- {"vol talk zero", conference_loop_fn_volume_talk_zero},
- {"vol talk dn", conference_loop_fn_volume_talk_dn},
- {"vol listen up", conference_loop_fn_volume_listen_up},
- {"vol listen zero", conference_loop_fn_volume_listen_zero},
- {"vol listen dn", conference_loop_fn_volume_listen_dn},
- {"hangup", conference_loop_fn_hangup},
- {"event", conference_loop_fn_event},
- {"lock", conference_loop_fn_lock_toggle},
- {"transfer", conference_loop_fn_transfer},
- {"execute_application", conference_loop_fn_exec_app},
- {"floor", conference_loop_fn_floor_toggle},
- {"vid-floor", conference_loop_fn_vid_floor_toggle},
- {"vid-floor-force", conference_loop_fn_vid_floor_force}
+ {"mute", conf_loop_mute_toggle},
+ {"mute on", conf_loop_mute_on},
+ {"mute off", conf_loop_mute_off},
+ {"vmute", conf_loop_vmute_toggle},
+ {"vmute on", conf_loop_vmute_on},
+ {"vmute off", conf_loop_vmute_off},
+ {"vmute snap", conf_loop_conf_video_vmute_snap},
+ {"vmute snapoff", conf_loop_conf_video_vmute_snapoff},
+ {"deaf mute", conf_loop_deafmute_toggle},
+ {"energy up", conf_loop_energy_up},
+ {"energy equ", conf_loop_energy_equ_conf},
+ {"energy dn", conf_loop_energy_dn},
+ {"vol talk up", conf_loop_volume_talk_up},
+ {"vol talk zero", conf_loop_volume_talk_zero},
+ {"vol talk dn", conf_loop_volume_talk_dn},
+ {"vol listen up", conf_loop_volume_listen_up},
+ {"vol listen zero", conf_loop_volume_listen_zero},
+ {"vol listen dn", conf_loop_volume_listen_dn},
+ {"hangup", conf_loop_hangup},
+ {"event", conf_loop_event},
+ {"lock", conf_loop_lock_toggle},
+ {"transfer", conf_loop_transfer},
+ {"execute_application", conf_loop_exec_app},
+ {"floor", conf_loop_floor_toggle},
+ {"vid-floor", conf_loop_vid_floor_toggle},
+ {"vid-floor-force", conf_loop_vid_floor_force}
};
-#define MAPPING_LEN (sizeof(control_mappings)/sizeof(control_mappings[0]))
+int conf_loop_mapping_len()
+{
+ return (sizeof(control_mappings)/sizeof(control_mappings[0]));
+}
-switch_status_t dmachine_dispatcher(switch_ivr_dmachine_match_t *match)
+switch_status_t conf_loop_dmachine_dispatcher(switch_ivr_dmachine_match_t *match)
{
key_binding_t *binding = match->user_data;
switch_channel_t *channel;
binding->action.expanded_data = NULL;
}
- member_set_flag_locked(binding->member, MFLAG_FLUSH_BUFFER);
+ conf_utils_member_set_flag_locked(binding->member, MFLAG_FLUSH_BUFFER);
return SWITCH_STATUS_SUCCESS;
}
-
-void do_binding(conference_member_t *member, conf_key_callback_t handler, const char *digits, const char *data)
-{
- key_binding_t *binding;
-
- binding = switch_core_alloc(member->pool, sizeof(*binding));
- binding->member = member;
-
- binding->action.binded_dtmf = switch_core_strdup(member->pool, digits);
-
- if (data) {
- binding->action.data = switch_core_strdup(member->pool, data);
- }
-
- binding->handler = handler;
- switch_ivr_dmachine_bind(member->dmachine, "conf", digits, 0, dmachine_dispatcher, binding);
-
-}
-
-void conference_loop_fn_floor_toggle(conference_member_t *member, caller_control_action_t *action)
+void conf_loop_floor_toggle(conf_member_t *member, caller_control_action_t *action)
{
if (member == NULL) return;
conf_api_sub_floor(member, NULL, NULL);
}
-void conference_loop_fn_vid_floor_toggle(conference_member_t *member, caller_control_action_t *action)
+void conf_loop_vid_floor_toggle(conf_member_t *member, caller_control_action_t *action)
{
if (member == NULL) return;
conf_api_sub_vid_floor(member, NULL, NULL);
}
-void conference_loop_fn_vid_floor_force(conference_member_t *member, caller_control_action_t *action)
+void conf_loop_vid_floor_force(conf_member_t *member, caller_control_action_t *action)
{
if (member == NULL) return;
conf_api_sub_vid_floor(member, NULL, "force");
}
-void conference_loop_fn_mute_toggle(conference_member_t *member, caller_control_action_t *action)
+void conf_loop_mute_toggle(conf_member_t *member, caller_control_action_t *action)
{
if (member == NULL)
return;
- if (member_test_flag(member, MFLAG_CAN_SPEAK)) {
+ if (conf_utils_member_test_flag(member, MFLAG_CAN_SPEAK)) {
conf_api_sub_mute(member, NULL, NULL);
} else {
conf_api_sub_unmute(member, NULL, NULL);
- if (!member_test_flag(member, MFLAG_CAN_HEAR)) {
+ if (!conf_utils_member_test_flag(member, MFLAG_CAN_HEAR)) {
conf_api_sub_undeaf(member, NULL, NULL);
}
}
}
-void conference_loop_fn_mute_on(conference_member_t *member, caller_control_action_t *action)
+void conf_loop_mute_on(conf_member_t *member, caller_control_action_t *action)
{
- if (member_test_flag(member, MFLAG_CAN_SPEAK)) {
+ if (conf_utils_member_test_flag(member, MFLAG_CAN_SPEAK)) {
conf_api_sub_mute(member, NULL, NULL);
}
}
-void conference_loop_fn_mute_off(conference_member_t *member, caller_control_action_t *action)
+void conf_loop_mute_off(conf_member_t *member, caller_control_action_t *action)
{
- if (!member_test_flag(member, MFLAG_CAN_SPEAK)) {
+ if (!conf_utils_member_test_flag(member, MFLAG_CAN_SPEAK)) {
conf_api_sub_unmute(member, NULL, NULL);
- if (!member_test_flag(member, MFLAG_CAN_HEAR)) {
+ if (!conf_utils_member_test_flag(member, MFLAG_CAN_HEAR)) {
conf_api_sub_undeaf(member, NULL, NULL);
}
}
}
-void conference_loop_fn_vmute_snap(conference_member_t *member, caller_control_action_t *action)
+void conf_loop_conf_video_vmute_snap(conf_member_t *member, caller_control_action_t *action)
{
- vmute_snap(member, SWITCH_FALSE);
+ conf_video_vmute_snap(member, SWITCH_FALSE);
}
-void conference_loop_fn_vmute_snapoff(conference_member_t *member, caller_control_action_t *action)
+void conf_loop_conf_video_vmute_snapoff(conf_member_t *member, caller_control_action_t *action)
{
- vmute_snap(member, SWITCH_TRUE);
+ conf_video_vmute_snap(member, SWITCH_TRUE);
}
-void conference_loop_fn_vmute_toggle(conference_member_t *member, caller_control_action_t *action)
+void conf_loop_vmute_toggle(conf_member_t *member, caller_control_action_t *action)
{
if (member == NULL)
return;
- if (member_test_flag(member, MFLAG_CAN_BE_SEEN)) {
+ if (conf_utils_member_test_flag(member, MFLAG_CAN_BE_SEEN)) {
conf_api_sub_vmute(member, NULL, NULL);
} else {
conf_api_sub_unvmute(member, NULL, NULL);
}
}
-void conference_loop_fn_vmute_on(conference_member_t *member, caller_control_action_t *action)
+void conf_loop_vmute_on(conf_member_t *member, caller_control_action_t *action)
{
- if (member_test_flag(member, MFLAG_CAN_BE_SEEN)) {
+ if (conf_utils_member_test_flag(member, MFLAG_CAN_BE_SEEN)) {
conf_api_sub_vmute(member, NULL, NULL);
}
}
-void conference_loop_fn_vmute_off(conference_member_t *member, caller_control_action_t *action)
+void conf_loop_vmute_off(conf_member_t *member, caller_control_action_t *action)
{
- if (!member_test_flag(member, MFLAG_CAN_BE_SEEN)) {
+ if (!conf_utils_member_test_flag(member, MFLAG_CAN_BE_SEEN)) {
conf_api_sub_unvmute(member, NULL, NULL);
}
}
-void conference_loop_fn_lock_toggle(conference_member_t *member, caller_control_action_t *action)
+void conf_loop_lock_toggle(conf_member_t *member, caller_control_action_t *action)
{
switch_event_t *event;
if (member == NULL)
return;
- if (conference_test_flag(member->conference, CFLAG_WAIT_MOD) && !member_test_flag(member, MFLAG_MOD) )
+ if (conf_utils_test_flag(member->conference, CFLAG_WAIT_MOD) && !conf_utils_member_test_flag(member, MFLAG_MOD) )
return;
- if (!conference_test_flag(member->conference, CFLAG_LOCKED)) {
+ if (!conf_utils_test_flag(member->conference, CFLAG_LOCKED)) {
if (member->conference->is_locked_sound) {
- conference_play_file(member->conference, member->conference->is_locked_sound, CONF_DEFAULT_LEADIN, NULL, 0);
+ conference_file_play(member->conference, member->conference->is_locked_sound, CONF_DEFAULT_LEADIN, NULL, 0);
}
- conference_set_flag_locked(member->conference, CFLAG_LOCKED);
+ conf_utils_set_flag_locked(member->conference, CFLAG_LOCKED);
if (test_eflag(member->conference, EFLAG_LOCK) &&
switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
- conference_add_event_data(member->conference, event);
+ conf_event_add_data(member->conference, event);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "lock");
switch_event_fire(&event);
}
} else {
if (member->conference->is_unlocked_sound) {
- conference_play_file(member->conference, member->conference->is_unlocked_sound, CONF_DEFAULT_LEADIN, NULL, 0);
+ conference_file_play(member->conference, member->conference->is_unlocked_sound, CONF_DEFAULT_LEADIN, NULL, 0);
}
- conference_clear_flag_locked(member->conference, CFLAG_LOCKED);
+ conf_utils_clear_flag_locked(member->conference, CFLAG_LOCKED);
if (test_eflag(member->conference, EFLAG_UNLOCK) &&
switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
- conference_add_event_data(member->conference, event);
+ conf_event_add_data(member->conference, event);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "unlock");
switch_event_fire(&event);
}
}
-void conference_loop_fn_deafmute_toggle(conference_member_t *member, caller_control_action_t *action)
+void conf_loop_deafmute_toggle(conf_member_t *member, caller_control_action_t *action)
{
if (member == NULL)
return;
- if (member_test_flag(member, MFLAG_CAN_SPEAK)) {
+ if (conf_utils_member_test_flag(member, MFLAG_CAN_SPEAK)) {
conf_api_sub_mute(member, NULL, NULL);
- if (member_test_flag(member, MFLAG_CAN_HEAR)) {
+ if (conf_utils_member_test_flag(member, MFLAG_CAN_HEAR)) {
conf_api_sub_deaf(member, NULL, NULL);
}
} else {
conf_api_sub_unmute(member, NULL, NULL);
- if (!member_test_flag(member, MFLAG_CAN_HEAR)) {
+ if (!conf_utils_member_test_flag(member, MFLAG_CAN_HEAR)) {
conf_api_sub_undeaf(member, NULL, NULL);
}
}
}
-void conference_loop_fn_energy_up(conference_member_t *member, caller_control_action_t *action)
+void conf_loop_energy_up(conf_member_t *member, caller_control_action_t *action)
{
char msg[512], str[30] = "";
switch_event_t *event;
if (test_eflag(member->conference, EFLAG_ENERGY_LEVEL) &&
switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
- conference_add_event_member_data(member, event);
+ conf_member_add_event_data(member, event);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "energy-level");
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "New-Level", "%d", member->energy_level);
switch_event_fire(&event);
}
//switch_snprintf(msg, sizeof(msg), "Energy level %d", member->energy_level);
- //conference_member_say(member, msg, 0);
+ //conf_member_say(member, msg, 0);
switch_snprintf(str, sizeof(str), "%d", abs(member->energy_level) / 200);
for (p = str; p && *p; p++) {
switch_snprintf(msg, sizeof(msg), "digits/%c.wav", *p);
- conference_member_play_file(member, msg, 0, SWITCH_TRUE);
+ conf_member_play_file(member, msg, 0, SWITCH_TRUE);
}
}
-void conference_loop_fn_energy_equ_conf(conference_member_t *member, caller_control_action_t *action)
+void conf_loop_energy_equ_conf(conf_member_t *member, caller_control_action_t *action)
{
char msg[512], str[30] = "", *p;
switch_event_t *event;
if (test_eflag(member->conference, EFLAG_ENERGY_LEVEL) &&
switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
- conference_add_event_member_data(member, event);
+ conf_member_add_event_data(member, event);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "energy-level");
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "New-Level", "%d", member->energy_level);
switch_event_fire(&event);
}
//switch_snprintf(msg, sizeof(msg), "Energy level %d", member->energy_level);
- //conference_member_say(member, msg, 0);
+ //conf_member_say(member, msg, 0);
switch_snprintf(str, sizeof(str), "%d", abs(member->energy_level) / 200);
for (p = str; p && *p; p++) {
switch_snprintf(msg, sizeof(msg), "digits/%c.wav", *p);
- conference_member_play_file(member, msg, 0, SWITCH_TRUE);
+ conf_member_play_file(member, msg, 0, SWITCH_TRUE);
}
}
-void conference_loop_fn_energy_dn(conference_member_t *member, caller_control_action_t *action)
+void conf_loop_energy_dn(conf_member_t *member, caller_control_action_t *action)
{
char msg[512], str[30] = "", *p;
switch_event_t *event;
if (test_eflag(member->conference, EFLAG_ENERGY_LEVEL) &&
switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
- conference_add_event_member_data(member, event);
+ conf_member_add_event_data(member, event);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "energy-level");
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "New-Level", "%d", member->energy_level);
switch_event_fire(&event);
}
//switch_snprintf(msg, sizeof(msg), "Energy level %d", member->energy_level);
- //conference_member_say(member, msg, 0);
+ //conf_member_say(member, msg, 0);
switch_snprintf(str, sizeof(str), "%d", abs(member->energy_level) / 200);
for (p = str; p && *p; p++) {
switch_snprintf(msg, sizeof(msg), "digits/%c.wav", *p);
- conference_member_play_file(member, msg, 0, SWITCH_TRUE);
+ conf_member_play_file(member, msg, 0, SWITCH_TRUE);
}
}
-void conference_loop_fn_volume_talk_up(conference_member_t *member, caller_control_action_t *action)
+void conf_loop_volume_talk_up(conf_member_t *member, caller_control_action_t *action)
{
char msg[512];
switch_event_t *event;
if (test_eflag(member->conference, EFLAG_VOLUME_LEVEL) &&
switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
- conference_add_event_member_data(member, event);
+ conf_member_add_event_data(member, event);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "volume-level");
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "New-Level", "%d", member->volume_out_level);
switch_event_fire(&event);
}
//switch_snprintf(msg, sizeof(msg), "Volume level %d", member->volume_out_level);
- //conference_member_say(member, msg, 0);
+ //conf_member_say(member, msg, 0);
if (member->volume_out_level < 0) {
switch_snprintf(msg, sizeof(msg), "currency/negative.wav", member->volume_out_level);
- conference_member_play_file(member, msg, 0, SWITCH_TRUE);
+ conf_member_play_file(member, msg, 0, SWITCH_TRUE);
}
switch_snprintf(msg, sizeof(msg), "digits/%d.wav", abs(member->volume_out_level));
- conference_member_play_file(member, msg, 0, SWITCH_TRUE);
+ conf_member_play_file(member, msg, 0, SWITCH_TRUE);
}
-void conference_loop_fn_volume_talk_zero(conference_member_t *member, caller_control_action_t *action)
+void conf_loop_volume_talk_zero(conf_member_t *member, caller_control_action_t *action)
{
char msg[512];
switch_event_t *event;
if (test_eflag(member->conference, EFLAG_VOLUME_LEVEL) &&
switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
- conference_add_event_member_data(member, event);
+ conf_member_add_event_data(member, event);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "volume-level");
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "New-Level", "%d", member->volume_out_level);
switch_event_fire(&event);
}
//switch_snprintf(msg, sizeof(msg), "Volume level %d", member->volume_out_level);
- //conference_member_say(member, msg, 0);
+ //conf_member_say(member, msg, 0);
if (member->volume_out_level < 0) {
switch_snprintf(msg, sizeof(msg), "currency/negative.wav", member->volume_out_level);
- conference_member_play_file(member, msg, 0, SWITCH_TRUE);
+ conf_member_play_file(member, msg, 0, SWITCH_TRUE);
}
switch_snprintf(msg, sizeof(msg), "digits/%d.wav", abs(member->volume_out_level));
- conference_member_play_file(member, msg, 0, SWITCH_TRUE);
+ conf_member_play_file(member, msg, 0, SWITCH_TRUE);
}
-void conference_loop_fn_volume_talk_dn(conference_member_t *member, caller_control_action_t *action)
+void conf_loop_volume_talk_dn(conf_member_t *member, caller_control_action_t *action)
{
char msg[512];
switch_event_t *event;
if (test_eflag(member->conference, EFLAG_VOLUME_LEVEL) &&
switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
- conference_add_event_member_data(member, event);
+ conf_member_add_event_data(member, event);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "volume-level");
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "New-Level", "%d", member->volume_out_level);
switch_event_fire(&event);
}
//switch_snprintf(msg, sizeof(msg), "Volume level %d", member->volume_out_level);
- //conference_member_say(member, msg, 0);
+ //conf_member_say(member, msg, 0);
if (member->volume_out_level < 0) {
switch_snprintf(msg, sizeof(msg), "currency/negative.wav", member->volume_out_level);
- conference_member_play_file(member, msg, 0, SWITCH_TRUE);
+ conf_member_play_file(member, msg, 0, SWITCH_TRUE);
}
switch_snprintf(msg, sizeof(msg), "digits/%d.wav", abs(member->volume_out_level));
- conference_member_play_file(member, msg, 0, SWITCH_TRUE);
+ conf_member_play_file(member, msg, 0, SWITCH_TRUE);
}
-void conference_loop_fn_volume_listen_up(conference_member_t *member, caller_control_action_t *action)
+void conf_loop_volume_listen_up(conf_member_t *member, caller_control_action_t *action)
{
char msg[512];
switch_event_t *event;
if (test_eflag(member->conference, EFLAG_GAIN_LEVEL) &&
switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
- conference_add_event_member_data(member, event);
+ conf_member_add_event_data(member, event);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "gain-level");
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "New-Level", "%d", member->volume_in_level);
switch_event_fire(&event);
}
//switch_snprintf(msg, sizeof(msg), "Gain level %d", member->volume_in_level);
- //conference_member_say(member, msg, 0);
+ //conf_member_say(member, msg, 0);
if (member->volume_in_level < 0) {
switch_snprintf(msg, sizeof(msg), "currency/negative.wav", member->volume_in_level);
- conference_member_play_file(member, msg, 0, SWITCH_TRUE);
+ conf_member_play_file(member, msg, 0, SWITCH_TRUE);
}
switch_snprintf(msg, sizeof(msg), "digits/%d.wav", abs(member->volume_in_level));
- conference_member_play_file(member, msg, 0, SWITCH_TRUE);
+ conf_member_play_file(member, msg, 0, SWITCH_TRUE);
}
-void conference_loop_fn_volume_listen_zero(conference_member_t *member, caller_control_action_t *action)
+void conf_loop_volume_listen_zero(conf_member_t *member, caller_control_action_t *action)
{
char msg[512];
switch_event_t *event;
if (test_eflag(member->conference, EFLAG_GAIN_LEVEL) &&
switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
- conference_add_event_member_data(member, event);
+ conf_member_add_event_data(member, event);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "gain-level");
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "New-Level", "%d", member->volume_in_level);
switch_event_fire(&event);
}
//switch_snprintf(msg, sizeof(msg), "Gain level %d", member->volume_in_level);
- //conference_member_say(member, msg, 0);
+ //conf_member_say(member, msg, 0);
if (member->volume_in_level < 0) {
switch_snprintf(msg, sizeof(msg), "currency/negative.wav", member->volume_in_level);
- conference_member_play_file(member, msg, 0, SWITCH_TRUE);
+ conf_member_play_file(member, msg, 0, SWITCH_TRUE);
}
switch_snprintf(msg, sizeof(msg), "digits/%d.wav", abs(member->volume_in_level));
- conference_member_play_file(member, msg, 0, SWITCH_TRUE);
+ conf_member_play_file(member, msg, 0, SWITCH_TRUE);
}
-void conference_loop_fn_volume_listen_dn(conference_member_t *member, caller_control_action_t *action)
+void conf_loop_volume_listen_dn(conf_member_t *member, caller_control_action_t *action)
{
char msg[512];
switch_event_t *event;
if (test_eflag(member->conference, EFLAG_GAIN_LEVEL) &&
switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
- conference_add_event_member_data(member, event);
+ conf_member_add_event_data(member, event);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "gain-level");
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "New-Level", "%d", member->volume_in_level);
switch_event_fire(&event);
}
//switch_snprintf(msg, sizeof(msg), "Gain level %d", member->volume_in_level);
- //conference_member_say(member, msg, 0);
+ //conf_member_say(member, msg, 0);
if (member->volume_in_level < 0) {
switch_snprintf(msg, sizeof(msg), "currency/negative.wav", member->volume_in_level);
- conference_member_play_file(member, msg, 0, SWITCH_TRUE);
+ conf_member_play_file(member, msg, 0, SWITCH_TRUE);
}
switch_snprintf(msg, sizeof(msg), "digits/%d.wav", abs(member->volume_in_level));
- conference_member_play_file(member, msg, 0, SWITCH_TRUE);
+ conf_member_play_file(member, msg, 0, SWITCH_TRUE);
}
-void conference_loop_fn_event(conference_member_t *member, caller_control_action_t *action)
+void conf_loop_event(conf_member_t *member, caller_control_action_t *action)
{
switch_event_t *event;
if (test_eflag(member->conference, EFLAG_DTMF) && switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
- conference_add_event_member_data(member, event);
+ conf_member_add_event_data(member, event);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "dtmf");
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "DTMF-Key", action->binded_dtmf);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Data", action->expanded_data);
}
}
-void conference_loop_fn_transfer(conference_member_t *member, caller_control_action_t *action)
+void conf_loop_transfer(conf_member_t *member, caller_control_action_t *action)
{
char *exten = NULL;
char *dialplan = "XML";
switch_event_t *event;
if (test_eflag(member->conference, EFLAG_DTMF) && switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
- conference_add_event_member_data(member, event);
+ conf_member_add_event_data(member, event);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "transfer");
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Dialplan", action->expanded_data);
switch_event_fire(&event);
}
- member_clear_flag_locked(member, MFLAG_RUNNING);
+ conf_utils_member_clear_flag_locked(member, MFLAG_RUNNING);
if ((mydata = switch_core_session_strdup(member->session, action->expanded_data))) {
if ((argc = switch_separate_string(mydata, ' ', argv, (sizeof(argv) / sizeof(argv[0]))))) {
return;
}
-void conference_loop_fn_exec_app(conference_member_t *member, caller_control_action_t *action)
+void conf_loop_exec_app(conf_member_t *member, caller_control_action_t *action)
{
char *app = NULL;
char *arg = "";
if (!action->expanded_data) return;
if (test_eflag(member->conference, EFLAG_DTMF) && switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
- conference_add_event_member_data(member, event);
+ conf_member_add_event_data(member, event);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "execute_app");
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Application", action->expanded_data);
switch_event_fire(&event);
return;
}
-void conference_loop_fn_hangup(conference_member_t *member, caller_control_action_t *action)
+void conf_loop_hangup(conf_member_t *member, caller_control_action_t *action)
{
- member_clear_flag_locked(member, MFLAG_RUNNING);
-}
-
-void member_bind_controls(conference_member_t *member, const char *controls)
-{
- switch_xml_t cxml, cfg, xgroups, xcontrol;
- switch_event_t *params;
- int i;
-
- switch_event_create(¶ms, SWITCH_EVENT_REQUEST_PARAMS);
- switch_event_add_header_string(params, SWITCH_STACK_BOTTOM, "Conf-Name", member->conference->name);
- switch_event_add_header_string(params, SWITCH_STACK_BOTTOM, "Action", "request-controls");
- switch_event_add_header_string(params, SWITCH_STACK_BOTTOM, "Controls", controls);
-
- if (!(cxml = switch_xml_open_cfg(mod_conference_cf_name, &cfg, params))) {
- switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Open of %s failed\n", mod_conference_cf_name);
- goto end;
- }
-
- if (!(xgroups = switch_xml_child(cfg, "caller-controls"))) {
- switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Can't find caller-controls in %s\n", mod_conference_cf_name);
- goto end;
- }
-
- if (!(xgroups = switch_xml_find_child(xgroups, "group", "name", controls))) {
- switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Can't find group '%s' in caller-controls section of %s\n", switch_str_nil(controls), mod_conference_cf_name);
- goto end;
- }
-
-
- for (xcontrol = switch_xml_child(xgroups, "control"); xcontrol; xcontrol = xcontrol->next) {
- const char *key = switch_xml_attr(xcontrol, "action");
- const char *digits = switch_xml_attr(xcontrol, "digits");
- const char *data = switch_xml_attr_soft(xcontrol, "data");
-
- if (zstr(key) || zstr(digits)) continue;
-
- for(i = 0; i < MAPPING_LEN; i++) {
- if (!strcasecmp(key, control_mappings[i].name)) {
- switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "%s binding '%s' to '%s'\n",
- switch_core_session_get_name(member->session), digits, key);
-
- do_binding(member, control_mappings[i].handler, digits, data);
- }
- }
- }
-
- end:
-
- /* Release the config registry handle */
- if (cxml) {
- switch_xml_free(cxml);
- cxml = NULL;
- }
-
- if (params) switch_event_destroy(¶ms);
-
+ conf_utils_member_clear_flag_locked(member, MFLAG_RUNNING);
}
/* marshall frames from the call leg to the conference thread for muxing to other call legs */
-void *SWITCH_THREAD_FUNC conference_loop_input(switch_thread_t *thread, void *obj)
+void *SWITCH_THREAD_FUNC conf_loop_input(switch_thread_t *thread, void *obj)
{
switch_event_t *event;
- conference_member_t *member = obj;
+ conf_member_t *member = obj;
switch_channel_t *channel;
switch_status_t status;
switch_frame_t *read_frame = NULL;
switch_assert(member != NULL);
- member_clear_flag_locked(member, MFLAG_TALKING);
+ conf_utils_member_clear_flag_locked(member, MFLAG_TALKING);
channel = switch_core_session_get_channel(session);
/* 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 (member_test_flag(member, MFLAG_RUNNING) && switch_channel_ready(channel)) {
+ while (conf_utils_member_test_flag(member, MFLAG_RUNNING) && switch_channel_ready(channel)) {
if (switch_channel_ready(channel) && switch_channel_test_app_flag(channel, CF_APP_TAGGED)) {
switch_yield(100000);
switch_mutex_lock(member->read_mutex);
/* end the loop, if appropriate */
- if (!SWITCH_READ_ACCEPTABLE(status) || !member_test_flag(member, MFLAG_RUNNING)) {
+ if (!SWITCH_READ_ACCEPTABLE(status) || !conf_utils_member_test_flag(member, MFLAG_RUNNING)) {
switch_mutex_unlock(member->read_mutex);
break;
}
- if (switch_channel_test_flag(channel, CF_VIDEO) && !member_test_flag(member, MFLAG_ACK_VIDEO)) {
- member_set_flag_locked(member, MFLAG_ACK_VIDEO);
- check_avatar(member, SWITCH_FALSE);
+ if (switch_channel_test_flag(channel, CF_VIDEO) && !conf_utils_member_test_flag(member, MFLAG_ACK_VIDEO)) {
+ conf_utils_member_set_flag_locked(member, MFLAG_ACK_VIDEO);
+ conf_video_check_avatar(member, SWITCH_FALSE);
switch_core_session_video_reinit(member->session);
- conference_set_video_floor_holder(member->conference, member, SWITCH_FALSE);
- } else if (member_test_flag(member, MFLAG_ACK_VIDEO) && !switch_channel_test_flag(channel, CF_VIDEO)) {
- check_avatar(member, SWITCH_FALSE);
+ conf_video_set_floor_holder(member->conference, member, SWITCH_FALSE);
+ } else if (conf_utils_member_test_flag(member, MFLAG_ACK_VIDEO) && !switch_channel_test_flag(channel, CF_VIDEO)) {
+ conf_video_check_avatar(member, SWITCH_FALSE);
}
/* if we have caller digits, feed them to the parser to find an action */
switch_channel_dequeue_dtmf_string(channel, dtmf, sizeof(dtmf));
- if (member_test_flag(member, MFLAG_DIST_DTMF)) {
- conference_send_all_dtmf(member, member->conference, dtmf);
+ if (conf_utils_member_test_flag(member, MFLAG_DIST_DTMF)) {
+ conf_member_send_all_dtmf(member, member->conference, dtmf);
} else if (member->dmachine) {
char *p;
char str[2] = "";
if (hangunder_hits) {
hangunder_hits--;
}
- if (member_test_flag(member, MFLAG_TALKING)) {
+ if (conf_utils_member_test_flag(member, MFLAG_TALKING)) {
if (++hangover_hits >= hangover) {
hangover_hits = hangunder_hits = 0;
- member_clear_flag_locked(member, MFLAG_TALKING);
- member_update_status_field(member);
- check_agc_levels(member);
- clear_avg(member);
+ conf_utils_member_clear_flag_locked(member, MFLAG_TALKING);
+ conf_member_update_status_field(member);
+ conf_member_check_agc_levels(member);
+ conf_member_clear_avg(member);
member->score_iir = 0;
member->floor_packets = 0;
if (test_eflag(member->conference, EFLAG_STOP_TALKING) &&
switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
- conference_add_event_member_data(member, event);
+ conf_member_add_event_data(member, event);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "stop-talking");
switch_event_fire(&event);
}
if (member->nt_tally > (int32_t)(member->read_impl.actual_samples_per_second / member->read_impl.samples_per_packet) * 3) {
member->agc_volume_in_level = 0;
- clear_avg(member);
+ conf_member_clear_avg(member);
}
/* Check for input volume adjustments */
if (!member->conference->agc_level) {
member->conference->agc_level = 0;
- clear_avg(member);
+ conf_member_clear_avg(member);
}
/* if the member can speak, compute the audio energy level and */
/* generate events when the level crosses the threshold */
- if ((member_test_flag(member, MFLAG_CAN_SPEAK) || member_test_flag(member, MFLAG_MUTE_DETECT))) {
+ if ((conf_utils_member_test_flag(member, MFLAG_CAN_SPEAK) || conf_utils_member_test_flag(member, MFLAG_MUTE_DETECT))) {
uint32_t energy = 0, i = 0, samples = 0, j = 0;
int16_t *data;
int agc_period = (member->read_impl.actual_samples_per_second / member->read_impl.samples_per_packet) / 4;
}
if (member->conference->agc_level && member->score &&
- member_test_flag(member, MFLAG_CAN_SPEAK) &&
- noise_gate_check(member)
+ conf_utils_member_test_flag(member, MFLAG_CAN_SPEAK) &&
+ conf_member_noise_gate_check(member)
) {
int last_shift = abs((int)(member->last_score - member->score));
if (++member->agc_concur >= agc_period) {
if (!member->vol_period) {
- check_agc_levels(member);
+ conf_member_check_agc_levels(member);
}
member->agc_concur = 0;
}
member->score_iir = SCORE_MAX_IIR;
}
- if (noise_gate_check(member)) {
+ if (conf_member_noise_gate_check(member)) {
uint32_t diff = member->score - member->energy_level;
if (hangover_hits) {
hangover_hits--;
hangover_hits = hangunder_hits = 0;
member->last_talking = switch_epoch_time_now(NULL);
- if (!member_test_flag(member, MFLAG_TALKING)) {
- member_set_flag_locked(member, MFLAG_TALKING);
- member_update_status_field(member);
+ if (!conf_utils_member_test_flag(member, MFLAG_TALKING)) {
+ conf_utils_member_set_flag_locked(member, MFLAG_TALKING);
+ conf_member_update_status_field(member);
member->floor_packets = 0;
- if (test_eflag(member->conference, EFLAG_START_TALKING) && member_test_flag(member, MFLAG_CAN_SPEAK) &&
+ if (test_eflag(member->conference, EFLAG_START_TALKING) && conf_utils_member_test_flag(member, MFLAG_CAN_SPEAK) &&
switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
- conference_add_event_member_data(member, event);
+ conf_member_add_event_data(member, event);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "start-talking");
switch_event_fire(&event);
}
- if (member_test_flag(member, MFLAG_MUTE_DETECT) && !member_test_flag(member, MFLAG_CAN_SPEAK)) {
+ if (conf_utils_member_test_flag(member, MFLAG_MUTE_DETECT) && !conf_utils_member_test_flag(member, MFLAG_CAN_SPEAK)) {
if (!zstr(member->conference->mute_detect_sound)) {
- member_set_flag(member, MFLAG_INDICATE_MUTE_DETECT);
+ conf_utils_member_set_flag(member, MFLAG_INDICATE_MUTE_DETECT);
}
if (test_eflag(member->conference, EFLAG_MUTE_DETECT) &&
switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
- conference_add_event_member_data(member, event);
+ conf_member_add_event_data(member, event);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "mute-detect");
switch_event_fire(&event);
}
member->nt_tally++;
}
- if (member_test_flag(member, MFLAG_TALKING) && member_test_flag(member, MFLAG_CAN_SPEAK)) {
+ if (conf_utils_member_test_flag(member, MFLAG_TALKING) && conf_utils_member_test_flag(member, MFLAG_CAN_SPEAK)) {
switch_event_t *event;
if (++hangover_hits >= hangover) {
hangover_hits = hangunder_hits = 0;
- member_clear_flag_locked(member, MFLAG_TALKING);
- member_update_status_field(member);
- check_agc_levels(member);
- clear_avg(member);
+ conf_utils_member_clear_flag_locked(member, MFLAG_TALKING);
+ conf_member_update_status_field(member);
+ conf_member_check_agc_levels(member);
+ conf_member_clear_avg(member);
if (test_eflag(member->conference, EFLAG_STOP_TALKING) &&
switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
- conference_add_event_member_data(member, event);
+ conf_member_add_event_data(member, event);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "stop-talking");
switch_event_fire(&event);
}
if (member == member->conference->floor_holder) {
if (member->id != member->conference->video_floor_holder &&
(member->floor_packets > member->conference->video_floor_packets || member->energy_level == 0)) {
- conference_set_video_floor_holder(member->conference, member, SWITCH_FALSE);
+ conf_video_set_floor_holder(member->conference, member, SWITCH_FALSE);
}
}
}
if (loops > 500) {
member->loop_loop = 1;
- if (setup_media(member, member->conference)) {
+ if (conf_member_setup_media(member, member->conference)) {
switch_mutex_unlock(member->read_mutex);
break;
}
}
/* skip frames that are not actual media or when we are muted or silent */
- if ((member_test_flag(member, MFLAG_TALKING) || member->energy_level == 0 || conference_test_flag(member->conference, CFLAG_AUDIO_ALWAYS))
- && member_test_flag(member, MFLAG_CAN_SPEAK) && !conference_test_flag(member->conference, CFLAG_WAIT_MOD)
+ if ((conf_utils_member_test_flag(member, MFLAG_TALKING) || member->energy_level == 0 || conf_utils_test_flag(member->conference, CFLAG_AUDIO_ALWAYS))
+ && conf_utils_member_test_flag(member, MFLAG_CAN_SPEAK) && !conf_utils_test_flag(member->conference, CFLAG_WAIT_MOD)
&& (member->conference->count > 1 || (member->conference->record_count && member->conference->count >= member->conference->min_recording_participants))) {
switch_audio_resampler_t *read_resampler = member->read_resampler;
void *data;
tmp_frame.data = data;
tmp_frame.datalen = datalen;
tmp_frame.rate = member->conference->rate;
- member_check_channels(&tmp_frame, member, SWITCH_TRUE);
+ conf_member_check_channels(&tmp_frame, member, SWITCH_TRUE);
if (datalen) {
end:
- member_clear_flag_locked(member, MFLAG_ITHREAD);
+ conf_utils_member_clear_flag_locked(member, MFLAG_ITHREAD);
return NULL;
}
/* launch an input thread for the call leg */
-void launch_conference_loop_input(conference_member_t *member, switch_memory_pool_t *pool)
+void conf_loop_launch_input(conf_member_t *member, switch_memory_pool_t *pool)
{
switch_threadattr_t *thd_attr = NULL;
switch_threadattr_create(&thd_attr, pool);
switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE);
- member_set_flag_locked(member, MFLAG_ITHREAD);
- if (switch_thread_create(&member->input_thread, thd_attr, conference_loop_input, member, pool) != SWITCH_STATUS_SUCCESS) {
- member_clear_flag_locked(member, MFLAG_ITHREAD);
+ conf_utils_member_set_flag_locked(member, MFLAG_ITHREAD);
+ if (switch_thread_create(&member->input_thread, thd_attr, conf_loop_input, member, pool) != SWITCH_STATUS_SUCCESS) {
+ conf_utils_member_clear_flag_locked(member, MFLAG_ITHREAD);
}
}
/* marshall frames from the conference (or file or tts output) to the call leg */
/* NB. this starts the input thread after some initial setup for the call leg */
-void conference_loop_output(conference_member_t *member)
+void conf_loop_output(conf_member_t *member)
{
switch_channel_t *channel;
switch_frame_t write_frame = { 0 };
write_frame.codec = &member->write_codec;
/* Start the input thread */
- launch_conference_loop_input(member, switch_core_session_get_pool(member->session));
+ conf_loop_launch_input(member, switch_core_session_get_pool(member->session));
if ((call_list = switch_channel_get_private(channel, "_conference_autocall_list_"))) {
const char *cid_name = switch_channel_get_variable(channel, "conference_auto_outcall_caller_id_name");
const char *cid_num = switch_channel_get_variable(channel, "conference_auto_outcall_caller_id_number");
const char *toval = switch_channel_get_variable(channel, "conference_auto_outcall_timeout");
- const char *flags = switch_channel_get_variable(channel, "conference_auto_outcall_flags");
+ const char *flags = switch_channel_get_variable(channel, "conf_utils_auto_outcall_flags");
const char *profile = switch_channel_get_variable(channel, "conference_auto_outcall_profile");
const char *ann = switch_channel_get_variable(channel, "conference_auto_outcall_announce");
const char *prefix = switch_channel_get_variable(channel, "conference_auto_outcall_prefix");
switch_channel_set_private(channel, "_conference_autocall_list_", NULL);
- conference_set_flag(member->conference, CFLAG_OUTCALL);
+ conf_utils_set_flag(member->conference, CFLAG_OUTCALL);
if (toval) {
to = atoi(toval);
for (x = 0; x < argc; x++) {
char *dial_str = switch_mprintf("%s%s", switch_str_nil(prefix), argv[x]);
switch_assert(dial_str);
- conference_outcall_bg(member->conference, NULL, NULL, dial_str, to, switch_str_nil(flags), cid_name, cid_num, NULL,
+ conf_outcall_bg(member->conference, NULL, NULL, dial_str, to, switch_str_nil(flags), cid_name, cid_num, NULL,
profile, &member->conference->cancel_cause, NULL);
switch_safe_free(dial_str);
}
goto end;
}
- conference_member_play_file(member, "tone_stream://%(500,0,640)", 0, SWITCH_TRUE);
+ conf_member_play_file(member, "tone_stream://%(500,0,640)", 0, SWITCH_TRUE);
}
- if (!conference_test_flag(member->conference, CFLAG_ANSWERED)) {
+ if (!conf_utils_test_flag(member->conference, CFLAG_ANSWERED)) {
switch_channel_answer(channel);
}
sanity = 2000;
- while(!member_test_flag(member, MFLAG_ITHREAD) && sanity > 0) {
+ while(!conf_utils_member_test_flag(member, MFLAG_ITHREAD) && sanity > 0) {
switch_cond_next();
sanity--;
}
/* Fair WARNING, If you expect the caller to hear anything or for digit handling to be processed, */
/* you better not block this thread loop for more than the duration of member->conference->timer_name! */
- while (!member->loop_loop && member_test_flag(member, MFLAG_RUNNING) && member_test_flag(member, MFLAG_ITHREAD)
+ while (!member->loop_loop && conf_utils_member_test_flag(member, MFLAG_RUNNING) && conf_utils_member_test_flag(member, MFLAG_ITHREAD)
&& switch_channel_ready(channel)) {
switch_event_t *event;
int use_timer = 0;
if (switch_channel_test_flag(member->channel, CF_CONFERENCE_ADV)) {
if (member->conference->la) {
- adv_la(member->conference, member, SWITCH_TRUE);
+ conf_event_adv_la(member->conference, member, SWITCH_TRUE);
}
switch_channel_clear_flag(member->channel, CF_CONFERENCE_ADV);
}
if (switch_channel_direction(channel) == SWITCH_CALL_DIRECTION_OUTBOUND) {
/* test to see if outbound channel has answered */
- if (switch_channel_test_flag(channel, CF_ANSWERED) && !conference_test_flag(member->conference, CFLAG_ANSWERED)) {
+ if (switch_channel_test_flag(channel, CF_ANSWERED) && !conf_utils_test_flag(member->conference, CFLAG_ANSWERED)) {
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(member->session), SWITCH_LOG_DEBUG,
"Outbound conference channel answered, setting CFLAG_ANSWERED\n");
- conference_set_flag(member->conference, CFLAG_ANSWERED);
+ conf_utils_set_flag(member->conference, CFLAG_ANSWERED);
}
} else {
- if (conference_test_flag(member->conference, CFLAG_ANSWERED) && !switch_channel_test_flag(channel, CF_ANSWERED)) {
+ if (conf_utils_test_flag(member->conference, CFLAG_ANSWERED) && !switch_channel_test_flag(channel, CF_ANSWERED)) {
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(member->session), SWITCH_LOG_DEBUG, "CLFAG_ANSWERED set, answering inbound channel\n");
switch_channel_answer(channel);
}
if (mux_used < bytes) {
if (++low_count >= 5) {
/* partial frame sitting around this long is useless and builds delay */
- member_set_flag_locked(member, MFLAG_FLUSH_BUFFER);
+ conf_utils_member_set_flag_locked(member, MFLAG_FLUSH_BUFFER);
}
} else if (mux_used > flush_len) {
/* getting behind, clear the buffer */
- member_set_flag_locked(member, MFLAG_FLUSH_BUFFER);
+ conf_utils_member_set_flag_locked(member, MFLAG_FLUSH_BUFFER);
}
}
if (switch_channel_test_app_flag(channel, CF_APP_TAGGED)) {
- member_set_flag_locked(member, MFLAG_FLUSH_BUFFER);
+ conf_utils_member_set_flag_locked(member, MFLAG_FLUSH_BUFFER);
} else if (mux_used >= bytes) {
/* Flush the output buffer and write all the data (presumably muxed) back to the channel */
switch_mutex_lock(member->audio_out_mutex);
if (write_frame.datalen) {
write_frame.samples = write_frame.datalen / 2 / member->conference->channels;
- if( !member_test_flag(member, MFLAG_CAN_HEAR)) {
+ if( !conf_utils_member_test_flag(member, MFLAG_CAN_HEAR)) {
memset(write_frame.data, 255, write_frame.datalen);
} else if (member->volume_out_level) { /* Check for output volume adjustments */
switch_change_sln_volume(write_frame.data, write_frame.samples * member->conference->channels, member->volume_out_level);
write_frame.timestamp = timer.samplecount;
if (member->fnode) {
- member_add_file_data(member, write_frame.data, write_frame.datalen);
+ conf_member_add_file_data(member, write_frame.data, write_frame.datalen);
}
- member_check_channels(&write_frame, member, SWITCH_FALSE);
+ conf_member_check_channels(&write_frame, member, SWITCH_FALSE);
if (switch_core_session_write_frame(member->session, &write_frame, SWITCH_IO_FLAG_NONE, 0) != SWITCH_STATUS_SUCCESS) {
switch_mutex_unlock(member->audio_out_mutex);
switch_mutex_unlock(member->audio_out_mutex);
}
- if (member_test_flag(member, MFLAG_FLUSH_BUFFER)) {
+ if (conf_utils_member_test_flag(member, MFLAG_FLUSH_BUFFER)) {
if (switch_buffer_inuse(member->mux_buffer)) {
switch_mutex_lock(member->audio_out_mutex);
switch_buffer_zero(member->mux_buffer);
switch_mutex_unlock(member->audio_out_mutex);
}
- member_clear_flag_locked(member, MFLAG_FLUSH_BUFFER);
+ conf_utils_member_clear_flag_locked(member, MFLAG_FLUSH_BUFFER);
}
switch_mutex_unlock(member->write_mutex);
- if (member_test_flag(member, MFLAG_INDICATE_MUTE)) {
+ if (conf_utils_member_test_flag(member, MFLAG_INDICATE_MUTE)) {
if (!zstr(member->conference->muted_sound)) {
- conference_member_play_file(member, member->conference->muted_sound, 0, SWITCH_TRUE);
+ conf_member_play_file(member, member->conference->muted_sound, 0, SWITCH_TRUE);
} else {
char msg[512];
switch_snprintf(msg, sizeof(msg), "Muted");
- conference_member_say(member, msg, 0);
+ conf_member_say(member, msg, 0);
}
- member_clear_flag(member, MFLAG_INDICATE_MUTE);
+ conf_utils_member_clear_flag(member, MFLAG_INDICATE_MUTE);
}
- if (member_test_flag(member, MFLAG_INDICATE_MUTE_DETECT)) {
+ if (conf_utils_member_test_flag(member, MFLAG_INDICATE_MUTE_DETECT)) {
if (!zstr(member->conference->mute_detect_sound)) {
- conference_member_play_file(member, member->conference->mute_detect_sound, 0, SWITCH_TRUE);
+ conf_member_play_file(member, member->conference->mute_detect_sound, 0, SWITCH_TRUE);
} else {
char msg[512];
switch_snprintf(msg, sizeof(msg), "Currently Muted");
- conference_member_say(member, msg, 0);
+ conf_member_say(member, msg, 0);
}
- member_clear_flag(member, MFLAG_INDICATE_MUTE_DETECT);
+ conf_utils_member_clear_flag(member, MFLAG_INDICATE_MUTE_DETECT);
}
- if (member_test_flag(member, MFLAG_INDICATE_UNMUTE)) {
+ if (conf_utils_member_test_flag(member, MFLAG_INDICATE_UNMUTE)) {
if (!zstr(member->conference->unmuted_sound)) {
- conference_member_play_file(member, member->conference->unmuted_sound, 0, SWITCH_TRUE);
+ conf_member_play_file(member, member->conference->unmuted_sound, 0, SWITCH_TRUE);
} else {
char msg[512];
switch_snprintf(msg, sizeof(msg), "Un-Muted");
- conference_member_say(member, msg, 0);
+ conf_member_say(member, msg, 0);
}
- member_clear_flag(member, MFLAG_INDICATE_UNMUTE);
+ conf_utils_member_clear_flag(member, MFLAG_INDICATE_UNMUTE);
}
if (switch_core_session_private_event_count(member->session)) {
switch_channel_set_app_flag(channel, CF_APP_TAGGED);
switch_ivr_parse_all_events(member->session);
switch_channel_clear_app_flag(channel, CF_APP_TAGGED);
- member_set_flag_locked(member, MFLAG_FLUSH_BUFFER);
+ conf_utils_member_set_flag_locked(member, MFLAG_FLUSH_BUFFER);
switch_core_session_set_read_codec(member->session, &member->read_codec);
} else {
switch_ivr_parse_all_messages(member->session);
end:
if (!member->loop_loop) {
- member_clear_flag_locked(member, MFLAG_RUNNING);
+ conf_utils_member_clear_flag_locked(member, MFLAG_RUNNING);
/* Wait for the input thread to end */
if (member->input_thread) {
}
}
-int noise_gate_check(conference_member_t *member)
-{
- int r = 0;
-
-
- if (member->conference->agc_level && member->agc_volume_in_level != 0) {
- int target_score = 0;
-
- target_score = (member->energy_level + (25 * member->agc_volume_in_level));
-
- if (target_score < 0) target_score = 0;
-
- r = (int)member->score > target_score;
-
- } else {
- r = (int32_t)member->score > member->energy_level;
- }
-
- return r;
-}
-
-void clear_avg(conference_member_t *member)
-{
-
- member->avg_score = 0;
- member->avg_itt = 0;
- member->avg_tally = 0;
- member->agc_concur = 0;
-}
-
*/
#include <mod_conference.h>
+int conf_member_noise_gate_check(conf_member_t *member)
+{
+ int r = 0;
+
+
+ if (member->conference->agc_level && member->agc_volume_in_level != 0) {
+ int target_score = 0;
+
+ target_score = (member->energy_level + (25 * member->agc_volume_in_level));
+
+ if (target_score < 0) target_score = 0;
+
+ r = (int)member->score > target_score;
+
+ } else {
+ r = (int32_t)member->score > member->energy_level;
+ }
+
+ return r;
+}
+
+void conf_member_clear_avg(conf_member_t *member)
+{
+
+ member->avg_score = 0;
+ member->avg_itt = 0;
+ member->avg_tally = 0;
+ member->agc_concur = 0;
+}
+
+void conf_member_do_binding(conf_member_t *member, conf_key_callback_t handler, const char *digits, const char *data)
+{
+ key_binding_t *binding;
+
+ binding = switch_core_alloc(member->pool, sizeof(*binding));
+ binding->member = member;
+
+ binding->action.binded_dtmf = switch_core_strdup(member->pool, digits);
+
+ if (data) {
+ binding->action.data = switch_core_strdup(member->pool, data);
+ }
+
+ binding->handler = handler;
+ switch_ivr_dmachine_bind(member->dmachine, "conf", digits, 0, conf_loop_dmachine_dispatcher, binding);
+
+}
+
+void conf_member_bind_controls(conf_member_t *member, const char *controls)
+{
+ switch_xml_t cxml, cfg, xgroups, xcontrol;
+ switch_event_t *params;
+ int i;
+
+ switch_event_create(¶ms, SWITCH_EVENT_REQUEST_PARAMS);
+ switch_event_add_header_string(params, SWITCH_STACK_BOTTOM, "Conf-Name", member->conference->name);
+ switch_event_add_header_string(params, SWITCH_STACK_BOTTOM, "Action", "request-controls");
+ switch_event_add_header_string(params, SWITCH_STACK_BOTTOM, "Controls", controls);
+
+ if (!(cxml = switch_xml_open_cfg(mod_conference_cf_name, &cfg, params))) {
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Open of %s failed\n", mod_conference_cf_name);
+ goto end;
+ }
+
+ if (!(xgroups = switch_xml_child(cfg, "caller-controls"))) {
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Can't find caller-controls in %s\n", mod_conference_cf_name);
+ goto end;
+ }
+
+ if (!(xgroups = switch_xml_find_child(xgroups, "group", "name", controls))) {
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Can't find group '%s' in caller-controls section of %s\n", switch_str_nil(controls), mod_conference_cf_name);
+ goto end;
+ }
+
+
+ for (xcontrol = switch_xml_child(xgroups, "control"); xcontrol; xcontrol = xcontrol->next) {
+ const char *key = switch_xml_attr(xcontrol, "action");
+ const char *digits = switch_xml_attr(xcontrol, "digits");
+ const char *data = switch_xml_attr_soft(xcontrol, "data");
+
+ if (zstr(key) || zstr(digits)) continue;
+
+ for(i = 0; i < conf_loop_mapping_len(); i++) {
+ if (!strcasecmp(key, control_mappings[i].name)) {
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "%s binding '%s' to '%s'\n",
+ switch_core_session_get_name(member->session), digits, key);
+
+ conf_member_do_binding(member, control_mappings[i].handler, digits, data);
+ }
+ }
+ }
+
+ end:
+
+ /* Release the config registry handle */
+ if (cxml) {
+ switch_xml_free(cxml);
+ cxml = NULL;
+ }
+
+ if (params) switch_event_destroy(¶ms);
+
+}
+
+void conf_member_update_status_field(conf_member_t *member)
+{
+ char *str, *vstr = "", display[128] = "", *json_display = NULL;
+ cJSON *json, *audio, *video;
+
+ if (!member->conference->la || !member->json ||
+ !member->status_field || switch_channel_test_flag(member->channel, CF_VIDEO_ONLY) || conf_utils_member_test_flag(member, MFLAG_SECOND_SCREEN)) {
+ return;
+ }
+
+ switch_live_array_lock(member->conference->la);
+
+ if (conf_utils_test_flag(member->conference, CFLAG_JSON_STATUS)) {
+ json = cJSON_CreateObject();
+ audio = cJSON_CreateObject();
+ cJSON_AddItemToObject(audio, "muted", cJSON_CreateBool(!conf_utils_member_test_flag(member, MFLAG_CAN_SPEAK)));
+ cJSON_AddItemToObject(audio, "onHold", cJSON_CreateBool(switch_channel_test_flag(member->channel, CF_HOLD)));
+ cJSON_AddItemToObject(audio, "talking", cJSON_CreateBool(conf_utils_member_test_flag(member, MFLAG_TALKING)));
+ cJSON_AddItemToObject(audio, "floor", cJSON_CreateBool(member == member->conference->floor_holder));
+ cJSON_AddItemToObject(audio, "energyScore", cJSON_CreateNumber(member->score));
+ cJSON_AddItemToObject(json, "audio", audio);
+
+ if (switch_channel_test_flag(member->channel, CF_VIDEO) || member->avatar_png_img) {
+ video = cJSON_CreateObject();
+ cJSON_AddItemToObject(video, "avatarPresented", cJSON_CreateBool(!!member->avatar_png_img));
+ cJSON_AddItemToObject(video, "mediaFlow", cJSON_CreateString(member->video_flow == SWITCH_MEDIA_FLOW_SENDONLY ? "sendOnly" : "sendRecv"));
+ cJSON_AddItemToObject(video, "muted", cJSON_CreateBool(!conf_utils_member_test_flag(member, MFLAG_CAN_BE_SEEN)));
+ cJSON_AddItemToObject(video, "floor", cJSON_CreateBool(member && member->id == member->conference->video_floor_holder));
+ if (member && member->id == member->conference->video_floor_holder && conf_utils_test_flag(member->conference, CFLAG_VID_FLOOR_LOCK)) {
+ cJSON_AddItemToObject(video, "floorLocked", cJSON_CreateTrue());
+ }
+ cJSON_AddItemToObject(video, "reservationID", member->video_reservation_id ?
+ cJSON_CreateString(member->video_reservation_id) : cJSON_CreateNull());
+
+ cJSON_AddItemToObject(video, "videoLayerID", cJSON_CreateNumber(member->video_layer_id));
+
+ cJSON_AddItemToObject(json, "video", video);
+ } else {
+ cJSON_AddItemToObject(json, "video", cJSON_CreateFalse());
+ }
+
+ json_display = cJSON_PrintUnformatted(json);
+ cJSON_Delete(json);
+ } else {
+ if (!conf_utils_member_test_flag(member, MFLAG_CAN_SPEAK)) {
+ str = "MUTE";
+ } else if (switch_channel_test_flag(member->channel, CF_HOLD)) {
+ str = "HOLD";
+ } else if (member == member->conference->floor_holder) {
+ if (conf_utils_member_test_flag(member, MFLAG_TALKING)) {
+ str = "TALKING (FLOOR)";
+ } else {
+ str = "FLOOR";
+ }
+ } else if (conf_utils_member_test_flag(member, MFLAG_TALKING)) {
+ str = "TALKING";
+ } else {
+ str = "ACTIVE";
+ }
+
+ if (switch_channel_test_flag(member->channel, CF_VIDEO)) {
+ if (!conf_utils_member_test_flag(member, MFLAG_CAN_BE_SEEN)) {
+ vstr = " VIDEO (BLIND)";
+ } else {
+ vstr = " VIDEO";
+ if (member && member->id == member->conference->video_floor_holder) {
+ vstr = " VIDEO (FLOOR)";
+ }
+ }
+ }
+
+ switch_snprintf(display, sizeof(display), "%s%s", str, vstr);
+ }
+
+ if (json_display) {
+ member->status_field->valuestring = json_display;
+ } else {
+ free(member->status_field->valuestring);
+ member->status_field->valuestring = strdup(display);
+ }
+
+ switch_live_array_add(member->conference->la, switch_core_session_get_uuid(member->session), -1, &member->json, SWITCH_FALSE);
+ switch_live_array_unlock(member->conference->la);
+}
+
+switch_status_t conf_member_add_event_data(conf_member_t *member, switch_event_t *event)
+{
+ switch_status_t status = SWITCH_STATUS_SUCCESS;
+
+ if (!member)
+ return status;
+
+ if (member->conference) {
+ status = conf_event_add_data(member->conference, event);
+ switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Floor", "%s", (member == member->conference->floor_holder) ? "true" : "false" );
+ }
+
+ if (member->session) {
+ switch_channel_t *channel = switch_core_session_get_channel(member->session);
+
+ if (member->verbose_events) {
+ switch_channel_event_set_data(channel, event);
+ } else {
+ switch_channel_event_set_basic_data(channel, event);
+ }
+ switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Video", "%s",
+ switch_channel_test_flag(switch_core_session_get_channel(member->session), CF_VIDEO) ? "true" : "false" );
+
+ }
+
+ switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Hear", "%s", conf_utils_member_test_flag(member, MFLAG_CAN_HEAR) ? "true" : "false" );
+ switch_event_add_header(event, SWITCH_STACK_BOTTOM, "See", "%s", conf_utils_member_test_flag(member, MFLAG_CAN_BE_SEEN) ? "true" : "false" );
+ switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Speak", "%s", conf_utils_member_test_flag(member, MFLAG_CAN_SPEAK) ? "true" : "false" );
+ switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Talking", "%s", conf_utils_member_test_flag(member, MFLAG_TALKING) ? "true" : "false" );
+ switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Mute-Detect", "%s", conf_utils_member_test_flag(member, MFLAG_MUTE_DETECT) ? "true" : "false" );
+ switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Member-ID", "%u", member->id);
+ switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Member-Type", "%s", conf_utils_member_test_flag(member, MFLAG_MOD) ? "moderator" : "member");
+ switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Member-Ghost", "%s", conf_utils_member_test_flag(member, MFLAG_GHOST) ? "true" : "false");
+ switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Energy-Level", "%d", member->energy_level);
+ switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Current-Energy", "%d", member->score);
+
+ return status;
+}
+
+
+#ifndef OPENAL_POSITIONING
+switch_status_t conf_member_parse_position(conf_member_t *member, const char *data)
+{
+ return SWITCH_STATUS_FALSE;
+}
+#else
+switch_status_t conf_member_parse_position(conf_member_t *member, const char *data)
+{
+ switch_status_t status = SWITCH_STATUS_FALSE;
+
+ if (member->al) {
+ status = conf_al_parse_position(member->al, data);
+ }
+
+ return status;
+
+}
+#endif
+
+/* if other_member has a relationship with member, produce it */
+conference_relationship_t *conf_member_get_relationship(conf_member_t *member, conf_member_t *other_member)
+{
+ conference_relationship_t *rel = NULL, *global = NULL;
+
+ if (member == NULL || other_member == NULL || member->relationships == NULL)
+ return NULL;
+
+ lock_member(member);
+ lock_member(other_member);
+
+ for (rel = member->relationships; rel; rel = rel->next) {
+ if (rel->id == other_member->id) {
+ break;
+ }
+
+ /* 0 matches everyone. (We will still test the others because a real match carries more clout) */
+ if (rel->id == 0) {
+ global = rel;
+ }
+ }
+
+ unlock_member(other_member);
+ unlock_member(member);
+
+ return rel ? rel : global;
+}
+
+/* stop playing a file for the member of the conference */
+uint32_t conf_member_stop_file(conf_member_t *member, file_stop_t stop)
+{
+ conference_file_node_t *nptr;
+ uint32_t count = 0;
+
+ if (member == NULL)
+ return count;
+
+
+ switch_mutex_lock(member->fnode_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->fnode_mutex);
+
+ return count;
+}
+
+
+
+/* traverse the conference member list for the specified member id and return it's pointer */
+conf_member_t *conf_member_get(conference_obj_t *conference, uint32_t id)
+{
+ conf_member_t *member = NULL;
+
+ switch_assert(conference != NULL);
+ if (!id) {
+ return NULL;
+ }
+
+ switch_mutex_lock(conference->member_mutex);
+ for (member = conference->members; member; member = member->next) {
+
+ if (conf_utils_member_test_flag(member, MFLAG_NOCHANNEL)) {
+ continue;
+ }
+
+ if (member->id == id) {
+ break;
+ }
+ }
+
+ if (member) {
+ if (!conf_utils_member_test_flag(member, MFLAG_INTREE) ||
+ conf_utils_member_test_flag(member, MFLAG_KICKED) ||
+ (member->session && !switch_channel_up(switch_core_session_get_channel(member->session)))) {
+
+ /* member is kicked or hanging up so forget it */
+ member = NULL;
+ }
+ }
+
+ if (member) {
+ if (switch_thread_rwlock_tryrdlock(member->rwlock) != SWITCH_STATUS_SUCCESS) {
+ /* if you cant readlock it's way to late to do anything */
+ member = NULL;
+ }
+ }
+
+ switch_mutex_unlock(conference->member_mutex);
+
+ return member;
+}
+
+void conf_member_check_agc_levels(conf_member_t *member)
+{
+ int x = 0;
+
+ if (!member->avg_score) return;
+
+ if ((int)member->avg_score < member->conference->agc_level - 100) {
+ member->agc_volume_in_level++;
+ switch_normalize_volume_granular(member->agc_volume_in_level);
+ x = 1;
+ } else if ((int)member->avg_score > member->conference->agc_level + 100) {
+ member->agc_volume_in_level--;
+ switch_normalize_volume_granular(member->agc_volume_in_level);
+ x = -1;
+ }
+
+ if (x) {
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG7,
+ "AGC %s:%d diff:%d level:%d cur:%d avg:%d vol:%d %s\n",
+ member->conference->name,
+ member->id, member->conference->agc_level - member->avg_score, member->conference->agc_level,
+ member->score, member->avg_score, member->agc_volume_in_level, x > 0 ? "+++" : "---");
+
+ conf_member_clear_avg(member);
+ }
+}
-void member_check_channels(switch_frame_t *frame, conference_member_t *member, switch_bool_t in)
+void conf_member_check_channels(switch_frame_t *frame, conf_member_t *member, switch_bool_t in)
{
- if (member->conference->channels != member->read_impl.number_of_channels || member_test_flag(member, MFLAG_POSITIONAL)) {
+ if (member->conference->channels != member->read_impl.number_of_channels || conf_utils_member_test_flag(member, MFLAG_POSITIONAL)) {
uint32_t rlen;
int from, to;
rlen = frame->datalen / 2 / from;
- if (in && frame->rate == 48000 && ((from == 1 && to == 2) || (from == 2 && to == 2)) && member_test_flag(member, MFLAG_POSITIONAL)) {
+ if (in && frame->rate == 48000 && ((from == 1 && to == 2) || (from == 2 && to == 2)) && conf_utils_member_test_flag(member, MFLAG_POSITIONAL)) {
if (from == 2 && to == 2) {
switch_mux_channels((int16_t *) frame->data, rlen, 2, 1);
frame->datalen /= 2;
rlen = frame->datalen / 2;
}
- process_al(member->al, frame->data, frame->datalen, frame->rate);
+ conf_al_process(member->al, frame->data, frame->datalen, frame->rate);
} else {
switch_mux_channels((int16_t *) frame->data, rlen, from, to);
}
}
-void member_add_file_data(conference_member_t *member, int16_t *data, switch_size_t file_data_len)
+void conf_member_add_file_data(conf_member_t *member, int16_t *data, switch_size_t file_data_len)
{
switch_size_t file_sample_len;
int16_t file_frame[SWITCH_RECOMMENDED_BUFFER_SIZE] = { 0 };
}
if (member->fnode->al) {
- process_al(member->fnode->al, file_frame, file_sample_len * 2, member->conference->rate);
+ conf_al_process(member->fnode->al, file_frame, file_sample_len * 2, member->conference->rate);
}
for (i = 0; i < (int)file_sample_len * member->conference->channels; i++) {
/* Add a custom relationship to a member */
-conference_relationship_t *member_add_relationship(conference_member_t *member, uint32_t id)
+conference_relationship_t *conf_member_add_relationship(conf_member_t *member, uint32_t id)
{
conference_relationship_t *rel = NULL;
}
/* Remove a custom relationship from a member */
-switch_status_t member_del_relationship(conference_member_t *member, uint32_t id)
+switch_status_t conf_member_del_relationship(conf_member_t *member, uint32_t id)
{
switch_status_t status = SWITCH_STATUS_FALSE;
conference_relationship_t *rel, *last = NULL;
if (id == 0 || 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 */
- conference_member_t *omember;
+ conf_member_t *omember;
status = SWITCH_STATUS_SUCCESS;
}
if ((rel->flags & RFLAG_CAN_SEND_VIDEO)) {
- member_clear_flag(member, MFLAG_RECEIVING_VIDEO);
- if ((omember = conference_member_get(member->conference, rel->id))) {
- member_clear_flag(omember, MFLAG_RECEIVING_VIDEO);
+ conf_utils_member_clear_flag(member, MFLAG_RECEIVING_VIDEO);
+ if ((omember = conf_member_get(member->conference, rel->id))) {
+ conf_utils_member_clear_flag(omember, MFLAG_RECEIVING_VIDEO);
switch_thread_rwlock_unlock(omember->rwlock);
}
}
/* Gain exclusive access and add the member to the list */
-switch_status_t conference_add_member(conference_obj_t *conference, conference_member_t *member)
+switch_status_t conf_member_add(conference_obj_t *conference, conf_member_t *member)
{
switch_status_t status = SWITCH_STATUS_FALSE;
switch_event_t *event;
switch_queue_create(&member->dtmf_queue, 100, member->pool);
- if (conference_test_flag(conference, CFLAG_PERSONAL_CANVAS)) {
+ if (conf_utils_test_flag(conference, CFLAG_PERSONAL_CANVAS)) {
video_layout_t *vlayout = NULL;
switch_mutex_lock(conference->canvas_mutex);
- if ((vlayout = get_layout(conference, conference->video_layout_name, conference->video_layout_group))) {
- init_canvas(conference, vlayout, &member->canvas);
- init_canvas_layers(conference, member->canvas, vlayout);
+ if ((vlayout = conf_video_get_layout(conference, conference->video_layout_name, conference->video_layout_group))) {
+ conf_video_init_canvas(conference, vlayout, &member->canvas);
+ conf_video_init_canvas_layers(conference, member->canvas, vlayout);
}
switch_mutex_unlock(conference->canvas_mutex);
}
if (member->video_flow == SWITCH_MEDIA_FLOW_SENDONLY) {
- member_clear_flag_locked(member, MFLAG_CAN_BE_SEEN);
+ conf_utils_member_clear_flag_locked(member, MFLAG_CAN_BE_SEEN);
}
conference->members = member;
- member_set_flag_locked(member, MFLAG_INTREE);
+ conf_utils_member_set_flag_locked(member, MFLAG_INTREE);
switch_mutex_unlock(conference->member_mutex);
- conference_cdr_add(member);
+ conf_cdr_add(member);
- if (!member_test_flag(member, MFLAG_NOCHANNEL)) {
- if (member_test_flag(member, MFLAG_GHOST)) {
+ if (!conf_utils_member_test_flag(member, MFLAG_NOCHANNEL)) {
+ if (conf_utils_member_test_flag(member, MFLAG_GHOST)) {
conference->count_ghosts++;
} else {
conference->count++;
}
- if (member_test_flag(member, MFLAG_ENDCONF)) {
+ if (conf_utils_member_test_flag(member, MFLAG_ENDCONF)) {
if (conference->end_count++) {
conference->endconf_time = 0;
}
}
- conference_send_presence(conference);
+ conf_send_presence(conference);
channel = switch_core_session_get_channel(member->session);
member->video_flow = switch_core_session_media_flow(member->session, SWITCH_MEDIA_TYPE_VIDEO);
- check_avatar(member, SWITCH_FALSE);
+ conf_video_check_avatar(member, SWITCH_FALSE);
if ((var = switch_channel_get_variable_dup(member->channel, "video_initial_canvas", SWITCH_FALSE, -1))) {
int id = atoi(var) - 1;
}
}
- reset_member_codec_index(member);
+ conf_video_reset_member_codec_index(member);
if ((var = switch_channel_get_variable_dup(member->channel, "video_mute_png", SWITCH_FALSE, -1))) {
member->video_mute_png = switch_core_strdup(member->pool, var);
}
if ((var = switch_channel_get_variable(channel, "video_use_dedicated_encoder")) && switch_true(var)) {
- member_set_flag_locked(member, MFLAG_NO_MINIMIZE_ENCODING);
+ conf_utils_member_set_flag_locked(member, MFLAG_NO_MINIMIZE_ENCODING);
}
- switch_channel_set_variable_printf(channel, "conference_member_id", "%d", member->id);
- switch_channel_set_variable_printf(channel, "conference_moderator", "%s", member_test_flag(member, MFLAG_MOD) ? "true" : "false");
- switch_channel_set_variable_printf(channel, "conference_ghost", "%s", member_test_flag(member, MFLAG_GHOST) ? "true" : "false");
+ switch_channel_set_variable_printf(channel, "conf_member_id", "%d", member->id);
+ switch_channel_set_variable_printf(channel, "conference_moderator", "%s", conf_utils_member_test_flag(member, MFLAG_MOD) ? "true" : "false");
+ switch_channel_set_variable_printf(channel, "conference_ghost", "%s", conf_utils_member_test_flag(member, MFLAG_GHOST) ? "true" : "false");
switch_channel_set_variable(channel, "conference_recording", conference->record_filename);
switch_channel_set_variable(channel, CONFERENCE_UUID_VARIABLE, conference->uuid_str);
}
- if (conference_test_flag(conference, CFLAG_WAIT_MOD) && member_test_flag(member, MFLAG_MOD)) {
- conference_clear_flag(conference, CFLAG_WAIT_MOD);
+ if (conf_utils_test_flag(conference, CFLAG_WAIT_MOD) && conf_utils_member_test_flag(member, MFLAG_MOD)) {
+ conf_utils_clear_flag(conference, CFLAG_WAIT_MOD);
}
if (conference->count > 1) {
- if ((conference->moh_sound && !conference_test_flag(conference, CFLAG_WAIT_MOD)) ||
- (conference_test_flag(conference, CFLAG_WAIT_MOD) && !switch_true(switch_channel_get_variable(channel, "conference_permanent_wait_mod_moh")))) {
+ if ((conference->moh_sound && !conf_utils_test_flag(conference, CFLAG_WAIT_MOD)) ||
+ (conf_utils_test_flag(conference, CFLAG_WAIT_MOD) && !switch_true(switch_channel_get_variable(channel, "conference_permanent_wait_mod_moh")))) {
/* stop MoH if any */
- conference_stop_file(conference, FILE_STOP_ASYNC);
+ conference_file_stop(conference, FILE_STOP_ASYNC);
}
if (!switch_channel_test_app_flag_key("conf_silent", channel, CONF_SILENT_REQ) && !zstr(conference->enter_sound)) {
const char * enter_sound = switch_channel_get_variable(channel, "conference_enter_sound");
- if (conference_test_flag(conference, CFLAG_ENTER_SOUND) && !member_test_flag(member, MFLAG_SILENT)) {
+ if (conf_utils_test_flag(conference, CFLAG_ENTER_SOUND) && !conf_utils_member_test_flag(member, MFLAG_SILENT)) {
if (!zstr(enter_sound)) {
- conference_play_file(conference, (char *)enter_sound, CONF_DEFAULT_LEADIN,
+ conference_file_play(conference, (char *)enter_sound, CONF_DEFAULT_LEADIN,
switch_core_session_get_channel(member->session), 0);
} else {
- conference_play_file(conference, conference->enter_sound, CONF_DEFAULT_LEADIN, switch_core_session_get_channel(member->session), 0);
+ conference_file_play(conference, conference->enter_sound, CONF_DEFAULT_LEADIN, switch_core_session_get_channel(member->session), 0);
}
}
}
if (call_list) {
char saymsg[1024];
switch_snprintf(saymsg, sizeof(saymsg), "Auto Calling %d parties", call_list->iteration);
- conference_member_say(member, saymsg, 0);
+ conf_member_say(member, saymsg, 0);
} else {
if (!switch_channel_test_app_flag_key("conf_silent", channel, CONF_SILENT_REQ)) {
/* announce the total number of members in the conference */
if (conference->count >= conference->announce_count && conference->announce_count > 1) {
switch_snprintf(msg, sizeof(msg), "There are %d callers", conference->count);
- conference_member_say(member, msg, CONF_DEFAULT_LEADIN);
- } else if (conference->count == 1 && !conference->perpetual_sound && !conference_test_flag(conference, CFLAG_WAIT_MOD)) {
+ conf_member_say(member, msg, CONF_DEFAULT_LEADIN);
+ } else if (conference->count == 1 && !conference->perpetual_sound && !conf_utils_test_flag(conference, CFLAG_WAIT_MOD)) {
/* as long as its not a bridge_to conference, announce if person is alone */
- if (!conference_test_flag(conference, CFLAG_BRIDGE_TO)) {
- if (conference->alone_sound && !member_test_flag(member, MFLAG_GHOST)) {
- conference_stop_file(conference, FILE_STOP_ASYNC);
- conference_play_file(conference, conference->alone_sound, CONF_DEFAULT_LEADIN,
+ if (!conf_utils_test_flag(conference, CFLAG_BRIDGE_TO)) {
+ if (conference->alone_sound && !conf_utils_member_test_flag(member, MFLAG_GHOST)) {
+ conference_file_stop(conference, FILE_STOP_ASYNC);
+ conference_file_play(conference, conference->alone_sound, CONF_DEFAULT_LEADIN,
switch_core_session_get_channel(member->session), 0);
} else {
switch_snprintf(msg, sizeof(msg), "You are currently the only person in this conference.");
- conference_member_say(member, msg, CONF_DEFAULT_LEADIN);
+ conf_member_say(member, msg, CONF_DEFAULT_LEADIN);
}
}
}
}
if (conference->min && conference->count >= conference->min) {
- conference_set_flag(conference, CFLAG_ENFORCE_MIN);
+ conf_utils_set_flag(conference, CFLAG_ENFORCE_MIN);
}
if (!switch_channel_test_app_flag_key("conf_silent", channel, CONF_SILENT_REQ) &&
switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
- conference_add_event_member_data(member, event);
+ conf_member_add_event_data(member, event);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "add-member");
switch_event_fire(&event);
}
if ((position = switch_channel_get_variable(channel, "conference_position"))) {
if (conference->channels == 2) {
- if (member_test_flag(member, MFLAG_NO_POSITIONAL)) {
+ if (conf_utils_member_test_flag(member, MFLAG_NO_POSITIONAL)) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING,
"%s has positional audio blocked.\n", switch_channel_get_name(channel));
} else {
- if (member_parse_position(member, position) != SWITCH_STATUS_SUCCESS) {
+ if (conf_member_parse_position(member, position) != SWITCH_STATUS_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "%s invalid position data\n", switch_channel_get_name(channel));
} else {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "%s position data set\n", switch_channel_get_name(channel));
}
- member_set_flag(member, MFLAG_POSITIONAL);
- member->al = create_al(member->pool);
+ conf_utils_member_set_flag(member, MFLAG_POSITIONAL);
+ member->al = conf_al_create(member->pool);
}
} else {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "%s cannot set position data on mono conference.\n", switch_channel_get_name(channel));
controls = switch_channel_get_variable(channel, "conference_controls");
if (zstr(controls)) {
- if (!member_test_flag(member, MFLAG_MOD) || !conference->moderator_controls) {
+ if (!conf_utils_member_test_flag(member, MFLAG_MOD) || !conference->moderator_controls) {
controls = conference->caller_controls;
} else {
controls = conference->moderator_controls;
if (strcasecmp(controls, "none")) {
switch_ivr_dmachine_create(&member->dmachine, "mod_conference", NULL,
conference->ivr_dtmf_timeout, conference->ivr_input_timeout, NULL, NULL, NULL);
- member_bind_controls(member, controls);
+ conf_member_bind_controls(member, controls);
}
}
switch_mutex_unlock(member->audio_in_mutex);
if (conference->la && member->channel && !switch_channel_test_flag(member->channel, CF_VIDEO_ONLY)) {
- if (!member_test_flag(member, MFLAG_SECOND_SCREEN)) {
+ if (!conf_utils_member_test_flag(member, MFLAG_SECOND_SCREEN)) {
member->json = cJSON_CreateArray();
cJSON_AddItemToArray(member->json, cJSON_CreateStringPrintf("%0.4d", member->id));
cJSON_AddItemToArray(member->json, cJSON_CreateString(switch_channel_get_variable(member->channel, "caller_id_number")));
cJSON_AddItemToArray(member->json, cJSON_CreateNull());
- member_update_status_field(member);
+ conf_member_update_status_field(member);
//switch_live_array_add_alias(conference->la, switch_core_session_get_uuid(member->session), "conference");
}
- adv_la(conference, member, SWITCH_TRUE);
+ conf_event_adv_la(conference, member, SWITCH_TRUE);
- if (!member_test_flag(member, MFLAG_SECOND_SCREEN)) {
+ if (!conf_utils_member_test_flag(member, MFLAG_SECOND_SCREEN)) {
switch_live_array_add(conference->la, switch_core_session_get_uuid(member->session), -1, &member->json, SWITCH_FALSE);
}
}
- if (conference_test_flag(conference, CFLAG_POSITIONAL)) {
- gen_arc(conference, NULL);
+ if (conf_utils_test_flag(conference, CFLAG_POSITIONAL)) {
+ conf_al_gen_arc(conference, NULL);
}
- send_rfc_event(conference);
- send_json_event(conference);
+ conf_event_send_rfc(conference);
+ conf_event_send_json(conference);
switch_mutex_unlock(conference->mutex);
status = SWITCH_STATUS_SUCCESS;
- find_video_floor(member, SWITCH_TRUE);
+ conf_video_find_floor(member, SWITCH_TRUE);
- if (member_test_flag(member, MFLAG_JOIN_VID_FLOOR)) {
- conference_set_video_floor_holder(conference, member, SWITCH_TRUE);
- conference_set_flag(member->conference, CFLAG_VID_FLOOR_LOCK);
+ if (conf_utils_member_test_flag(member, MFLAG_JOIN_VID_FLOOR)) {
+ conf_video_set_floor_holder(conference, member, SWITCH_TRUE);
+ conf_utils_set_flag(member->conference, CFLAG_VID_FLOOR_LOCK);
if (test_eflag(conference, EFLAG_FLOOR_CHANGE)) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "conference %s OK video floor %d %s\n",
return status;
}
-void conference_set_floor_holder(conference_obj_t *conference, conference_member_t *member)
+void conf_member_set_floor_holder(conference_obj_t *conference, conf_member_t *member)
{
switch_event_t *event;
- conference_member_t *old_member = NULL;
+ conf_member_t *old_member = NULL;
int old_id = 0;
if (conference->floor_holder) {
switch_channel_get_name(member->channel));
conference->floor_holder = member;
- member_update_status_field(member);
+ conf_member_update_status_field(member);
} else {
conference->floor_holder = NULL;
}
if (old_member) {
old_id = old_member->id;
- member_update_status_field(old_member);
+ conf_member_update_status_field(old_member);
old_member->floor_packets = 0;
}
- conference_set_flag(conference, CFLAG_FLOOR_CHANGE);
+ conf_utils_set_flag(conference, CFLAG_FLOOR_CHANGE);
switch_mutex_unlock(conference->mutex);
if (test_eflag(conference, EFLAG_FLOOR_CHANGE)) {
switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT);
- conference_add_event_data(conference, event);
+ conf_event_add_data(conference, event);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "floor-change");
if (old_id) {
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Old-ID", "%d", old_id);
}
if (conference->floor_holder) {
- conference_add_event_member_data(conference->floor_holder, event);
+ conf_member_add_event_data(conference->floor_holder, event);
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "New-ID", "%d", conference->floor_holder->id);
} else {
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "New-ID", "none");
}
/* Gain exclusive access and remove the member from the list */
-switch_status_t conference_del_member(conference_obj_t *conference, conference_member_t *member)
+switch_status_t conf_member_del(conference_obj_t *conference, conf_member_t *member)
{
switch_status_t status = SWITCH_STATUS_FALSE;
- conference_member_t *imember, *last = NULL;
+ conf_member_t *imember, *last = NULL;
switch_event_t *event;
conference_file_node_t *member_fnode;
switch_speech_handle_t *member_sh;
switch_thread_rwlock_wrlock(member->rwlock);
if (member->session && (exit_sound = switch_channel_get_variable(switch_core_session_get_channel(member->session), "conference_exit_sound"))) {
- conference_play_file(conference, (char *)exit_sound, CONF_DEFAULT_LEADIN,
+ conference_file_play(conference, (char *)exit_sound, CONF_DEFAULT_LEADIN,
switch_core_session_get_channel(member->session), 0);
}
lock_member(member);
- member_del_relationship(member, 0);
+ conf_member_del_relationship(member, 0);
- conference_cdr_del(member);
+ conf_cdr_del(member);
#ifdef OPENAL_POSITIONING
if (member->al && member->al->device) {
- close_al(member->al);
+ conf_al_close(member->al);
}
#endif
if (member->canvas) {
- destroy_canvas(&member->canvas);
+ conf_video_destroy_canvas(&member->canvas);
}
member_fnode = member->fnode;
switch_mutex_lock(member->audio_in_mutex);
switch_mutex_lock(member->audio_out_mutex);
lock_member(member);
- member_clear_flag(member, MFLAG_INTREE);
+ conf_utils_member_clear_flag(member, MFLAG_INTREE);
if (member->rec) {
conference->recording_members--;
}
if (member == member->conference->floor_holder) {
- conference_set_floor_holder(member->conference, NULL);
+ conf_member_set_floor_holder(member->conference, NULL);
}
if (member->id == member->conference->video_floor_holder) {
- conference_clear_flag(member->conference, CFLAG_VID_FLOOR_LOCK);
+ conf_utils_clear_flag(member->conference, CFLAG_VID_FLOOR_LOCK);
if (member->conference->last_video_floor_holder) {
member->conference->video_floor_holder = member->conference->last_video_floor_holder;
member->conference->last_video_floor_holder = 0;
member->conference->video_floor_holder = 0;
}
- if (!member_test_flag(member, MFLAG_NOCHANNEL)) {
+ if (!conf_utils_member_test_flag(member, MFLAG_NOCHANNEL)) {
switch_channel_t *channel = switch_core_session_get_channel(member->session);
- if (member_test_flag(member, MFLAG_GHOST)) {
+ if (conf_utils_member_test_flag(member, MFLAG_GHOST)) {
conference->count_ghosts--;
} else {
conference->count--;
}
- if (member_test_flag(member, MFLAG_ENDCONF)) {
+ if (conf_utils_member_test_flag(member, MFLAG_ENDCONF)) {
if (!--conference->end_count) {
- //conference_set_flag_locked(conference, CFLAG_DESTRUCT);
+ //conf_utils_set_flag_locked(conference, CFLAG_DESTRUCT);
conference->endconf_time = switch_epoch_time_now(NULL);
}
}
- conference_send_presence(conference);
+ conf_send_presence(conference);
switch_channel_set_variable(channel, "conference_call_key", NULL);
- if ((conference->min && conference_test_flag(conference, CFLAG_ENFORCE_MIN) && (conference->count + conference->count_ghosts) < conference->min)
- || (conference_test_flag(conference, CFLAG_DYNAMIC) && (conference->count + conference->count_ghosts == 0))) {
- conference_set_flag(conference, CFLAG_DESTRUCT);
+ if ((conference->min && conf_utils_test_flag(conference, CFLAG_ENFORCE_MIN) && (conference->count + conference->count_ghosts) < conference->min)
+ || (conf_utils_test_flag(conference, CFLAG_DYNAMIC) && (conference->count + conference->count_ghosts == 0))) {
+ conf_utils_set_flag(conference, CFLAG_DESTRUCT);
} else {
- if (!switch_true(switch_channel_get_variable(channel, "conference_permanent_wait_mod_moh")) && conference_test_flag(conference, CFLAG_WAIT_MOD)) {
+ if (!switch_true(switch_channel_get_variable(channel, "conference_permanent_wait_mod_moh")) && conf_utils_test_flag(conference, CFLAG_WAIT_MOD)) {
/* Stop MOH if any */
- conference_stop_file(conference, FILE_STOP_ASYNC);
+ conference_file_stop(conference, FILE_STOP_ASYNC);
}
- if (!exit_sound && conference->exit_sound && conference_test_flag(conference, CFLAG_EXIT_SOUND) && !member_test_flag(member, MFLAG_SILENT)) {
- conference_play_file(conference, conference->exit_sound, 0, channel, 0);
+ if (!exit_sound && conference->exit_sound && conf_utils_test_flag(conference, CFLAG_EXIT_SOUND) && !conf_utils_member_test_flag(member, MFLAG_SILENT)) {
+ conference_file_play(conference, conference->exit_sound, 0, channel, 0);
}
- if (conference->count == 1 && conference->alone_sound && !conference_test_flag(conference, CFLAG_WAIT_MOD) && !member_test_flag(member, MFLAG_GHOST)) {
- conference_stop_file(conference, FILE_STOP_ASYNC);
- conference_play_file(conference, conference->alone_sound, 0, channel, 0);
+ if (conference->count == 1 && conference->alone_sound && !conf_utils_test_flag(conference, CFLAG_WAIT_MOD) && !conf_utils_member_test_flag(member, MFLAG_GHOST)) {
+ conference_file_stop(conference, FILE_STOP_ASYNC);
+ conference_file_play(conference, conference->alone_sound, 0, channel, 0);
}
}
if (test_eflag(conference, EFLAG_DEL_MEMBER) &&
switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
- conference_add_event_member_data(member, event);
- conference_add_event_data(conference, event);
+ conf_member_add_event_data(member, event);
+ conf_event_add_data(conference, event);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "del-member");
switch_event_fire(&event);
}
}
- find_video_floor(member, SWITCH_FALSE);
- detach_video_layer(member);
+ conf_video_find_floor(member, SWITCH_FALSE);
+ conf_video_detach_video_layer(member);
member->conference = NULL;
if (conference->la && member->session && !switch_channel_test_flag(member->channel, CF_VIDEO_ONLY)) {
switch_live_array_del(conference->la, switch_core_session_get_uuid(member->session));
//switch_live_array_clear_alias(conference->la, switch_core_session_get_uuid(member->session), "conference");
- adv_la(conference, member, SWITCH_FALSE);
+ conf_event_adv_la(conference, member, SWITCH_FALSE);
}
- send_rfc_event(conference);
- send_json_event(conference);
+ conf_event_send_rfc(conference);
+ conf_event_send_json(conference);
- if (conference_test_flag(conference, CFLAG_POSITIONAL)) {
- gen_arc(conference, NULL);
+ if (conf_utils_test_flag(conference, CFLAG_POSITIONAL)) {
+ conf_al_gen_arc(conference, NULL);
}
if (member->session) {
return status;
}
-void conference_send_all_dtmf(conference_member_t *member, conference_obj_t *conference, const char *dtmf)
+void conf_member_send_all_dtmf(conf_member_t *member, conference_obj_t *conference, const char *dtmf)
{
- conference_member_t *imember;
+ conf_member_t *imember;
switch_mutex_lock(conference->mutex);
switch_mutex_lock(conference->member_mutex);
/* Play a file in the conference room to a member */
-switch_status_t conference_member_play_file(conference_member_t *member, char *file, uint32_t leadin, switch_bool_t mux)
+switch_status_t conf_member_play_file(conf_member_t *member, char *file, uint32_t leadin, switch_bool_t mux)
{
switch_status_t status = SWITCH_STATUS_FALSE;
char *dfile = NULL, *expanded = NULL;
int channels = member->conference->channels;
int bad_params = 0;
- if (member == NULL || file == NULL || member_test_flag(member, MFLAG_KICKED))
+ if (member == NULL || file == NULL || conf_utils_member_test_flag(member, MFLAG_KICKED))
return status;
if ((expanded = switch_channel_expand_variables(switch_core_session_get_channel(member->session), file)) != file) {
}
if (!strncasecmp(file, "say:", 4)) {
if (!zstr(file + 4)) {
- status = conference_member_say(member, file + 4, leadin);
+ status = conf_member_say(member, file + 4, leadin);
}
goto done;
}
}
file = dfile;
} else if (!zstr(file)) {
- status = conference_member_say(member, file, leadin);
+ status = conf_member_say(member, file, leadin);
goto done;
}
}
const char *position = switch_event_get_header(fnode->fh.params, "position");
if (!bad_params && !zstr(position) && member->conference->channels == 2) {
- fnode->al = create_al(pool);
- if (parse_position(fnode->al, position) != SWITCH_STATUS_SUCCESS) {
+ fnode->al = conf_al_create(pool);
+ if (conf_al_parse_position(fnode->al, position) != SWITCH_STATUS_SUCCESS) {
switch_core_file_close(&fnode->fh);
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(member->session), SWITCH_LOG_ERROR, "Invalid Position Data.\n");
fnode->al = NULL;
}
/* Say some thing with TTS in the conference room */
-switch_status_t conference_member_say(conference_member_t *member, char *text, uint32_t leadin)
+switch_status_t conf_member_say(conf_member_t *member, char *text, uint32_t leadin)
{
conference_obj_t *conference = member->conference;
conference_file_node_t *fnode, *nptr;
position = NULL;
} else {
channels = 1;
- fnode->al = create_al(pool);
- if (parse_position(fnode->al, position) != SWITCH_STATUS_SUCCESS) {
+ fnode->al = conf_al_create(pool);
+ if (conf_al_parse_position(fnode->al, position) != SWITCH_STATUS_SUCCESS) {
fnode->al = NULL;
channels = conference->channels;
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invalid Position Data.\n");
/* execute a callback for every member of the conference */
-void conference_member_itterator(conference_obj_t *conference, switch_stream_handle_t *stream, uint8_t non_mod, conf_api_member_cmd_t pfncallback, void *data)
+void conf_member_itterator(conference_obj_t *conference, switch_stream_handle_t *stream, uint8_t non_mod, conf_api_member_cmd_t pfncallback, void *data)
{
- conference_member_t *member = NULL;
+ conf_member_t *member = NULL;
switch_assert(conference != NULL);
switch_assert(stream != NULL);
switch_mutex_lock(conference->member_mutex);
for (member = conference->members; member; member = member->next) {
- if (!(non_mod && member_test_flag(member, MFLAG_MOD))) {
- if (member->session && !member_test_flag(member, MFLAG_NOCHANNEL)) {
+ if (!(non_mod && conf_utils_member_test_flag(member, MFLAG_MOD))) {
+ if (member->session && !conf_utils_member_test_flag(member, MFLAG_NOCHANNEL)) {
pfncallback(member, stream, data);
}
} else {
}
-int get_canvas_id(conference_member_t *member, const char *val, switch_bool_t watching)
+int conf_member_get_canvas_id(conf_member_t *member, const char *val, switch_bool_t watching)
{
int index = -1;
int cur;
}
-int setup_media(conference_member_t *member, conference_obj_t *conference)
+int conf_member_setup_media(conf_member_t *member, conference_obj_t *conference)
{
switch_codec_implementation_t read_impl = { 0 };
*/
#include <mod_conference.h>
+void conf_record_launch_thread(conference_obj_t *conference, char *path, switch_bool_t autorec)
+{
+ switch_thread_t *thread;
+ switch_threadattr_t *thd_attr = NULL;
+ switch_memory_pool_t *pool;
+ conf_record_t *rec;
+
+ /* 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");
+ }
+
+ /* Create a node object */
+ if (!(rec = switch_core_alloc(pool, sizeof(*rec)))) {
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Alloc Failure\n");
+ switch_core_destroy_memory_pool(&pool);
+ return;
+ }
+
+ rec->conference = conference;
+ rec->path = switch_core_strdup(pool, path);
+ rec->pool = pool;
+ rec->autorec = autorec;
+
+ switch_mutex_lock(conference->flag_mutex);
+ rec->next = conference->rec_node_head;
+ conference->rec_node_head = rec;
+ switch_mutex_unlock(conference->flag_mutex);
+
+ switch_threadattr_create(&thd_attr, rec->pool);
+ switch_threadattr_detach_set(thd_attr, 1);
+ switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE);
+ switch_thread_create(&thread, thd_attr, conf_record_thread_run, rec, rec->pool);
+}
+
/* stop the specified recording */
-switch_status_t conference_record_stop(conference_obj_t *conference, switch_stream_handle_t *stream, char *path)
+switch_status_t conf_record_stop(conference_obj_t *conference, switch_stream_handle_t *stream, char *path)
{
- conference_member_t *member = NULL;
+ conf_member_t *member = NULL;
int count = 0;
switch_assert(conference != NULL);
switch_mutex_lock(conference->member_mutex);
for (member = conference->members; member; member = member->next) {
- if (member_test_flag(member, MFLAG_NOCHANNEL) && (!path || !strcmp(path, member->rec_path))) {
- if (!conference_test_flag(conference, CFLAG_CONF_RESTART_AUTO_RECORD) && member->rec && member->rec->autorec) {
+ if (conf_utils_member_test_flag(member, MFLAG_NOCHANNEL) && (!path || !strcmp(path, member->rec_path))) {
+ if (!conf_utils_test_flag(conference, CFLAG_CONF_RESTART_AUTO_RECORD) && member->rec && member->rec->autorec) {
stream->write_function(stream, "Stopped AUTO recording file %s (Auto Recording Now Disabled)\n", member->rec_path);
conference->auto_record = 0;
} else {
stream->write_function(stream, "Stopped recording file %s\n", member->rec_path);
}
- member_clear_flag_locked(member, MFLAG_RUNNING);
+ conf_utils_member_clear_flag_locked(member, MFLAG_RUNNING);
count++;
}
return count;
}
/* stop/pause/resume the specified recording */
-switch_status_t conference_record_action(conference_obj_t *conference, char *path, recording_action_type_t action)
+switch_status_t conf_record_action(conference_obj_t *conference, char *path, recording_action_type_t action)
{
- conference_member_t *member = NULL;
+ conf_member_t *member = NULL;
int count = 0;
//switch_file_handle_t *fh = NULL;
switch_mutex_lock(conference->member_mutex);
for (member = conference->members; member; member = member->next)
{
- if (member_test_flag(member, MFLAG_NOCHANNEL) && (!path || !strcmp(path, member->rec_path)))
+ if (conf_utils_member_test_flag(member, MFLAG_NOCHANNEL) && (!path || !strcmp(path, member->rec_path)))
{
//switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Action: %d\n", action);
switch (action)
{
case REC_ACTION_STOP:
- member_clear_flag_locked(member, MFLAG_RUNNING);
+ conf_utils_member_clear_flag_locked(member, MFLAG_RUNNING);
count++;
break;
case REC_ACTION_PAUSE:
- member_set_flag_locked(member, MFLAG_PAUSE_RECORDING);
+ conf_utils_member_set_flag_locked(member, MFLAG_PAUSE_RECORDING);
count = 1;
break;
case REC_ACTION_RESUME:
- member_clear_flag_locked(member, MFLAG_PAUSE_RECORDING);
+ conf_utils_member_clear_flag_locked(member, MFLAG_PAUSE_RECORDING);
count = 1;
break;
}
/* Sub-Routine called by a record entity inside a conference */
-void *SWITCH_THREAD_FUNC conference_record_thread_run(switch_thread_t *thread, void *obj)
+void *SWITCH_THREAD_FUNC conf_record_thread_run(switch_thread_t *thread, void *obj)
{
int16_t *data_buf;
- conference_member_t smember = { 0 }, *member;
- conference_record_t *rp, *last = NULL, *rec = (conference_record_t *) obj;
+ conf_member_t smember = { 0 }, *member;
+ conf_record_t *rp, *last = NULL, *rec = (conf_record_t *) obj;
conference_obj_t *conference = rec->conference;
uint32_t samples = switch_samples_per_packet(conference->rate, conference->interval);
uint32_t mux_used;
data_buf_len = samples * sizeof(int16_t) * conference->channels;
switch_zmalloc(data_buf, data_buf_len);
- switch_mutex_lock(mod_conference_globals.hash_mutex);
- mod_conference_globals.threads++;
- switch_mutex_unlock(mod_conference_globals.hash_mutex);
+ switch_mutex_lock(conf_globals.hash_mutex);
+ conf_globals.threads++;
+ switch_mutex_unlock(conf_globals.hash_mutex);
member = &smember;
flags = SWITCH_FILE_FLAG_WRITE | SWITCH_FILE_DATA_SHORT;
- if (conference->members_with_video && conference_test_flag(conference, CFLAG_TRANSCODE_VIDEO)) {
+ if (conference->members_with_video && conf_utils_test_flag(conference, CFLAG_TRANSCODE_VIDEO)) {
flags |= SWITCH_FILE_FLAG_VIDEO;
if (conference->canvas) {
char *orig_path = rec->path;
if (test_eflag(conference, EFLAG_RECORD) &&
switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
- conference_add_event_data(conference, event);
+ conf_event_add_data(conference, event);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "start-recording");
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Path", rec->path);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Error", "File could not be opened for recording");
switch_mutex_lock(conference->mutex);
if (conference->video_floor_holder) {
- conference_member_t *member;
- if ((member = conference_member_get(conference, conference->video_floor_holder))) {
+ conf_member_t *member;
+ if ((member = conf_member_get(conference, conference->video_floor_holder))) {
if (member->session) {
switch_core_session_video_reinit(member->session);
}
if (test_eflag(conference, EFLAG_RECORD) &&
switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
- conference_add_event_data(conference, event);
+ conf_event_add_data(conference, event);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "start-recording");
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Path", rec->path);
switch_event_fire(&event);
}
- if (conference_add_member(conference, member) != SWITCH_STATUS_SUCCESS) {
+ if (conf_member_add(conference, member) != SWITCH_STATUS_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error Joining Conference\n");
goto end;
}
- while (member_test_flag(member, MFLAG_RUNNING) && conference_test_flag(conference, CFLAG_RUNNING) && (conference->count + conference->count_ghosts)) {
+ while (conf_utils_member_test_flag(member, MFLAG_RUNNING) && conf_utils_test_flag(conference, CFLAG_RUNNING) && (conference->count + conference->count_ghosts)) {
len = 0;
mux_used = (uint32_t) switch_buffer_inuse(member->mux_buffer);
- if (member_test_flag(member, MFLAG_FLUSH_BUFFER)) {
+ if (conf_utils_member_test_flag(member, MFLAG_FLUSH_BUFFER)) {
if (mux_used) {
switch_mutex_lock(member->audio_out_mutex);
switch_buffer_zero(member->mux_buffer);
switch_mutex_unlock(member->audio_out_mutex);
mux_used = 0;
}
- member_clear_flag_locked(member, MFLAG_FLUSH_BUFFER);
+ conf_utils_member_clear_flag_locked(member, MFLAG_FLUSH_BUFFER);
}
again:
if (switch_test_flag((&member->rec->fh), SWITCH_FILE_PAUSE)) {
- member_set_flag_locked(member, MFLAG_FLUSH_BUFFER);
+ conf_utils_member_set_flag_locked(member, MFLAG_FLUSH_BUFFER);
goto loop;
}
len = (switch_size_t) samples;
}
- if (!member_test_flag(member, MFLAG_PAUSE_RECORDING)) {
+ if (!conf_utils_member_test_flag(member, MFLAG_PAUSE_RECORDING)) {
if (!len || switch_core_file_write(&member->rec->fh, data_buf, &len) != SWITCH_STATUS_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Write Failed\n");
- member_clear_flag_locked(member, MFLAG_RUNNING);
+ conf_utils_member_clear_flag_locked(member, MFLAG_RUNNING);
}
}
switch_safe_free(data_buf);
switch_core_timer_destroy(&timer);
- conference_del_member(conference, member);
+ conf_member_del(conference, member);
if (conference->canvas) {
conference->canvas->send_keyframe = 1;
switch_buffer_destroy(&member->audio_buffer);
switch_buffer_destroy(&member->mux_buffer);
- member_clear_flag_locked(member, MFLAG_RUNNING);
+ conf_utils_member_clear_flag_locked(member, MFLAG_RUNNING);
if (switch_test_flag((&member->rec->fh), SWITCH_FILE_OPEN)) {
switch_mutex_lock(conference->mutex);
switch_mutex_unlock(conference->mutex);
}
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Recording of %s Stopped\n", rec->path);
if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT) == SWITCH_STATUS_SUCCESS) {
- conference_add_event_data(conference, event);
+ conf_event_add_data(conference, event);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "stop-recording");
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Path", rec->path);
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Samples-Out", "%ld", (long) member->rec->fh.samples_out);
switch_core_destroy_memory_pool(&pool);
}
- switch_mutex_lock(mod_conference_globals.hash_mutex);
- mod_conference_globals.threads--;
- switch_mutex_unlock(mod_conference_globals.hash_mutex);
+ switch_mutex_lock(conf_globals.hash_mutex);
+ conf_globals.threads--;
+ switch_mutex_unlock(conf_globals.hash_mutex);
switch_thread_rwlock_unlock(conference->rwlock);
return NULL;
*/
#include <mod_conference.h>
-void set_mflags(const char *flags, member_flag_t *f)
+const char *conf_utils_combine_flag_var(switch_core_session_t *session, const char *var_name)
+{
+ switch_event_header_t *hp;
+ switch_event_t *event, *cevent;
+ char *ret = NULL;
+ switch_channel_t *channel = switch_core_session_get_channel(session);
+
+ switch_core_get_variables(&event);
+ switch_channel_get_variables(channel, &cevent);
+ switch_event_merge(event, cevent);
+
+
+ for (hp = event->headers; hp; hp = hp->next) {
+ char *var = hp->name;
+ char *val = hp->value;
+
+ if (!strcasecmp(var, var_name)) {
+ if (hp->idx) {
+ int i;
+ for (i = 0; i < hp->idx; i++) {
+ if (zstr(ret)) {
+ ret = switch_core_session_sprintf(session, "%s", hp->array[i]);
+ } else {
+ ret = switch_core_session_sprintf(session, "%s|%s", ret, hp->array[i]);
+ }
+ }
+ } else {
+ if (zstr(ret)) {
+ ret = switch_core_session_sprintf(session, "%s", val);
+ } else {
+ ret = switch_core_session_sprintf(session, "%s|%s", ret, val);
+ }
+ }
+ }
+ }
+
+
+ switch_event_destroy(&event);
+ switch_event_destroy(&cevent);
+
+ return ret;
+
+}
+
+void conf_utils_set_mflags(const char *flags, member_flag_t *f)
{
if (flags) {
char *dup = strdup(flags);
-void set_cflags(const char *flags, conference_flag_t *f)
+void conf_utils_set_cflags(const char *flags, conference_flag_t *f)
{
if (flags) {
char *dup = strdup(flags);
}
-void clear_eflags(char *events, uint32_t *f)
+void conf_utils_clear_eflags(char *events, uint32_t *f)
{
char buf[512] = "";
char *next = NULL;
}
-void merge_mflags(member_flag_t *a, member_flag_t *b)
+void conf_utils_merge_mflags(member_flag_t *a, member_flag_t *b)
{
int x;
}
}
-void conference_set_flag(conference_obj_t *conference, conference_flag_t flag)
+void conf_utils_set_flag(conference_obj_t *conference, conference_flag_t flag)
{
conference->flags[flag] = 1;
}
-void conference_set_flag_locked(conference_obj_t *conference, conference_flag_t flag)
+void conf_utils_set_flag_locked(conference_obj_t *conference, conference_flag_t flag)
{
switch_mutex_lock(conference->flag_mutex);
conference->flags[flag] = 1;
switch_mutex_unlock(conference->flag_mutex);
}
-void conference_clear_flag(conference_obj_t *conference, conference_flag_t flag)
+void conf_utils_clear_flag(conference_obj_t *conference, conference_flag_t flag)
{
conference->flags[flag] = 0;
}
-void conference_clear_flag_locked(conference_obj_t *conference, conference_flag_t flag)
+void conf_utils_clear_flag_locked(conference_obj_t *conference, conference_flag_t flag)
{
switch_mutex_lock(conference->flag_mutex);
conference->flags[flag] = 0;
switch_mutex_unlock(conference->flag_mutex);
}
-switch_bool_t conference_test_flag(conference_obj_t *conference, conference_flag_t flag)
+switch_bool_t conf_utils_test_flag(conference_obj_t *conference, conference_flag_t flag)
{
return !!conference->flags[flag];
}
#if 0
-void conference_set_mflag(conference_obj_t *conference, member_flag_t mflag)
+void conf_utils_conf_utils_set_mflag(conference_obj_t *conference, member_flag_t mflag)
{
conference->mflags[mflag] = 1;
}
-void conference_clear_mflag(conference_obj_t *conference, member_flag_t mflag)
+void conf_utils_clear_mflag(conference_obj_t *conference, member_flag_t mflag)
{
conference->mflags[mflag] = 0;
}
-switch_bool_t conference_test_mflag(conference_obj_t *conference, member_flag_t mflag)
+switch_bool_t conf_utils_test_mflag(conference_obj_t *conference, member_flag_t mflag)
{
return !!conference->mflags[mflag];
}
#endif
-void member_set_flag(conference_member_t *member, member_flag_t flag)
+void conf_utils_member_set_flag(conf_member_t *member, member_flag_t flag)
{
member->flags[flag] = 1;
}
-void member_set_flag_locked(conference_member_t *member, member_flag_t flag)
+void conf_utils_member_set_flag_locked(conf_member_t *member, member_flag_t flag)
{
switch_mutex_lock(member->flag_mutex);
member->flags[flag] = 1;
switch_mutex_unlock(member->flag_mutex);
}
-void member_clear_flag(conference_member_t *member, member_flag_t flag)
+void conf_utils_member_clear_flag(conf_member_t *member, member_flag_t flag)
{
member->flags[flag] = 0;
}
-void member_clear_flag_locked(conference_member_t *member, member_flag_t flag)
+void conf_utils_member_clear_flag_locked(conf_member_t *member, member_flag_t flag)
{
switch_mutex_lock(member->flag_mutex);
member->flags[flag] = 0;
switch_mutex_unlock(member->flag_mutex);
}
-switch_bool_t member_test_flag(conference_member_t *member, member_flag_t flag)
+switch_bool_t conf_utils_member_test_flag(conf_member_t *member, member_flag_t flag)
{
return !!member->flags[flag];
}
};
-int conference_set_fps(conference_obj_t *conference, float fps)
+int conf_video_set_fps(conference_obj_t *conference, float fps)
{
int i = 0, j = 0;
}
-void conference_parse_layouts(conference_obj_t *conference, int WIDTH, int HEIGHT)
+void conf_video_parse_layouts(conference_obj_t *conference, int WIDTH, int HEIGHT)
{
switch_event_t *params;
switch_xml_t cxml = NULL, cfg = NULL, x_layouts, x_layout, x_layout_settings, x_group, x_groups, x_image;
char cmd_str[256] = "";
- switch_mutex_lock(mod_conference_globals.setup_mutex);
+ switch_mutex_lock(conf_globals.setup_mutex);
if (!conference->layout_hash) {
switch_core_hash_init(&conference->layout_hash);
}
if (!conference->layout_group_hash) {
switch_core_hash_init(&conference->layout_group_hash);
}
- switch_mutex_unlock(mod_conference_globals.setup_mutex);
+ switch_mutex_unlock(conf_globals.setup_mutex);
switch_event_create(¶ms, SWITCH_EVENT_COMMAND);
switch_assert(params);
}
switch_core_hash_insert(conference->layout_hash, name, vlayout);
- switch_snprintf(cmd_str, sizeof(cmd_str), "add conference ::conference::list_conferences vid-layout %s", name);
+ switch_snprintf(cmd_str, sizeof(cmd_str), "add conference ::conference::conf_list_conferences vid-layout %s", name);
switch_console_set_complete(cmd_str);
}
}
/* do not use this on an img cropped with switch_img_set_rect() */
-void reset_image(switch_image_t *img, switch_rgb_color_t *color)
+void conf_video_reset_image(switch_image_t *img, switch_rgb_color_t *color)
{
switch_img_fill(img, 0, 0, img->d_w, img->d_h, color);
}
-/* clear layer and reset_layer called inside lock always */
+/* clear layer and conf_video_reset_layer called inside lock always */
-void clear_layer(mcu_layer_t *layer)
+void conf_video_clear_layer(mcu_layer_t *layer)
{
switch_img_fill(layer->canvas->img, layer->x_pos, layer->y_pos, layer->screen_w, layer->screen_h, &layer->canvas->bgcolor);
layer->banner_patched = 0;
layer->refresh = 1;
}
-void reset_layer(mcu_layer_t *layer)
+void conf_video_reset_layer(mcu_layer_t *layer)
{
layer->tagged = 0;
layer->img = switch_img_alloc(NULL, SWITCH_IMG_FMT_I420, layer->screen_w, layer->screen_h, 1);
switch_assert(layer->img);
- clear_layer(layer);
+ conf_video_clear_layer(layer);
switch_img_free(&layer->cur_img);
}
-void scale_and_patch(mcu_layer_t *layer, switch_image_t *ximg, switch_bool_t freeze)
+void conf_video_scale_and_patch(mcu_layer_t *layer, switch_image_t *ximg, switch_bool_t freeze)
{
switch_image_t *IMG, *img;
if (layer->img && (layer->img->d_w != img_w || layer->img->d_h != img_h)) {
switch_img_free(&layer->img);
layer->banner_patched = 0;
- clear_layer(layer);
+ conf_video_clear_layer(layer);
}
if (!layer->img) {
if (switch_img_scale(img, &layer->img, img_w, img_h) == SWITCH_STATUS_SUCCESS) {
if (layer->bugged && layer->member_id > -1) {
- conference_member_t *member;
- if ((member = conference_member_get(layer->canvas->conference, layer->member_id))) {
+ conf_member_t *member;
+ if ((member = conf_member_get(layer->canvas->conference, layer->member_id))) {
switch_frame_t write_frame = { 0 };
write_frame.img = layer->img;
switch_core_media_bug_patch_video(member->session, &write_frame);
switch_mutex_unlock(layer->canvas->mutex);
}
-void set_canvas_bgcolor(mcu_canvas_t *canvas, char *color)
+void conf_video_set_canvas_bgcolor(mcu_canvas_t *canvas, char *color)
{
switch_color_set_rgb(&canvas->bgcolor, color);
- reset_image(canvas->img, &canvas->bgcolor);
+ conf_video_reset_image(canvas->img, &canvas->bgcolor);
}
-void set_canvas_letterbox_bgcolor(mcu_canvas_t *canvas, char *color)
+void conf_video_set_canvas_letterbox_bgcolor(mcu_canvas_t *canvas, char *color)
{
switch_color_set_rgb(&canvas->letterbox_bgcolor, color);
}
-void check_used_layers(mcu_canvas_t *canvas)
+void conf_video_check_used_layers(mcu_canvas_t *canvas)
{
int i;
}
}
-void detach_video_layer(conference_member_t *member)
+void conf_video_detach_video_layer(conf_member_t *member)
{
mcu_layer_t *layer = NULL;
mcu_canvas_t *canvas = NULL;
switch_img_txt_handle_destroy(&layer->txthandle);
}
- reset_layer(layer);
+ conf_video_reset_layer(layer);
layer->member_id = 0;
member->video_layer_id = -1;
member->layer_timeout = DEFAULT_LAYER_TIMEOUT;
//member->canvas_id = 0;
//member->watching_canvas_id = -1;
member->avatar_patched = 0;
- check_used_layers(canvas);
+ conf_video_check_used_layers(canvas);
canvas->send_keyframe = 1;
switch_mutex_unlock(canvas->mutex);
}
-void layer_set_logo(conference_member_t *member, mcu_layer_t *layer, const char *path)
+void conf_video_layer_set_logo(conf_member_t *member, mcu_layer_t *layer, const char *path)
{
const char *var = NULL;
char *dup = NULL;
}
-void layer_set_banner(conference_member_t *member, mcu_layer_t *layer, const char *text)
+void conf_video_layer_set_banner(conf_member_t *member, mcu_layer_t *layer, const char *text)
{
switch_rgb_color_t fgcolor, bgcolor;
int font_scale = 4;
switch_img_free(&layer->logo_text_img);
layer->banner_img = switch_img_alloc(NULL, SWITCH_IMG_FMT_I420, layer->screen_w, font_size * 2, 1);
- reset_image(layer->banner_img, &bgcolor);
+ conf_video_reset_image(layer->banner_img, &bgcolor);
switch_img_txt_handle_render(layer->txthandle, layer->banner_img, font_size / 2, font_size / 2, text, NULL, fg, bg, 0, 0);
end:
switch_mutex_unlock(layer->canvas->mutex);
}
-void reset_video_bitrate_counters(conference_member_t *member)
+void conf_video_reset_video_bitrate_counters(conf_member_t *member)
{
member->managed_kps = 0;
member->blackouts = 0;
member->blanks = 0;
}
-switch_status_t attach_video_layer(conference_member_t *member, mcu_canvas_t *canvas, int idx)
+switch_status_t conf_video_attach_video_layer(conf_member_t *member, mcu_canvas_t *canvas, int idx)
{
mcu_layer_t *layer = NULL;
switch_channel_t *channel = NULL;
}
if (member->video_layer_id > -1) {
- detach_video_layer(member);
+ conf_video_detach_video_layer(member);
}
- reset_layer(layer);
+ conf_video_reset_layer(layer);
switch_img_free(&layer->mute_img);
member->avatar_patched = 0;
var = NULL;
if (member->video_banner_text || (var = switch_channel_get_variable_dup(channel, "video_banner_text", SWITCH_FALSE, -1))) {
- layer_set_banner(member, layer, var);
+ conf_video_layer_set_banner(member, layer, var);
}
var = NULL;
if (member->video_logo || (var = switch_channel_get_variable_dup(channel, "video_logo_path", SWITCH_FALSE, -1))) {
- layer_set_logo(member, layer, var);
+ conf_video_layer_set_logo(member, layer, var);
}
layer->member_id = member->id;
canvas->send_keyframe = 1;
//member->watching_canvas_id = canvas->canvas_id;
- check_used_layers(canvas);
+ conf_video_check_used_layers(canvas);
if (layer->geometry.audio_position) {
conf_api_sub_position(member, NULL, layer->geometry.audio_position);
}
switch_img_fill(canvas->img, layer->x_pos, layer->y_pos, layer->screen_w, layer->screen_h, &canvas->letterbox_bgcolor);
- reset_video_bitrate_counters(member);
+ conf_video_reset_video_bitrate_counters(member);
end:
return status;
}
-void init_canvas_layers(conference_obj_t *conference, mcu_canvas_t *canvas, video_layout_t *vlayout)
+void conf_video_init_canvas_layers(conference_obj_t *conference, mcu_canvas_t *canvas, video_layout_t *vlayout)
{
int i = 0;
layer->geometry.audio_position = vlayout->images[i].audio_position;
}
- reset_image(canvas->img, &canvas->bgcolor);
+ conf_video_reset_image(canvas->img, &canvas->bgcolor);
for (i = 0; i < MCU_MAX_LAYERS; i++) {
mcu_layer_t *layer = &canvas->layers[i];
layer->banner_patched = 0;
layer->refresh = 1;
layer->canvas = canvas;
- reset_layer(layer);
+ conf_video_reset_layer(layer);
}
canvas->layers_used = 0;
}
-switch_status_t attach_canvas(conference_obj_t *conference, mcu_canvas_t *canvas, int super)
+switch_status_t conf_video_attach_canvas(conference_obj_t *conference, mcu_canvas_t *canvas, int super)
{
if (conference->canvas_count >= MAX_CANVASES + 1) {
return SWITCH_STATUS_FALSE;
return SWITCH_STATUS_SUCCESS;
}
-switch_status_t init_canvas(conference_obj_t *conference, video_layout_t *vlayout, mcu_canvas_t **canvasP)
+switch_status_t conf_video_init_canvas(conference_obj_t *conference, video_layout_t *vlayout, mcu_canvas_t **canvasP)
{
mcu_canvas_t *canvas;
switch_assert(canvas->img);
switch_mutex_lock(canvas->mutex);
- set_canvas_bgcolor(canvas, conference->video_canvas_bgcolor);
- set_canvas_letterbox_bgcolor(canvas, conference->video_letterbox_bgcolor);
- init_canvas_layers(conference, canvas, vlayout);
+ conf_video_set_canvas_bgcolor(canvas, conference->video_canvas_bgcolor);
+ conf_video_set_canvas_letterbox_bgcolor(canvas, conference->video_letterbox_bgcolor);
+ conf_video_init_canvas_layers(conference, canvas, vlayout);
switch_mutex_unlock(canvas->mutex);
canvas->canvas_id = -1;
return SWITCH_STATUS_SUCCESS;
}
-int flush_video_queue(switch_queue_t *q)
+int conf_video_flush_queue(switch_queue_t *q)
{
switch_image_t *img;
void *pop;
}
-void destroy_canvas(mcu_canvas_t **canvasP) {
+void conf_video_destroy_canvas(mcu_canvas_t **canvasP) {
int i;
mcu_canvas_t *canvas = *canvasP;
switch_img_free(&canvas->img);
- flush_video_queue(canvas->video_queue);
+ conf_video_flush_queue(canvas->video_queue);
for (i = 0; i < MCU_MAX_LAYERS; i++) {
switch_img_free(&canvas->layers[i].img);
*canvasP = NULL;
}
-void write_canvas_image_to_codec_group(conference_obj_t *conference, mcu_canvas_t *canvas, codec_set_t *codec_set,
+void conf_video_write_canvas_image_to_codec_group(conference_obj_t *conference, mcu_canvas_t *canvas, codec_set_t *codec_set,
int codec_index, uint32_t timestamp, switch_bool_t need_refresh,
switch_bool_t need_keyframe, switch_bool_t need_reset)
{
- conference_member_t *imember;
+ conf_member_t *imember;
switch_frame_t write_frame = { 0 }, *frame = NULL;
switch_status_t encode_status = SWITCH_STATUS_FALSE;
continue;
}
- if (member_test_flag(imember, MFLAG_NO_MINIMIZE_ENCODING)) {
+ if (conf_utils_member_test_flag(imember, MFLAG_NO_MINIMIZE_ENCODING)) {
continue;
}
} while(encode_status == SWITCH_STATUS_MORE_DATA);
}
-video_layout_t *find_best_layout(conference_obj_t *conference, layout_group_t *lg, uint32_t count)
+video_layout_t *conf_video_find_best_layout(conference_obj_t *conference, layout_group_t *lg, uint32_t count)
{
video_layout_node_t *vlnode = NULL, *last = NULL;
return vlnode? vlnode->vlayout : last ? last->vlayout : NULL;
}
-video_layout_t *get_layout(conference_obj_t *conference, const char *video_layout_name, const char *video_layout_group)
+video_layout_t *conf_video_get_layout(conference_obj_t *conference, const char *video_layout_name, const char *video_layout_group)
{
layout_group_t *lg = NULL;
video_layout_t *vlayout = NULL;
if (video_layout_group) {
lg = switch_core_hash_find(conference->layout_group_hash, video_layout_group);
- vlayout = find_best_layout(conference, lg, 0);
+ vlayout = conf_video_find_best_layout(conference, lg, 0);
} else {
vlayout = switch_core_hash_find(conference->layout_hash, video_layout_name);
}
return vlayout;
}
-void vmute_snap(conference_member_t *member, switch_bool_t clear)
+void conf_video_vmute_snap(conf_member_t *member, switch_bool_t clear)
{
}
-void canvas_del_fnode_layer(conference_obj_t *conference, conference_file_node_t *fnode)
+void conf_video_canvas_del_fnode_layer(conference_obj_t *conference, conference_file_node_t *fnode)
{
mcu_canvas_t *canvas = conference->canvases[fnode->canvas_id];
fnode->layer_id = -1;
fnode->canvas_id = -1;
xlayer->fnode = NULL;
- reset_layer(xlayer);
+ conf_video_reset_layer(xlayer);
}
switch_mutex_unlock(canvas->mutex);
}
-void canvas_set_fnode_layer(mcu_canvas_t *canvas, conference_file_node_t *fnode, int idx)
+void conf_video_canvas_set_fnode_layer(mcu_canvas_t *canvas, conference_file_node_t *fnode, int idx)
{
mcu_layer_t *layer = NULL;
mcu_layer_t *xlayer = NULL;
fnode->canvas_id = canvas->canvas_id;
if (layer->member_id > -1) {
- conference_member_t *member;
+ conf_member_t *member;
- if ((member = conference_member_get(canvas->conference, layer->member_id))) {
- detach_video_layer(member);
+ if ((member = conf_member_get(canvas->conference, layer->member_id))) {
+ conf_video_detach_video_layer(member);
switch_thread_rwlock_unlock(member->rwlock);
}
}
}
-void launch_conference_video_muxing_write_thread(conference_member_t *member)
+void conf_video_launch_muxing_write_thread(conf_member_t *member)
{
switch_threadattr_t *thd_attr = NULL;
- switch_mutex_lock(mod_conference_globals.hash_mutex);
+ switch_mutex_lock(conf_globals.hash_mutex);
if (!member->video_muxing_write_thread) {
switch_threadattr_create(&thd_attr, member->pool);
switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE);
- switch_thread_create(&member->video_muxing_write_thread, thd_attr, conference_video_muxing_write_thread_run, member, member->pool);
+ switch_thread_create(&member->video_muxing_write_thread, thd_attr, conf_video_muxing_write_thread_run, member, member->pool);
}
- switch_mutex_unlock(mod_conference_globals.hash_mutex);
+ switch_mutex_unlock(conf_globals.hash_mutex);
}
-void launch_conference_video_muxing_thread(conference_obj_t *conference, mcu_canvas_t *canvas, int super)
+void conf_video_launch_muxing_thread(conference_obj_t *conference, mcu_canvas_t *canvas, int super)
{
switch_threadattr_t *thd_attr = NULL;
- switch_mutex_lock(mod_conference_globals.hash_mutex);
+ switch_mutex_lock(conf_globals.hash_mutex);
if (!canvas->video_muxing_thread) {
switch_threadattr_create(&thd_attr, conference->pool);
switch_threadattr_priority_set(thd_attr, SWITCH_PRI_REALTIME);
switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE);
- conference_set_flag(conference, CFLAG_VIDEO_MUXING);
+ conf_utils_set_flag(conference, CFLAG_VIDEO_MUXING);
switch_thread_create(&canvas->video_muxing_thread, thd_attr,
- super ? conference_super_video_muxing_thread_run : conference_video_muxing_thread_run, canvas, conference->pool);
+ super ? conf_video_super_muxing_thread_run : conf_video_muxing_thread_run, canvas, conference->pool);
}
- switch_mutex_unlock(mod_conference_globals.hash_mutex);
+ switch_mutex_unlock(conf_globals.hash_mutex);
}
-void *SWITCH_THREAD_FUNC conference_video_muxing_write_thread_run(switch_thread_t *thread, void *obj)
+void *SWITCH_THREAD_FUNC conf_video_muxing_write_thread_run(switch_thread_t *thread, void *obj)
{
- conference_member_t *member = (conference_member_t *) obj;
+ conf_member_t *member = (conf_member_t *) obj;
void *pop;
int loops = 0;
- while(member_test_flag(member, MFLAG_RUNNING) || switch_queue_size(member->mux_out_queue)) {
+ while(conf_utils_member_test_flag(member, MFLAG_RUNNING) || switch_queue_size(member->mux_out_queue)) {
switch_frame_t *frame;
- if (member_test_flag(member, MFLAG_RUNNING)) {
+ if (conf_utils_member_test_flag(member, MFLAG_RUNNING)) {
if (switch_queue_pop(member->mux_out_queue, &pop) == SWITCH_STATUS_SUCCESS) {
if (!pop) continue;
return NULL;
}
-void check_video_recording(conference_obj_t *conference, switch_frame_t *frame)
+void conf_video_check_recording(conference_obj_t *conference, switch_frame_t *frame)
{
- conference_member_t *imember;
+ conf_member_t *imember;
if (!conference->recording_members) {
return;
}
-void check_avatar(conference_member_t *member, switch_bool_t force)
+void conf_video_check_avatar(conf_member_t *member, switch_bool_t force)
{
const char *avatar = NULL, *var = NULL;
mcu_canvas_t *canvas;
canvas = member->conference->canvases[member->canvas_id];
- if (conference_test_flag(member->conference, CFLAG_VIDEO_REQUIRED_FOR_CANVAS) &&
+ if (conf_utils_test_flag(member->conference, CFLAG_VIDEO_REQUIRED_FOR_CANVAS) &&
(!switch_channel_test_flag(member->channel, CF_VIDEO) || member->video_flow == SWITCH_MEDIA_FLOW_SENDONLY)) {
return;
}
member->avatar_patched = 0;
if (!force && switch_channel_test_flag(member->channel, CF_VIDEO) && member->video_flow != SWITCH_MEDIA_FLOW_SENDONLY) {
- member_set_flag_locked(member, MFLAG_ACK_VIDEO);
+ conf_utils_member_set_flag_locked(member, MFLAG_ACK_VIDEO);
} else {
if (member->conference->no_video_avatar) {
avatar = member->conference->no_video_avatar;
}
}
-void check_flush(conference_member_t *member)
+void conf_video_check_flush(conf_member_t *member)
{
int flushed;
return;
}
- flushed = flush_video_queue(member->video_queue);
+ flushed = conf_video_flush_queue(member->video_queue);
if (flushed && member->auto_avatar) {
switch_channel_video_sync(member->channel);
switch_img_free(&member->avatar_png_img);
member->avatar_patched = 0;
- reset_video_bitrate_counters(member);
+ conf_video_reset_video_bitrate_counters(member);
member->blanks = 0;
member->auto_avatar = 0;
}
}
-void patch_fnode(mcu_canvas_t *canvas, conference_file_node_t *fnode)
+void conf_video_patch_fnode(mcu_canvas_t *canvas, conference_file_node_t *fnode)
{
if (fnode && fnode->layer_id > -1) {
mcu_layer_t *layer = &canvas->layers[fnode->layer_id];
layer->tagged = 1;
} else if (status == SWITCH_STATUS_IGNORE) {
if (canvas && fnode->layer_id > -1 ) {
- canvas_del_fnode_layer(canvas->conference, fnode);
+ conf_video_canvas_del_fnode_layer(canvas->conference, fnode);
}
}
}
}
-void fnode_check_video(conference_file_node_t *fnode) {
+void conf_video_fnode_check(conference_file_node_t *fnode) {
mcu_canvas_t *canvas = fnode->conference->canvases[fnode->canvas_id];
if (switch_core_file_has_video(&fnode->fh) && switch_core_file_read_video(&fnode->fh, NULL, SVR_CHECK) == SWITCH_STATUS_BREAK) {
canvas->play_file = 1;
canvas->conference->playing_video_file = 1;
} else {
- canvas_set_fnode_layer(canvas, fnode, -1);
+ conf_video_canvas_set_fnode_layer(canvas, fnode, -1);
}
}
}
-switch_status_t find_layer(conference_obj_t *conference, mcu_canvas_t *canvas, conference_member_t *member, mcu_layer_t **layerP)
+switch_status_t conf_video_find_layer(conference_obj_t *conference, mcu_canvas_t *canvas, conf_member_t *member, mcu_layer_t **layerP)
{
uint32_t avatar_layers = 0;
mcu_layer_t *layer = NULL;
if (!layer &&
(canvas->layers_used < canvas->total_layers ||
- (avatar_layers && !member->avatar_png_img) || member_test_flag(member, MFLAG_MOD)) &&
+ (avatar_layers && !member->avatar_png_img) || conf_utils_member_test_flag(member, MFLAG_MOD)) &&
(member->avatar_png_img || member->video_flow != SWITCH_MEDIA_FLOW_SENDONLY)) {
/* find an empty layer */
for (i = 0; i < canvas->total_layers; i++) {
if (xlayer->geometry.res_id) {
if (member->video_reservation_id && !strcmp(xlayer->geometry.res_id, member->video_reservation_id)) {
layer = xlayer;
- attach_video_layer(member, canvas, i);
+ conf_video_attach_video_layer(member, canvas, i);
break;
}
} else if (xlayer->geometry.flooronly && !xlayer->fnode) {
if (member->id == conference->video_floor_holder) {
layer = xlayer;
- attach_video_layer(member, canvas, i);
+ conf_video_attach_video_layer(member, canvas, i);
break;
}
} else if ((!xlayer->member_id || (!member->avatar_png_img &&
!xlayer->fnode && !xlayer->geometry.fileonly) {
switch_status_t lstatus;
- lstatus = attach_video_layer(member, canvas, i);
+ lstatus = conf_video_attach_video_layer(member, canvas, i);
if (lstatus == SWITCH_STATUS_SUCCESS || lstatus == SWITCH_STATUS_BREAK) {
layer = xlayer;
}
-void next_canvas(conference_member_t *imember)
+void conf_video_next_canvas(conf_member_t *imember)
{
if (imember->canvas_id == imember->conference->canvas_count - 1) {
imember->canvas_id = 0;
imember->layer_timeout = DEFAULT_LAYER_TIMEOUT;
}
-void pop_next_image(conference_member_t *member, switch_image_t **imgP)
+void conf_video_pop_next_image(conf_member_t *member, switch_image_t **imgP)
{
switch_image_t *img = *imgP;
int size = 0;
size = switch_queue_size(member->video_queue);
} while(size > member->conference->video_fps.fps / 2);
- if (member_test_flag(member, MFLAG_CAN_BE_SEEN) && member->video_layer_id > -1 && member->video_flow != SWITCH_MEDIA_FLOW_SENDONLY) {
+ if (conf_utils_member_test_flag(member, MFLAG_CAN_BE_SEEN) && member->video_layer_id > -1 && member->video_flow != SWITCH_MEDIA_FLOW_SENDONLY) {
if (img) {
member->good_img++;
if ((member->good_img % (int)(member->conference->video_fps.fps * 10)) == 0) {
- reset_video_bitrate_counters(member);
+ conf_video_reset_video_bitrate_counters(member);
}
} else {
member->blanks++;
if (member->blanks == member->conference->video_fps.fps * 5) {
member->blackouts++;
- check_avatar(member, SWITCH_TRUE);
+ conf_video_check_avatar(member, SWITCH_TRUE);
member->managed_kps = 0;
if (member->avatar_png_img) {
}
}
} else {
- check_flush(member);
+ conf_video_check_flush(member);
}
*imgP = img;
}
-void check_auto_bitrate(conference_member_t *member, mcu_layer_t *layer)
+void conf_video_check_auto_bitrate(conf_member_t *member, mcu_layer_t *layer)
{
- if (conference_test_flag(member->conference, CFLAG_MANAGE_INBOUND_VIDEO_BITRATE) && !member->managed_kps) {
+ if (conf_utils_test_flag(member->conference, CFLAG_MANAGE_INBOUND_VIDEO_BITRATE) && !member->managed_kps) {
switch_core_session_message_t msg = { 0 };
int kps;
int w = 320;
}
}
- if (!layer || !member_test_flag(member, MFLAG_CAN_BE_SEEN) || member->avatar_png_img) {
+ if (!layer || !conf_utils_member_test_flag(member, MFLAG_CAN_BE_SEEN) || member->avatar_png_img) {
kps = 200;
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG1, "%s auto-setting bitrate to %dkps because user's image is not visible\n",
switch_channel_get_name(member->channel), kps);
}
}
-void *SWITCH_THREAD_FUNC conference_video_muxing_thread_run(switch_thread_t *thread, void *obj)
+void *SWITCH_THREAD_FUNC conf_video_muxing_thread_run(switch_thread_t *thread, void *obj)
{
mcu_canvas_t *canvas = (mcu_canvas_t *) obj;
conference_obj_t *conference = canvas->conference;
- conference_member_t *imember;
+ conf_member_t *imember;
switch_codec_t *check_codec = NULL;
codec_set_t *write_codecs[MAX_MUX_CODECS] = { 0 };
int buflen = SWITCH_RTP_MAX_BUF_LEN;
uint8_t *packet = NULL;
switch_image_t *write_img = NULL, *file_img = NULL;
uint32_t timestamp = 0;
- //video_layout_t *vlayout = get_layout(conference);
+ //video_layout_t *vlayout = conf_video_get_layout(conference);
int members_with_video = 0, members_with_avatar = 0;
int do_refresh = 0;
int last_file_count = 0;
packet = switch_core_alloc(conference->pool, SWITCH_RTP_MAX_BUF_LEN);
- while (mod_conference_globals.running && !conference_test_flag(conference, CFLAG_DESTRUCT) && conference_test_flag(conference, CFLAG_VIDEO_MUXING)) {
+ while (conf_globals.running && !conf_utils_test_flag(conference, CFLAG_DESTRUCT) && conf_utils_test_flag(conference, CFLAG_VIDEO_MUXING)) {
switch_bool_t need_refresh = SWITCH_FALSE, need_keyframe = SWITCH_FALSE, need_reset = SWITCH_FALSE;
switch_time_t now;
int min_members = 0;
switch_mutex_lock(canvas->mutex);
if (canvas->new_vlayout) {
- init_canvas_layers(conference, canvas, NULL);
+ conf_video_init_canvas_layers(conference, canvas, NULL);
}
switch_mutex_unlock(canvas->mutex);
count_changed = 1;
}
- if (count_changed && !conference_test_flag(conference, CFLAG_PERSONAL_CANVAS)) {
+ if (count_changed && !conf_utils_test_flag(conference, CFLAG_PERSONAL_CANVAS)) {
layout_group_t *lg = NULL;
video_layout_t *vlayout = NULL;
int canvas_count = 0;
switch_mutex_unlock(conference->member_mutex);
if (conference->video_layout_group && (lg = switch_core_hash_find(conference->layout_group_hash, conference->video_layout_group))) {
- if ((vlayout = find_best_layout(conference, lg, canvas_count))) {
+ if ((vlayout = conf_video_find_best_layout(conference, lg, canvas_count))) {
switch_mutex_lock(conference->member_mutex);
conference->canvas->new_vlayout = vlayout;
switch_mutex_unlock(conference->member_mutex);
members_with_video = conference->members_with_video;
members_with_avatar = conference->members_with_avatar;
- if (conference_test_flag(conference, CFLAG_VIDEO_BRIDGE_FIRST_TWO)) {
+ if (conf_utils_test_flag(conference, CFLAG_VIDEO_BRIDGE_FIRST_TWO)) {
if (conference->members_with_video < 3) {
switch_yield(20000);
continue;
int i;
if (!imember->session || (!switch_channel_test_flag(imember->channel, CF_VIDEO) && !imember->avatar_png_img) ||
- conference_test_flag(conference, CFLAG_PERSONAL_CANVAS) || switch_core_session_read_lock(imember->session) != SWITCH_STATUS_SUCCESS) {
+ conf_utils_test_flag(conference, CFLAG_PERSONAL_CANVAS) || switch_core_session_read_lock(imember->session) != SWITCH_STATUS_SUCCESS) {
continue;
}
need_keyframe = SWITCH_TRUE;
}
- if (conference_test_flag(conference, CFLAG_MINIMIZE_VIDEO_ENCODING) &&
+ if (conf_utils_test_flag(conference, CFLAG_MINIMIZE_VIDEO_ENCODING) &&
imember->watching_canvas_id > -1 && imember->watching_canvas_id == canvas->canvas_id &&
- !member_test_flag(imember, MFLAG_NO_MINIMIZE_ENCODING)) {
+ !conf_utils_member_test_flag(imember, MFLAG_NO_MINIMIZE_ENCODING)) {
min_members++;
if (switch_channel_test_flag(imember->channel, CF_VIDEO)) {
//VIDFLOOR
if (conference->canvas_count == 1 && canvas->layout_floor_id > -1 && imember->id == conference->video_floor_holder &&
imember->video_layer_id != canvas->layout_floor_id) {
- attach_video_layer(imember, canvas, canvas->layout_floor_id);
+ conf_video_attach_video_layer(imember, canvas, canvas->layout_floor_id);
}
- pop_next_image(imember, &img);
+ conf_video_pop_next_image(imember, &img);
layer = NULL;
switch_mutex_lock(canvas->mutex);
}
if (!layer) {
- if (find_layer(conference, canvas, imember, &layer) == SWITCH_STATUS_SUCCESS) {
+ if (conf_video_find_layer(conference, canvas, imember, &layer) == SWITCH_STATUS_SUCCESS) {
imember->layer_timeout = 0;
} else {
if (--imember->layer_timeout <= 0) {
- next_canvas(imember);
+ conf_video_next_canvas(imember);
}
}
}
- check_auto_bitrate(imember, layer);
+ conf_video_check_auto_bitrate(imember, layer);
if (layer) {
// switch_img_free(&layer->cur_img);
//}
- if (member_test_flag(imember, MFLAG_CAN_BE_SEEN)) {
+ if (conf_utils_member_test_flag(imember, MFLAG_CAN_BE_SEEN)) {
layer->mute_patched = 0;
} else {
switch_image_t *tmp;
if (!layer->mute_patched) {
if (imember->video_mute_img || layer->mute_img) {
- clear_layer(layer);
+ conf_video_clear_layer(layer);
if (!layer->mute_img && imember->video_mute_img) {
//layer->mute_img = switch_img_read_png(imember->video_mute_png, SWITCH_IMG_FMT_I420);
}
if (layer->mute_img) {
- scale_and_patch(layer, layer->mute_img, SWITCH_FALSE);
+ conf_video_scale_and_patch(layer, layer->mute_img, SWITCH_FALSE);
}
}
switch_mutex_unlock(conference->member_mutex);
- if (conference_test_flag(conference, CFLAG_PERSONAL_CANVAS)) {
+ if (conf_utils_test_flag(conference, CFLAG_PERSONAL_CANVAS)) {
layout_group_t *lg = NULL;
video_layout_t *vlayout = NULL;
- conference_member_t *omember;
+ conf_member_t *omember;
if (video_key_freq && (now - last_key_time) > video_key_freq) {
need_keyframe = SWITCH_TRUE;
if (count_changed) {
int total = conference->members_with_video;
- if (!conference_test_flag(conference, CFLAG_VIDEO_REQUIRED_FOR_CANVAS)) {
+ if (!conf_utils_test_flag(conference, CFLAG_VIDEO_REQUIRED_FOR_CANVAS)) {
total += conference->members_with_avatar;
}
if (total < 1) total = 1;
if (conference->video_layout_group && (lg = switch_core_hash_find(conference->layout_group_hash, conference->video_layout_group))) {
- if ((vlayout = find_best_layout(conference, lg, total + file_count))) {
- init_canvas_layers(conference, imember->canvas, vlayout);
+ if ((vlayout = conf_video_find_best_layout(conference, lg, total + file_count))) {
+ conf_video_init_canvas_layers(conference, imember->canvas, vlayout);
}
}
}
if (imember->video_flow != SWITCH_MEDIA_FLOW_SENDONLY) {
- pop_next_image(imember, &imember->pcanvas_img);
+ conf_video_pop_next_image(imember, &imember->pcanvas_img);
}
switch_core_session_rwunlock(imember->session);
var = NULL;
if (omember->video_banner_text ||
(var = switch_channel_get_variable_dup(omember->channel, "video_banner_text", SWITCH_FALSE, -1))) {
- layer_set_banner(omember, layer, var);
+ conf_video_layer_set_banner(omember, layer, var);
}
var = NULL;
if (omember->video_logo ||
(var = switch_channel_get_variable_dup(omember->channel, "video_logo_path", SWITCH_FALSE, -1))) {
- layer_set_logo(omember, layer, var);
+ conf_video_layer_set_logo(omember, layer, var);
}
}
layer->avatar_patched = 0;
} else {
if (!layer->avatar_patched) {
- scale_and_patch(layer, omember->avatar_png_img, SWITCH_FALSE);
+ conf_video_scale_and_patch(layer, omember->avatar_png_img, SWITCH_FALSE);
layer->avatar_patched = 1;
}
use_img = NULL;
}
if (layer) {
- if (member_test_flag(imember, MFLAG_CAN_BE_SEEN)) {
+ if (conf_utils_member_test_flag(imember, MFLAG_CAN_BE_SEEN)) {
layer->mute_patched = 0;
} else {
if (!layer->mute_patched) {
switch_image_t *tmp;
- scale_and_patch(layer, imember->video_mute_img ? imember->video_mute_img : omember->pcanvas_img, SWITCH_FALSE);
+ conf_video_scale_and_patch(layer, imember->video_mute_img ? imember->video_mute_img : omember->pcanvas_img, SWITCH_FALSE);
tmp = switch_img_write_text_img(layer->screen_w, layer->screen_h, SWITCH_TRUE, "VIDEO MUTED");
switch_img_patch(imember->canvas->img, tmp, layer->x_pos, layer->y_pos);
switch_img_free(&tmp);
}
if (layer && use_img) {
- scale_and_patch(layer, use_img, SWITCH_FALSE);
+ conf_video_scale_and_patch(layer, use_img, SWITCH_FALSE);
}
}
- check_auto_bitrate(omember, layer);
+ conf_video_check_auto_bitrate(omember, layer);
}
for (j = 0; j < file_count; j++) {
if (i < imember->canvas->total_layers) {
layer = &imember->canvas->layers[i++];
- scale_and_patch(layer, img, SWITCH_FALSE);
+ conf_video_scale_and_patch(layer, img, SWITCH_FALSE);
}
}
if (canvas->canvas_id == 0) {
if (conference->async_fnode) {
if (conference->async_fnode->layer_id > -1) {
- patch_fnode(canvas, conference->async_fnode);
+ conf_video_patch_fnode(canvas, conference->async_fnode);
} else {
- fnode_check_video(conference->async_fnode);
+ conf_video_fnode_check(conference->async_fnode);
}
}
if (conference->fnode) {
if (conference->fnode->layer_id > -1) {
- patch_fnode(canvas, conference->fnode);
+ conf_video_patch_fnode(canvas, conference->fnode);
} else {
- fnode_check_video(conference->fnode);
+ conf_video_fnode_check(conference->fnode);
}
}
}
}
if (layer->cur_img) {
- scale_and_patch(layer, NULL, SWITCH_FALSE);
+ conf_video_scale_and_patch(layer, NULL, SWITCH_FALSE);
}
layer->tagged = 0;
write_frame.img = write_img;
if (conference->canvas_count == 1) {
- check_video_recording(conference, &write_frame);
+ conf_video_check_recording(conference, &write_frame);
}
if (conference->canvas_count > 1) {
}
}
- if (min_members && conference_test_flag(conference, CFLAG_MINIMIZE_VIDEO_ENCODING)) {
+ if (min_members && conf_utils_test_flag(conference, CFLAG_MINIMIZE_VIDEO_ENCODING)) {
for (i = 0; write_codecs[i] && switch_core_codec_ready(&write_codecs[i]->codec) && i < MAX_MUX_CODECS; i++) {
write_codecs[i]->frame.img = write_img;
- write_canvas_image_to_codec_group(conference, canvas, write_codecs[i], i,
+ conf_video_write_canvas_image_to_codec_group(conference, canvas, write_codecs[i], i,
timestamp, need_refresh, need_keyframe, need_reset);
if (canvas->video_write_bandwidth) {
if (imember->watching_canvas_id != canvas->canvas_id) continue;
- if (conference_test_flag(conference, CFLAG_MINIMIZE_VIDEO_ENCODING) && !member_test_flag(imember, MFLAG_NO_MINIMIZE_ENCODING)) {
+ if (conf_utils_test_flag(conference, CFLAG_MINIMIZE_VIDEO_ENCODING) && !conf_utils_member_test_flag(imember, MFLAG_NO_MINIMIZE_ENCODING)) {
continue;
}
}
switch_core_timer_destroy(&canvas->timer);
- destroy_canvas(&canvas);
+ conf_video_destroy_canvas(&canvas);
return NULL;
}
-void pop_next_canvas_image(mcu_canvas_t *canvas, switch_image_t **imgP)
+void pop_conf_video_next_canvas_image(mcu_canvas_t *canvas, switch_image_t **imgP)
{
switch_image_t *img = *imgP;
int size = 0;
*imgP = img;
}
-void *SWITCH_THREAD_FUNC conference_super_video_muxing_thread_run(switch_thread_t *thread, void *obj)
+void *SWITCH_THREAD_FUNC conf_video_super_muxing_thread_run(switch_thread_t *thread, void *obj)
{
mcu_canvas_t *canvas = (mcu_canvas_t *) obj;
conference_obj_t *conference = canvas->conference;
- conference_member_t *imember;
+ conf_member_t *imember;
switch_codec_t *check_codec = NULL;
codec_set_t *write_codecs[MAX_MUX_CODECS] = { 0 };
int buflen = SWITCH_RTP_MAX_BUF_LEN;
packet = switch_core_alloc(conference->pool, SWITCH_RTP_MAX_BUF_LEN);
- while (mod_conference_globals.running && !conference_test_flag(conference, CFLAG_DESTRUCT) && conference_test_flag(conference, CFLAG_VIDEO_MUXING)) {
+ while (conf_globals.running && !conf_utils_test_flag(conference, CFLAG_DESTRUCT) && conf_utils_test_flag(conference, CFLAG_VIDEO_MUXING)) {
switch_bool_t need_refresh = SWITCH_FALSE, need_keyframe = SWITCH_FALSE, need_reset = SWITCH_FALSE;
switch_time_t now;
int min_members = 0;
switch_mutex_lock(canvas->mutex);
if (canvas->new_vlayout) {
- init_canvas_layers(conference, canvas, NULL);
+ conf_video_init_canvas_layers(conference, canvas, NULL);
}
switch_mutex_unlock(canvas->mutex);
if (total < 1) total = 1;
if ((lg = switch_core_hash_find(conference->layout_group_hash, CONFERENCE_MUX_DEFAULT_SUPER_LAYOUT))) {
- if ((vlayout = find_best_layout(conference, lg, total))) {
- init_canvas_layers(conference, canvas, vlayout);
+ if ((vlayout = conf_video_find_best_layout(conference, lg, total))) {
+ conf_video_init_canvas_layers(conference, canvas, vlayout);
}
}
}
int i;
if (!imember->session || (!switch_channel_test_flag(imember->channel, CF_VIDEO) && !imember->avatar_png_img) ||
- conference_test_flag(conference, CFLAG_PERSONAL_CANVAS) || switch_core_session_read_lock(imember->session) != SWITCH_STATUS_SUCCESS) {
+ conf_utils_test_flag(conference, CFLAG_PERSONAL_CANVAS) || switch_core_session_read_lock(imember->session) != SWITCH_STATUS_SUCCESS) {
continue;
}
need_keyframe = SWITCH_TRUE;
}
- if (conference_test_flag(conference, CFLAG_MINIMIZE_VIDEO_ENCODING) &&
+ if (conf_utils_test_flag(conference, CFLAG_MINIMIZE_VIDEO_ENCODING) &&
imember->watching_canvas_id > -1 && imember->watching_canvas_id == canvas->canvas_id &&
- !member_test_flag(imember, MFLAG_NO_MINIMIZE_ENCODING)) {
+ !conf_utils_member_test_flag(imember, MFLAG_NO_MINIMIZE_ENCODING)) {
min_members++;
if (switch_channel_test_flag(imember->channel, CF_VIDEO)) {
for (j = 0; j < conference->canvas_count; j++) {
mcu_canvas_t *jcanvas = (mcu_canvas_t *) conference->canvases[j];
- pop_next_canvas_image(jcanvas, &img);
+ pop_conf_video_next_canvas_image(jcanvas, &img);
if (!jcanvas->layers_used && !conference->super_canvas_show_all_layers) {
switch_img_free(&img);
img = NULL;
}
- scale_and_patch(layer, NULL, SWITCH_FALSE);
+ conf_video_scale_and_patch(layer, NULL, SWITCH_FALSE);
}
switch_img_free(&img);
if (!write_img) continue;
write_frame.img = write_img;
- check_video_recording(conference, &write_frame);
+ conf_video_check_recording(conference, &write_frame);
- if (min_members && conference_test_flag(conference, CFLAG_MINIMIZE_VIDEO_ENCODING)) {
+ if (min_members && conf_utils_test_flag(conference, CFLAG_MINIMIZE_VIDEO_ENCODING)) {
for (i = 0; write_codecs[i] && switch_core_codec_ready(&write_codecs[i]->codec) && i < MAX_MUX_CODECS; i++) {
write_codecs[i]->frame.img = write_img;
- write_canvas_image_to_codec_group(conference, canvas, write_codecs[i], i, timestamp, need_refresh, need_keyframe, need_reset);
+ conf_video_write_canvas_image_to_codec_group(conference, canvas, write_codecs[i], i, timestamp, need_refresh, need_keyframe, need_reset);
if (canvas->video_write_bandwidth) {
switch_core_codec_control(&write_codecs[i]->codec, SCC_VIDEO_BANDWIDTH, SCCT_INT, &canvas->video_write_bandwidth, NULL, NULL);
if (imember->watching_canvas_id != canvas->canvas_id) continue;
- if (conference_test_flag(conference, CFLAG_MINIMIZE_VIDEO_ENCODING) && !member_test_flag(imember, MFLAG_NO_MINIMIZE_ENCODING)) {
+ if (conf_utils_test_flag(conference, CFLAG_MINIMIZE_VIDEO_ENCODING) && !conf_utils_member_test_flag(imember, MFLAG_NO_MINIMIZE_ENCODING)) {
continue;
}
}
switch_core_timer_destroy(&canvas->timer);
- destroy_canvas(&canvas);
+ conf_video_destroy_canvas(&canvas);
return NULL;
}
-void find_video_floor(conference_member_t *member, switch_bool_t entering)
+void conf_video_find_floor(conf_member_t *member, switch_bool_t entering)
{
- conference_member_t *imember;
+ conf_member_t *imember;
conference_obj_t *conference = member->conference;
if (!entering) {
if (member->id == conference->video_floor_holder) {
- conference_set_video_floor_holder(conference, NULL, SWITCH_FALSE);
+ conf_video_set_floor_holder(conference, NULL, SWITCH_FALSE);
} else if (member->id == conference->last_video_floor_holder) {
conference->last_video_floor_holder = 0;
}
}
if (conference->floor_holder && imember == conference->floor_holder) {
- conference_set_video_floor_holder(conference, imember, 0);
+ conf_video_set_floor_holder(conference, imember, 0);
continue;
}
if (!conference->video_floor_holder) {
- conference_set_video_floor_holder(conference, imember, 0);
+ conf_video_set_floor_holder(conference, imember, 0);
continue;
}
}
}
-void reset_member_codec_index(conference_member_t *member)
+void conf_video_reset_member_codec_index(conf_member_t *member)
{
member->video_codec_index = -1;
}
-void conference_set_video_floor_holder(conference_obj_t *conference, conference_member_t *member, switch_bool_t force)
+void conf_video_set_floor_holder(conference_obj_t *conference, conf_member_t *member, switch_bool_t force)
{
switch_event_t *event;
- conference_member_t *imember = NULL;
+ conf_member_t *imember = NULL;
int old_id = 0;
uint32_t old_member = 0;
if (!member) {
- conference_clear_flag(conference, CFLAG_VID_FLOOR_LOCK);
+ conf_utils_clear_flag(conference, CFLAG_VID_FLOOR_LOCK);
}
- if ((!force && conference_test_flag(conference, CFLAG_VID_FLOOR_LOCK))) {
+ if ((!force && conf_utils_test_flag(conference, CFLAG_VID_FLOOR_LOCK))) {
return;
}
conference->last_video_floor_holder = conference->video_floor_holder;
}
- if (conference->last_video_floor_holder && (imember = conference_member_get(conference, conference->last_video_floor_holder))) {
+ if (conference->last_video_floor_holder && (imember = conf_member_get(conference, conference->last_video_floor_holder))) {
switch_core_session_request_video_refresh(imember->session);
- if (member_test_flag(imember, MFLAG_VIDEO_BRIDGE)) {
- conference_set_flag(conference, CFLAG_VID_FLOOR_LOCK);
+ if (conf_utils_member_test_flag(imember, MFLAG_VIDEO_BRIDGE)) {
+ conf_utils_set_flag(conference, CFLAG_VID_FLOOR_LOCK);
}
switch_thread_rwlock_unlock(imember->rwlock);
imember = NULL;
//VIDFLOOR
if (conference->canvas_count == 1 && member && conference->canvas && conference->canvas->layout_floor_id > -1) {
- attach_video_layer(member, conference->canvas, conference->canvas->layout_floor_id);
+ conf_video_attach_video_layer(member, conference->canvas, conference->canvas->layout_floor_id);
}
if (member) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG1, "Adding video floor %s\n",
switch_channel_get_name(member->channel));
- check_flush(member);
+ conf_video_check_flush(member);
switch_core_session_video_reinit(member->session);
conference->video_floor_holder = member->id;
- member_update_status_field(member);
+ conf_member_update_status_field(member);
} else {
conference->video_floor_holder = 0;
}
if (old_member) {
- conference_member_t *old_member_p = NULL;
+ conf_member_t *old_member_p = NULL;
old_id = old_member;
- if ((old_member_p = conference_member_get(conference, old_id))) {
- member_update_status_field(old_member_p);
+ if ((old_member_p = conf_member_get(conference, old_id))) {
+ conf_member_update_status_field(old_member_p);
switch_thread_rwlock_unlock(old_member_p->rwlock);
}
}
}
switch_mutex_unlock(conference->member_mutex);
- conference_set_flag(conference, CFLAG_FLOOR_CHANGE);
+ conf_utils_set_flag(conference, CFLAG_FLOOR_CHANGE);
if (test_eflag(conference, EFLAG_FLOOR_CHANGE)) {
switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, CONF_EVENT_MAINT);
- conference_add_event_data(conference, event);
+ conf_event_add_data(conference, event);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Action", "video-floor-change");
if (old_id) {
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Old-ID", "%d", old_id);
}
-void conference_write_video_frame(conference_obj_t *conference, conference_member_t *floor_holder, switch_frame_t *vid_frame)
+void conf_video_write_frame(conference_obj_t *conference, conf_member_t *floor_holder, switch_frame_t *vid_frame)
{
- conference_member_t *imember;
+ conf_member_t *imember;
int want_refresh = 0;
unsigned char buf[SWITCH_RTP_MAX_BUF_LEN] = "";
switch_frame_t tmp_frame = { 0 };
return;
}
- if (conference_test_flag(conference, CFLAG_FLOOR_CHANGE)) {
- conference_clear_flag(conference, CFLAG_FLOOR_CHANGE);
+ if (conf_utils_test_flag(conference, CFLAG_FLOOR_CHANGE)) {
+ conf_utils_clear_flag(conference, CFLAG_FLOOR_CHANGE);
}
if (vid_frame->img && conference->canvas) {
switch_img_copy(vid_frame->img, &tmp_img);
switch_img_fit(&tmp_img, conference->canvas->width, conference->canvas->height);
frame_img = switch_img_alloc(NULL, SWITCH_IMG_FMT_I420, conference->canvas->width, conference->canvas->height, 1);
- reset_image(frame_img, &conference->canvas->bgcolor);
+ conf_video_reset_image(frame_img, &conference->canvas->bgcolor);
switch_img_find_position(POS_CENTER_MID, frame_img->d_w, frame_img->d_h, tmp_img->d_w, tmp_img->d_h, &x, &y);
switch_img_patch(frame_img, tmp_img, x, y);
tmp_frame.packet = buf;
if (isession && switch_channel_test_flag(imember->channel, CF_VIDEO)) {
int send_frame = 0;
- if (conference->canvas && conference_test_flag(imember->conference, CFLAG_VIDEO_BRIDGE_FIRST_TWO)) {
+ if (conference->canvas && conf_utils_test_flag(imember->conference, CFLAG_VIDEO_BRIDGE_FIRST_TWO)) {
if (switch_channel_test_flag(imember->channel, CF_VIDEO) && (conference->members_with_video == 1 || imember != floor_holder)) {
send_frame = 1;
}
- } else if (!member_test_flag(imember, MFLAG_RECEIVING_VIDEO) &&
- (conference_test_flag(conference, CFLAG_VID_FLOOR_LOCK) ||
+ } else if (!conf_utils_member_test_flag(imember, MFLAG_RECEIVING_VIDEO) &&
+ (conf_utils_test_flag(conference, CFLAG_VID_FLOOR_LOCK) ||
!(imember->id == imember->conference->video_floor_holder && imember->conference->last_video_floor_holder))) {
send_frame = 1;
}
}
}
-switch_status_t video_thread_callback(switch_core_session_t *session, switch_frame_t *frame, void *user_data)
+switch_status_t conf_video_thread_callback(switch_core_session_t *session, switch_frame_t *frame, void *user_data)
{
//switch_channel_t *channel = switch_core_session_get_channel(session);
//char *name = switch_channel_get_name(channel);
- conference_member_t *member = (conference_member_t *)user_data;
+ conf_member_t *member = (conf_member_t *)user_data;
conference_relationship_t *rel = NULL, *last = NULL;
switch_assert(member);
}
- if (conference_test_flag(member->conference, CFLAG_VIDEO_BRIDGE_FIRST_TWO)) {
+ if (conf_utils_test_flag(member->conference, CFLAG_VIDEO_BRIDGE_FIRST_TWO)) {
if (member->conference->members_with_video < 3) {
- conference_write_video_frame(member->conference, member, frame);
- check_video_recording(member->conference, frame);
+ conf_video_write_frame(member->conference, member, frame);
+ conf_video_check_recording(member->conference, frame);
switch_thread_rwlock_unlock(member->conference->rwlock);
return SWITCH_STATUS_SUCCESS;
}
}
- if (conference_test_flag(member->conference, CFLAG_VIDEO_MUXING)) {
+ if (conf_utils_test_flag(member->conference, CFLAG_VIDEO_MUXING)) {
switch_image_t *img_copy = NULL;
- if (frame->img && (member->video_layer_id > -1 || member->canvas) && member_test_flag(member, MFLAG_CAN_BE_SEEN) &&
+ if (frame->img && (member->video_layer_id > -1 || member->canvas) && conf_utils_member_test_flag(member, MFLAG_CAN_BE_SEEN) &&
!member->conference->playing_video_file && switch_queue_size(member->video_queue) < member->conference->video_fps.fps) {
switch_img_copy(frame->img, &img_copy);
switch_queue_push(member->video_queue, img_copy);
}
for (rel = member->relationships; rel; rel = rel->next) {
- conference_member_t *imember;
+ conf_member_t *imember;
if (!(rel->flags & RFLAG_CAN_SEND_VIDEO)) continue;
- if ((imember = conference_member_get(member->conference, rel->id)) && member_test_flag(imember, MFLAG_RECEIVING_VIDEO)) {
+ if ((imember = conf_member_get(member->conference, rel->id)) && conf_utils_member_test_flag(imember, MFLAG_RECEIVING_VIDEO)) {
//switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "%s %d->%d %d\n", name, member->id, imember->id, frame->datalen);
switch_core_session_write_video_frame(imember->session, frame, SWITCH_IO_FLAG_NONE, 0);
switch_thread_rwlock_unlock(imember->rwlock);
if (member) {
if (member->id == member->conference->video_floor_holder) {
- conference_write_video_frame(member->conference, member, frame);
- check_video_recording(member->conference, frame);
- } else if (!conference_test_flag(member->conference, CFLAG_VID_FLOOR_LOCK) && member->id == member->conference->last_video_floor_holder) {
- conference_member_t *fmember;
+ conf_video_write_frame(member->conference, member, frame);
+ conf_video_check_recording(member->conference, frame);
+ } else if (!conf_utils_test_flag(member->conference, CFLAG_VID_FLOOR_LOCK) && member->id == member->conference->last_video_floor_holder) {
+ conf_member_t *fmember;
- if ((fmember = conference_member_get(member->conference, member->conference->video_floor_holder))) {
+ if ((fmember = conf_member_get(member->conference, member->conference->video_floor_holder))) {
switch_core_session_write_video_frame(fmember->session, frame, SWITCH_IO_FLAG_NONE, 0);
switch_thread_rwlock_unlock(fmember->rwlock);
}
projects / thirdparty / freeswitch.git / commitdiff
