/* * * BlueZ - Bluetooth protocol stack for Linux * * Copyright (C) 2006-2007 Nokia Corporation * Copyright (C) 2004-2009 Marcel Holtmann <marcel@holtmann.org> * * * 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 <stdlib.h> #include <errno.h> #include <dbus/dbus.h> #include <glib.h> #include <bluetooth/bluetooth.h> #include <bluetooth/sdp.h> #include <bluetooth/sdp_lib.h> #include "logging.h" #include "device.h" #include "manager.h" #include "avdtp.h" #include "sink.h" #include "source.h" #include "a2dp.h" #include "sdpd.h" /* The duration that streams without users are allowed to stay in * STREAMING state. */ #define SUSPEND_TIMEOUT 5 #define RECONFIGURE_TIMEOUT 500 #ifndef MIN # define MIN(x, y) ((x) < (y) ? (x) : (y)) #endif #ifndef MAX # define MAX(x, y) ((x) > (y) ? (x) : (y)) #endif struct a2dp_sep { uint8_t type; uint8_t codec; struct avdtp_local_sep *sep; struct avdtp *session; struct avdtp_stream *stream; guint suspend_timer; gboolean locked; gboolean suspending; gboolean starting; }; struct a2dp_setup_cb { a2dp_config_cb_t config_cb; a2dp_stream_cb_t resume_cb; a2dp_stream_cb_t suspend_cb; void *user_data; unsigned int id; }; struct a2dp_setup { struct audio_device *dev; struct avdtp *session; struct a2dp_sep *sep; struct avdtp_stream *stream; struct avdtp_error *err; GSList *client_caps; gboolean reconfigure; gboolean canceled; gboolean start; GSList *cb; int ref; }; static DBusConnection *connection = NULL; struct a2dp_server { bdaddr_t src; GSList *sinks; GSList *sources; uint32_t source_record_id; uint32_t sink_record_id; }; static GSList *servers = NULL; static GSList *setups = NULL; static unsigned int cb_id = 0; static struct a2dp_setup *setup_ref(struct a2dp_setup *setup) { setup->ref++; debug("setup_ref(%p): ref=%d", setup, setup->ref); return setup; } static void setup_free(struct a2dp_setup *s) { debug("setup_free(%p)", s); setups = g_slist_remove(setups, s); if (s->session) avdtp_unref(s->session); g_slist_foreach(s->cb, (GFunc) g_free, NULL); g_slist_free(s->cb); g_free(s); } static void setup_unref(struct a2dp_setup *setup) { setup->ref--; debug("setup_unref(%p): ref=%d", setup, setup->ref); if (setup->ref <= 0) setup_free(setup); } static struct audio_device *a2dp_get_dev(struct avdtp *session) { bdaddr_t src, dst; avdtp_get_peers(session, &src, &dst); return manager_find_device(NULL, &src, &dst, NULL, FALSE); } static gboolean finalize_config(struct a2dp_setup *s) { GSList *l; setup_ref(s); for (l = s->cb; l != NULL; l = l->next) { struct a2dp_setup_cb *cb = l->data; struct avdtp_stream *stream = s->err ? NULL : s->stream; if (!cb->config_cb) continue; cb->config_cb(s->session, s->sep, stream, s->err, cb->user_data); cb->config_cb = NULL; setup_unref(s); } setup_unref(s); return FALSE; } static gboolean finalize_config_errno(struct a2dp_setup *s, int err) { struct avdtp_error avdtp_err; avdtp_error_init(&avdtp_err, AVDTP_ERROR_ERRNO, -err); s->err = err ? &avdtp_err : NULL; return finalize_config(s); } static gboolean finalize_resume(struct a2dp_setup *s) { GSList *l; setup_ref(s); for (l = s->cb; l != NULL; l = l->next) { struct a2dp_setup_cb *cb = l->data; if (cb && cb->resume_cb) { cb->resume_cb(s->session, s->err, cb->user_data); cb->resume_cb = NULL; setup_unref(s); } } setup_unref(s); return FALSE; } static gboolean finalize_suspend(struct a2dp_setup *s) { GSList *l; setup_ref(s); for (l = s->cb; l != NULL; l = l->next) { struct a2dp_setup_cb *cb = l->data; if (cb->suspend_cb) { cb->suspend_cb(s->session, s->err, cb->user_data); cb->suspend_cb = NULL; setup_unref(s); } } setup_unref(s); return FALSE; } static gboolean finalize_suspend_errno(struct a2dp_setup *s, int err) { struct avdtp_error avdtp_err; avdtp_error_init(&avdtp_err, AVDTP_ERROR_ERRNO, -err); s->err = err ? &avdtp_err : NULL; return finalize_suspend(s); } static struct a2dp_setup *find_setup_by_session(struct avdtp *session) { GSList *l; for (l = setups; l != NULL; l = l->next) { struct a2dp_setup *setup = l->data; if (setup->session == session) return setup; } return NULL; } static struct a2dp_setup *find_setup_by_dev(struct audio_device *dev) { GSList *l; for (l = setups; l != NULL; l = l->next) { struct a2dp_setup *setup = l->data; if (setup->dev == dev) return setup; } return NULL; } 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 a2dp_sep *sep = user_data; if (new_state != AVDTP_STATE_IDLE) return; if (sep->suspend_timer) { g_source_remove(sep->suspend_timer); sep->suspend_timer = 0; } if (sep->session) { avdtp_unref(sep->session); sep->session = NULL; } sep->stream = NULL; } static gboolean sbc_setconf_ind(struct avdtp *session, struct avdtp_local_sep *sep, struct avdtp_stream *stream, GSList *caps, uint8_t *err, uint8_t *category, void *user_data) { struct a2dp_sep *a2dp_sep = user_data; struct audio_device *dev; struct avdtp_service_capability *cap; struct avdtp_media_codec_capability *codec_cap; struct sbc_codec_cap *sbc_cap; if (a2dp_sep->type == AVDTP_SEP_TYPE_SINK) debug("Sink %p: Set_Configuration_Ind", sep); else debug("Source %p: Set_Configuration_Ind", sep); dev = a2dp_get_dev(session); if (!dev) { *err = AVDTP_UNSUPPORTED_CONFIGURATION; *category = 0x00; return FALSE; } /* Check bipool range */ for (codec_cap = NULL; caps; caps = g_slist_next(caps)) { cap = caps->data; if (cap->category != AVDTP_MEDIA_CODEC) continue; if (cap->length < sizeof(struct sbc_codec_cap)) continue; codec_cap = (void *) cap->data; if (codec_cap->media_codec_type != A2DP_CODEC_SBC) continue; sbc_cap = (void *) codec_cap; if (sbc_cap->min_bitpool < MIN_BITPOOL || sbc_cap->max_bitpool > MAX_BITPOOL) { *err = AVDTP_UNSUPPORTED_CONFIGURATION; *category = AVDTP_MEDIA_CODEC; return FALSE; } break; } avdtp_stream_add_cb(session, stream, stream_state_changed, a2dp_sep); a2dp_sep->stream = stream; if (a2dp_sep->type == AVDTP_SEP_TYPE_SOURCE) sink_new_stream(dev, session, stream); return TRUE; } static gboolean sbc_getcap_ind(struct avdtp *session, struct avdtp_local_sep *sep, GSList **caps, uint8_t *err, void *user_data) { struct a2dp_sep *a2dp_sep = user_data; struct avdtp_service_capability *media_transport, *media_codec; struct sbc_codec_cap sbc_cap; if (a2dp_sep->type == AVDTP_SEP_TYPE_SINK) debug("Sink %p: Get_Capability_Ind", sep); else debug("Source %p: Get_Capability_Ind", sep); *caps = NULL; media_transport = avdtp_service_cap_new(AVDTP_MEDIA_TRANSPORT, NULL, 0); *caps = g_slist_append(*caps, media_transport); memset(&sbc_cap, 0, sizeof(struct sbc_codec_cap)); sbc_cap.cap.media_type = AVDTP_MEDIA_TYPE_AUDIO; sbc_cap.cap.media_codec_type = A2DP_CODEC_SBC; #ifdef ANDROID sbc_cap.frequency = SBC_SAMPLING_FREQ_44100; #else sbc_cap.frequency = ( SBC_SAMPLING_FREQ_48000 | SBC_SAMPLING_FREQ_44100 | SBC_SAMPLING_FREQ_32000 | SBC_SAMPLING_FREQ_16000 ); #endif sbc_cap.channel_mode = ( SBC_CHANNEL_MODE_JOINT_STEREO | SBC_CHANNEL_MODE_STEREO | SBC_CHANNEL_MODE_DUAL_CHANNEL | SBC_CHANNEL_MODE_MONO ); sbc_cap.block_length = ( SBC_BLOCK_LENGTH_16 | SBC_BLOCK_LENGTH_12 | SBC_BLOCK_LENGTH_8 | SBC_BLOCK_LENGTH_4 ); sbc_cap.subbands = ( SBC_SUBBANDS_8 | SBC_SUBBANDS_4 ); sbc_cap.allocation_method = ( SBC_ALLOCATION_LOUDNESS | SBC_ALLOCATION_SNR ); sbc_cap.min_bitpool = MIN_BITPOOL; sbc_cap.max_bitpool = MAX_BITPOOL; media_codec = avdtp_service_cap_new(AVDTP_MEDIA_CODEC, &sbc_cap, sizeof(sbc_cap)); *caps = g_slist_append(*caps, media_codec); return TRUE; } static gboolean mpeg_setconf_ind(struct avdtp *session, struct avdtp_local_sep *sep, struct avdtp_stream *stream, GSList *caps, uint8_t *err, uint8_t *category, void *user_data) { struct a2dp_sep *a2dp_sep = user_data; struct audio_device *dev; if (a2dp_sep->type == AVDTP_SEP_TYPE_SINK) debug("Sink %p: Set_Configuration_Ind", sep); else debug("Source %p: Set_Configuration_Ind", sep); dev = a2dp_get_dev(session); if (!dev) { *err = AVDTP_UNSUPPORTED_CONFIGURATION; *category = 0x00; return FALSE; } avdtp_stream_add_cb(session, stream, stream_state_changed, a2dp_sep); a2dp_sep->stream = stream; if (a2dp_sep->type == AVDTP_SEP_TYPE_SOURCE) sink_new_stream(dev, session, stream); return TRUE; } static gboolean mpeg_getcap_ind(struct avdtp *session, struct avdtp_local_sep *sep, GSList **caps, uint8_t *err, void *user_data) { struct a2dp_sep *a2dp_sep = user_data; struct avdtp_service_capability *media_transport, *media_codec; struct mpeg_codec_cap mpeg_cap; if (a2dp_sep->type == AVDTP_SEP_TYPE_SINK) debug("Sink %p: Get_Capability_Ind", sep); else debug("Source %p: Get_Capability_Ind", sep); *caps = NULL; media_transport = avdtp_service_cap_new(AVDTP_MEDIA_TRANSPORT, NULL, 0); *caps = g_slist_append(*caps, media_transport); memset(&mpeg_cap, 0, sizeof(struct mpeg_codec_cap)); mpeg_cap.cap.media_type = AVDTP_MEDIA_TYPE_AUDIO; mpeg_cap.cap.media_codec_type = A2DP_CODEC_MPEG12; mpeg_cap.frequency = ( MPEG_SAMPLING_FREQ_48000 | MPEG_SAMPLING_FREQ_44100 | MPEG_SAMPLING_FREQ_32000 | MPEG_SAMPLING_FREQ_24000 | MPEG_SAMPLING_FREQ_22050 | MPEG_SAMPLING_FREQ_16000 ); mpeg_cap.channel_mode = ( MPEG_CHANNEL_MODE_JOINT_STEREO | MPEG_CHANNEL_MODE_STEREO | MPEG_CHANNEL_MODE_DUAL_CHANNEL | MPEG_CHANNEL_MODE_MONO ); mpeg_cap.layer = ( MPEG_LAYER_MP3 | MPEG_LAYER_MP2 | MPEG_LAYER_MP1 ); mpeg_cap.bitrate = 0xFFFF; media_codec = avdtp_service_cap_new(AVDTP_MEDIA_CODEC, &mpeg_cap, sizeof(mpeg_cap)); *caps = g_slist_append(*caps, media_codec); return TRUE; } static void setconf_cfm(struct avdtp *session, struct avdtp_local_sep *sep, struct avdtp_stream *stream, struct avdtp_error *err, void *user_data) { struct a2dp_sep *a2dp_sep = user_data; struct a2dp_setup *setup; struct audio_device *dev; int ret; if (a2dp_sep->type == AVDTP_SEP_TYPE_SINK) debug("Sink %p: Set_Configuration_Cfm", sep); else debug("Source %p: Set_Configuration_Cfm", sep); setup = find_setup_by_session(session); if (err) { if (setup) { setup->err = err; finalize_config(setup); } return; } avdtp_stream_add_cb(session, stream, stream_state_changed, a2dp_sep); a2dp_sep->stream = stream; if (!setup) return; dev = a2dp_get_dev(session); /* 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) { error("Error on avdtp_open %s (%d)", strerror(-ret), -ret); setup->stream = NULL; finalize_config_errno(setup, ret); } } static gboolean getconf_ind(struct avdtp *session, struct avdtp_local_sep *sep, uint8_t *err, void *user_data) { struct a2dp_sep *a2dp_sep = user_data; if (a2dp_sep->type == AVDTP_SEP_TYPE_SINK) debug("Sink %p: Get_Configuration_Ind", sep); else debug("Source %p: Get_Configuration_Ind", sep); return TRUE; } static void getconf_cfm(struct avdtp *session, struct avdtp_local_sep *sep, struct avdtp_stream *stream, struct avdtp_error *err, void *user_data) { struct a2dp_sep *a2dp_sep = user_data; if (a2dp_sep->type == AVDTP_SEP_TYPE_SINK) debug("Sink %p: Set_Configuration_Cfm", sep); else debug("Source %p: Set_Configuration_Cfm", sep); } static gboolean open_ind(struct avdtp *session, struct avdtp_local_sep *sep, struct avdtp_stream *stream, uint8_t *err, void *user_data) { struct a2dp_sep *a2dp_sep = user_data; if (a2dp_sep->type == AVDTP_SEP_TYPE_SINK) debug("Sink %p: Open_Ind", sep); else debug("Source %p: Open_Ind", sep); return TRUE; } static void open_cfm(struct avdtp *session, struct avdtp_local_sep *sep, struct avdtp_stream *stream, struct avdtp_error *err, void *user_data) { struct a2dp_sep *a2dp_sep = user_data; struct a2dp_setup *setup; if (a2dp_sep->type == AVDTP_SEP_TYPE_SINK) debug("Sink %p: Open_Cfm", sep); else debug("Source %p: Open_Cfm", sep); setup = find_setup_by_session(session); if (!setup) return; if (setup->canceled) { if (!err) avdtp_close(session, stream); setup_unref(setup); return; } if (setup->reconfigure) setup->reconfigure = FALSE; if (err) { setup->stream = NULL; setup->err = err; } finalize_config(setup); } static gboolean suspend_timeout(struct a2dp_sep *sep) { if (avdtp_suspend(sep->session, sep->stream) == 0) sep->suspending = TRUE; sep->suspend_timer = 0; avdtp_unref(sep->session); sep->session = NULL; return FALSE; } static gboolean start_ind(struct avdtp *session, struct avdtp_local_sep *sep, struct avdtp_stream *stream, uint8_t *err, void *user_data) { struct a2dp_sep *a2dp_sep = user_data; struct a2dp_setup *setup; if (a2dp_sep->type == AVDTP_SEP_TYPE_SINK) debug("Sink %p: Start_Ind", sep); else debug("Source %p: Start_Ind", sep); setup = find_setup_by_session(session); if (setup) { if (setup->canceled) setup_unref(setup); else finalize_resume(setup); } if (!a2dp_sep->locked) { a2dp_sep->session = avdtp_ref(session); a2dp_sep->suspend_timer = g_timeout_add_seconds(SUSPEND_TIMEOUT, (GSourceFunc) suspend_timeout, a2dp_sep); } return TRUE; } static void start_cfm(struct avdtp *session, struct avdtp_local_sep *sep, struct avdtp_stream *stream, struct avdtp_error *err, void *user_data) { struct a2dp_sep *a2dp_sep = user_data; struct a2dp_setup *setup; if (a2dp_sep->type == AVDTP_SEP_TYPE_SINK) debug("Sink %p: Start_Cfm", sep); else debug("Source %p: Start_Cfm", sep); setup = find_setup_by_session(session); if (!setup) return; if (setup->canceled) { if (!err) avdtp_close(session, stream); setup_unref(setup); return; } if (err) { setup->stream = NULL; setup->err = err; } finalize_resume(setup); } static gboolean suspend_ind(struct avdtp *session, struct avdtp_local_sep *sep, struct avdtp_stream *stream, uint8_t *err, void *user_data) { struct a2dp_sep *a2dp_sep = user_data; if (a2dp_sep->type == AVDTP_SEP_TYPE_SINK) debug("Sink %p: Suspend_Ind", sep); else debug("Source %p: Suspend_Ind", sep); if (a2dp_sep->suspend_timer) { g_source_remove(a2dp_sep->suspend_timer); a2dp_sep->suspend_timer = 0; avdtp_unref(a2dp_sep->session); a2dp_sep->session = NULL; } return TRUE; } static void suspend_cfm(struct avdtp *session, struct avdtp_local_sep *sep, struct avdtp_stream *stream, struct avdtp_error *err, void *user_data) { struct a2dp_sep *a2dp_sep = user_data; struct a2dp_setup *setup; gboolean start; if (a2dp_sep->type == AVDTP_SEP_TYPE_SINK) debug("Sink %p: Suspend_Cfm", sep); else debug("Source %p: Suspend_Cfm", sep); a2dp_sep->suspending = FALSE; setup = find_setup_by_session(session); if (!setup) return; start = setup->start; setup->start = FALSE; if (err) { setup->stream = NULL; setup->err = err; finalize_suspend(setup); } else finalize_suspend_errno(setup, 0); if (!start) return; if (err) { setup->err = err; finalize_suspend(setup); } else if (avdtp_start(session, a2dp_sep->stream) < 0) { struct avdtp_error start_err; error("avdtp_start failed"); avdtp_error_init(&start_err, AVDTP_ERROR_ERRNO, EIO); setup->err = err; finalize_suspend(setup); } } static gboolean close_ind(struct avdtp *session, struct avdtp_local_sep *sep, struct avdtp_stream *stream, uint8_t *err, void *user_data) { struct a2dp_sep *a2dp_sep = user_data; if (a2dp_sep->type == AVDTP_SEP_TYPE_SINK) debug("Sink %p: Close_Ind", sep); else debug("Source %p: Close_Ind", sep); return TRUE; } static gboolean a2dp_reconfigure(gpointer data) { struct a2dp_setup *setup = data; struct avdtp_local_sep *lsep; struct avdtp_remote_sep *rsep; struct avdtp_service_capability *cap; struct avdtp_media_codec_capability *codec_cap = NULL; GSList *l; int posix_err; for (l = setup->client_caps; l != NULL; l = l->next) { cap = l->data; if (cap->category != AVDTP_MEDIA_CODEC) continue; codec_cap = (void *) cap->data; break; } if (!codec_cap) { error("Cannot find capabilities to reconfigure"); posix_err = -EINVAL; goto failed; } posix_err = avdtp_get_seps(setup->session, AVDTP_SEP_TYPE_SINK, codec_cap->media_type, codec_cap->media_codec_type, &lsep, &rsep); if (posix_err < 0) { error("No matching ACP and INT SEPs found"); goto failed; } posix_err = avdtp_set_configuration(setup->session, rsep, lsep, setup->client_caps, &setup->stream); if (posix_err < 0) { error("avdtp_set_configuration: %s", strerror(-posix_err)); goto failed; } return FALSE; failed: finalize_config_errno(setup, posix_err); return FALSE; } static void close_cfm(struct avdtp *session, struct avdtp_local_sep *sep, struct avdtp_stream *stream, struct avdtp_error *err, void *user_data) { struct a2dp_sep *a2dp_sep = user_data; struct a2dp_setup *setup; if (a2dp_sep->type == AVDTP_SEP_TYPE_SINK) debug("Sink %p: Close_Cfm", sep); else debug("Source %p: Close_Cfm", sep); setup = find_setup_by_session(session); if (!setup) return; if (setup->canceled) { setup_unref(setup); return; } if (err) { setup->stream = NULL; setup->err = err; finalize_config(setup); return; } if (setup->reconfigure) g_timeout_add(RECONFIGURE_TIMEOUT, a2dp_reconfigure, setup); } static gboolean abort_ind(struct avdtp *session, struct avdtp_local_sep *sep, struct avdtp_stream *stream, uint8_t *err, void *user_data) { struct a2dp_sep *a2dp_sep = user_data; if (a2dp_sep->type == AVDTP_SEP_TYPE_SINK) debug("Sink %p: Abort_Ind", sep); else debug("Source %p: Abort_Ind", sep); a2dp_sep->stream = NULL; return TRUE; } static void abort_cfm(struct avdtp *session, struct avdtp_local_sep *sep, struct avdtp_stream *stream, struct avdtp_error *err, void *user_data) { struct a2dp_sep *a2dp_sep = user_data; struct a2dp_setup *setup; if (a2dp_sep->type == AVDTP_SEP_TYPE_SINK) debug("Sink %p: Abort_Cfm", sep); else debug("Source %p: Abort_Cfm", sep); setup = find_setup_by_session(session); if (!setup) return; setup_unref(setup); } static gboolean reconf_ind(struct avdtp *session, struct avdtp_local_sep *sep, uint8_t *err, void *user_data) { struct a2dp_sep *a2dp_sep = user_data; if (a2dp_sep->type == AVDTP_SEP_TYPE_SINK) debug("Sink %p: ReConfigure_Ind", sep); else debug("Source %p: ReConfigure_Ind", sep); return TRUE; } static void reconf_cfm(struct avdtp *session, struct avdtp_local_sep *sep, struct avdtp_stream *stream, struct avdtp_error *err, void *user_data) { struct a2dp_sep *a2dp_sep = user_data; struct a2dp_setup *setup; if (a2dp_sep->type == AVDTP_SEP_TYPE_SINK) debug("Sink %p: ReConfigure_Cfm", sep); else debug("Source %p: ReConfigure_Cfm", sep); setup = find_setup_by_session(session); if (!setup) return; if (setup->canceled) { if (!err) avdtp_close(session, stream); setup_unref(setup); return; } if (err) { setup->stream = NULL; setup->err = err; } finalize_config(setup); } static struct avdtp_sep_cfm cfm = { .set_configuration = setconf_cfm, .get_configuration = getconf_cfm, .open = open_cfm, .start = start_cfm, .suspend = suspend_cfm, .close = close_cfm, .abort = abort_cfm, .reconfigure = reconf_cfm }; static struct avdtp_sep_ind sbc_ind = { .get_capability = sbc_getcap_ind, .set_configuration = sbc_setconf_ind, .get_configuration = getconf_ind, .open = open_ind, .start = start_ind, .suspend = suspend_ind, .close = close_ind, .abort = abort_ind, .reconfigure = reconf_ind }; static struct avdtp_sep_ind mpeg_ind = { .get_capability = mpeg_getcap_ind, .set_configuration = mpeg_setconf_ind, .get_configuration = getconf_ind, .open = open_ind, .start = start_ind, .suspend = suspend_ind, .close = close_ind, .abort = abort_ind, .reconfigure = reconf_ind }; static sdp_record_t *a2dp_record(uint8_t type) { sdp_list_t *svclass_id, *pfseq, *apseq, *root; 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; sdp_data_t *psm, *version, *features; uint16_t lp = AVDTP_UUID, ver = 0x0100, feat = 0x000F; record = sdp_record_alloc(); if (!record) return NULL; sdp_uuid16_create(&root_uuid, PUBLIC_BROWSE_GROUP); root = sdp_list_append(0, &root_uuid); sdp_set_browse_groups(record, root); 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); profile[0].version = 0x0100; pfseq = sdp_list_append(0, &profile[0]); sdp_set_profile_descs(record, pfseq); 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_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]); aproto = sdp_list_append(0, apseq); sdp_set_access_protos(record, aproto); features = sdp_data_alloc(SDP_UINT16, &feat); sdp_attr_add(record, SDP_ATTR_SUPPORTED_FEATURES, features); 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); sdp_list_free(proto[0], 0); sdp_list_free(proto[1], 0); sdp_list_free(apseq, 0); sdp_list_free(pfseq, 0); sdp_list_free(aproto, 0); sdp_list_free(root, 0); sdp_list_free(svclass_id, 0); return record; } static struct a2dp_sep *a2dp_add_sep(struct a2dp_server *server, uint8_t type, uint8_t codec) { struct a2dp_sep *sep; GSList **l; uint32_t *record_id; sdp_record_t *record; struct avdtp_sep_ind *ind; sep = g_new0(struct a2dp_sep, 1); ind = (codec == A2DP_CODEC_MPEG12) ? &mpeg_ind : &sbc_ind; sep->sep = avdtp_register_sep(&server->src, type, AVDTP_MEDIA_TYPE_AUDIO, codec, ind, &cfm, sep); if (sep->sep == NULL) { g_free(sep); return NULL; } sep->codec = codec; sep->type = type; if (type == AVDTP_SEP_TYPE_SOURCE) { l = &server->sources; record_id = &server->source_record_id; } else { l = &server->sinks; record_id = &server->sink_record_id; } if (*record_id != 0) goto add; record = a2dp_record(type); if (!record) { error("Unable to allocate new service record"); avdtp_unregister_sep(sep->sep); g_free(sep); return NULL; } if (add_record_to_server(&server->src, record) < 0) { error("Unable to register A2DP service record");\ sdp_record_free(record); avdtp_unregister_sep(sep->sep); g_free(sep); return NULL; } *record_id = record->handle; add: *l = g_slist_append(*l, sep); return sep; } static struct a2dp_server *find_server(GSList *list, const bdaddr_t *src) { GSList *l; for (l = list; l; l = l->next) { struct a2dp_server *server = l->data; if (bacmp(&server->src, src) == 0) return server; } return NULL; } int a2dp_register(DBusConnection *conn, const bdaddr_t *src, GKeyFile *config) { int sbc_srcs = 1, sbc_sinks = 1; int mpeg12_srcs = 0, mpeg12_sinks = 0; gboolean source = TRUE, sink = FALSE; char *str; GError *err = NULL; int i; struct a2dp_server *server; if (!config) goto proceed; str = g_key_file_get_string(config, "General", "Enable", &err); if (err) { debug("audio.conf: %s", err->message); g_clear_error(&err); } else { if (strstr(str, "Sink")) source = TRUE; if (strstr(str, "Source")) sink = TRUE; g_free(str); } str = g_key_file_get_string(config, "General", "Disable", &err); if (err) { debug("audio.conf: %s", err->message); g_clear_error(&err); } else { if (strstr(str, "Sink")) source = FALSE; if (strstr(str, "Source")) sink = FALSE; g_free(str); } str = g_key_file_get_string(config, "A2DP", "SBCSources", &err); if (err) { debug("audio.conf: %s", err->message); g_clear_error(&err); } else { sbc_srcs = atoi(str); g_free(str); } str = g_key_file_get_string(config, "A2DP", "MPEG12Sources", &err); if (err) { debug("audio.conf: %s", err->message); g_clear_error(&err); } else { mpeg12_srcs = atoi(str); g_free(str); } str = g_key_file_get_string(config, "A2DP", "SBCSinks", &err); if (err) { debug("audio.conf: %s", err->message); g_clear_error(&err); } else { sbc_sinks = atoi(str); g_free(str); } str = g_key_file_get_string(config, "A2DP", "MPEG12Sinks", &err); if (err) { debug("audio.conf: %s", err->message); g_clear_error(&err); } else { mpeg12_sinks = atoi(str); g_free(str); } proceed: if (!connection) connection = dbus_connection_ref(conn); server = find_server(servers, src); if (!server) { int av_err; server = g_new0(struct a2dp_server, 1); if (!server) return -ENOMEM; av_err = avdtp_init(src, config); if (av_err < 0) return av_err; bacpy(&server->src, src); servers = g_slist_append(servers, server); } if (source) { for (i = 0; i < sbc_srcs; i++) a2dp_add_sep(server, AVDTP_SEP_TYPE_SOURCE, A2DP_CODEC_SBC); for (i = 0; i < mpeg12_srcs; i++) a2dp_add_sep(server, AVDTP_SEP_TYPE_SOURCE, A2DP_CODEC_MPEG12); } if (sink) { for (i = 0; i < sbc_sinks; i++) a2dp_add_sep(server, AVDTP_SEP_TYPE_SINK, A2DP_CODEC_SBC); for (i = 0; i < mpeg12_sinks; i++) a2dp_add_sep(server, AVDTP_SEP_TYPE_SINK, A2DP_CODEC_MPEG12); } return 0; } static void a2dp_unregister_sep(struct a2dp_sep *sep) { avdtp_unregister_sep(sep->sep); g_free(sep); } void a2dp_unregister(const bdaddr_t *src) { struct a2dp_server *server; server = find_server(servers, src); if (!server) return; g_slist_foreach(server->sinks, (GFunc) a2dp_unregister_sep, NULL); g_slist_free(server->sinks); g_slist_foreach(server->sources, (GFunc) a2dp_unregister_sep, NULL); g_slist_free(server->sources); avdtp_exit(src); if (server->source_record_id) remove_record_from_server(server->source_record_id); if (server->sink_record_id) remove_record_from_server(server->sink_record_id); servers = g_slist_remove(servers, server); g_free(server); if (servers) return; dbus_connection_unref(connection); connection = NULL; } struct a2dp_sep *a2dp_get(struct avdtp *session, struct avdtp_remote_sep *rsep) { GSList *l; struct a2dp_server *server; struct avdtp_service_capability *cap; struct avdtp_media_codec_capability *codec_cap = NULL; bdaddr_t src; avdtp_get_peers(session, &src, NULL); server = find_server(servers, &src); if (!server) return NULL; cap = avdtp_get_codec(rsep); codec_cap = (void *) cap->data; if (avdtp_get_type(rsep) == AVDTP_SEP_TYPE_SINK) l = server->sources; else l = server->sinks; for (; 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_config(struct avdtp *session, struct a2dp_sep *sep, a2dp_config_cb_t cb, GSList *caps, void *user_data) { struct a2dp_setup_cb *cb_data; GSList *l; struct a2dp_server *server; struct a2dp_setup *setup; struct a2dp_sep *tmp; struct avdtp_local_sep *lsep; struct avdtp_remote_sep *rsep; struct avdtp_service_capability *cap; struct avdtp_media_codec_capability *codec_cap = NULL; int posix_err; bdaddr_t src; uint8_t remote_type; avdtp_get_peers(session, &src, NULL); server = find_server(servers, &src); if (!server) return 0; for (l = caps; l != NULL; l = l->next) { cap = l->data; if (cap->category != AVDTP_MEDIA_CODEC) continue; codec_cap = (void *) cap->data; break; } if (!codec_cap) return 0; if (sep->codec != codec_cap->media_codec_type) return 0; debug("a2dp_config: selected SEP %p", sep->sep); cb_data = g_new0(struct a2dp_setup_cb, 1); cb_data->config_cb = cb; cb_data->user_data = user_data; cb_data->id = ++cb_id; setup = find_setup_by_session(session); if (!setup) { setup = g_new0(struct a2dp_setup, 1); setup->session = avdtp_ref(session); setup->dev = a2dp_get_dev(session); setups = g_slist_append(setups, setup); } setup_ref(setup); setup->cb = g_slist_append(setup->cb, cb_data); setup->sep = sep; setup->stream = sep->stream; setup->client_caps = caps; switch (avdtp_sep_get_state(sep->sep)) { case AVDTP_STATE_IDLE: if (sep->type == AVDTP_SEP_TYPE_SOURCE) { l = server->sources; remote_type = AVDTP_SEP_TYPE_SINK; } else { remote_type = AVDTP_SEP_TYPE_SOURCE; l = server->sinks; } for (; l != NULL; l = l->next) { tmp = l->data; if (avdtp_has_stream(session, tmp->stream)) break; } if (l != NULL) { setup->reconfigure = TRUE; if (avdtp_close(session, tmp->stream) < 0) { error("avdtp_close failed"); goto failed; } break; } if (avdtp_get_seps(session, remote_type, 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); if (posix_err < 0) { error("avdtp_set_configuration: %s", strerror(-posix_err)); goto failed; } break; case AVDTP_STATE_OPEN: case AVDTP_STATE_STREAMING: if (avdtp_stream_has_capabilities(setup->stream, caps)) { debug("Configuration match: resuming"); g_idle_add((GSourceFunc) finalize_config, setup); } else if (!setup->reconfigure) { setup->reconfigure = TRUE; if (avdtp_close(session, sep->stream) < 0) { error("avdtp_close failed"); goto failed; } } break; default: error("SEP in bad state for requesting a new stream"); goto failed; } return cb_data->id; failed: setup_unref(setup); cb_id--; return 0; } 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; struct a2dp_setup *setup; cb_data = g_new0(struct a2dp_setup_cb, 1); cb_data->resume_cb = cb; cb_data->user_data = user_data; cb_data->id = ++cb_id; setup = find_setup_by_session(session); if (!setup) { setup = g_new0(struct a2dp_setup, 1); setup->session = avdtp_ref(session); setup->dev = a2dp_get_dev(session); setups = g_slist_append(setups, setup); } setup_ref(setup); setup->cb = g_slist_append(setup->cb, cb_data); setup->sep = sep; setup->stream = sep->stream; switch (avdtp_sep_get_state(sep->sep)) { case AVDTP_STATE_IDLE: goto failed; break; case AVDTP_STATE_OPEN: if (avdtp_start(session, sep->stream) < 0) { error("avdtp_start failed"); goto failed; } break; case AVDTP_STATE_STREAMING: if (!sep->suspending && sep->suspend_timer) { g_source_remove(sep->suspend_timer); sep->suspend_timer = 0; avdtp_unref(sep->session); sep->session = NULL; } if (sep->suspending) setup->start = TRUE; else g_idle_add((GSourceFunc) finalize_resume, setup); break; default: error("SEP in bad state for resume"); goto failed; } return cb_data->id; failed: setup_unref(setup); cb_id--; return 0; } 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; struct a2dp_setup *setup; cb_data = g_new0(struct a2dp_setup_cb, 1); cb_data->suspend_cb = cb; cb_data->user_data = user_data; cb_data->id = ++cb_id; setup = find_setup_by_session(session); if (!setup) { setup = g_new0(struct a2dp_setup, 1); setup->session = avdtp_ref(session); setup->dev = a2dp_get_dev(session); setups = g_slist_append(setups, setup); } setup_ref(setup); setup->cb = g_slist_append(setup->cb, cb_data); setup->sep = sep; setup->stream = sep->stream; switch (avdtp_sep_get_state(sep->sep)) { case AVDTP_STATE_IDLE: error("a2dp_suspend: no stream to suspend"); goto failed; break; case AVDTP_STATE_OPEN: g_idle_add((GSourceFunc) finalize_suspend, setup); break; case AVDTP_STATE_STREAMING: if (avdtp_suspend(session, sep->stream) < 0) { error("avdtp_suspend failed"); goto failed; } break; default: error("SEP in bad state for suspend"); goto failed; } return cb_data->id; failed: setup_unref(setup); cb_id--; 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) return FALSE; debug("SEP %p locked", sep->sep); sep->locked = TRUE; return TRUE; } gboolean a2dp_sep_unlock(struct a2dp_sep *sep, struct avdtp *session) { avdtp_state_t state; state = avdtp_sep_get_state(sep->sep); sep->locked = FALSE; debug("SEP %p unlocked", sep->sep); if (!sep->stream || state == AVDTP_STATE_IDLE) return TRUE; switch (state) { case AVDTP_STATE_OPEN: /* Set timer here */ break; case AVDTP_STATE_STREAMING: if (avdtp_suspend(session, sep->stream) == 0) sep->suspending = TRUE; break; default: break; } return TRUE; } gboolean a2dp_sep_get_lock(struct a2dp_sep *sep) { return sep->locked; } static int stream_cmp(gconstpointer data, gconstpointer user_data) { const struct a2dp_sep *sep = data; const struct avdtp_stream *stream = user_data; return (sep->stream != stream); } struct a2dp_sep *a2dp_get_sep(struct avdtp *session, struct avdtp_stream *stream) { struct a2dp_server *server; bdaddr_t src, dst; GSList *l; avdtp_get_peers(session, &src, &dst); for (l = servers; l; l = l->next) { server = l->data; if (bacmp(&src, &server->src) == 0) break; } if (!l) return NULL; l = g_slist_find_custom(server->sources, stream, stream_cmp); if (l) return l->data; l = g_slist_find_custom(server->sinks, stream, stream_cmp); if (l) return l->data; return NULL; }