A2DP Sink implementation

A2DP Sink implementation

[João Paulo Rechi Vita]

The following serie of patches implements the necessary code for the A2DP Sink
in bluetoothd. It needs kernel version 2.6.30+ to work. The sink is disabled by
default, since there is no client to handle the incoming stream yet. To enable
it, just add an "Enable=Source" line to /etc/bluetooth/audio.conf.

[PATCH 1/4] Adapt A2DP functions to support the Sink role.

[João Paulo Rechi Vita]

Modify a2dp_source_* functions to more generic a2dp_record(), a2dp_get(),
a2dp_config(), a2dp_resume(), a2dp_suspend(), and a2dp_cancel() which can handle
both the Sink and Source roles.
---
 audio/a2dp.c |  191 ++++++++++++++++++++++++++++++++++------------------------
 audio/a2dp.h |   11 ++--
 audio/sink.c |    7 +-
 audio/unix.c |   19 +++---
 4 files changed, 128 insertions(+), 100 deletions(-)

diff --git a/audio/a2dp.c b/audio/a2dp.c
index 2c4d047..7d14865 100644
--- a/audio/a2dp.c
+++ b/audio/a2dp.c
@@ -41,6 +41,7 @@
 #include "manager.h"
 #include "avdtp.h"
 #include "sink.h"
+#include "source.h"
 #include "a2dp.h"
 #include "sdpd.h"
 
@@ -933,10 +934,10 @@ static struct avdtp_sep_ind mpeg_ind = {
 	.reconfigure		= reconf_ind
 };
 
-static sdp_record_t *a2dp_source_record()
+static sdp_record_t *a2dp_record(uint8_t type)
 {
 	sdp_list_t *svclass_id, *pfseq, *apseq, *root;
-	uuid_t root_uuid, l2cap, avdtp, a2src;
+	uuid_t root_uuid, l2cap_uuid, avdtp_uuid, a2dp_uuid;
 	sdp_profile_desc_t profile[1];
 	sdp_list_t *aproto, *proto[2];
 	sdp_record_t *record;
@@ -951,8 +952,11 @@ static sdp_record_t *a2dp_source_record()
 	root = sdp_list_append(0, &root_uuid);
 	sdp_set_browse_groups(record, root);
 
-	sdp_uuid16_create(&a2src, AUDIO_SOURCE_SVCLASS_ID);
-	svclass_id = sdp_list_append(0, &a2src);
+	if (type == AVDTP_SEP_TYPE_SOURCE)
+		sdp_uuid16_create(&a2dp_uuid, AUDIO_SOURCE_SVCLASS_ID);
+	else
+		sdp_uuid16_create(&a2dp_uuid, AUDIO_SINK_SVCLASS_ID);
+	svclass_id = sdp_list_append(0, &a2dp_uuid);
 	sdp_set_service_classes(record, svclass_id);
 
 	sdp_uuid16_create(&profile[0].uuid, ADVANCED_AUDIO_PROFILE_ID);
@@ -960,14 +964,14 @@ static sdp_record_t *a2dp_source_record()
 	pfseq = sdp_list_append(0, &profile[0]);
 	sdp_set_profile_descs(record, pfseq);
 
-	sdp_uuid16_create(&l2cap, L2CAP_UUID);
-	proto[0] = sdp_list_append(0, &l2cap);
+	sdp_uuid16_create(&l2cap_uuid, L2CAP_UUID);
+	proto[0] = sdp_list_append(0, &l2cap_uuid);
 	psm = sdp_data_alloc(SDP_UINT16, &lp);
 	proto[0] = sdp_list_append(proto[0], psm);
 	apseq = sdp_list_append(0, proto[0]);
 
-	sdp_uuid16_create(&avdtp, AVDTP_UUID);
-	proto[1] = sdp_list_append(0, &avdtp);
+	sdp_uuid16_create(&avdtp_uuid, AVDTP_UUID);
+	proto[1] = sdp_list_append(0, &avdtp_uuid);
 	version = sdp_data_alloc(SDP_UINT16, &ver);
 	proto[1] = sdp_list_append(proto[1], version);
 	apseq = sdp_list_append(apseq, proto[1]);
@@ -978,7 +982,10 @@ static sdp_record_t *a2dp_source_record()
 	features = sdp_data_alloc(SDP_UINT16, &feat);
 	sdp_attr_add(record, SDP_ATTR_SUPPORTED_FEATURES, features);
 
-	sdp_set_info_attr(record, "Audio Source", 0, 0);
+	if (type == AVDTP_SEP_TYPE_SOURCE)
+		sdp_set_info_attr(record, "Audio Source", 0, 0);
+	else
+		sdp_set_info_attr(record, "Audio Sink", 0, 0);
 
 	free(psm);
 	free(version);
@@ -993,17 +1000,11 @@ static sdp_record_t *a2dp_source_record()
 	return record;
 }
 
