FS-7845 Rename functions so that they relate to the file that they are

located in.

src/mod/applications/mod_conference/mod_conference_al.c

@@ -43,7 +43,7 @@
 
 
 
-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;
 
@@ -54,22 +54,22 @@ al_handle_t *create_al(switch_memory_pool_t *pool)
 }
 
 #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) {
@@ -78,14 +78,14 @@ void gen_arc(conference_obj_t *conference, switch_stream_handle_t *stream)
 
 	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;
@@ -112,14 +112,14 @@ void gen_arc(conference_obj_t *conference, switch_stream_handle_t *stream)
 	
 	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;
@@ -163,7 +163,7 @@ 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 conf_al_process(al_handle_t *al, void *data, switch_size_t datalen, int rate)
 {
 
 	if (rate != 48000) {
@@ -180,7 +180,7 @@ void process_al(al_handle_t *al, void *data, switch_size_t datalen, int rate)
 			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. };
@@ -205,7 +205,7 @@ void process_al(al_handle_t *al, void *data, switch_size_t datalen, int rate)
 			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) {
@@ -237,42 +237,14 @@ void process_al(al_handle_t *al, void *data, switch_size_t datalen, int rate)
 }
 #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;
@@ -297,31 +269,12 @@ switch_status_t parse_position(al_handle_t *al, const char *data)
 }
 #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;
@@ -342,7 +295,7 @@ void close_al(al_handle_t *al)
 		alcCloseDevice(al->device);
 		al->device = NULL;
 	}
-	switch_mutex_unlock(mod_conference_globals.setup_mutex);
+	switch_mutex_unlock(conf_globals.setup_mutex);
 }
 #endif
 

src/mod/applications/mod_conference/mod_conference_cdr.c

@@ -42,28 +42,28 @@
 #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];
@@ -71,7 +71,7 @@ char *conference_rfc4579_render(conference_obj_t *conference, switch_event_t *ev
 	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;
 
@@ -276,7 +276,7 @@ char *conference_rfc4579_render(conference_obj_t *conference, switch_event_t *ev
 			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)) {
@@ -327,13 +327,13 @@ char *conference_rfc4579_render(conference_obj_t *conference, switch_event_t *ev
 }
 
 
-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;
 
@@ -457,7 +457,7 @@ cJSON *conference_json_render(conference_obj_t *conference, cJSON *req)
 				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)) {
@@ -486,7 +486,7 @@ cJSON *conference_json_render(conference_obj_t *conference, cJSON *req)
 	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);
@@ -498,9 +498,9 @@ void conference_cdr_del(conference_member_t *member)
 	}
 }
 
-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;
 
@@ -530,9 +530,9 @@ 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 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));
@@ -549,11 +549,11 @@ void conference_cdr_rejected(conference_obj_t *conference, switch_channel_t *cha
 	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;
@@ -605,7 +605,7 @@ void conference_cdr_render(conference_obj_t *conference)
 	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);
@@ -647,16 +647,16 @@ void conference_cdr_render(conference_obj_t *conference)
 			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();

src/mod/applications/mod_conference/mod_conference_file.c

@@ -45,12 +45,12 @@
 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));
@@ -63,8 +63,8 @@ switch_status_t conference_file_close(conference_obj_t *conference, conference_f
 		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);
 			}
 
@@ -83,7 +83,7 @@ switch_status_t conference_file_close(conference_obj_t *conference, conference_f
 
 #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) {
@@ -98,7 +98,7 @@ switch_status_t conference_file_close(conference_obj_t *conference, conference_f
 
 
 /* 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;
@@ -134,7 +134,7 @@ uint32_t conference_stop_file(conference_obj_t *conference, file_stop_t stop)
 }
 
 /* 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;
@@ -175,7 +175,7 @@ switch_status_t conference_play_file(conference_obj_t *conference, char *file, u
 	}
 
 	if (!async && say) {
-		status = conference_say(conference, file + 4, leadin);
+		status = conf_say(conference, file + 4, leadin);
 		goto done;
 	}
 
@@ -196,7 +196,7 @@ switch_status_t conference_play_file(conference_obj_t *conference, char *file, u
 			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;
@@ -232,7 +232,7 @@ switch_status_t conference_play_file(conference_obj_t *conference, char *file, u
 
 	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;
 	}
 
@@ -244,7 +244,7 @@ switch_status_t conference_play_file(conference_obj_t *conference, char *file, u
 
 		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);
@@ -271,8 +271,8 @@ switch_status_t conference_play_file(conference_obj_t *conference, char *file, u
 		}
 
 		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;
@@ -288,7 +288,7 @@ switch_status_t conference_play_file(conference_obj_t *conference, char *file, u
 	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 */
@@ -328,7 +328,7 @@ switch_status_t conference_play_file(conference_obj_t *conference, char *file, u
 }
 
 /* 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;

src/mod/applications/mod_conference/mod_conference_utils.c

@@ -41,7 +41,51 @@
  */
 #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);
@@ -106,7 +150,7 @@ void set_mflags(const char *flags, member_flag_t *f)
 
 
 
-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);
@@ -159,7 +203,7 @@ void set_cflags(const char *flags, conference_flag_t *f)
 }
 
 
-void clear_eflags(char *events, uint32_t *f)
+void conf_utils_clear_eflags(char *events, uint32_t *f)
 {
 	char buf[512] = "";
 	char *next = NULL;
@@ -236,7 +280,7 @@ void clear_eflags(char *events, uint32_t *f)
 }
 
 
-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;
 
@@ -245,71 +289,71 @@ void merge_mflags(member_flag_t *a, member_flag_t *b)
 	}
 }
 
-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];
 }