Rename all internal pa_ definitions to agl_

The plugin often uses "pa_" for its internal structures
and functions, which is misleading because this prefix is
also used by PulseAudio itself. Thus, reading the code can
be confusing.
Rename everything to "agl_".

Change-Id: Iadd03daf528ec0cbed1cb526aeb3bada757a211f
Signed-off-by: Manuel Bachmann <manuel.bachmann@iot.bzh>

25 files changed, 291 insertions, 292 deletions

diff --git a/audiomgr.c b/audiomgr.c
index 138d9f1..cfbdc67 100644
--- a/audiomgr.c
+++ b/audiomgr.c
@@ -41,20 +41,20 @@ typedef struct {
 	link_t      *links;
 } routes_t;
 
-struct pa_audiomgr {
+struct agl_audiomgr {
 	domain_t      domain;
 	pa_hashmap   *nodes;        /**< nodes ie. sinks and sources */
 	pa_hashmap   *conns;        /**< connections */
 	routes_t      defrts;       /**< default routes */
 };
 
-struct pa_audiomgr *pa_audiomgr_init (struct userdata *u)
+struct agl_audiomgr *agl_audiomgr_init (struct userdata *u)
 {
-	pa_audiomgr *am;
+	agl_audiomgr *am;
 
 	pa_assert (u);
 
-	am = pa_xnew0 (pa_audiomgr, 1);
+	am = pa_xnew0 (agl_audiomgr, 1);
 	am->domain.id = AM_ID_INVALID;
 	am->domain.state = DS_DOWN;
 	am->nodes = pa_hashmap_new (pa_idxset_trivial_hash_func,
@@ -64,9 +64,9 @@ struct pa_audiomgr *pa_audiomgr_init (struct userdata *u)
 	return am;
 }
 
-void pa_audiomgr_done (struct userdata *u)
+void agl_audiomgr_done (struct userdata *u)
 {
-	pa_audiomgr *am;
+	agl_audiomgr *am;
 
 	if (u && (am = u->audiomgr)) {
 		//if (u->routerif && am->domain.id != AM_ID_INVALID)
diff --git a/audiomgr.h b/audiomgr.h
index c668a27..3cffe2a 100644
--- a/audiomgr.h
+++ b/audiomgr.h
@@ -24,7 +24,7 @@
 
 #include "userdata.h"
 
-pa_audiomgr *pa_audiomgr_init (struct userdata *);
-void pa_audiomgr_done (struct userdata *);
+agl_audiomgr *agl_audiomgr_init (struct userdata *);
+void agl_audiomgr_done (struct userdata *);
 
 #endif
diff --git a/classify.c b/classify.c
index 23d991d..c049fad 100644
--- a/classify.c
+++ b/classify.c
@@ -24,7 +24,7 @@
 
 #include "classify.h"
 
-agl_node_type pa_classify_guess_stream_node_type (struct userdata *u,  pa_proplist *pl)
+agl_node_type agl_classify_guess_stream_node_type (struct userdata *u,  pa_proplist *pl)
 {
 	agl_node_type type;
 	const char *role;
diff --git a/classify.h b/classify.h
index 301a440..336c169 100644
--- a/classify.h
+++ b/classify.h
@@ -3,6 +3,6 @@
 
 #include "userdata.h"
 
-agl_node_type pa_classify_guess_stream_node_type (struct userdata *,  pa_proplist *);
+agl_node_type agl_classify_guess_stream_node_type (struct userdata *,  pa_proplist *);
 
 #endif
diff --git a/config.c b/config.c
index 4c4ed7d..1a74f23 100644
--- a/config.c
+++ b/config.c
@@ -21,7 +21,7 @@
  */
 #include "config.h"
 
-const char *pa_config_file_get_path (const char *dir, const char *file, char *buf, size_t len)
+const char *agl_config_file_get_path (const char *dir, const char *file, char *buf, size_t len)
 {
 	pa_assert (file);
 	pa_assert (buf);
@@ -32,7 +32,7 @@ const char *pa_config_file_get_path (const char *dir, const char *file, char *bu
 	return buf;
 }
 
-bool pa_config_parse_file (struct userdata *u, const char *path)
+bool agl_config_parse_file (struct userdata *u, const char *path)
 {
 	bool success;
 
@@ -42,7 +42,7 @@ bool pa_config_parse_file (struct userdata *u, const char *path)
 		return false;
 	else {
 		pa_log_info ("parsing configuration file '%s'", path);
-		success = pa_config_dofile (u, path);
+		success = agl_config_dofile (u, path);
 	}
 
 	if (!success) {
@@ -53,7 +53,7 @@ bool pa_config_parse_file (struct userdata *u, const char *path)
 	return success;
 }
 
-bool pa_config_dofile (struct userdata *u, const char *path)
+bool agl_config_dofile (struct userdata *u, const char *path)
 {
 	/* TODO */
 	return false;
diff --git a/config.h b/config.h
index 738f254..1430824 100644
--- a/config.h
+++ b/config.h
@@ -58,8 +58,8 @@ typedef struct {
 	int priority;
 } prior_def;
 
-const char *pa_config_file_get_path (const char *, const char *, char *, size_t);
-bool pa_config_parse_file (struct userdata *, const char *);
-bool pa_config_dofile (struct userdata *, const char *);
+const char *agl_config_file_get_path (const char *, const char *, char *, size_t);
+bool agl_config_parse_file (struct userdata *, const char *);
+bool agl_config_dofile (struct userdata *, const char *);
 
 #endif
diff --git a/discover.c b/discover.c
index 93a5d8b..79164bb 100644
--- a/discover.c
+++ b/discover.c
@@ -42,9 +42,9 @@ static const char *node_key (struct userdata *, agl_direction,
 			     void *, pa_device_port *, char *, size_t);
 static agl_node *create_node (struct userdata *, agl_node *, bool *);
 
-struct pa_discover *pa_discover_init (struct userdata *u)
+struct agl_discover *agl_discover_init (struct userdata *u)
 {
-	pa_discover *discover = pa_xnew0 (pa_discover, 1);
+	agl_discover *discover = pa_xnew0 (agl_discover, 1);
 	discover->chmin = 1;
 	discover->chmax = 2;
 	discover->selected = true;
@@ -56,9 +56,9 @@ struct pa_discover *pa_discover_init (struct userdata *u)
 	return discover;
 }
 
-void pa_discover_done (struct userdata *u)
+void agl_discover_done (struct userdata *u)
 {
-	pa_discover *discover;
+	agl_discover *discover;
 	void *state;
 	agl_node *node;
 
@@ -73,27 +73,27 @@ void pa_discover_done (struct userdata *u)
 	}
 }
 
-void pa_discover_add_card (struct userdata *u, pa_card *card)
+void agl_discover_add_card (struct userdata *u, pa_card *card)
 {
 	const char *bus;
 
 	pa_assert(u);
 	pa_assert(card);
 
-	if (!(bus = pa_utils_get_card_bus (card))) {
+	if (!(bus = agl_utils_get_card_bus (card))) {
 		pa_log_debug ("ignoring card '%s' due to lack of '%s' property",
-			      pa_utils_get_card_name (card), PA_PROP_DEVICE_BUS);
+			      agl_utils_get_card_name (card), PA_PROP_DEVICE_BUS);
 		return;
 	}
 
 	if (pa_streq(bus, "pci") || pa_streq(bus, "usb") || pa_streq(bus, "platform")) {
 		pa_log_debug ("adding card '%s' thanks to its '%s' property",
-			      pa_utils_get_card_name (card), PA_PROP_DEVICE_BUS);
+			      agl_utils_get_card_name (card), PA_PROP_DEVICE_BUS);
 		pa_log_debug ("card  type is '%s'", bus);
 		handle_alsa_card (u, card);
 		return;
 	}
-/* this never happens, because "pa_utils_get_card_bus()" never returns "bluetooth",
+/* this never happens, because "agl_utils_get_card_bus()" never returns "bluetooth",
  * but have this here as a reminder */
 #if 0
 	else if (pa_streq(bus, "bluetooth")) {
@@ -103,13 +103,13 @@ void pa_discover_add_card (struct userdata *u, pa_card *card)
 #endif
 
 	pa_log_debug ("ignoring card '%s' due to unsupported bus type '%s'",
-		      pa_utils_get_card_name (card), bus);
+		      agl_utils_get_card_name (card), bus);
 }
 
-void pa_discover_remove_card (struct userdata *u, pa_card *card)
+void agl_discover_remove_card (struct userdata *u, pa_card *card)
 {
 	const char  *bus;
-	pa_discover *discover;
+	agl_discover *discover;
 	agl_node    *node;
 	void        *state;
 
@@ -117,7 +117,7 @@ void pa_discover_remove_card (struct userdata *u, pa_card *card)
 	pa_assert (card);
 	pa_assert_se (discover = u->discover);
 
-	if (!(bus = pa_utils_get_card_bus(card)))
+	if (!(bus = agl_utils_get_card_bus(card)))
 		bus = "<unknown>";
 
 	/*PA_HASHMAP_FOREACH(node, discover->nodes.byname, state) {
@@ -130,7 +130,7 @@ void pa_discover_remove_card (struct userdata *u, pa_card *card)
 		destroy_node(u, node);
 	}*/
 
-  /* this never happens, because "pa_utils_get_card_bus()" never returns "bluetooth",
+  /* this never happens, because "agl_utils_get_card_bus()" never returns "bluetooth",
   * but have this here as a reminder */
 #if 0
     if (pa_streq(bus, "bluetooth"))
@@ -138,12 +138,12 @@ void pa_discover_remove_card (struct userdata *u, pa_card *card)
 #endif
 }
 
-void pa_discover_add_sink (struct userdata *u, pa_sink *sink, bool route)
+void agl_discover_add_sink (struct userdata *u, pa_sink *sink, bool route)
 {
 	pa_core *core;
-	pa_discover *discover;
 	pa_module *module;
 	pa_card *card;
+	agl_discover *discover;
 	char kbf[256];
 	const char *key;
 	agl_node *node;
@@ -162,7 +162,7 @@ void pa_discover_add_sink (struct userdata *u, pa_sink *sink, bool route)
 		key = node_key (u, agl_output, sink, NULL, kbf, sizeof(kbf));
 		if (!key) return;
 		pa_log_debug ("Sink key: %s", key);
-		node = pa_discover_find_node_by_key (u, key);
+		node = agl_discover_find_node_by_key (u, key);
 		if (!node) {	/* ALWAYS NULL, IF CALL "handle_card_ports" FROM "handle_alsa_card" !!! */
 			if (u->state.profile)
 				pa_log_debug ("can't find node for sink (key '%s')", key);
@@ -176,12 +176,12 @@ void pa_discover_add_sink (struct userdata *u, pa_sink *sink, bool route)
 			     node->paname, node->key);
         	node->paidx = sink->index;
 		node->available = true;
-		pa_discover_add_node_to_ptr_hash (u, sink, node);
+		agl_discover_add_node_to_ptr_hash (u, sink, node);
 
 #if 0
 		/* loopback part : it is a device node, use "module-loopback" to make its */
 		if (node->implement == agl_device) {
-			null_source = pa_utils_get_null_source (u);
+			null_source = agl_utils_get_null_source (u);
 			if (!null_source) {
 				pa_log ("Can't load loopback module: no initial null source");
 				return;
@@ -201,14 +201,14 @@ static void handle_alsa_card (struct userdata *u, pa_card *card)
 	const char *udd;	/* managed by udev ("1" = yes) */
 
 	memset (&data, 0, sizeof(data));
-	data.zone = pa_utils_get_zone (card->proplist, NULL);
+	data.zone = agl_utils_get_zone (card->proplist, NULL);
 	data.visible = true;
 	data.amid = AM_ID_INVALID;
 	data.implement = agl_device;		/* this node is a physical device */
 	data.paidx = PA_IDXSET_INVALID;
-	data.stamp = pa_utils_get_stamp ();	/* each time incremented by one */
+	data.stamp = agl_utils_get_stamp ();	/* each time incremented by one */
 
-	cnam = pa_utils_get_card_name (card);	/* PulseAudio name */
+	cnam = agl_utils_get_card_name (card);	/* PulseAudio name */
 	cid = cnam + 10;			/* PulseAudio short name, with "alsa_card." prefix removed */
 	alsanam = pa_proplist_gets (card->proplist, "alsa.card_name"); /* ALSA name */
 	udd = pa_proplist_gets (card->proplist, "module-udev-detect.discovered");
@@ -234,7 +234,7 @@ static void handle_alsa_card (struct userdata *u, pa_card *card)
                                               ;
 static void handle_alsa_card_sinks_and_sources (struct userdata *u, pa_card *card, agl_node *data, const char *cardid)
 {
-	pa_discover *discover; /* discovery restrictions (max channels...) */
+	agl_discover *discover; /* discovery restrictions (max channels...) */
 	pa_card_profile *prof;
 	void *state;
 	char *sinks[MAX_CARD_TARGET+1];	  /* discovered sinks array */
@@ -384,7 +384,7 @@ static void handle_card_ports (struct userdata *u, agl_node *data, pa_card *card
 				printf ("Key : %s\n", key);
 
 				 /* this is needed to fill the "port->type" field */
-				//pa_classify_node_by_card (data, card, prof, port);
+				//agl_classify_node_by_card (data, card, prof, port);
 
 				 /* this is needed to complete the "pa_discover_add_sink" first pass */
 				node = create_node (u, data, &created);
@@ -414,14 +414,14 @@ static const char *node_key (struct userdata *u, agl_direction direction,
 	if (direction == agl_output) {
 		pa_sink *sink = data;
 		type = pa_xstrdup ("sink");
-		name = pa_utils_get_sink_name (sink);
+		name = agl_utils_get_sink_name (sink);
 		card = sink->card;
 		if (!port)
 			port = sink->active_port;
 	} else {
 		pa_source *source = data;
 		type = pa_xstrdup ("source");
-		name = pa_utils_get_source_name (source);
+		name = agl_utils_get_source_name (source);
 		card = source->card;
 		if (!port)
 			port = source->active_port;
@@ -443,9 +443,9 @@ static const char *node_key (struct userdata *u, agl_direction direction,
 		profile_name = u->state.profile;
 	}
 
-	if (!(bus = pa_utils_get_card_bus (card))) {
+	if (!(bus = agl_utils_get_card_bus (card))) {
 		pa_log_debug ("ignoring card '%s' due to lack of '%s' property",
-			      pa_utils_get_card_name (card), PA_PROP_DEVICE_BUS);
+			      agl_utils_get_card_name (card), PA_PROP_DEVICE_BUS);
 		return NULL;
 	}
 
@@ -464,9 +464,9 @@ static const char *node_key (struct userdata *u, agl_direction direction,
 	return (const char *)key;
 }
 
-agl_node *pa_discover_find_node_by_key (struct userdata *u, const char *key)
+agl_node *agl_discover_find_node_by_key (struct userdata *u, const char *key)
 {
-	pa_discover *discover;
+	agl_discover *discover;
 	agl_node *node;
 
 	pa_assert (u);
@@ -480,9 +480,9 @@ agl_node *pa_discover_find_node_by_key (struct userdata *u, const char *key)
 	return node;
 }
 
-void pa_discover_add_node_to_ptr_hash (struct userdata *u, void *ptr, agl_node *node)
+void agl_discover_add_node_to_ptr_hash (struct userdata *u, void *ptr, agl_node *node)
 {
-	pa_discover *discover;
+	agl_discover *discover;
 
 	pa_assert (u);
 	pa_assert (ptr);
@@ -494,7 +494,7 @@ void pa_discover_add_node_to_ptr_hash (struct userdata *u, void *ptr, agl_node *
 
 static agl_node *create_node (struct userdata *u, agl_node *data, bool *created_ret)
 {
-	pa_discover *discover;
+	agl_discover *discover;
 	agl_node *node;
 	bool created;
 
@@ -526,14 +526,14 @@ static agl_node *create_node (struct userdata *u, agl_node *data, bool *created_
 	return node;
 }
 
-void pa_discover_add_source (struct userdata *u, pa_source *source)
+void agl_discover_add_source (struct userdata *u, pa_source *source)
 {
-	static pa_nodeset_resdef def_resdef = {0, {0, 0}};
+	static agl_nodeset_resdef def_resdef = {0, {0, 0}};
 
 	pa_core *core;
-	pa_discover *discover;
 	pa_module *module;
 	pa_card *card;
+	agl_discover *discover;
 	const char *key;
 	char kbf[256];
 	agl_node *node;
@@ -551,7 +551,7 @@ void pa_discover_add_source (struct userdata *u, pa_source *source)
 		key = node_key (u, agl_input, source, NULL, kbf, sizeof(kbf));
 		if (!key) return;
 		pa_log_debug ("Source key: %s", key);
-		node = pa_discover_find_node_by_key (u, key);
+		node = agl_discover_find_node_by_key (u, key);
 		if (!node) {	/* VERIFY IF THIS WORKS */
 			if (u->state.profile)
 				pa_log_debug ("can't find node for source (key '%s')", key);
@@ -565,17 +565,17 @@ void pa_discover_add_source (struct userdata *u, pa_source *source)
 			     node->paname, node->key);
         	node->paidx = source->index;
 		node->available = true;
-		pa_discover_add_node_to_ptr_hash (u, source, node);
+		agl_discover_add_node_to_ptr_hash (u, source, node);
 	}
 }
 
-bool pa_discover_preroute_sink_input(struct userdata *u, pa_sink_input_new_data *data)
+bool agl_discover_preroute_sink_input(struct userdata *u, pa_sink_input_new_data *data)
 {
 	pa_core *core;
 	pa_sink *sink;
 	pa_source *source;
-	pa_discover *discover;
-	pa_nodeset *nodeset;
+	agl_discover *discover;
+	agl_nodeset *nodeset;
 	pa_proplist *pl;
 	agl_node *node;
 
@@ -598,7 +598,7 @@ bool pa_discover_preroute_sink_input(struct userdata *u, pa_sink_input_new_data
 		node = agl_node_create (u, NULL);
 		node->direction = agl_input;
 		node->implement = agl_stream;
-		node->type = pa_classify_guess_stream_node_type (u, pl);
+		node->type = agl_classify_guess_stream_node_type (u, pl);
 		node->visible = true;
 		node->available = true;
 		node->ignore = true; /* gets ignored initially */
@@ -610,12 +610,12 @@ bool pa_discover_preroute_sink_input(struct userdata *u, pa_sink_input_new_data
 
 	 /* create NULL sink */
 	if (!node->nullsink)
-		node->nullsink = pa_utils_create_null_sink (u, u->nsnam);
+		node->nullsink = agl_utils_create_null_sink (u, u->nsnam);
 	if (!node->nullsink)
 		return false;
 
 	 /* redirect sink input to NULL sink */
-	sink = pa_utils_get_null_sink (u, node->nullsink);
+	sink = agl_utils_get_null_sink (u, node->nullsink);
 
 	if (pa_sink_input_new_data_set_sink (data, sink, false))
 		pa_log_debug ("set sink %u for new sink-input", sink->index);
@@ -625,11 +625,11 @@ bool pa_discover_preroute_sink_input(struct userdata *u, pa_sink_input_new_data
 	return true;
 }
 
-void pa_discover_register_sink_input (struct userdata *u, pa_sink_input *sinp)
+void agl_discover_register_sink_input (struct userdata *u, pa_sink_input *sinp)
 {
 	pa_core *core;
-	pa_discover *discover;
 	pa_proplist *pl, *client_proplist;
+	agl_discover *discover;
 	const char *media;
 	const char *name;
 	const char *role;
@@ -651,7 +651,7 @@ void pa_discover_register_sink_input (struct userdata *u, pa_sink_input *sinp)
 		/* return; */
 	}
 
-	name = pa_utils_get_sink_input_name (sinp);
+	name = agl_utils_get_sink_input_name (sinp);
 	client_proplist = sinp->client ? sinp->client->proplist : NULL;
 
 	pa_log_debug ("registering input stream '%s'", name);
@@ -668,7 +668,7 @@ void pa_discover_register_sink_input (struct userdata *u, pa_sink_input *sinp)
 	 *	#define PA_PROP_ROUTING_CLASS_NAME "routing.class.name"
 	 *	#define PA_PROP_ROUTING_CLASS_ID   "routing.class.id"
 	 *	#define PA_PROP_ROUTING_METHOD     "routing.method" */
-	pa_utils_set_stream_routing_properties (pl, type, NULL);
+	agl_utils_set_stream_routing_properties (pl, type, NULL);
 
 	/* we now create a new node for this sink */
 	memset (&node_data, 0, sizeof(node_data));
@@ -677,7 +677,7 @@ void pa_discover_register_sink_input (struct userdata *u, pa_sink_input *sinp)
 	node_data.implement = agl_stream;
 	node_data.channels  = sinp->channel_map.channels;
 	node_data.type      = type;
-	node_data.zone      = pa_utils_get_zone (sinp->proplist, client_proplist);
+	node_data.zone      = agl_utils_get_zone (sinp->proplist, client_proplist);
 	node_data.visible   = true;
 	node_data.available = true;
 	node_data.amname    = pa_proplist_gets (pl, "resource.set.appid");
@@ -693,7 +693,7 @@ void pa_discover_register_sink_input (struct userdata *u, pa_sink_input *sinp)
 
 	node = create_node (u, &node_data, NULL);
 	pa_assert (node);
-	pa_discover_add_node_to_ptr_hash (u, sinp, node);
+	agl_discover_add_node_to_ptr_hash (u, sinp, node);
 /*
 	if (sink && target) {
 		pa_log_debug ("move stream to sink %u (%s)", sink->index, sink->name);
@@ -705,11 +705,11 @@ void pa_discover_register_sink_input (struct userdata *u, pa_sink_input *sinp)
 	}*/
 }
 
-void pa_discover_register_source_output (struct userdata *u, pa_source_output *sout)
+void agl_discover_register_source_output (struct userdata *u, pa_source_output *sout)
 {
 	pa_core *core;
-	pa_discover *discover;
 	pa_proplist *pl, *client_proplist;
+	agl_discover *discover;
 	const char *media;
 	const char *name;
 	const char *role;
@@ -731,17 +731,17 @@ void pa_discover_register_source_output (struct userdata *u, pa_source_output *s
 		/* return; */
 	}
 
-	 /* TODO : contrary to "pa_discover_register_sink_input", this function is always called
+	 /* TODO : contrary to "agl_discover_register_sink_input", this function is always called
 	  * even if we do not find PA_PROP_MEDIA_NAME (see above). */
-	//pa_utils_set_stream_routing_properties (pl, type, NULL);
+	//agl_utils_set_stream_routing_properties (pl, type, NULL);
 
-	name = pa_utils_get_source_output_name (sout);
+	name = agl_utils_get_source_output_name (sout);
 	client_proplist = sout->client ? sout->client->proplist : NULL;
 
 	pa_log_debug("registering output stream '%s'", name);
 }
 
-void pa_discover_add_sink_input (struct userdata *u, pa_sink_input *sinp) 
+void agl_discover_add_sink_input (struct userdata *u, pa_sink_input *sinp) 
 {
 	pa_core *core;
 	agl_node *node;
@@ -761,7 +761,7 @@ void pa_discover_add_sink_input (struct userdata *u, pa_sink_input *sinp)
 	agl_router_register_node (u, node);
 }
 
-void pa_discover_remove_sink_input (struct userdata *u, pa_sink_input *sinp)
+void agl_discover_remove_sink_input (struct userdata *u, pa_sink_input *sinp)
 {
 	pa_core *core;
 	agl_node *node;
diff --git a/discover.h b/discover.h
index 8845e40..210a8a5 100644
--- a/discover.h
+++ b/discover.h
@@ -24,7 +24,7 @@
 
 #include "userdata.h"
 
-struct pa_discover {
+struct agl_discover {
     /* criteria for filtering sinks and sources */
 	unsigned chmin;    /**< minimum of max channels */
 	unsigned chmax;    /**< maximum of max channels */
@@ -37,22 +37,22 @@ struct pa_discover {
 	} nodes;
 };
 
-struct pa_discover *pa_discover_init (struct userdata *);
-void pa_discover_done (struct userdata *);
+struct agl_discover *agl_discover_init (struct userdata *);
+void agl_discover_done (struct userdata *);
 
-void pa_discover_add_card (struct userdata *, pa_card *);
-void pa_discover_remove_card (struct userdata *, pa_card *);
-void pa_discover_add_sink (struct userdata *, pa_sink *, bool);
-void pa_discover_remove_sink (struct userdata *, pa_sink *);
-void pa_discover_add_source (struct userdata *, pa_source *);
-void pa_discover_remove_source (struct userdata *, pa_source *);
-void pa_discover_add_sink_input (struct userdata *, pa_sink_input *);
-void pa_discover_remove_sink_input (struct userdata *, pa_sink_input *);
-bool pa_discover_preroute_sink_input (struct userdata *, pa_sink_input_new_data *);
-void pa_discover_register_sink_input (struct userdata *, pa_sink_input *);
-void pa_discover_register_source_output (struct userdata *, pa_source_output *);
+void agl_discover_add_card (struct userdata *, pa_card *);
+void agl_discover_remove_card (struct userdata *, pa_card *);
+void agl_discover_add_sink (struct userdata *, pa_sink *, bool);
+void agl_discover_remove_sink (struct userdata *, pa_sink *);
+void agl_discover_add_source (struct userdata *, pa_source *);
+void agl_discover_remove_source (struct userdata *, pa_source *);
+void agl_discover_add_sink_input (struct userdata *, pa_sink_input *);
+void agl_discover_remove_sink_input (struct userdata *, pa_sink_input *);
+bool agl_discover_preroute_sink_input (struct userdata *, pa_sink_input_new_data *);
+void agl_discover_register_sink_input (struct userdata *, pa_sink_input *);
+void agl_discover_register_source_output (struct userdata *, pa_source_output *);
 
-agl_node *pa_discover_find_node_by_key (struct userdata *, const char *);
-void pa_discover_add_node_to_ptr_hash (struct userdata *, void *, agl_node *);
+agl_node *agl_discover_find_node_by_key (struct userdata *, const char *);
+void agl_discover_add_node_to_ptr_hash (struct userdata *, void *, agl_node *);
 
 #endif
diff --git a/loopback.c b/loopback.c
index 5b07ef7..c7ff7c6 100644
--- a/loopback.c
+++ b/loopback.c
@@ -23,27 +23,27 @@
 #include "utils.h"
 #include "list.h"
 
-pa_loopback *pa_loopback_init (void)
+agl_loopback *agl_loopback_init (void)
 {
-	pa_loopback *loopback = pa_xnew0 (pa_loopback, 1);
+	agl_loopback *loopback = pa_xnew0 (agl_loopback, 1);
 
 	return loopback;
 }
 
-void pa_loopback_done (struct userdata *u, pa_loopback *loopback)
+void agl_loopback_done (struct userdata *u, agl_loopback *loopback)
 {
-	pa_loopnode *loop, *n;
+	agl_loopnode *loop, *n;
 	pa_core *core;
 
 	pa_assert_se (core = u->core);
 
 	PA_LLIST_FOREACH_SAFE(loop, n, loopback->loopnodes) {
-		pa_module_unload_by_index(core, loop->module_index, false);
+		pa_module_unload_by_index (core, loop->module_index, false);
     }
 }
 
-pa_loopnode *pa_loopnode_create (struct userdata *u, pa_loopnode_type type,
-				 uint32_t node_index, uint32_t source_index, uint32_t sink_index)
+agl_loopnode *agl_loopnode_create (struct userdata *u, agl_loopnode_type type,
+				   uint32_t node_index, uint32_t source_index, uint32_t sink_index)
 {
 	pa_core *core;
 	pa_module *module;
@@ -53,7 +53,7 @@ pa_loopnode *pa_loopnode_create (struct userdata *u, pa_loopnode_type type,
 	const char *sinam;
 	pa_source_output *sout;
 	pa_sink_input *sinp;
-	pa_loopnode *loopnode;
+	agl_loopnode *loopnode;
 	int idx;
 	char args[256];
 
@@ -61,9 +61,9 @@ pa_loopnode *pa_loopnode_create (struct userdata *u, pa_loopnode_type type,
 	pa_assert_se (core = u->core);
 
 	source = pa_idxset_get_by_index (core->sources, source_index);
-	sonam = pa_utils_get_source_name (source);
 	sink = pa_idxset_get_by_index (core->sinks, sink_index);
-	sinam = pa_utils_get_sink_name (sink);
+	sonam = agl_utils_get_source_name (source);
+	sinam = agl_utils_get_sink_name (sink);
 
 	snprintf (args, sizeof(args), "source=\"%s\" sink=\"%s\"", sonam, sinam);
 	module = pa_module_load (core, "module-loopback", args);
@@ -89,7 +89,7 @@ pa_loopnode *pa_loopnode_create (struct userdata *u, pa_loopnode_type type,
 		return NULL;
 	}
 
-	loopnode = pa_xnew0 (pa_loopnode, 1);
+	loopnode = pa_xnew0 (agl_loopnode, 1);
 	loopnode->module_index = module->index;
 	loopnode->source_output_index = sout->index;
 	loopnode->sink_input_index = sinp->index;
@@ -97,7 +97,7 @@ pa_loopnode *pa_loopnode_create (struct userdata *u, pa_loopnode_type type,
 	return loopnode;
 }
 
-void pa_loopnode_destroy (struct userdata *u, pa_loopnode *loopnode)
+void agl_loopnode_destroy (struct userdata *u, agl_loopnode *loopnode)
 {
 	pa_core      *core;
 	pa_module    *module;
diff --git a/loopback.h b/loopback.h
index 27cdef9..ffa27ac 100644
--- a/loopback.h
+++ b/loopback.h
@@ -29,30 +29,30 @@
 
 #include "userdata.h"
 
-typedef struct pa_loopnode pa_loopnode;
-struct pa_loopnode {
-	PA_LLIST_FIELDS(pa_loopnode);
+typedef struct agl_loopnode agl_loopnode;
+struct agl_loopnode {
+	PA_LLIST_FIELDS(agl_loopnode);
 	uint32_t   module_index;
 	uint32_t   node_index;
 	uint32_t   sink_input_index;
 	uint32_t   source_output_index;
 };
 
-typedef struct pa_loopback {
-    PA_LLIST_HEAD(pa_loopnode, loopnodes);
-} pa_loopback;
+typedef struct agl_loopback {
+    PA_LLIST_HEAD(agl_loopnode, loopnodes);
+} agl_loopback;
 
 typedef enum {
-	PA_LOOPNODE_TYPE_UNKNOWN = 0,
-	PA_LOOPNODE_SOURCE,
-	PA_LOOPNODE_SINK,
-} pa_loopnode_type;
+	AGL_LOOPNODE_TYPE_UNKNOWN = 0,
+	AGL_LOOPNODE_SOURCE,
+	AGL_LOOPNODE_SINK,
+} agl_loopnode_type;
 
-pa_loopback *pa_loopback_init (void);
-void pa_loopback_done (struct userdata *, pa_loopback *);
+agl_loopback *agl_loopback_init (void);
+void agl_loopback_done (struct userdata *, agl_loopback *);
 
-pa_loopnode *pa_loopnode_create (struct userdata *, pa_loopnode_type,
-				 uint32_t, uint32_t, uint32_t);
-void pa_loopnode_destroy (struct userdata *, pa_loopnode *);
+agl_loopnode *agl_loopnode_create (struct userdata *, agl_loopnode_type,
+				   uint32_t, uint32_t, uint32_t);
+void agl_loopnode_destroy (struct userdata *, agl_loopnode *);
 
 #endif
diff --git a/module.c b/module.c
index d047b26..e949b28 100644
--- a/module.c
+++ b/module.c
@@ -34,16 +34,16 @@ $ pactl load-module mypamodule
 #include <pulsecore/modargs.h>		/* for "pa_modargs" */
 
 #include "userdata.h"			/* for "struct userdata" */
-#include "config.h"			/* for "pa_config_...()" */
-#include "utils.h"			/* for "struct pa_null_sink", "pa_utils_create_null_sink()"... */
-#include "loopback.h"			/* for "struct pa_loopback/loopnode" */
-#include "zone.h"			/* for "struct pa_zoneset" */
-#include "node.h"			/* for "struct pa_nodeset" */
-#include "audiomgr.h"			/* for "struct pa_audiomgr" */
-#include "routerif.h"			/* for "struct pa_routerif" */
-#include "discover.h"			/* for "struct pa_discover" */
-#include "tracker.h"			/* for "struct pa_tracker" */
-#include "router.h"			/* for "struct pa_router" */
+#include "config.h"			/* for "agl_config_...()" */
+#include "utils.h"			/* for "struct agl_null_sink", "agl_utils_create_null_sink()"... */
+#include "loopback.h"			/* for "struct agl_loopback/loopnode" */
+#include "zone.h"			/* for "struct agl_zoneset" */
+#include "node.h"			/* for "struct agl_nodeset" */
+#include "audiomgr.h"			/* for "struct agl_audiomgr" */
+#include "routerif.h"			/* for "struct agl_routerif" */
+#include "router.h"			/* for "struct agl_router" */
+#include "discover.h"			/* for "struct agl_discover" */
+#include "tracker.h"			/* for "struct agl_tracker" */
 
 #ifndef DEFAULT_CONFIG_DIR
 #define DEFAULT_CONFIG_DIR "/etc/pulse"
@@ -100,7 +100,9 @@ int pa__init (pa_module *m)
 	pa_log ("cfgdir : %s", cfgdir);
 	pa_log ("cfgfile : %s", cfgfile);
 
-	pa_utils_init_stamp ();
+	 /* initialize "stamp" incremental integer to 0 */
+
+	agl_utils_init_stamp ();
 
 	 /* initialize userdata */
 
@@ -108,28 +110,28 @@ int pa__init (pa_module *m)
 	u->core      = m->core;
 	u->module    = m;
 	u->nsnam     = pa_xstrdup (nsnam) ;
-	u->zoneset   = pa_zoneset_init (u);
-	u->nodeset   = pa_nodeset_init (u);
-	u->audiomgr  = pa_audiomgr_init (u);
-	u->routerif  = pa_routerif_init (u, amsocktype, amaddr, amport);
-	u->router    = pa_router_init (u);
-	u->discover  = pa_discover_init (u);
-	u->tracker   = pa_tracker_init (u);
+	u->zoneset   = agl_zoneset_init (u);
+	u->nodeset   = agl_nodeset_init (u);
+	u->audiomgr  = agl_audiomgr_init (u);
+	u->routerif  = agl_routerif_init (u, amsocktype, amaddr, amport);
+	u->router    = agl_router_init (u);
+	u->discover  = agl_discover_init (u);
+	u->tracker   = agl_tracker_init (u);
 
 	m->userdata = u;
 
 	 /* apply the config file */
 
-	cfgpath = pa_config_file_get_path (cfgdir, cfgfile, buf, sizeof(buf));
-	pa_config_parse_file (u, cfgpath);
+	cfgpath = agl_config_file_get_path (cfgdir, cfgfile, buf, sizeof(buf));
+	agl_config_parse_file (u, cfgpath);
 
 	 /* really initialize the module's core logic */
 
-	pa_tracker_synchronize (u);
+	agl_tracker_synchronize (u);
 
 	 /* end */
 
-	pa_modargs_free(ma);
+	pa_modargs_free (ma);
 
 	return 0;
 }
@@ -145,12 +147,13 @@ void pa__done (pa_module *m)
 	pa_assert (m);
 
 	if (u = m->userdata) {
-		pa_tracker_done (u);
-		pa_discover_done (u);
-		pa_routerif_done (u);
-		pa_audiomgr_done (u);
-		pa_nodeset_done (u);
-		pa_zoneset_done (u);
+		agl_tracker_done (u);
+		agl_discover_done (u);
+		agl_router_done (u);
+		agl_routerif_done (u);
+		agl_audiomgr_done (u);
+		agl_nodeset_done (u);
+		agl_zoneset_done (u);
 		pa_xfree (u->nsnam);
 		pa_xfree (u);
 	}	
diff --git a/node.c b/node.c
index c6c59e2..212a923 100644
--- a/node.c
+++ b/node.c
@@ -23,13 +23,13 @@
 
 #include <pulsecore/idxset.h>
 
-pa_nodeset *pa_nodeset_init (struct userdata *u)
+agl_nodeset *agl_nodeset_init (struct userdata *u)
 {
-	pa_nodeset *ns;
+	agl_nodeset *ns;
 
 	pa_assert (u);
 
-	ns = pa_xnew0 (pa_nodeset, 1);
+	ns = pa_xnew0 (agl_nodeset, 1);
 	ns->nodes = pa_idxset_new (pa_idxset_trivial_hash_func,
 		                   pa_idxset_trivial_compare_func);
 	ns->roles = pa_hashmap_new (pa_idxset_string_hash_func,
@@ -39,10 +39,10 @@ pa_nodeset *pa_nodeset_init (struct userdata *u)
 	return ns;
 }
 
-void pa_nodeset_done(struct userdata *u)
+void agl_nodeset_done(struct userdata *u)
 {
-	pa_nodeset *ns;
-	pa_nodeset_map *role, *binary;
+	agl_nodeset *ns;
+	agl_nodeset_map *role, *binary;
 	void *state;
 	int i;
 
@@ -70,7 +70,7 @@ void pa_nodeset_done(struct userdata *u)
 
 agl_node *agl_node_create (struct userdata *u, agl_node *data)
 {
-	pa_nodeset *ns;
+	agl_nodeset *ns;
 	agl_node *node;
 
 	pa_assert (u);
@@ -136,7 +136,7 @@ agl_node *agl_node_get_from_data (struct userdata *u, agl_direction type, void *
 {
 	pa_sink_input_new_data *sinp_data;
 	pa_source_output_new_data *sout_data;
-	pa_nodeset *nodeset;
+	agl_nodeset *nodeset;
 	agl_node *node;
 	uint32_t index;
 
@@ -162,7 +162,7 @@ agl_node *agl_node_get_from_data (struct userdata *u, agl_direction type, void *
 
 agl_node *agl_node_get_from_client (struct userdata *u, pa_client *client)
 {
-	pa_nodeset *nodeset;
+	agl_nodeset *nodeset;
 	agl_node *node;
 	uint32_t index;
 
diff --git a/node.h b/node.h
index e46ae62..13f2303 100644
--- a/node.h
+++ b/node.h
@@ -31,14 +31,14 @@
 
 #define APCLASS_DIM  (agl_application_class_end - agl_application_class_begin + 1)
 
-struct pa_nodeset {
+struct agl_nodeset {
 	pa_idxset  *nodes;
 	pa_hashmap *roles;
 	pa_hashmap *binaries;
 	const char *class_name[APCLASS_DIM]; /* as much elements as app.classes (see in "userdata.h") */
 };
 
-struct pa_nodeset_resdef {
+struct agl_nodeset_resdef {
 	uint32_t priority;
 	struct {
 		uint32_t rset;
@@ -46,19 +46,19 @@ struct pa_nodeset_resdef {
 	} flags;
 };
 
-struct pa_nodeset_map {
+struct agl_nodeset_map {
 	const char *name;
 	agl_node_type type;
 	const char *role;
-	pa_nodeset_resdef *resdef;
+	agl_nodeset_resdef *resdef;
 };
 
-struct pa_node_card {
+struct agl_node_card {
 	uint32_t  index;
 	char     *profile;
 };
 
-struct pa_node_rset {
+struct agl_node_rset {
 	char     *id;               /**< resource set id, if any */
 	bool      grant;            /**< permission to play/render etc */
 };
@@ -69,8 +69,8 @@ struct agl_node {
 	agl_direction  direction; /**< agl_input | agl_output */
 	agl_implement  implement; /**< agl_device | agl_stream */
 	pa_client     *client;    /**< matching client pointer (for agl_input nodes only) */
-	pa_null_sink  *nullsink;  /**< associated null sink (for agl_input nodes only) */
-	pa_loopnode   *loopnode;  /**< associated loopback */
+	agl_null_sink  *nullsink; /**< associated null sink (for agl_input nodes only) */
+	agl_loopnode   *loopnode; /**< associated loopback */
 	uint32_t       channels;  /**< number of channels (eg. 1=mono, 2=stereo) */
 	agl_location   location;  /**< mir_internal | mir_external */
 	agl_privacy    privacy;   /**< mir_public | mir_private */
@@ -85,22 +85,21 @@ struct agl_node {
 	uint16_t       amid;      /**< handle to audiomanager, if any */
 	const char    *paname;    /**< sink|source|sink_input|source_output name */
 	uint32_t       paidx;     /**< sink|source|sink_input|source_output index*/
-	pa_node_card   pacard;    /**< pulse card related data, if any  */
+	agl_node_card   pacard;   /**< pulse card related data, if any  */
 	const char    *paport;    /**< sink or source port if applies */
 	/*pa_muxnode    *mux;*/       /**< for multiplexable input streams only */
-    	/*pa_loopnode   *loop;*/      /**< for looped back sources only */
 	agl_dlist      rtentries; /**< in device nodes: listhead of nodchain */
 	agl_dlist      rtprilist; /**< in stream nodes: priority link (head is in
                                                                    pa_router)*/
 	agl_dlist      constrains; /**< listhead of constrains */
 	/*mir_vlim       vlim;*/      /**< volume limit */
-	pa_node_rset   rset;      /**< resource set info if applies */
+	agl_node_rset   rset;      /**< resource set info if applies */
 	uint32_t       stamp;
 	/*scripting_node *scripting;*/ /** scripting data, if any */
 };
 
-pa_nodeset *pa_nodeset_init (struct userdata *);
-void pa_nodeset_done (struct userdata *);
+agl_nodeset *agl_nodeset_init (struct userdata *);
+void agl_nodeset_done (struct userdata *);
 
 agl_node *agl_node_create (struct userdata *, agl_node *);
 const char *agl_node_type_str (agl_node_type);
diff --git a/router.c b/router.c
index c1e7d2a..a431b69 100644
--- a/router.c
+++ b/router.c
@@ -23,14 +23,14 @@
 #include "switch.h"
 #include "utils.h"
 
-pa_router *pa_router_init (struct userdata *u)
+agl_router *agl_router_init (struct userdata *u)
 {
-	pa_router *router;
+	agl_router *router;
 	size_t num_classes;
 
 	num_classes = agl_application_class_end;
 
-	router = pa_xnew0 (pa_router, 1);
+	router = pa_xnew0 (agl_router, 1);
 	router->rtgroups.input = pa_hashmap_new (pa_idxset_string_hash_func,
 		                                 pa_idxset_string_compare_func);
 	router->rtgroups.output = pa_hashmap_new (pa_idxset_string_hash_func,
@@ -44,9 +44,9 @@ pa_router *pa_router_init (struct userdata *u)
 	return router;
 }
 
-void pa_router_done (struct userdata *u)
+void agl_router_done (struct userdata *u)
 {
-	pa_router *router;
+	agl_router *router;
 	agl_node *e,*n;
 	agl_connection *conn, *c;
 	agl_rtgroup *rtg;
@@ -113,7 +113,7 @@ void agl_router_register_node (struct userdata *u, agl_node *node)
 	pa_assert (u);
 	pa_assert (node);
 
-	implement_default_route (u, node, NULL, pa_utils_new_stamp ());
+	implement_default_route (u, node, NULL, agl_utils_new_stamp ());
 }
 
 void agl_router_unregister_node (struct userdata *u, agl_node *node)
@@ -121,12 +121,12 @@ void agl_router_unregister_node (struct userdata *u, agl_node *node)
 	pa_assert (u);
 	pa_assert (node);
 
-	remove_routes (u, node, NULL, pa_utils_new_stamp ());
+	remove_routes (u, node, NULL, agl_utils_new_stamp ());
 }
 
 agl_node *agl_router_make_prerouting (struct userdata *u, agl_node *data)
 {
-	pa_router *router;
+	agl_router *router;
 	int priority;
 	static bool done_prerouting;
 	uint32_t stamp;
@@ -141,7 +141,7 @@ agl_node *agl_router_make_prerouting (struct userdata *u, agl_node *data)
 
 	done_prerouting = false;
 	target = NULL;
-	stamp = pa_utils_new_stamp ();
+	stamp = agl_utils_new_stamp ();
 
 	//make_explicit_routes (u, stamp);
 
@@ -181,7 +181,7 @@ agl_node *agl_router_make_prerouting (struct userdata *u, agl_node *data)
 
 void agl_router_make_routing (struct userdata *u)
 {
-	pa_router *router;
+	agl_router *router;
 	static bool ongoing_routing;	/* true while we are actively routing */
 	uint32_t stamp;
 	agl_node *start, *end;
@@ -192,7 +192,7 @@ void agl_router_make_routing (struct userdata *u)
 	if (ongoing_routing)		/* already routing, canceling */
 		return;
 	ongoing_routing = true;
-	stamp = pa_utils_new_stamp ();
+	stamp = agl_utils_new_stamp ();
 
 	pa_log_debug("stamp for routing: %d", stamp);
 
diff --git a/router.h b/router.h
index a1d2f7f..d3096ac 100644
--- a/router.h
+++ b/router.h
@@ -41,17 +41,17 @@ struct agl_rtgroup {
 typedef struct {
 	pa_hashmap *input;
 	pa_hashmap *output;
-} pa_rtgroup_hash;
+} agl_rtgroup_hash;
 
 typedef struct {
 	agl_rtgroup **input[AGL_ZONE_MAX];
 	agl_rtgroup **output[AGL_ZONE_MAX];
-} pa_rtgroup_classmap;
+} agl_rtgroup_classmap;
 
-struct pa_router {
-	pa_rtgroup_hash rtgroups;
+struct agl_router {
+	agl_rtgroup_hash rtgroups;
 	size_t maplen;		      /**< length of the class */
-	pa_rtgroup_classmap classmap; /**< map device node types to rtgroups */
+	agl_rtgroup_classmap classmap; /**< map device node types to rtgroups */
 	int *priormap;                /**< stream node priorities */
 	agl_dlist nodlist;            /**< priorized list of the stream nodes
                                         (entry in node: rtprilist) */
@@ -67,8 +67,8 @@ struct agl_connection {
 	uint32_t stream;   /**< index of the sink-input to be routed */
 };
 
-pa_router *pa_router_init (struct userdata *);
-void pa_router_done (struct userdata *);
+agl_router *agl_router_init (struct userdata *);
+void agl_router_done (struct userdata *);
 
 bool agl_router_default_accept (struct userdata *, agl_rtgroup *, agl_node *);
 bool agl_router_phone_accept (struct userdata *, agl_rtgroup *, agl_node *);
diff --git a/routerif.h b/routerif.h
index 05d2d96..9dd4319 100644
--- a/routerif.h
+++ b/routerif.h
@@ -3,8 +3,8 @@
 
 #include "userdata.h"
 
-pa_routerif *pa_routerif_init (struct userdata *, const char *,
-	                       const char *, const char *);
-void pa_routerif_done (struct userdata *);
+agl_routerif *agl_routerif_init (struct userdata *, const char *,
+	                         const char *, const char *);
+void agl_routerif_done (struct userdata *);
 
 #endif
diff --git a/socketif.c b/socketif.c
index dd29752..8c37369 100644
--- a/socketif.c
+++ b/socketif.c
@@ -21,27 +21,27 @@
  */
 #include "routerif.h"
 
-struct pa_routerif {
+struct agl_routerif {
     int  sock;
 };
 
-pa_routerif *pa_routerif_init (struct userdata *u,
-                               const char      *socktyp,
-                               const char      *addr,
-                               const char      *port)
+agl_routerif *agl_routerif_init (struct userdata *u,
+                                 const char      *socktyp,
+                                 const char      *addr,
+                                 const char      *port)
 {
 	pa_module *m = u->module;
-	pa_routerif *routerif = NULL;
+	agl_routerif *routerif = NULL;
     
-	routerif = pa_xnew0 (pa_routerif, 1);
+	routerif = pa_xnew0 (agl_routerif, 1);
 	routerif->sock = -1;
 
 	return routerif;
 }
 
-void pa_routerif_done (struct userdata *u)
+void agl_routerif_done (struct userdata *u)
 {
-	pa_routerif *routerif;
+	agl_routerif *routerif;
 
 	if (u && (routerif = u->routerif)) {
 		if (routerif->sock >= 0)
diff --git a/switch.c b/switch.c
index 05386a0..954effd 100644
--- a/switch.c
+++ b/switch.c
@@ -147,10 +147,10 @@ bool agl_switch_setup_link (struct userdata *u, agl_node *from, agl_node *to, bo
 				return false;
 			}
 
-			sink = pa_utils_get_primary_alsa_sink (u);
-			source = pa_utils_get_null_source (u, from->nullsink);
+			sink = agl_utils_get_primary_alsa_sink (u);
+			source = agl_utils_get_null_source (u, from->nullsink);
 
-			from->loopnode = pa_loopnode_create (u, PA_LOOPNODE_SINK, from->index, source->index, sink->index);
+			from->loopnode = agl_loopnode_create (u, AGL_LOOPNODE_SINK, from->index, source->index, sink->index);
 		}
 	}
 
@@ -181,9 +181,9 @@ bool agl_switch_teardown_link (struct userdata *u, agl_node *from, agl_node *to)
 		}
 		/* (the rest supposes "from->implement == agl_stream") */
 		if (from->loopnode)
-			pa_loopnode_destroy (u, from->loopnode);
+			agl_loopnode_destroy (u, from->loopnode);
 		if (from->nullsink)
-			pa_utils_destroy_null_sink (u, from->nullsink);
+			agl_utils_destroy_null_sink (u, from->nullsink);
 	}
 
 	//pa_log_debug("link %s => %s is torn down", from->amname, to->amname);
diff --git a/tracker.c b/tracker.c
index 95c5f0a..5ad14f2 100644
--- a/tracker.c
+++ b/tracker.c
@@ -58,7 +58,7 @@ struct pa_source_output_hooks {
     pa_hook_slot    *unlink;
 };
 
-struct pa_tracker {
+struct agl_tracker {
     pa_card_hooks           card;
     pa_port_hooks           port;
     pa_sink_hooks           sink;
@@ -91,11 +91,11 @@ static pa_hook_result_t source_output_put (void *, void *, void *);
 static pa_hook_result_t source_output_unlink (void *, void *, void *);
 
 
-pa_tracker *pa_tracker_init (struct userdata *u)
+agl_tracker *agl_tracker_init (struct userdata *u)
 {
 	pa_core *core;
 	pa_hook *hooks;
-	pa_tracker *tracker;
+	agl_tracker *tracker;
 	pa_card_hooks *card;
 	pa_port_hooks *port;
 	pa_sink_hooks *sink;
@@ -107,7 +107,7 @@ pa_tracker *pa_tracker_init (struct userdata *u)
 	pa_assert_se (core = u->core);
 	pa_assert_se (hooks = core->hooks);
 
-	tracker = pa_xnew0 (pa_tracker, 1);
+	tracker = pa_xnew0 (agl_tracker, 1);
 	card = &tracker->card;
 	port = &tracker->port;
 	sink = &tracker->sink;
@@ -162,9 +162,9 @@ pa_tracker *pa_tracker_init (struct userdata *u)
 	return tracker;	
 }
 
-void pa_tracker_done (struct userdata *u)
+void agl_tracker_done (struct userdata *u)
 {
-	pa_tracker *tracker;	
+	agl_tracker *tracker;	
 	pa_card_hooks *card;
 	pa_port_hooks *port;
 	pa_sink_hooks *sink;
@@ -203,7 +203,7 @@ void pa_tracker_done (struct userdata *u)
 }
 
  /* main logic initialization function */
-void pa_tracker_synchronize (struct userdata *u)
+void agl_tracker_synchronize (struct userdata *u)
 {
 	pa_core *core;
 	pa_card *card;
@@ -216,28 +216,25 @@ void pa_tracker_synchronize (struct userdata *u)
 	pa_assert (u);
 	pa_assert_se (core = u->core);
 
-	 /* initialize "stamp" incremental card property to 0 */
-	pa_utils_init_stamp ();
-
 	 /* discover.c : add each valid USB/PCI/Platform ALSA sound card */
 	PA_IDXSET_FOREACH (card, core->cards, index) {
-        	pa_discover_add_card (u, card);
+        	agl_discover_add_card (u, card);
 	}
 
 	PA_IDXSET_FOREACH (sink, core->sinks, index) {
-		pa_discover_add_sink (u, sink, false);
+		agl_discover_add_sink (u, sink, false);
 	}
 
 	PA_IDXSET_FOREACH (source, core->sources, index) {
-		pa_discover_add_source (u, source);
+		agl_discover_add_source (u, source);
 	}
 
 	PA_IDXSET_FOREACH(sinp, core->sink_inputs, index) {
-		pa_discover_register_sink_input (u, sinp);
+		agl_discover_register_sink_input (u, sinp);
 	}
 
 	PA_IDXSET_FOREACH(sout, core->source_outputs, index) {
-		pa_discover_register_source_output (u, sout);
+		agl_discover_register_source_output (u, sout);
 	}
 
 	agl_router_make_routing (u);
@@ -324,7 +321,7 @@ static pa_hook_result_t sink_input_new (void *hook_data,
 	struct userdata *u = (struct userdata *)slot_data;
 	bool success;
 
-	success = pa_discover_preroute_sink_input (u, data);
+	success = agl_discover_preroute_sink_input (u, data);
 
 	return success ? PA_HOOK_OK : PA_HOOK_CANCEL;
 }
@@ -337,7 +334,7 @@ static pa_hook_result_t sink_input_put (void *hook_data,
 	pa_sink_input *sinp = (pa_sink_input *)call_data;
 	struct userdata *u = (struct userdata *)slot_data;
 
-	pa_discover_add_sink_input (u, sinp);
+	agl_discover_add_sink_input (u, sinp);
 
 	return PA_HOOK_OK;
 }
@@ -350,7 +347,7 @@ static pa_hook_result_t sink_input_unlink (void *hook_data,
 	pa_sink_input *sinp = (pa_sink_input *)call_data;
 	struct userdata *u = (struct userdata *)slot_data;
 
-	pa_discover_remove_sink_input (u, sinp);
+	agl_discover_remove_sink_input (u, sinp);
 
 	return PA_HOOK_OK;
 }
diff --git a/tracker.h b/tracker.h
index aae5a83..91d4579 100644
--- a/tracker.h
+++ b/tracker.h
@@ -3,9 +3,9 @@
 
 #include "userdata.h"
 
-pa_tracker *pa_tracker_init (struct userdata *);
-void pa_tracker_done (struct userdata *);
+agl_tracker *agl_tracker_init (struct userdata *);
+void agl_tracker_done (struct userdata *);
 
-void pa_tracker_synchronize(struct userdata *);
+void agl_tracker_synchronize(struct userdata *);
 
 #endif
diff --git a/userdata.h b/userdata.h
index d484cbf..a6585d6 100644
--- a/userdata.h
+++ b/userdata.h
@@ -29,19 +29,19 @@
 #define AM_ID_INVALID 65535		/* invalid state in several places */
 
 
-typedef struct pa_null_sink pa_null_sink;
-typedef struct pa_zoneset pa_zoneset;
-typedef struct pa_nodeset pa_nodeset;
-typedef struct pa_audiomgr pa_audiomgr;
-typedef struct pa_routerif pa_routerif;
-typedef struct pa_discover pa_discover;
-typedef struct pa_tracker pa_tracker;
-typedef struct pa_router pa_router;
-
-typedef struct pa_nodeset_resdef pa_nodeset_resdef;
-typedef struct pa_nodeset_map pa_nodeset_map;
-typedef struct pa_node_card pa_node_card;
-typedef struct pa_node_rset pa_node_rset;
+typedef struct agl_null_sink agl_null_sink;
+typedef struct agl_zoneset agl_zoneset;
+typedef struct agl_nodeset agl_nodeset;
+typedef struct agl_audiomgr agl_audiomgr;
+typedef struct agl_routerif agl_routerif;
+typedef struct agl_router agl_router;
+typedef struct agl_discover agl_discover;
+typedef struct agl_tracker agl_tracker;
+
+typedef struct agl_nodeset_resdef agl_nodeset_resdef;
+typedef struct agl_nodeset_map agl_nodeset_map;
+typedef struct agl_node_card agl_node_card;
+typedef struct agl_node_rset agl_node_rset;
 
 typedef struct pa_card_hooks pa_card_hooks;
 typedef struct pa_port_hooks pa_port_hooks;
@@ -65,13 +65,13 @@ struct userdata {
 	pa_core       *core;
 	pa_module     *module;
 	char          *nsnam;
-	pa_zoneset    *zoneset;
-	pa_nodeset    *nodeset;
-	pa_audiomgr   *audiomgr;
-	pa_routerif   *routerif;
-	pa_router     *router;
-	pa_discover   *discover;
-	pa_tracker    *tracker;
+	agl_zoneset    *zoneset;
+	agl_nodeset    *nodeset;
+	agl_audiomgr   *audiomgr;
+	agl_routerif   *routerif;
+	agl_router     *router;
+	agl_discover   *discover;
+	agl_tracker    *tracker;
 	pa_agl_state state;
 };
 
diff --git a/utils.c b/utils.c
index dc9c756..88425d2 100644
--- a/utils.c
+++ b/utils.c
@@ -38,18 +38,18 @@
 
 static uint32_t stamp;
 
-struct pa_null_sink {
+struct agl_null_sink {
 	char      *name;
 	uint32_t   module_index;
 	uint32_t   sink_index;
 };
 
-pa_null_sink *pa_utils_create_null_sink (struct userdata *u, const char *name)
+agl_null_sink *agl_utils_create_null_sink (struct userdata *u, const char *name)
 {
 	pa_core      *core;
 	pa_module    *module;
-	pa_null_sink *ns;
 	pa_sink      *s, *sink;
+	agl_null_sink *ns;
 	uint32_t      idx;
 	char          args[256];
 
@@ -59,7 +59,7 @@ pa_null_sink *pa_utils_create_null_sink (struct userdata *u, const char *name)
 	if (!name)
 		name = DEFAULT_NULL_SINK_NAME;	/* default is "null.agl" */
 
-	snprintf (args, sizeof(args), "sink_name=\"%s.%d\" channels=2", name, pa_utils_new_stamp ());
+	snprintf (args, sizeof(args), "sink_name=\"%s.%d\" channels=2", name, agl_utils_new_stamp ());
 	module = pa_module_load (core, "module-null-sink", args);
 	sink = NULL;
 
@@ -76,7 +76,7 @@ pa_null_sink *pa_utils_create_null_sink (struct userdata *u, const char *name)
 		}
 	}
 
-	ns = pa_xnew0 (pa_null_sink, 1);
+	ns = pa_xnew0 (agl_null_sink, 1);
 	ns->name = pa_xstrdup (name);
 	ns->module_index = module ? module->index : PA_IDXSET_INVALID;
 	ns->sink_index = sink ? sink->index : PA_IDXSET_INVALID;
@@ -84,7 +84,7 @@ pa_null_sink *pa_utils_create_null_sink (struct userdata *u, const char *name)
 	return ns;
 }
 
-void pa_utils_destroy_null_sink (struct userdata *u, pa_null_sink *ns)
+void agl_utils_destroy_null_sink (struct userdata *u, agl_null_sink *ns)
 {
 	pa_core      *core;
 	pa_module    *module;
@@ -100,7 +100,7 @@ void pa_utils_destroy_null_sink (struct userdata *u, pa_null_sink *ns)
 	}
 }
 
-pa_sink *pa_utils_get_null_sink (struct userdata *u, struct pa_null_sink *ns)
+pa_sink *agl_utils_get_null_sink (struct userdata *u, struct agl_null_sink *ns)
 {
 	pa_core *core;
 	pa_sink *sink;
@@ -111,28 +111,28 @@ pa_sink *pa_utils_get_null_sink (struct userdata *u, struct pa_null_sink *ns)
 	return pa_idxset_get_by_index (core->sinks, ns->sink_index);
 }
 
-pa_source *pa_utils_get_null_source (struct userdata *u, struct pa_null_sink *ns)
+pa_source *agl_utils_get_null_source (struct userdata *u, struct agl_null_sink *ns)
 {
 	pa_sink *sink;
 
-	sink = pa_utils_get_null_sink (u, ns);
+	sink = agl_utils_get_null_sink (u, ns);
 
 	return sink ? sink->monitor_source : NULL;
 }
 
 
-const char *pa_utils_get_card_name (pa_card *card)
+const char *agl_utils_get_card_name (pa_card *card)
 {
 	return (card && card->name) ? card->name : "<unknown>";
 }
 
-const char *pa_utils_get_card_bus (pa_card *card)
+const char *agl_utils_get_card_bus (pa_card *card)
 {
 	const char *bus = NULL;
 	const char *name;
 
 	if (card && !(bus = pa_proplist_gets (card->proplist,PA_PROP_DEVICE_BUS))) {
-		name = pa_utils_get_card_name (card);
+		name = agl_utils_get_card_name (card);
 		if (!strncmp (name, "alsa_card.", 10)) {
 			if (!strncmp (name + 10, "pci-", 4))
 				bus = "pci";
@@ -146,17 +146,17 @@ const char *pa_utils_get_card_bus (pa_card *card)
 	return (char *)bus;
 }
 
-const char *pa_utils_get_sink_name (pa_sink *sink)
+const char *agl_utils_get_sink_name (pa_sink *sink)
 {
 	return (sink && sink->name) ? sink->name : "<unknown>";
 }
 
-const char *pa_utils_get_source_name (pa_source *source)
+const char *agl_utils_get_source_name (pa_source *source)
 {
 	return (source && source->name) ? source->name : "<unknown>";
 }
 
-const char *pa_utils_get_sink_input_name (pa_sink_input *sinp)
+const char *agl_utils_get_sink_input_name (pa_sink_input *sinp)
 {
 	char *name = NULL;
 
@@ -171,7 +171,7 @@ const char *pa_utils_get_sink_input_name (pa_sink_input *sinp)
         return (const char *)name;
 }
 
-const char *pa_utils_get_source_output_name (pa_source_output *sout)
+const char *agl_utils_get_source_output_name (pa_source_output *sout)
 {
 	char *name = NULL;
 
@@ -186,7 +186,7 @@ const char *pa_utils_get_source_output_name (pa_source_output *sout)
         return (const char *)name;
 }
 
-pa_sink *pa_utils_get_primary_alsa_sink (struct userdata *u)
+pa_sink *agl_utils_get_primary_alsa_sink (struct userdata *u)
 {
 	pa_core *core;
 	pa_sink *sink;
@@ -203,24 +203,24 @@ pa_sink *pa_utils_get_primary_alsa_sink (struct userdata *u)
 	return NULL;
 }
 
-void pa_utils_init_stamp (void)
+void agl_utils_init_stamp (void)
 {
 	stamp = 0;
 }
 
-uint32_t pa_utils_new_stamp (void)
+uint32_t agl_utils_new_stamp (void)
 {
 	return ++stamp;
 }
 
-uint32_t pa_utils_get_stamp (void)
+uint32_t agl_utils_get_stamp (void)
 {
 	return stamp;
 }
 
 
 
-char *pa_utils_get_zone (pa_proplist *pl, pa_proplist *client_props)
+char *agl_utils_get_zone (pa_proplist *pl, pa_proplist *client_props)
 {
 	const char *zone;
 
@@ -237,7 +237,7 @@ char *pa_utils_get_zone (pa_proplist *pl, pa_proplist *client_props)
 	return (char *)zone;
 }
 
-bool pa_utils_set_stream_routing_properties (pa_proplist *pl, int styp, void *target)
+bool agl_utils_set_stream_routing_properties (pa_proplist *pl, int styp, void *target)
 {
 	const char *clnam;	/* will become "agl_player" e.g. */
 	char clid[32];		/* will become "1" e.g. */
@@ -261,7 +261,7 @@ bool pa_utils_set_stream_routing_properties (pa_proplist *pl, int styp, void *ta
 	return true;
 }
 
-bool pa_utils_unset_stream_routing_properties (pa_proplist *pl)
+bool agl_utils_unset_stream_routing_properties (pa_proplist *pl)
 {
 	pa_assert (pl);
 
diff --git a/utils.h b/utils.h
index dac35b9..611283a 100644
--- a/utils.h
+++ b/utils.h
@@ -26,28 +26,28 @@
 
 #include "userdata.h"
 
-struct pa_null_sink;
+struct agl_null_sink;
 
-struct pa_null_sink *pa_utils_create_null_sink (struct userdata *, const char *);
-void pa_utils_destroy_null_sink (struct userdata *, struct pa_null_sink *);
-pa_sink *pa_utils_get_null_sink (struct userdata *, struct pa_null_sink *);
-pa_source *pa_utils_get_null_source (struct userdata *, struct pa_null_sink *);
+struct agl_null_sink *agl_utils_create_null_sink (struct userdata *, const char *);
+void agl_utils_destroy_null_sink (struct userdata *, struct agl_null_sink *);
+pa_sink *agl_utils_get_null_sink (struct userdata *, struct agl_null_sink *);
+pa_source *agl_utils_get_null_source (struct userdata *, struct agl_null_sink *);
 
  /* general helper functions */ 
-const char *pa_utils_get_card_name (pa_card *);
-const char *pa_utils_get_card_bus (pa_card *);
-const char *pa_utils_get_sink_name (pa_sink *);
-const char *pa_utils_get_source_name (pa_source *);
-const char *pa_utils_get_sink_input_name (pa_sink_input *);
-const char *pa_utils_get_source_output_name (pa_source_output *);
-pa_sink *pa_utils_get_primary_alsa_sink (struct userdata *);
-void pa_utils_init_stamp (void);
-uint32_t pa_utils_new_stamp (void);
-uint32_t pa_utils_get_stamp (void);
+const char *agl_utils_get_card_name (pa_card *);
+const char *agl_utils_get_card_bus (pa_card *);
+const char *agl_utils_get_sink_name (pa_sink *);
+const char *agl_utils_get_source_name (pa_source *);
+const char *agl_utils_get_sink_input_name (pa_sink_input *);
+const char *agl_utils_get_source_output_name (pa_source_output *);
+pa_sink *agl_utils_get_primary_alsa_sink (struct userdata *);
+void agl_utils_init_stamp (void);
+uint32_t agl_utils_new_stamp (void);
+uint32_t agl_utils_get_stamp (void);
 
  /* AM-oriented helper functions */
-char *pa_utils_get_zone (pa_proplist *, pa_proplist *);
-bool pa_utils_set_stream_routing_properties (pa_proplist *, int, void *);
-bool pa_utils_unset_stream_routing_properties (pa_proplist *);
+char *agl_utils_get_zone (pa_proplist *, pa_proplist *);
+bool agl_utils_set_stream_routing_properties (pa_proplist *, int, void *);
+bool agl_utils_unset_stream_routing_properties (pa_proplist *);
 
 #endif
diff --git a/zone.c b/zone.c
index 7b1b04a..3a20ab9 100644
--- a/zone.c
+++ b/zone.c
@@ -21,29 +21,29 @@
  */
 #include "zone.h"
 
-struct pa_zoneset {
+struct agl_zoneset {
 	struct {
 		pa_hashmap     *hash;
 		agl_zone       *index[AGL_ZONE_MAX];
 	} zones;
 };
 
-pa_zoneset *pa_zoneset_init (struct userdata *u)
+agl_zoneset *agl_zoneset_init (struct userdata *u)
 {
-	pa_zoneset *zs;
+	agl_zoneset *zs;
 
 	pa_assert (u);
 
-	zs = pa_xnew0 (pa_zoneset, 1);
+	zs = pa_xnew0 (agl_zoneset, 1);
 	zs->zones.hash = pa_hashmap_new (pa_idxset_string_hash_func,
 		                         pa_idxset_string_compare_func);
 
 	return zs;
 }
 
-void pa_zoneset_done (struct userdata *u)
+void agl_zoneset_done (struct userdata *u)
 {
-	pa_zoneset *zs;
+	agl_zoneset *zs;
 	void *state;
 	agl_zone *zone;
 
diff --git a/zone.h b/zone.h
index d9ae9a9..c64b879 100644
--- a/zone.h
+++ b/zone.h
@@ -31,7 +31,7 @@ struct agl_zone {
 	uint32_t    index;
 };
 
-pa_zoneset *pa_zoneset_init (struct userdata *);
-void pa_zoneset_done (struct userdata *);
+agl_zoneset *agl_zoneset_init (struct userdata *);
+void agl_zoneset_done (struct userdata *);
 
 #endif