-static sdp_record_t *a2dp_sink_record()
-{
-	return NULL;
-}
-
 static struct a2dp_sep *a2dp_add_sep(struct a2dp_server *server, uint8_t type,
 					uint8_t codec)
 {
 	struct a2dp_sep *sep;
 	GSList **l;
-	sdp_record_t *(*create_record)(void);
 	uint32_t *record_id;
 	sdp_record_t *record;
 	struct avdtp_sep_ind *ind;
@@ -1024,18 +1025,16 @@ static struct a2dp_sep *a2dp_add_sep(struct a2dp_server *server, uint8_t type,
 
 	if (type == AVDTP_SEP_TYPE_SOURCE) {
 		l = &server->sources;
-		create_record = a2dp_source_record;
 		record_id = &server->source_record_id;
 	} else {
 		l = &server->sinks;
-		create_record = a2dp_sink_record;
 		record_id = &server->sink_record_id;
 	}
 
 	if (*record_id != 0)
 		goto add;
 
-	record = create_record();
+	record = a2dp_record(type);
 	if (!record) {
 		error("Unable to allocate new service record");
 		avdtp_unregister_sep(sep->sep);
@@ -1215,42 +1214,7 @@ void a2dp_unregister(const bdaddr_t *src)
 	connection = NULL;
 }
 
-gboolean a2dp_source_cancel(struct audio_device *dev, unsigned int id)
-{
-	struct a2dp_setup_cb *cb_data;
-	struct a2dp_setup *setup;
-	GSList *l;
-
-	debug("a2dp_source_cancel()");
-
-	setup = find_setup_by_dev(dev);
-	if (!setup)
-		return FALSE;
-
-	for (cb_data = NULL, l = setup->cb; l != NULL; l = g_slist_next(l)) {
-		struct a2dp_setup_cb *cb = l->data;
-
-		if (cb->id == id) {
-			cb_data = cb;
-			break;
-		}
-	}
-
-	if (!cb_data)
-		error("a2dp_source_cancel: no matching callback with id %u", id);
-
-	setup->cb = g_slist_remove(setup->cb, cb_data);
-	g_free(cb_data);
-
-	if (!setup->cb) {
-		setup->canceled = TRUE;
-		setup->sep = NULL;
-	}
-
-	return TRUE;
-}
-
-struct a2dp_sep *a2dp_source_get(struct avdtp *session,
+struct a2dp_sep *a2dp_get(struct avdtp *session,
 				struct avdtp_remote_sep *rsep)
 {
 	GSList *l;
@@ -1267,23 +1231,38 @@ struct a2dp_sep *a2dp_source_get(struct avdtp *session,
 	cap = avdtp_get_codec(rsep);
 	codec_cap = (void *) cap->data;
 
-	for (l = server->sources; l != NULL; l = l->next) {
-		struct a2dp_sep *sep = l->data;
+	if (avdtp_get_type(rsep) == AVDTP_SEP_TYPE_SINK)
+		for (l = server->sources; l != NULL; l = l->next) {
+			struct a2dp_sep *sep = l->data;
 
-		if (sep->locked)
-			continue;
+			if (sep->locked)
+				continue;
 
-		if (sep->codec != codec_cap->media_codec_type)
-			continue;
+			if (sep->codec != codec_cap->media_codec_type)
+				continue;
 
-		if (!sep->stream || avdtp_has_stream(session, sep->stream))
-			return sep;
-	}
+			if (!sep->stream || avdtp_has_stream(session, sep->stream))
+				return sep;
+		}
+
+	if (avdtp_get_type(rsep) == AVDTP_SEP_TYPE_SOURCE)
+		for (l = server->sinks; l != NULL; l = l->next) {
+			struct a2dp_sep *sep = l->data;
+
+			if (sep->locked)
+				continue;
+
+			if (sep->codec != codec_cap->media_codec_type)
+				continue;
+
+			if (!sep->stream || avdtp_has_stream(session, sep->stream))
+				return sep;
+		}
 
 	return NULL;
 }
 
-unsigned int a2dp_source_config(struct avdtp *session, struct a2dp_sep *sep,
+unsigned int a2dp_config(struct avdtp *session, struct a2dp_sep *sep,
 				a2dp_config_cb_t cb, GSList *caps,
 				void *user_data)
 {
@@ -1320,7 +1299,7 @@ unsigned int a2dp_source_config(struct avdtp *session, struct a2dp_sep *sep,
 	if (sep->codec != codec_cap->media_codec_type)
 		return 0;
 
-	debug("a2dp_source_config: selected SEP %p", sep->sep);
+	debug("a2dp_config: selected SEP %p", sep->sep);
 
 	cb_data = g_new0(struct a2dp_setup_cb, 1);
 	cb_data->config_cb = cb;
@@ -1343,12 +1322,19 @@ unsigned int a2dp_source_config(struct avdtp *session, struct a2dp_sep *sep,
 
 	switch (avdtp_sep_get_state(sep->sep)) {
 	case AVDTP_STATE_IDLE:
-		for (l = server->sources; l != NULL; l = l->next) {
-			tmp = l->data;
+		if (sep->type == AVDTP_SEP_TYPE_SOURCE)
+			for (l = server->sources; l != NULL; l = l->next) {
+				tmp = l->data;
+				if (avdtp_has_stream(session, tmp->stream))
+					break;
+			}
 
-			if (avdtp_has_stream(session, tmp->stream))
-				break;
-		}
+		if (sep->type == AVDTP_SEP_TYPE_SINK)
+			for (l = server->sinks; l != NULL; l = l->next) {
+				tmp = l->data;
+				if (avdtp_has_stream(session, tmp->stream))
+					break;
+			}
 
 		if (l != NULL) {
 			setup->reconfigure = TRUE;
@@ -1359,13 +1345,23 @@ unsigned int a2dp_source_config(struct avdtp *session, struct a2dp_sep *sep,
 			break;
 		}
 
-		if (avdtp_get_seps(session, AVDTP_SEP_TYPE_SINK,
-				codec_cap->media_type,
-				codec_cap->media_codec_type,
-				&lsep, &rsep) < 0) {
-			error("No matching ACP and INT SEPs found");
-			goto failed;
-		}
+		if (sep->type == AVDTP_SEP_TYPE_SOURCE)
+			if (avdtp_get_seps(session, AVDTP_SEP_TYPE_SINK,
+					codec_cap->media_type,
+					codec_cap->media_codec_type,
+					&lsep, &rsep) < 0) {
+				error("No matching ACP and INT SEPs found");
+				goto failed;
+			}
+
+		if (sep->type == AVDTP_SEP_TYPE_SINK)
+			if (avdtp_get_seps(session, AVDTP_SEP_TYPE_SOURCE,
+					codec_cap->media_type,
+					codec_cap->media_codec_type,
+					&lsep, &rsep) < 0) {
+				error("No matching ACP and INT SEPs found");
+				goto failed;
+			}
 
 		posix_err = avdtp_set_configuration(session, rsep, lsep,
 							caps, &setup->stream);
@@ -1401,7 +1397,7 @@ failed:
 	return 0;
 }
 
-unsigned int a2dp_source_resume(struct avdtp *session, struct a2dp_sep *sep,
+unsigned int a2dp_resume(struct avdtp *session, struct a2dp_sep *sep,
 				a2dp_stream_cb_t cb, void *user_data)
 {
 	struct a2dp_setup_cb *cb_data;
@@ -1460,7 +1456,7 @@ failed:
 	return 0;
 }
 
-unsigned int a2dp_source_suspend(struct avdtp *session, struct a2dp_sep *sep,
+unsigned int a2dp_suspend(struct avdtp *session, struct a2dp_sep *sep,
 				a2dp_stream_cb_t cb, void *user_data)
 {
 	struct a2dp_setup_cb *cb_data;
@@ -1486,7 +1482,7 @@ unsigned int a2dp_source_suspend(struct avdtp *session, struct a2dp_sep *sep,
 
 	switch (avdtp_sep_get_state(sep->sep)) {
 	case AVDTP_STATE_IDLE:
-		error("a2dp_source_suspend: no stream to suspend");
+		error("a2dp_suspend: no stream to suspend");
 		goto failed;
 		break;
 	case AVDTP_STATE_OPEN:
@@ -1511,6 +1507,41 @@ failed:
 	return 0;
 }
 
+gboolean a2dp_cancel(struct audio_device *dev, unsigned int id)
+{
+	struct a2dp_setup_cb *cb_data;
+	struct a2dp_setup *setup;
+	GSList *l;
+
+	debug("a2dp_cancel()");
+
+	setup = find_setup_by_dev(dev);
+	if (!setup)
+		return FALSE;
+
+	for (cb_data = NULL, l = setup->cb; l != NULL; l = g_slist_next(l)) {
+		struct a2dp_setup_cb *cb = l->data;
+
+		if (cb->id == id) {
+			cb_data = cb;
+			break;
+		}
+	}
+
+	if (!cb_data)
+		error("a2dp_cancel: no matching callback with id %u", id);
+
+	setup->cb = g_slist_remove(setup->cb, cb_data);
+	g_free(cb_data);
+
+	if (!setup->cb) {
+		setup->canceled = TRUE;
+		setup->sep = NULL;
+	}
+
+	return TRUE;
+}
+
 gboolean a2dp_sep_lock(struct a2dp_sep *sep, struct avdtp *session)
 {
 	if (sep->locked)
diff --git a/audio/a2dp.h b/audio/a2dp.h
index 0e5f796..f08c643 100644
--- a/audio/a2dp.h
+++ b/audio/a2dp.h
@@ -132,16 +132,15 @@ typedef void (*a2dp_stream_cb_t) (struct avdtp *session,
 int a2dp_register(DBusConnection *conn, const bdaddr_t *src, GKeyFile *config);
 void a2dp_unregister(const bdaddr_t *src);
 
-struct a2dp_sep *a2dp_source_get(struct avdtp *session,
-				struct avdtp_remote_sep *sep);
-unsigned int a2dp_source_config(struct avdtp *session, struct a2dp_sep *sep,
+struct a2dp_sep *a2dp_get(struct avdtp *session, struct avdtp_remote_sep *sep);
+unsigned int a2dp_config(struct avdtp *session, struct a2dp_sep *sep,
 				a2dp_config_cb_t cb, GSList *caps,
 				void *user_data);
-unsigned int a2dp_source_resume(struct avdtp *session, struct a2dp_sep *sep,
+unsigned int a2dp_resume(struct avdtp *session, struct a2dp_sep *sep,
 				a2dp_stream_cb_t cb, void *user_data);
-unsigned int a2dp_source_suspend(struct avdtp *session, struct a2dp_sep *sep,
+unsigned int a2dp_suspend(struct avdtp *session, struct a2dp_sep *sep,
 				a2dp_stream_cb_t cb, void *user_data);
-gboolean a2dp_source_cancel(struct audio_device *dev, unsigned int id);
+gboolean a2dp_cancel(struct audio_device *dev, unsigned int id);
 
 gboolean a2dp_sep_lock(struct a2dp_sep *sep, struct avdtp *session);
 gboolean a2dp_sep_unlock(struct a2dp_sep *sep, struct avdtp *session);
diff --git a/audio/sink.c b/audio/sink.c
index 17e07b1..00b2ea7 100644
--- a/audio/sink.c
+++ b/audio/sink.c
@@ -165,7 +165,7 @@ static void pending_request_free(struct audio_device *dev,
 	if (pending->msg)
 		dbus_message_unref(pending->msg);
 	if (pending->id)
-		a2dp_source_cancel(dev, pending->id);
+		a2dp_cancel(dev, pending->id);
 
 	g_free(pending);
 }
@@ -520,14 +520,13 @@ static void discovery_complete(struct avdtp *session, GSList *seps, struct avdtp
 		goto failed;
 	}
 
-	sep = a2dp_source_get(session, rsep);
+	sep = a2dp_get(session, rsep);
 	if (!sep) {
 		error("Unable to get a local source SEP");
 		goto failed;
 	}
 
-	id = a2dp_source_config(sink->session, sep, stream_setup_complete,
-				caps, sink);
+	id = a2dp_config(sink->session, sep, stream_setup_complete, caps, sink);
 	if (id == 0)
 		goto failed;
 
diff --git a/audio/unix.c b/audio/unix.c
index 1212f5b..f241a83 100644
--- a/audio/unix.c
+++ b/audio/unix.c
@@ -903,7 +903,7 @@ static void start_open(struct audio_device *dev, struct unix_client *client)
 			goto failed;
 		}
 
-		a2dp->sep = a2dp_source_get(a2dp->session, rsep);
+		a2dp->sep = a2dp_get(a2dp->session, rsep);
 		if (!a2dp->sep) {
 			error("seid %d not available or locked", client->seid);
 			goto failed;
@@ -972,10 +972,9 @@ static void start_config(struct audio_device *dev, struct unix_client *client)
 			goto failed;
 		}
 
-		id = a2dp_source_config(a2dp->session, a2dp->sep,
-					a2dp_config_complete, client->caps,
-					client);
-		client->cancel = a2dp_source_cancel;
+		id = a2dp_config(a2dp->session, a2dp->sep, a2dp_config_complete,
+					client->caps, client);
+		client->cancel = a2dp_cancel;
 		break;
 
 	case TYPE_HEADSET:
@@ -1039,9 +1038,9 @@ static void start_resume(struct audio_device *dev, struct unix_client *client)
 			goto failed;
 		}
 
-		id = a2dp_source_resume(a2dp->session, a2dp->sep,
-					a2dp_resume_complete, client);
-		client->cancel = a2dp_source_cancel;
+		id = a2dp_resume(a2dp->session, a2dp->sep, a2dp_resume_complete,
+					client);
+		client->cancel = a2dp_cancel;
 
 		break;
 
@@ -1107,9 +1106,9 @@ static void start_suspend(struct audio_device *dev, struct unix_client *client)
 			goto failed;
 		}
 
-		id = a2dp_source_suspend(a2dp->session, a2dp->sep,
+		id = a2dp_suspend(a2dp->session, a2dp->sep,
 					a2dp_suspend_complete, client);
-		client->cancel = a2dp_source_cancel;
+		client->cancel = a2dp_cancel;
 		break;
 
 	case TYPE_HEADSET:
-- 
1.6.0.4

[PATCH 2/4] Create A2DP Source interface.

[João Paulo Rechi Vita]

---
 audio/Makefile.am |    3 +-
 audio/a2dp.c      |    7 +-
 audio/avdtp.c     |    3 +
 audio/device.c    |    4 +
 audio/manager.c   |    5 +
 audio/source.c    |  870 +++++++++++++++++++++++++++++++++++++++++++++++++++++
 audio/source.h    |   50 +++
 7 files changed, 939 insertions(+), 3 deletions(-)
 create mode 100644 audio/source.c
 create mode 100644 audio/source.h

diff --git a/audio/Makefile.am b/audio/Makefile.am
index cbdad9f..31736b4 100644
--- a/audio/Makefile.am
+++ b/audio/Makefile.am
@@ -9,7 +9,8 @@ plugin_LTLIBRARIES = audio.la
 audio_la_SOURCES = main.c \
 	ipc.h ipc.c unix.h unix.c manager.h manager.c telephony.h \
 	device.h device.c headset.h headset.c gateway.h gateway.c \
-	avdtp.h avdtp.c a2dp.h a2dp.c sink.h sink.c control.h control.c
+	avdtp.h avdtp.c a2dp.h a2dp.c sink.h sink.c source.h source.c \
+	control.h control.c
 
 nodist_audio_la_SOURCES = $(BUILT_SOURCES)
 
diff --git a/audio/a2dp.c b/audio/a2dp.c
index 7d14865..87b2077 100644
--- a/audio/a2dp.c
+++ b/audio/a2dp.c
@@ -503,8 +503,11 @@ static void setconf_cfm(struct avdtp *session, struct avdtp_local_sep *sep,
 
 	dev = a2dp_get_dev(session);
 
-	/* Notify sink.c of the new stream */
-	sink_new_stream(dev, session, setup->stream);
+	/* Notify D-Bus interface of the new stream */
+	if (a2dp_sep->type == AVDTP_SEP_TYPE_SOURCE)
+		sink_new_stream(dev, session, setup->stream);
+	else
+		source_new_stream(dev, session, setup->stream);
 
 	ret = avdtp_open(session, stream);
 	if (ret < 0) {
diff --git a/audio/avdtp.c b/audio/avdtp.c
index ed84b21..8046dda 100644
--- a/audio/avdtp.c
+++ b/audio/avdtp.c
@@ -52,6 +52,7 @@
 #include "glib-helper.h"
 #include "btio.h"
 #include "sink.h"
+#include "source.h"
 
 #include <bluetooth/l2cap.h>
 
@@ -631,6 +632,8 @@ static gboolean disconnect_timeout(gpointer user_data)
 
 	if (dev && dev->sink && stream_setup)
 		sink_setup_stream(dev->sink, session);
+	else if (dev && dev->source && stream_setup)
+		source_setup_stream(dev->source, session);
 	else
 		connection_lost(session, ETIMEDOUT);
 
diff --git a/audio/device.c b/audio/device.c
index ea66f4a..8568954 100644
--- a/audio/device.c
+++ b/audio/device.c
@@ -58,6 +58,7 @@
 #include "headset.h"
 #include "gateway.h"
 #include "sink.h"
+#include "source.h"
 
 #define AUDIO_INTERFACE "org.bluez.Audio"
 
@@ -651,6 +652,9 @@ void audio_device_unregister(struct audio_device *device)
 	if (device->sink)
 		sink_unregister(device);
 
+	if (device->source)
+		source_unregister(device);
+
 	if (device->control)
 		control_unregister(device);
 
diff --git a/audio/manager.c b/audio/manager.c
index f137d1b..00e9158 100644
--- a/audio/manager.c
+++ b/audio/manager.c
@@ -65,6 +65,7 @@
 #include "headset.h"
 #include "gateway.h"
 #include "sink.h"
+#include "source.h"
 #include "control.h"
 #include "manager.h"
 #include "sdpd.h"
@@ -142,6 +143,8 @@ gboolean server_is_enabled(bdaddr_t *src, uint16_t svc)
 		return enabled.gateway;
 	case AUDIO_SINK_SVCLASS_ID:
 		return enabled.sink;
+	case AUDIO_SOURCE_SVCLASS_ID:
+		return enabled.source;
 	case AV_REMOTE_TARGET_SVCLASS_ID:
 	case AV_REMOTE_SVCLASS_ID:
 		return enabled.control;
@@ -205,6 +208,8 @@ static void handle_uuid(const char *uuidstr, struct audio_device *device)
 		break;
 	case AUDIO_SOURCE_SVCLASS_ID:
 		debug("Found Audio Source");
+		if (device->source == NULL)
+			device->source = source_init(device);
 		break;
 	case AV_REMOTE_SVCLASS_ID:
 	case AV_REMOTE_TARGET_SVCLASS_ID:
diff --git a/audio/source.c b/audio/source.c
new file mode 100644
index 0000000..9b9655c
--- /dev/null
+++ b/audio/source.c
@@ -0,0 +1,870 @@
+/*
+ *
+ *  BlueZ - Bluetooth protocol stack for Linux
+ *
+ *  Copyright (C) 2006-2007  Nokia Corporation
+ *  Copyright (C) 2004-2009  Marcel Holtmann <marcel@holtmann.org>
+ *  Copyright (C) 2009  Joao Paulo Rechi Vita
+ *
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdint.h>
+#include <errno.h>
+
+#include <bluetooth/bluetooth.h>
+#include <bluetooth/sdp.h>
+
+#include <glib.h>
+#include <dbus/dbus.h>
+#include <gdbus.h>
+
+#include "logging.h"
+
+#include "device.h"
+#include "avdtp.h"
+#include "a2dp.h"
+#include "error.h"
+#include "source.h"
+#include "dbus-common.h"
+#include "../src/adapter.h"
+#include "../src/device.h"
+
+#define STREAM_SETUP_RETRY_TIMER 2
+
+struct pending_request {
+	DBusConnection *conn;
+	DBusMessage *msg;
+	unsigned int id;
+};
+
+struct source {
+	struct audio_device *dev;
+	struct avdtp *session;
+	struct avdtp_stream *stream;
+	unsigned int cb_id;
+	guint dc_id;
+	guint retry_id;
+	avdtp_session_state_t session_state;
+	avdtp_state_t stream_state;
+	source_state_t state;
+	struct pending_request *connect;
+	struct pending_request *disconnect;
+	DBusConnection *conn;
+};
+
+struct source_state_callback {
+	source_state_cb cb;
+	void *user_data;
+	unsigned int id;
+};
+
+static GSList *source_callbacks = NULL;
+
+static unsigned int avdtp_callback_id = 0;
+
+static const char *state2str(source_state_t state)
+{
+	switch (state) {
+	case SOURCE_STATE_DISCONNECTED:
+		return "disconnected";
+	case SOURCE_STATE_CONNECTING:
+		return "connecting";
+	case SOURCE_STATE_CONNECTED:
+		return "connected";
+	case SOURCE_STATE_PLAYING:
+		return "playing";
+	default:
+		error("Invalid source state %d", state);
+		return NULL;
+	}
+}
+
+static void source_set_state(struct audio_device *dev, source_state_t new_state)
+{
+	struct source *source = dev->source;
+	const char *state_str;
+	source_state_t old_state = source->state;
+	GSList *l;
+
+	source->state = new_state;
+
+	state_str = state2str(new_state);
+	if (state_str)
+		emit_property_changed(dev->conn, dev->path,
+					AUDIO_SOURCE_INTERFACE, "State",
+					DBUS_TYPE_STRING, &state_str);
+
+	for (l = source_callbacks; l != NULL; l = l->next) {
+		struct source_state_callback *cb = l->data;
+		cb->cb(dev, old_state, new_state, cb->user_data);
+	}
+}
+
+static void avdtp_state_callback(struct audio_device *dev,
+					struct avdtp *session,
+					avdtp_session_state_t old_state,
+					avdtp_session_state_t new_state,
+					void *user_data)
+{
+	struct source *source = dev->source;
+
+	if (source == NULL)
+		return;
+
+	switch (new_state) {
+	case AVDTP_SESSION_STATE_DISCONNECTED:
+		if (source->state != SOURCE_STATE_CONNECTING) {
+			gboolean value = FALSE;
+			g_dbus_emit_signal(dev->conn, dev->path,
+					AUDIO_SOURCE_INTERFACE, "Disconnected",
+					DBUS_TYPE_INVALID);
+			emit_property_changed(dev->conn, dev->path,
+					AUDIO_SOURCE_INTERFACE, "Connected",
+					DBUS_TYPE_BOOLEAN, &value);
+			if (source->dc_id) {
+				device_remove_disconnect_watch(dev->btd_dev,
+								source->dc_id);
+				source->dc_id = 0;
+			}
+		}
+		source_set_state(dev, SOURCE_STATE_DISCONNECTED);
+		break;
+	case AVDTP_SESSION_STATE_CONNECTING:
+		source_set_state(dev, SOURCE_STATE_CONNECTING);
+		break;
+	case AVDTP_SESSION_STATE_CONNECTED:
+		break;
+	}
+
+	source->session_state = new_state;
+}
+
+static void pending_request_free(struct audio_device *dev,
+					struct pending_request *pending)
+{
+	if (pending->conn)
+		dbus_connection_unref(pending->conn);
+	if (pending->msg)
+		dbus_message_unref(pending->msg);
+	if (pending->id)
+		a2dp_cancel(dev, pending->id);
+
+	g_free(pending);
+}
+
+static void disconnect_cb(struct btd_device *btd_dev, gboolean removal,
+				void *user_data)
+{
+	struct audio_device *device = user_data;
+	struct source *source = device->source;
+
+	debug("Source: disconnect %s", device->path);
+
+	avdtp_close(source->session, source->stream);
+}
+
+static void stream_state_changed(struct avdtp_stream *stream,
+					avdtp_state_t old_state,
+					avdtp_state_t new_state,
+					struct avdtp_error *err,
+					void *user_data)
+{
+	struct audio_device *dev = user_data;
+	struct source *source = dev->source;
+	gboolean value;
+
+	if (err)
+		return;
+
+	switch (new_state) {
+	case AVDTP_STATE_IDLE:
+		if (source->disconnect) {
+			DBusMessage *reply;
+			struct pending_request *p;
+
+			p = source->disconnect;
+			source->disconnect = NULL;
+
+			reply = dbus_message_new_method_return(p->msg);
+			g_dbus_send_message(p->conn, reply);
+			pending_request_free(dev, p);
+		}
+
+		if (source->dc_id) {
+			device_remove_disconnect_watch(dev->btd_dev,
+							source->dc_id);
+			source->dc_id = 0;
+		}
+
+		if (source->session) {
+			avdtp_unref(source->session);
+			source->session = NULL;
+		}
+		source->stream = NULL;
+		source->cb_id = 0;
+		break;
+	case AVDTP_STATE_OPEN:
+		if (old_state == AVDTP_STATE_CONFIGURED &&
+				source->state == SOURCE_STATE_CONNECTING) {
+			value = TRUE;
+			g_dbus_emit_signal(dev->conn, dev->path,
+						AUDIO_SOURCE_INTERFACE,
+						"Connected",
+						DBUS_TYPE_INVALID);
+			emit_property_changed(dev->conn, dev->path,
+						AUDIO_SOURCE_INTERFACE,
+						"Connected",
+						DBUS_TYPE_BOOLEAN, &value);
+			source->dc_id = device_add_disconnect_watch(dev->btd_dev,
+								disconnect_cb,
+								dev, NULL);
+		} else if (old_state == AVDTP_STATE_STREAMING) {
+			value = FALSE;
+			g_dbus_emit_signal(dev->conn, dev->path,
+						AUDIO_SOURCE_INTERFACE,
+						"Stopped",
+						DBUS_TYPE_INVALID);
+			emit_property_changed(dev->conn, dev->path,
+						AUDIO_SOURCE_INTERFACE,
+						"Playing",
+						DBUS_TYPE_BOOLEAN, &value);
+		}
+		source_set_state(dev, SOURCE_STATE_CONNECTED);
+		break;
+	case AVDTP_STATE_STREAMING:
+		value = TRUE;
+		g_dbus_emit_signal(dev->conn, dev->path, AUDIO_SOURCE_INTERFACE,
+					"Playing", DBUS_TYPE_INVALID);
+		emit_property_changed(dev->conn, dev->path,
+					AUDIO_SOURCE_INTERFACE, "Playing",
+					DBUS_TYPE_BOOLEAN, &value);
+		source_set_state(dev, SOURCE_STATE_PLAYING);
+		break;
+	case AVDTP_STATE_CONFIGURED:
+	case AVDTP_STATE_CLOSING:
+	case AVDTP_STATE_ABORTING:
+	default:
+		break;
+	}
+
+	source->stream_state = new_state;
+}
+
+static DBusHandlerResult error_failed(DBusConnection *conn,
+					DBusMessage *msg, const char * desc)
+{
+	return error_common_reply(conn, msg, ERROR_INTERFACE ".Failed", desc);
+}
+
+static gboolean stream_setup_retry(gpointer user_data)
+{
+	struct source *source = user_data;
+	struct pending_request *pending = source->connect;
+
+	source->retry_id = 0;
+
+	if (source->stream_state >= AVDTP_STATE_OPEN) {
+		debug("Stream successfully created, after XCASE connect:connect");
+		if (pending->msg) {
+			DBusMessage *reply;
+			reply = dbus_message_new_method_return(pending->msg);
+			g_dbus_send_message(pending->conn, reply);
+		}
+	} else {
+		debug("Stream setup failed, after XCASE connect:connect");
+		if (pending->msg)
+			error_failed(pending->conn, pending->msg, "Stream setup failed");
+	}
+
+	source->connect = NULL;
+	pending_request_free(source->dev, pending);
+
+	return FALSE;
+}
+
+static void stream_setup_complete(struct avdtp *session, struct a2dp_sep *sep,
+					struct avdtp_stream *stream,
+					struct avdtp_error *err, void *user_data)
+{
+	struct source *source = user_data;
+	struct pending_request *pending;
+
+	pending = source->connect;
+
+	pending->id = 0;
+
+	if (stream) {
+		debug("Stream successfully created");
+
+		if (pending->msg) {
+			DBusMessage *reply;
+			reply = dbus_message_new_method_return(pending->msg);
+			g_dbus_send_message(pending->conn, reply);
+		}
+
+		source->connect = NULL;
+		pending_request_free(source->dev, pending);
+
+		return;
+	}
+
+	avdtp_unref(source->session);
+	source->session = NULL;
+	if (avdtp_error_type(err) == AVDTP_ERROR_ERRNO
+			&& avdtp_error_posix_errno(err) != EHOSTDOWN) {
+		debug("connect:connect XCASE detected");
+		source->retry_id = g_timeout_add_seconds(STREAM_SETUP_RETRY_TIMER,
+							stream_setup_retry,
+							source);
+	} else {
+		if (pending->msg)
+			error_failed(pending->conn, pending->msg, "Stream setup failed");
+		source->connect = NULL;
+		pending_request_free(source->dev, pending);
+		debug("Stream setup failed : %s", avdtp_strerror(err));
+	}
+}
+
+static uint8_t default_bitpool(uint8_t freq, uint8_t mode)
+{
+	switch (freq) {
+	case SBC_SAMPLING_FREQ_16000:
+	case SBC_SAMPLING_FREQ_32000:
+		return 53;
+	case SBC_SAMPLING_FREQ_44100:
+		switch (mode) {
+		case SBC_CHANNEL_MODE_MONO:
+		case SBC_CHANNEL_MODE_DUAL_CHANNEL:
+			return 31;
+		case SBC_CHANNEL_MODE_STEREO:
+		case SBC_CHANNEL_MODE_JOINT_STEREO:
+			return 53;
+		default:
+			error("Invalid channel mode %u", mode);
+			return 53;
+		}
+	case SBC_SAMPLING_FREQ_48000:
+		switch (mode) {
+		case SBC_CHANNEL_MODE_MONO:
+		case SBC_CHANNEL_MODE_DUAL_CHANNEL:
+			return 29;
+		case SBC_CHANNEL_MODE_STEREO:
+		case SBC_CHANNEL_MODE_JOINT_STEREO:
+			return 51;
+		default:
+			error("Invalid channel mode %u", mode);
+			return 51;
+		}
+	default:
+		error("Invalid sampling freq %u", freq);
+		return 53;
+	}
+}
+
+static gboolean select_sbc_params(struct sbc_codec_cap *cap,
+					struct sbc_codec_cap *supported)
+{
+	unsigned int max_bitpool, min_bitpool;
+
+	memset(cap, 0, sizeof(struct sbc_codec_cap));
+
+	cap->cap.media_type = AVDTP_MEDIA_TYPE_AUDIO;
+	cap->cap.media_codec_type = A2DP_CODEC_SBC;
+
+	if (supported->frequency & SBC_SAMPLING_FREQ_44100)
+		cap->frequency = SBC_SAMPLING_FREQ_44100;
+	else if (supported->frequency & SBC_SAMPLING_FREQ_48000)
+		cap->frequency = SBC_SAMPLING_FREQ_48000;
+	else if (supported->frequency & SBC_SAMPLING_FREQ_32000)
+		cap->frequency = SBC_SAMPLING_FREQ_32000;
+	else if (supported->frequency & SBC_SAMPLING_FREQ_16000)
+		cap->frequency = SBC_SAMPLING_FREQ_16000;
+	else {
+		error("No supported frequencies");
+		return FALSE;
+	}
+
+	if (supported->channel_mode & SBC_CHANNEL_MODE_JOINT_STEREO)
+		cap->channel_mode = SBC_CHANNEL_MODE_JOINT_STEREO;
+	else if (supported->channel_mode & SBC_CHANNEL_MODE_STEREO)
+		cap->channel_mode = SBC_CHANNEL_MODE_STEREO;
+	else if (supported->channel_mode & SBC_CHANNEL_MODE_DUAL_CHANNEL)
+		cap->channel_mode = SBC_CHANNEL_MODE_DUAL_CHANNEL;
+	else if (supported->channel_mode & SBC_CHANNEL_MODE_MONO)
+		cap->channel_mode = SBC_CHANNEL_MODE_MONO;
+	else {
+		error("No supported channel modes");
+		return FALSE;
+	}
+
+	if (supported->block_length & SBC_BLOCK_LENGTH_16)
+		cap->block_length = SBC_BLOCK_LENGTH_16;
+	else if (supported->block_length & SBC_BLOCK_LENGTH_12)
+		cap->block_length = SBC_BLOCK_LENGTH_12;
+	else if (supported->block_length & SBC_BLOCK_LENGTH_8)
+		cap->block_length = SBC_BLOCK_LENGTH_8;
+	else if (supported->block_length & SBC_BLOCK_LENGTH_4)
+		cap->block_length = SBC_BLOCK_LENGTH_4;
+	else {
+		error("No supported block lengths");
+		return FALSE;
+	}
+
+	if (supported->subbands & SBC_SUBBANDS_8)
+		cap->subbands = SBC_SUBBANDS_8;
+	else if (supported->subbands & SBC_SUBBANDS_4)
+		cap->subbands = SBC_SUBBANDS_4;
+	else {
+		error("No supported subbands");
+		return FALSE;
+	}
+
+	if (supported->allocation_method & SBC_ALLOCATION_LOUDNESS)
+		cap->allocation_method = SBC_ALLOCATION_LOUDNESS;
+	else if (supported->allocation_method & SBC_ALLOCATION_SNR)
+		cap->allocation_method = SBC_ALLOCATION_SNR;
+
+	min_bitpool = MAX(MIN_BITPOOL, supported->min_bitpool);
+	max_bitpool = MIN(default_bitpool(cap->frequency, cap->channel_mode),
+							supported->max_bitpool);
+
+	cap->min_bitpool = min_bitpool;
+	cap->max_bitpool = max_bitpool;
+
+	return TRUE;
+}
+
+static gboolean select_capabilities(struct avdtp *session,
+					struct avdtp_remote_sep *rsep,
+					GSList **caps)
+{
+	struct avdtp_service_capability *media_transport, *media_codec;
+	struct sbc_codec_cap sbc_cap;
+
+	media_codec = avdtp_get_codec(rsep);
+	if (!media_codec)
+		return FALSE;
+
+	select_sbc_params(&sbc_cap, (struct sbc_codec_cap *) media_codec->data);
+
+	media_transport = avdtp_service_cap_new(AVDTP_MEDIA_TRANSPORT,
+						NULL, 0);
+
+	*caps = g_slist_append(*caps, media_transport);
+
+	media_codec = avdtp_service_cap_new(AVDTP_MEDIA_CODEC, &sbc_cap,
+						sizeof(sbc_cap));
+
+	*caps = g_slist_append(*caps, media_codec);
+
+
+	return TRUE;
+}
+
+static void discovery_complete(struct avdtp *session, GSList *seps, struct avdtp_error *err,
+				void *user_data)
+{
+	struct source *source = user_data;
+	struct pending_request *pending;
+	struct avdtp_local_sep *lsep;
+	struct avdtp_remote_sep *rsep;
+	struct a2dp_sep *sep;
+	GSList *caps = NULL;
+	int id;
+
+	pending = source->connect;
+
+	if (err) {
+		avdtp_unref(source->session);
+		source->session = NULL;
+		if (avdtp_error_type(err) == AVDTP_ERROR_ERRNO
+				&& avdtp_error_posix_errno(err) != EHOSTDOWN) {
+			debug("connect:connect XCASE detected");
+			source->retry_id =
+				g_timeout_add_seconds(STREAM_SETUP_RETRY_TIMER,
+							stream_setup_retry,
+							source);
+		} else
+			goto failed;
+		return;
+	}
+
+	debug("Discovery complete");
+
+	if (avdtp_get_seps(session, AVDTP_SEP_TYPE_SOURCE, AVDTP_MEDIA_TYPE_AUDIO,
+				A2DP_CODEC_SBC, &lsep, &rsep) < 0) {
+		error("No matching ACP and INT SEPs found");
+		goto failed;
+	}
+
+	if (!select_capabilities(session, rsep, &caps)) {
+		error("Unable to select remote SEP capabilities");
+		goto failed;
+	}
+
+	sep = a2dp_get(session, rsep);
+	if (!sep) {
+		error("Unable to get a local sink SEP");
+		goto failed;
+	}
+
+	id = a2dp_config(source->session, sep, stream_setup_complete, caps,
+				source);
+	if (id == 0)
+		goto failed;
+
+	pending->id = id;
+	return;
+
+failed:
+	if (pending->msg)
+		error_failed(pending->conn, pending->msg, "Stream setup failed");
+	pending_request_free(source->dev, pending);
+	source->connect = NULL;
+	avdtp_unref(source->session);
+	source->session = NULL;
+}
+
+gboolean source_setup_stream(struct source *source, struct avdtp *session)
+{
+	if (source->connect || source->disconnect)
+		return FALSE;
+
+	if (session && !source->session)
+		source->session = avdtp_ref(session);
+
+	if (!source->session)
+		return FALSE;
+
+	avdtp_set_auto_disconnect(source->session, FALSE);
+
+	if (avdtp_discover(source->session, discovery_complete, source) < 0)
+		return FALSE;
+
+	source->connect = g_new0(struct pending_request, 1);
+
+	return TRUE;
+}
+
+static DBusMessage *source_connect(DBusConnection *conn,
+				DBusMessage *msg, void *data)
+{
+	struct audio_device *dev = data;
+	struct source *source = dev->source;
+	struct pending_request *pending;
+
+	if (!source->session)
+		source->session = avdtp_get(&dev->src, &dev->dst);
+
+	if (!source->session)
+		return g_dbus_create_error(msg, ERROR_INTERFACE ".Failed",
+						"Unable to get a session");
+
+	if (source->connect || source->disconnect)
+		return g_dbus_create_error(msg, ERROR_INTERFACE ".Failed",
+						"%s", strerror(EBUSY));
+
+	if (source->stream_state >= AVDTP_STATE_OPEN)
+		return g_dbus_create_error(msg, ERROR_INTERFACE
+						".AlreadyConnected",
+						"Device Already Connected");
+
+	if (!source_setup_stream(source, NULL))
+		return g_dbus_create_error(msg, ERROR_INTERFACE ".Failed",
+						"Failed to create a stream");
+
+	dev->auto_connect = FALSE;
+
+	pending = source->connect;
+
+	pending->conn = dbus_connection_ref(conn);
+	pending->msg = dbus_message_ref(msg);
+
+	debug("stream creation in progress");
+
+	return NULL;
+}
+
+static DBusMessage *source_disconnect(DBusConnection *conn,
+					DBusMessage *msg, void *data)
+{
+	struct audio_device *device = data;
+	struct source *source = device->source;
+	struct pending_request *pending;
+	int err;
+
+	if (!source->session)
+		return g_dbus_create_error(msg, ERROR_INTERFACE
+						".NotConnected",
+						"Device not Connected");
+
+	if (source->connect || source->disconnect)
+		return g_dbus_create_error(msg, ERROR_INTERFACE ".Failed",
+						"%s", strerror(EBUSY));
+
+	if (source->stream_state < AVDTP_STATE_OPEN) {
+		DBusMessage *reply = dbus_message_new_method_return(msg);
+		if (!reply)
+			return NULL;
+		avdtp_unref(source->session);
+		source->session = NULL;
+		return reply;
+	}
+
+	err = avdtp_close(source->session, source->stream);
+	if (err < 0)
+		return g_dbus_create_error(msg, ERROR_INTERFACE ".Failed",
+						"%s", strerror(-err));
+
+	pending = g_new0(struct pending_request, 1);
+	pending->conn = dbus_connection_ref(conn);
+	pending->msg = dbus_message_ref(msg);
+	source->disconnect = pending;
+
+	return NULL;
+}
+
+static DBusMessage *source_is_connected(DBusConnection *conn,
+					DBusMessage *msg,
+					void *data)
+{
+	struct audio_device *device = data;
+	struct source *source = device->source;
+	DBusMessage *reply;
+	dbus_bool_t connected;
+
+	reply = dbus_message_new_method_return(msg);
+	if (!reply)
+		return NULL;
+
+	connected = (source->stream_state >= AVDTP_STATE_CONFIGURED);
+
+	dbus_message_append_args(reply, DBUS_TYPE_BOOLEAN, &connected,
+					DBUS_TYPE_INVALID);
+
+	return reply;
+}
+
+static DBusMessage *source_get_properties(DBusConnection *conn,
+					DBusMessage *msg, void *data)
+{
+	struct audio_device *device = data;
+	struct source *source = device->source;
+	DBusMessage *reply;
+	DBusMessageIter iter;
+	DBusMessageIter dict;
+	const char *state;
+	gboolean value;
+
+	reply = dbus_message_new_method_return(msg);
+	if (!reply)
+		return NULL;
+
+	dbus_message_iter_init_append(reply, &iter);
+
+	dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
+			DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
+			DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
+			DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict);
+
+	/* Playing */
+	value = (source->stream_state == AVDTP_STATE_STREAMING);
+	dict_append_entry(&dict, "Playing", DBUS_TYPE_BOOLEAN, &value);
+
+	/* Connected */
+	value = (source->stream_state >= AVDTP_STATE_CONFIGURED);
+	dict_append_entry(&dict, "Connected", DBUS_TYPE_BOOLEAN, &value);
+
+	/* State */
+	state = state2str(source->state);
+	if (state)
+		dict_append_entry(&dict, "State", DBUS_TYPE_STRING, &state);
+
+	dbus_message_iter_close_container(&iter, &dict);
+
+	return reply;
+}
+
+static GDBusMethodTable source_methods[] = {
+	{ "Connect",		"",	"",	source_connect,
+						G_DBUS_METHOD_FLAG_ASYNC },
+	{ "Disconnect",		"",	"",	source_disconnect,
+						G_DBUS_METHOD_FLAG_ASYNC },
+	{ "IsConnected",	"",	"b",	source_is_connected,
+						G_DBUS_METHOD_FLAG_DEPRECATED },
+	{ "GetProperties",	"",	"a{sv}",source_get_properties },
+	{ NULL, NULL, NULL, NULL }
+};
+
+static GDBusSignalTable source_signals[] = {
+	{ "Connected",			"",	G_DBUS_SIGNAL_FLAG_DEPRECATED },
+	{ "Disconnected",		"",	G_DBUS_SIGNAL_FLAG_DEPRECATED },
+	{ "Playing",			"",	G_DBUS_SIGNAL_FLAG_DEPRECATED },
+	{ "Stopped",			"",	G_DBUS_SIGNAL_FLAG_DEPRECATED },
+	{ "PropertyChanged",		"sv"	},
+	{ NULL, NULL }
+};
+
+static void source_free(struct audio_device *dev)
+{
+	struct source *source = dev->source;
+
+	if (source->cb_id)
+		avdtp_stream_remove_cb(source->session, source->stream,
+					source->cb_id);
+
+	if (source->dc_id)
+		device_remove_disconnect_watch(dev->btd_dev, source->dc_id);
+
+	if (source->session)
+		avdtp_unref(source->session);
+
+	if (source->connect)
+		pending_request_free(dev, source->connect);
+
+	if (source->disconnect)
+		pending_request_free(dev, source->disconnect);
+
+	if (source->retry_id)
+		g_source_remove(source->retry_id);
+
+	g_free(source);
+	dev->source = NULL;
+}
+
+static void path_unregister(void *data)
+{
+	struct audio_device *dev = data;
+
+	debug("Unregistered interface %s on path %s",
+		AUDIO_SOURCE_INTERFACE, dev->path);
+
+	source_free(dev);
+}
+
+void source_unregister(struct audio_device *dev)
+{
+	g_dbus_unregister_interface(dev->conn, dev->path,
+		AUDIO_SOURCE_INTERFACE);
+}
+
+struct source *source_init(struct audio_device *dev)
+{
+	struct source *source;
+
+	if (!g_dbus_register_interface(dev->conn, dev->path,
+					AUDIO_SOURCE_INTERFACE,
+					source_methods, source_signals, NULL,
+					dev, path_unregister))
+		return NULL;
+
+	debug("Registered interface %s on path %s",
+		AUDIO_SOURCE_INTERFACE, dev->path);
+
+	if (avdtp_callback_id == 0)
+		avdtp_callback_id = avdtp_add_state_cb(avdtp_state_callback,
+									NULL);
+
+	source = g_new0(struct source, 1);
+
+	source->dev = dev;
+
+	return source;
+}
+
+gboolean source_is_active(struct audio_device *dev)
+{
+	struct source *source = dev->source;
+
+	if (source->session)
+		return TRUE;
+
+	return FALSE;
+}
+
+avdtp_state_t source_get_state(struct audio_device *dev)
+{
+	struct source *source = dev->source;
+
+	return source->stream_state;
+}
+
+gboolean source_new_stream(struct audio_device *dev, struct avdtp *session,
+				struct avdtp_stream *stream)
+{
+	struct source *source = dev->source;
+
+	if (source->stream)
+		return FALSE;
+
+	if (!source->session)
+		source->session = avdtp_ref(session);
+
+	source->stream = stream;
+
+	source->cb_id = avdtp_stream_add_cb(session, stream,
+						stream_state_changed, dev);
+
+	return TRUE;
+}
+
+gboolean source_shutdown(struct source *source)
+{
+	if (!source->stream)
+		return FALSE;
+
+	if (avdtp_close(source->session, source->stream) < 0)
+		return FALSE;
+
+	return TRUE;
+}
+
+unsigned int source_add_state_cb(source_state_cb cb, void *user_data)
+{
+	struct source_state_callback *state_cb;
+	static unsigned int id = 0;
+
+	state_cb = g_new(struct source_state_callback, 1);
+	state_cb->cb = cb;
+	state_cb->user_data = user_data;
+	state_cb->id = ++id;
+
+	source_callbacks = g_slist_append(source_callbacks, state_cb);
+
+	return state_cb->id;
+}
+
+gboolean source_remove_state_cb(unsigned int id)
+{
+	GSList *l;
+
+	for (l = source_callbacks; l != NULL; l = l->next) {
+		struct source_state_callback *cb = l->data;
+		if (cb && cb->id == id) {
+			source_callbacks = g_slist_remove(source_callbacks, cb);
+			g_free(cb);
+			return TRUE;
+		}
+	}
+
+	return FALSE;
+}
diff --git a/audio/source.h b/audio/source.h
new file mode 100644
index 0000000..8250814
--- /dev/null
+++ b/audio/source.h
@@ -0,0 +1,50 @@
+/*
+ *
+ *  BlueZ - Bluetooth protocol stack for Linux
+ *
+ *  Copyright (C) 2006-2007  Nokia Corporation
+ *  Copyright (C) 2004-2009  Marcel Holtmann <marcel@holtmann.org>
+ *  Copyright (C) 2009  Joao Paulo Rechi Vita
+ *
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+
+#define AUDIO_SOURCE_INTERFACE "org.bluez.AudioSource"
+
+typedef enum {
+	SOURCE_STATE_DISCONNECTED,
+	SOURCE_STATE_CONNECTING,
+	SOURCE_STATE_CONNECTED,
+	SOURCE_STATE_PLAYING,
+} source_state_t;
+
+typedef void (*source_state_cb) (struct audio_device *dev,
+				source_state_t old_state,
+				source_state_t new_state,
+				void *user_data);
+
+unsigned int source_add_state_cb(source_state_cb cb, void *user_data);
+gboolean source_remove_state_cb(unsigned int id);
+
+struct source *source_init(struct audio_device *dev);
+void source_unregister(struct audio_device *dev);
+gboolean source_is_active(struct audio_device *dev);
+avdtp_state_t source_get_state(struct audio_device *dev);
+gboolean source_new_stream(struct audio_device *dev, struct avdtp *session,
+				struct avdtp_stream *stream);
+gboolean source_setup_stream(struct source *source, struct avdtp *session);
+gboolean source_shutdown(struct source *source);
-- 
1.6.0.4

[PATCH 3/4] Create one SBC Sink when registering A2DP server.

[João Paulo Rechi Vita]

---
 audio/a2dp.c |    2 +-
 1 files changed, 1 insertions(+), 1 deletions(-)

diff --git a/audio/a2dp.c b/audio/a2dp.c
index 87b2077..7b5632d 100644
--- a/audio/a2dp.c
+++ b/audio/a2dp.c
@@ -1076,7 +1076,7 @@ static struct a2dp_server *find_server(GSList *list, const bdaddr_t *src)
 
 int a2dp_register(DBusConnection *conn, const bdaddr_t *src, GKeyFile *config)
 {
-	int sbc_srcs = 1, sbc_sinks = 0;
+	int sbc_srcs = 1, sbc_sinks = 1;
 	int mpeg12_srcs = 0, mpeg12_sinks = 0;
 	gboolean source = TRUE, sink = TRUE;
 	char *str;
-- 
1.6.0.4

[PATCH 4/4] Add Sink role support to audio IPC.

[João Paulo Rechi Vita]

---
 audio/unix.c |    4 ++++
 1 files changed, 4 insertions(+), 0 deletions(-)

diff --git a/audio/unix.c b/audio/unix.c
index f241a83..2646302 100644
--- a/audio/unix.c
+++ b/audio/unix.c
@@ -882,6 +882,7 @@ static void start_open(struct audio_device *dev, struct unix_client *client)
 
 	switch (client->type) {
 	case TYPE_SINK:
+	case TYPE_SOURCE:
 		a2dp = &client->d.a2dp;
 
 		if (!a2dp->session)
@@ -957,6 +958,7 @@ static void start_config(struct audio_device *dev, struct unix_client *client)
 
 	switch (client->type) {
 	case TYPE_SINK:
+	case TYPE_SOURCE:
 		a2dp = &client->d.a2dp;
 
 		if (!a2dp->session)
@@ -1023,6 +1025,7 @@ static void start_resume(struct audio_device *dev, struct unix_client *client)
 
 	switch (client->type) {
 	case TYPE_SINK:
+	case TYPE_SOURCE:
 		a2dp = &client->d.a2dp;
 
 		if (!a2dp->session)
@@ -1091,6 +1094,7 @@ static void start_suspend(struct audio_device *dev, struct unix_client *client)
 
 	switch (client->type) {
 	case TYPE_SINK:
+	case TYPE_SOURCE:
 		a2dp = &client->d.a2dp;
 
 		if (!a2dp->session)
-- 
1.6.0.4

Re: [PATCH 1/4] Adapt A2DP functions to support the Sink role.

[Luiz Augusto von Dentz]

Hi,

2009/7/13 João Paulo Rechi Vita <jprvita@gmail.com>:
> Modify a2dp_source_* functions to more generic a2dp_record(), a2dp_get(),
> a2dp_config(), a2dp_resume(), a2dp_suspend(), and a2dp_cancel() which can handle
> both the Sink and Source roles.

Ive pushed a simplified version of this patch to my tree, here:

http://gitorious.org/~vudentz/bluez/vudentzs-clone/commit/27c976732dea3d2599c005715369651df76eac83

-- 
Luiz Augusto von Dentz
Engenheiro de Computação

Re: [PATCH 1/4] Adapt A2DP functions to support the Sink role.

[Johan Hedberg]

On Mon, Jul 13, 2009, Luiz Augusto von Dentz wrote:
> 2009/7/13 João Paulo Rechi Vita <jprvita@gmail.com>:
> > Modify a2dp_source_* functions to more generic a2dp_record(), a2dp_get(),
> > a2dp_config(), a2dp_resume(), a2dp_suspend(), and a2dp_cancel() which can handle
> > both the Sink and Source roles.
> 
> Ive pushed a simplified version of this patch to my tree, here:
> 
> http://gitorious.org/~vudentz/bluez/vudentzs-clone/commit/27c976732dea3d2599c005715369651df76eac83

The patches have been merged and pushed upstream. Thanks.

Johan