2 This file is part of PulseAudio.
4 Copyright 2008-2009 Joao Paulo Rechi Vita
6 PulseAudio is free software; you can redistribute it and/or modify
7 it under the terms of the GNU Lesser General Public License as
8 published by the Free Software Foundation; either version 2.1 of the
9 License, or (at your option) any later version.
11 PulseAudio is distributed in the hope that it will be useful, but
12 WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 General Public License for more details.
16 You should have received a copy of the GNU Lesser General Public
17 License along with PulseAudio; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
29 #include <sys/ioctl.h>
30 #include <linux/sockios.h>
31 #include <arpa/inet.h>
33 #include <pulse/i18n.h>
34 #include <pulse/rtclock.h>
35 #include <pulse/sample.h>
36 #include <pulse/timeval.h>
37 #include <pulse/xmalloc.h>
39 #include <pulsecore/module.h>
40 #include <pulsecore/modargs.h>
41 #include <pulsecore/core-rtclock.h>
42 #include <pulsecore/core-util.h>
43 #include <pulsecore/core-error.h>
44 #include <pulsecore/socket-util.h>
45 #include <pulsecore/thread.h>
46 #include <pulsecore/thread-mq.h>
47 #include <pulsecore/rtpoll.h>
48 #include <pulsecore/time-smoother.h>
49 #include <pulsecore/namereg.h>
50 #include <pulsecore/dbus-shared.h>
52 #include "module-bluetooth-device-symdef.h"
56 #include "bluetooth-util.h"
58 #define MAX_BITPOOL 64
59 #define MIN_BITPOOL 2U
61 PA_MODULE_AUTHOR("Joao Paulo Rechi Vita");
62 PA_MODULE_DESCRIPTION("Bluetooth audio sink and source");
63 PA_MODULE_VERSION(PACKAGE_VERSION);
64 PA_MODULE_LOAD_ONCE(FALSE);
66 "name=<name for the card/sink/source, to be prefixed> "
67 "card_name=<name for the card> "
68 "card_properties=<properties for the card> "
69 "sink_name=<name for the sink> "
70 "sink_properties=<properties for the sink> "
71 "source_name=<name for the source> "
72 "source_properties=<properties for the source> "
73 "address=<address of the device> "
76 "channels=<number of channels> "
77 "path=<device object path> "
78 "auto_connect=<automatically connect?>");
82 "sco_sink=<SCO over PCM sink name> "
83 "sco_source=<SCO over PCM source name>"
87 /* TODO: not close fd when entering suspend mode in a2dp */
89 static const char* const valid_modargs[] = {
111 sbc_capabilities_t sbc_capabilities;
112 sbc_t sbc; /* Codec data */
113 pa_bool_t sbc_initialized; /* Keep track if the encoder is initialized */
114 size_t codesize, frame_length; /* SBC Codesize, frame_length. We simply cache those values here */
116 void* buffer; /* Codec transfer buffer */
117 size_t buffer_size; /* Size of the buffer */
119 uint16_t seq_num; /* Cumulative packet sequence */
123 pcm_capabilities_t pcm_capabilities;
126 pa_source *sco_source;
128 pa_hook_slot *sink_state_changed_slot;
129 pa_hook_slot *source_state_changed_slot;
145 pa_bluetooth_discovery *discovery;
146 pa_bool_t auto_connect;
148 pa_dbus_connection *connection;
154 pa_thread_mq thread_mq;
156 pa_rtpoll_item *rtpoll_item;
159 uint64_t read_index, write_index;
160 pa_usec_t started_at;
161 pa_smoother *read_smoother;
163 pa_memchunk write_memchunk;
165 pa_sample_spec sample_spec, requested_sample_spec;
173 struct a2dp_info a2dp;
176 enum profile profile;
180 int stream_write_type;
181 int service_write_type, service_read_type;
183 pa_bool_t filter_added;
186 #define FIXED_LATENCY_PLAYBACK_A2DP (25*PA_USEC_PER_MSEC)
187 #define FIXED_LATENCY_RECORD_A2DP (25*PA_USEC_PER_MSEC)
188 #define FIXED_LATENCY_PLAYBACK_HSP (125*PA_USEC_PER_MSEC)
189 #define FIXED_LATENCY_RECORD_HSP (25*PA_USEC_PER_MSEC)
191 #define MAX_PLAYBACK_CATCH_UP_USEC (100*PA_USEC_PER_MSEC)
194 #define USE_SCO_OVER_PCM(u) (u->profile == PROFILE_HSP && (u->hsp.sco_sink && u->hsp.sco_source))
197 static int init_bt(struct userdata *u);
198 static int init_profile(struct userdata *u);
200 static int service_send(struct userdata *u, const bt_audio_msg_header_t *msg) {
204 pa_assert(u->service_fd >= 0);
206 pa_assert(msg->length > 0);
208 pa_log_debug("Sending %s -> %s",
209 pa_strnull(bt_audio_strtype(msg->type)),
210 pa_strnull(bt_audio_strname(msg->name)));
212 if ((r = pa_loop_write(u->service_fd, msg, msg->length, &u->service_write_type)) == (ssize_t) msg->length)
216 pa_log_error("Error sending data to audio service: %s", pa_cstrerror(errno));
218 pa_log_error("Short write()");
223 static int service_recv(struct userdata *u, bt_audio_msg_header_t *msg, size_t room) {
227 pa_assert(u->service_fd >= 0);
229 pa_assert(room >= sizeof(*msg));
231 pa_log_debug("Trying to receive message from audio service...");
233 /* First, read the header */
234 if ((r = pa_loop_read(u->service_fd, msg, sizeof(*msg), &u->service_read_type)) != sizeof(*msg))
237 if (msg->length < sizeof(*msg)) {
238 pa_log_error("Invalid message size.");
242 if (msg->length > room) {
243 pa_log_error("Not enough room.");
247 /* Secondly, read the payload */
248 if (msg->length > sizeof(*msg)) {
250 size_t remains = msg->length - sizeof(*msg);
252 if ((r = pa_loop_read(u->service_fd,
253 (uint8_t*) msg + sizeof(*msg),
255 &u->service_read_type)) != (ssize_t) remains)
259 pa_log_debug("Received %s <- %s",
260 pa_strnull(bt_audio_strtype(msg->type)),
261 pa_strnull(bt_audio_strname(msg->name)));
268 pa_log_error("Error receiving data from audio service: %s", pa_cstrerror(errno));
270 pa_log_error("Short read()");
275 static ssize_t service_expect(struct userdata*u, bt_audio_msg_header_t *rsp, size_t room, uint8_t expected_name, size_t expected_size) {
279 pa_assert(u->service_fd >= 0);
282 if ((r = service_recv(u, rsp, room)) < 0)
285 if ((rsp->type != BT_INDICATION && rsp->type != BT_RESPONSE) ||
286 rsp->name != expected_name ||
287 (expected_size > 0 && rsp->length != expected_size)) {
289 if (rsp->type == BT_ERROR && rsp->length == sizeof(bt_audio_error_t))
290 pa_log_error("Received error condition: %s", pa_cstrerror(((bt_audio_error_t*) rsp)->posix_errno));
292 pa_log_error("Bogus message %s received while %s was expected",
293 pa_strnull(bt_audio_strname(rsp->name)),
294 pa_strnull(bt_audio_strname(expected_name)));
301 /* Run from main thread */
302 static int parse_caps(struct userdata *u, uint8_t seid, const struct bt_get_capabilities_rsp *rsp) {
304 const codec_capabilities_t *codec;
309 bytes_left = rsp->h.length - sizeof(*rsp);
311 if (bytes_left < sizeof(codec_capabilities_t)) {
312 pa_log_error("Packet too small to store codec information.");
316 codec = (codec_capabilities_t *) rsp->data; /** ALIGNMENT? **/
318 pa_log_debug("Payload size is %lu %lu", (unsigned long) bytes_left, (unsigned long) sizeof(*codec));
320 if (((u->profile == PROFILE_A2DP || u->profile == PROFILE_A2DP_SOURCE) && codec->transport != BT_CAPABILITIES_TRANSPORT_A2DP) ||
321 (u->profile == PROFILE_HSP && codec->transport != BT_CAPABILITIES_TRANSPORT_SCO)) {
322 pa_log_error("Got capabilities for wrong codec.");
326 if (u->profile == PROFILE_HSP) {
328 if (bytes_left <= 0 || codec->length != sizeof(u->hsp.pcm_capabilities))
331 pa_assert(codec->type == BT_HFP_CODEC_PCM);
333 if (codec->configured && seid == 0)
336 memcpy(&u->hsp.pcm_capabilities, codec, sizeof(u->hsp.pcm_capabilities));
338 } else if (u->profile == PROFILE_A2DP) {
340 while (bytes_left > 0) {
341 if ((codec->type == BT_A2DP_SBC_SINK) && !codec->lock)
344 bytes_left -= codec->length;
345 codec = (const codec_capabilities_t*) ((const uint8_t*) codec + codec->length);
348 if (bytes_left <= 0 || codec->length != sizeof(u->a2dp.sbc_capabilities))
351 pa_assert(codec->type == BT_A2DP_SBC_SINK);
353 if (codec->configured && seid == 0)
356 memcpy(&u->a2dp.sbc_capabilities, codec, sizeof(u->a2dp.sbc_capabilities));
358 } else if (u->profile == PROFILE_A2DP_SOURCE) {
360 while (bytes_left > 0) {
361 if ((codec->type == BT_A2DP_SBC_SOURCE) && !codec->lock)
364 bytes_left -= codec->length;
365 codec = (const codec_capabilities_t*) ((const uint8_t*) codec + codec->length);
368 if (bytes_left <= 0 || codec->length != sizeof(u->a2dp.sbc_capabilities))
371 pa_assert(codec->type == BT_A2DP_SBC_SOURCE);
373 if (codec->configured && seid == 0)
376 memcpy(&u->a2dp.sbc_capabilities, codec, sizeof(u->a2dp.sbc_capabilities));
382 /* Run from main thread */
383 static int get_caps(struct userdata *u, uint8_t seid) {
385 struct bt_get_capabilities_req getcaps_req;
386 struct bt_get_capabilities_rsp getcaps_rsp;
387 bt_audio_error_t error;
388 uint8_t buf[BT_SUGGESTED_BUFFER_SIZE];
394 memset(&msg, 0, sizeof(msg));
395 msg.getcaps_req.h.type = BT_REQUEST;
396 msg.getcaps_req.h.name = BT_GET_CAPABILITIES;
397 msg.getcaps_req.h.length = sizeof(msg.getcaps_req);
398 msg.getcaps_req.seid = seid;
400 pa_strlcpy(msg.getcaps_req.object, u->path, sizeof(msg.getcaps_req.object));
401 if (u->profile == PROFILE_A2DP || u->profile == PROFILE_A2DP_SOURCE)
402 msg.getcaps_req.transport = BT_CAPABILITIES_TRANSPORT_A2DP;
404 pa_assert(u->profile == PROFILE_HSP);
405 msg.getcaps_req.transport = BT_CAPABILITIES_TRANSPORT_SCO;
407 msg.getcaps_req.flags = u->auto_connect ? BT_FLAG_AUTOCONNECT : 0;
409 if (service_send(u, &msg.getcaps_req.h) < 0)
412 if (service_expect(u, &msg.getcaps_rsp.h, sizeof(msg), BT_GET_CAPABILITIES, 0) < 0)
415 ret = parse_caps(u, seid, &msg.getcaps_rsp);
419 return get_caps(u, ret);
422 /* Run from main thread */
423 static uint8_t a2dp_default_bitpool(uint8_t freq, uint8_t mode) {
426 case BT_SBC_SAMPLING_FREQ_16000:
427 case BT_SBC_SAMPLING_FREQ_32000:
430 case BT_SBC_SAMPLING_FREQ_44100:
433 case BT_A2DP_CHANNEL_MODE_MONO:
434 case BT_A2DP_CHANNEL_MODE_DUAL_CHANNEL:
437 case BT_A2DP_CHANNEL_MODE_STEREO:
438 case BT_A2DP_CHANNEL_MODE_JOINT_STEREO:
442 pa_log_warn("Invalid channel mode %u", mode);
446 case BT_SBC_SAMPLING_FREQ_48000:
449 case BT_A2DP_CHANNEL_MODE_MONO:
450 case BT_A2DP_CHANNEL_MODE_DUAL_CHANNEL:
453 case BT_A2DP_CHANNEL_MODE_STEREO:
454 case BT_A2DP_CHANNEL_MODE_JOINT_STEREO:
458 pa_log_warn("Invalid channel mode %u", mode);
463 pa_log_warn("Invalid sampling freq %u", freq);
468 /* Run from main thread */
469 static int setup_a2dp(struct userdata *u) {
470 sbc_capabilities_t *cap;
473 static const struct {
477 { 16000U, BT_SBC_SAMPLING_FREQ_16000 },
478 { 32000U, BT_SBC_SAMPLING_FREQ_32000 },
479 { 44100U, BT_SBC_SAMPLING_FREQ_44100 },
480 { 48000U, BT_SBC_SAMPLING_FREQ_48000 }
484 pa_assert(u->profile == PROFILE_A2DP || u->profile == PROFILE_A2DP_SOURCE);
486 cap = &u->a2dp.sbc_capabilities;
488 /* Find the lowest freq that is at least as high as the requested
490 for (i = 0; (unsigned) i < PA_ELEMENTSOF(freq_table); i++)
491 if (freq_table[i].rate >= u->sample_spec.rate && (cap->frequency & freq_table[i].cap)) {
492 u->sample_spec.rate = freq_table[i].rate;
493 cap->frequency = freq_table[i].cap;
497 if ((unsigned) i == PA_ELEMENTSOF(freq_table)) {
498 for (--i; i >= 0; i--) {
499 if (cap->frequency & freq_table[i].cap) {
500 u->sample_spec.rate = freq_table[i].rate;
501 cap->frequency = freq_table[i].cap;
507 pa_log("Not suitable sample rate");
512 pa_assert((unsigned) i < PA_ELEMENTSOF(freq_table));
514 if (cap->capability.configured)
517 if (u->sample_spec.channels <= 1) {
518 if (cap->channel_mode & BT_A2DP_CHANNEL_MODE_MONO) {
519 cap->channel_mode = BT_A2DP_CHANNEL_MODE_MONO;
520 u->sample_spec.channels = 1;
522 u->sample_spec.channels = 2;
525 if (u->sample_spec.channels >= 2) {
526 u->sample_spec.channels = 2;
528 if (cap->channel_mode & BT_A2DP_CHANNEL_MODE_JOINT_STEREO)
529 cap->channel_mode = BT_A2DP_CHANNEL_MODE_JOINT_STEREO;
530 else if (cap->channel_mode & BT_A2DP_CHANNEL_MODE_STEREO)
531 cap->channel_mode = BT_A2DP_CHANNEL_MODE_STEREO;
532 else if (cap->channel_mode & BT_A2DP_CHANNEL_MODE_DUAL_CHANNEL)
533 cap->channel_mode = BT_A2DP_CHANNEL_MODE_DUAL_CHANNEL;
534 else if (cap->channel_mode & BT_A2DP_CHANNEL_MODE_MONO) {
535 cap->channel_mode = BT_A2DP_CHANNEL_MODE_MONO;
536 u->sample_spec.channels = 1;
538 pa_log("No supported channel modes");
543 if (cap->block_length & BT_A2DP_BLOCK_LENGTH_16)
544 cap->block_length = BT_A2DP_BLOCK_LENGTH_16;
545 else if (cap->block_length & BT_A2DP_BLOCK_LENGTH_12)
546 cap->block_length = BT_A2DP_BLOCK_LENGTH_12;
547 else if (cap->block_length & BT_A2DP_BLOCK_LENGTH_8)
548 cap->block_length = BT_A2DP_BLOCK_LENGTH_8;
549 else if (cap->block_length & BT_A2DP_BLOCK_LENGTH_4)
550 cap->block_length = BT_A2DP_BLOCK_LENGTH_4;
552 pa_log_error("No supported block lengths");
556 if (cap->subbands & BT_A2DP_SUBBANDS_8)
557 cap->subbands = BT_A2DP_SUBBANDS_8;
558 else if (cap->subbands & BT_A2DP_SUBBANDS_4)
559 cap->subbands = BT_A2DP_SUBBANDS_4;
561 pa_log_error("No supported subbands");
565 if (cap->allocation_method & BT_A2DP_ALLOCATION_LOUDNESS)
566 cap->allocation_method = BT_A2DP_ALLOCATION_LOUDNESS;
567 else if (cap->allocation_method & BT_A2DP_ALLOCATION_SNR)
568 cap->allocation_method = BT_A2DP_ALLOCATION_SNR;
570 cap->min_bitpool = (uint8_t) PA_MAX(MIN_BITPOOL, cap->min_bitpool);
571 cap->max_bitpool = (uint8_t) PA_MIN(a2dp_default_bitpool(cap->frequency, cap->channel_mode), cap->max_bitpool);
576 /* Run from main thread */
577 static void setup_sbc(struct a2dp_info *a2dp) {
578 sbc_capabilities_t *active_capabilities;
582 active_capabilities = &a2dp->sbc_capabilities;
584 if (a2dp->sbc_initialized)
585 sbc_reinit(&a2dp->sbc, 0);
587 sbc_init(&a2dp->sbc, 0);
588 a2dp->sbc_initialized = TRUE;
590 switch (active_capabilities->frequency) {
591 case BT_SBC_SAMPLING_FREQ_16000:
592 a2dp->sbc.frequency = SBC_FREQ_16000;
594 case BT_SBC_SAMPLING_FREQ_32000:
595 a2dp->sbc.frequency = SBC_FREQ_32000;
597 case BT_SBC_SAMPLING_FREQ_44100:
598 a2dp->sbc.frequency = SBC_FREQ_44100;
600 case BT_SBC_SAMPLING_FREQ_48000:
601 a2dp->sbc.frequency = SBC_FREQ_48000;
604 pa_assert_not_reached();
607 switch (active_capabilities->channel_mode) {
608 case BT_A2DP_CHANNEL_MODE_MONO:
609 a2dp->sbc.mode = SBC_MODE_MONO;
611 case BT_A2DP_CHANNEL_MODE_DUAL_CHANNEL:
612 a2dp->sbc.mode = SBC_MODE_DUAL_CHANNEL;
614 case BT_A2DP_CHANNEL_MODE_STEREO:
615 a2dp->sbc.mode = SBC_MODE_STEREO;
617 case BT_A2DP_CHANNEL_MODE_JOINT_STEREO:
618 a2dp->sbc.mode = SBC_MODE_JOINT_STEREO;
621 pa_assert_not_reached();
624 switch (active_capabilities->allocation_method) {
625 case BT_A2DP_ALLOCATION_SNR:
626 a2dp->sbc.allocation = SBC_AM_SNR;
628 case BT_A2DP_ALLOCATION_LOUDNESS:
629 a2dp->sbc.allocation = SBC_AM_LOUDNESS;
632 pa_assert_not_reached();
635 switch (active_capabilities->subbands) {
636 case BT_A2DP_SUBBANDS_4:
637 a2dp->sbc.subbands = SBC_SB_4;
639 case BT_A2DP_SUBBANDS_8:
640 a2dp->sbc.subbands = SBC_SB_8;
643 pa_assert_not_reached();
646 switch (active_capabilities->block_length) {
647 case BT_A2DP_BLOCK_LENGTH_4:
648 a2dp->sbc.blocks = SBC_BLK_4;
650 case BT_A2DP_BLOCK_LENGTH_8:
651 a2dp->sbc.blocks = SBC_BLK_8;
653 case BT_A2DP_BLOCK_LENGTH_12:
654 a2dp->sbc.blocks = SBC_BLK_12;
656 case BT_A2DP_BLOCK_LENGTH_16:
657 a2dp->sbc.blocks = SBC_BLK_16;
660 pa_assert_not_reached();
663 a2dp->sbc.bitpool = active_capabilities->max_bitpool;
664 a2dp->codesize = sbc_get_codesize(&a2dp->sbc);
665 a2dp->frame_length = sbc_get_frame_length(&a2dp->sbc);
668 /* Run from main thread */
669 static int set_conf(struct userdata *u) {
671 struct bt_open_req open_req;
672 struct bt_open_rsp open_rsp;
673 struct bt_set_configuration_req setconf_req;
674 struct bt_set_configuration_rsp setconf_rsp;
675 bt_audio_error_t error;
676 uint8_t buf[BT_SUGGESTED_BUFFER_SIZE];
679 memset(&msg, 0, sizeof(msg));
680 msg.open_req.h.type = BT_REQUEST;
681 msg.open_req.h.name = BT_OPEN;
682 msg.open_req.h.length = sizeof(msg.open_req);
684 pa_strlcpy(msg.open_req.object, u->path, sizeof(msg.open_req.object));
685 msg.open_req.seid = (u->profile == PROFILE_A2DP || u->profile == PROFILE_A2DP_SOURCE) ? u->a2dp.sbc_capabilities.capability.seid : BT_A2DP_SEID_RANGE + 1;
686 msg.open_req.lock = (u->profile == PROFILE_A2DP) ? BT_WRITE_LOCK : BT_READ_LOCK | BT_WRITE_LOCK;
688 if (service_send(u, &msg.open_req.h) < 0)
691 if (service_expect(u, &msg.open_rsp.h, sizeof(msg), BT_OPEN, sizeof(msg.open_rsp)) < 0)
694 if (u->profile == PROFILE_A2DP || u->profile == PROFILE_A2DP_SOURCE) {
695 u->sample_spec.format = PA_SAMPLE_S16LE;
697 if (setup_a2dp(u) < 0)
700 pa_assert(u->profile == PROFILE_HSP);
702 u->sample_spec.format = PA_SAMPLE_S16LE;
703 u->sample_spec.channels = 1;
704 u->sample_spec.rate = 8000;
707 memset(&msg, 0, sizeof(msg));
708 msg.setconf_req.h.type = BT_REQUEST;
709 msg.setconf_req.h.name = BT_SET_CONFIGURATION;
710 msg.setconf_req.h.length = sizeof(msg.setconf_req);
712 if (u->profile == PROFILE_A2DP || u->profile == PROFILE_A2DP_SOURCE) {
713 memcpy(&msg.setconf_req.codec, &u->a2dp.sbc_capabilities, sizeof(u->a2dp.sbc_capabilities));
715 msg.setconf_req.codec.transport = BT_CAPABILITIES_TRANSPORT_SCO;
716 msg.setconf_req.codec.seid = BT_A2DP_SEID_RANGE + 1;
717 msg.setconf_req.codec.length = sizeof(pcm_capabilities_t);
719 msg.setconf_req.h.length += msg.setconf_req.codec.length - sizeof(msg.setconf_req.codec);
721 if (service_send(u, &msg.setconf_req.h) < 0)
724 if (service_expect(u, &msg.setconf_rsp.h, sizeof(msg), BT_SET_CONFIGURATION, sizeof(msg.setconf_rsp)) < 0)
727 u->link_mtu = msg.setconf_rsp.link_mtu;
729 /* setup SBC encoder now we agree on parameters */
730 if (u->profile == PROFILE_A2DP || u->profile == PROFILE_A2DP_SOURCE) {
734 ((u->link_mtu - sizeof(struct rtp_header) - sizeof(struct rtp_payload))
735 / u->a2dp.frame_length
738 pa_log_info("SBC parameters:\n\tallocation=%u\n\tsubbands=%u\n\tblocks=%u\n\tbitpool=%u\n",
739 u->a2dp.sbc.allocation, u->a2dp.sbc.subbands, u->a2dp.sbc.blocks, u->a2dp.sbc.bitpool);
741 u->block_size = u->link_mtu;
746 /* from IO thread, except in SCO over PCM */
747 static int start_stream_fd(struct userdata *u) {
749 bt_audio_msg_header_t rsp;
750 struct bt_start_stream_req start_req;
751 struct bt_start_stream_rsp start_rsp;
752 struct bt_new_stream_ind streamfd_ind;
753 bt_audio_error_t error;
754 uint8_t buf[BT_SUGGESTED_BUFFER_SIZE];
756 struct pollfd *pollfd;
760 pa_assert(u->rtpoll);
761 pa_assert(!u->rtpoll_item);
762 pa_assert(u->stream_fd < 0);
764 memset(msg.buf, 0, BT_SUGGESTED_BUFFER_SIZE);
765 msg.start_req.h.type = BT_REQUEST;
766 msg.start_req.h.name = BT_START_STREAM;
767 msg.start_req.h.length = sizeof(msg.start_req);
769 if (service_send(u, &msg.start_req.h) < 0)
772 if (service_expect(u, &msg.rsp, sizeof(msg), BT_START_STREAM, sizeof(msg.start_rsp)) < 0)
775 if (service_expect(u, &msg.rsp, sizeof(msg), BT_NEW_STREAM, sizeof(msg.streamfd_ind)) < 0)
778 if ((u->stream_fd = bt_audio_service_get_data_fd(u->service_fd)) < 0) {
779 pa_log("Failed to get stream fd from audio service.");
783 pa_make_fd_nonblock(u->stream_fd);
784 pa_make_socket_low_delay(u->stream_fd);
787 if (setsockopt(u->stream_fd, SOL_SOCKET, SO_TIMESTAMP, &one, sizeof(one)) < 0)
788 pa_log_warn("Failed to enable SO_TIMESTAMP: %s", pa_cstrerror(errno));
790 pa_log_debug("Stream properly set up, we're ready to roll!");
792 u->rtpoll_item = pa_rtpoll_item_new(u->rtpoll, PA_RTPOLL_NEVER, 1);
793 pollfd = pa_rtpoll_item_get_pollfd(u->rtpoll_item, NULL);
794 pollfd->fd = u->stream_fd;
795 pollfd->events = pollfd->revents = 0;
797 u->read_index = u->write_index = 0;
801 u->read_smoother = pa_smoother_new(
814 static int stop_stream_fd(struct userdata *u) {
816 bt_audio_msg_header_t rsp;
817 struct bt_stop_stream_req start_req;
818 struct bt_stop_stream_rsp start_rsp;
819 bt_audio_error_t error;
820 uint8_t buf[BT_SUGGESTED_BUFFER_SIZE];
825 pa_assert(u->rtpoll);
826 pa_assert(u->rtpoll_item);
827 pa_assert(u->stream_fd >= 0);
829 pa_rtpoll_item_free(u->rtpoll_item);
830 u->rtpoll_item = NULL;
832 memset(msg.buf, 0, BT_SUGGESTED_BUFFER_SIZE);
833 msg.start_req.h.type = BT_REQUEST;
834 msg.start_req.h.name = BT_STOP_STREAM;
835 msg.start_req.h.length = sizeof(msg.start_req);
837 if (service_send(u, &msg.start_req.h) < 0 ||
838 service_expect(u, &msg.rsp, sizeof(msg), BT_STOP_STREAM, sizeof(msg.start_rsp)) < 0)
841 pa_close(u->stream_fd);
844 if (u->read_smoother) {
845 pa_smoother_free(u->read_smoother);
846 u->read_smoother = NULL;
852 /* Run from IO thread */
853 static int sink_process_msg(pa_msgobject *o, int code, void *data, int64_t offset, pa_memchunk *chunk) {
854 struct userdata *u = PA_SINK(o)->userdata;
855 pa_bool_t failed = FALSE;
858 pa_assert(u->sink == PA_SINK(o));
862 case PA_SINK_MESSAGE_SET_STATE:
864 switch ((pa_sink_state_t) PA_PTR_TO_UINT(data)) {
866 case PA_SINK_SUSPENDED:
867 pa_assert(PA_SINK_IS_OPENED(u->sink->thread_info.state));
869 /* Stop the device if the source is suspended as well */
870 if (!u->source || u->source->state == PA_SOURCE_SUSPENDED)
871 /* We deliberately ignore whether stopping
872 * actually worked. Since the stream_fd is
873 * closed it doesn't really matter */
879 case PA_SINK_RUNNING:
880 if (u->sink->thread_info.state != PA_SINK_SUSPENDED)
883 /* Resume the device if the source was suspended as well */
884 if (!u->source || u->source->state == PA_SOURCE_SUSPENDED)
885 if (start_stream_fd(u) < 0)
889 case PA_SINK_UNLINKED:
891 case PA_SINK_INVALID_STATE:
896 case PA_SINK_MESSAGE_GET_LATENCY: {
898 if (u->read_smoother) {
901 ri = pa_smoother_get(u->read_smoother, pa_rtclock_now());
902 wi = pa_bytes_to_usec(u->write_index + u->block_size, &u->sample_spec);
904 *((pa_usec_t*) data) = wi > ri ? wi - ri : 0;
908 ri = pa_rtclock_now() - u->started_at;
909 wi = pa_bytes_to_usec(u->write_index, &u->sample_spec);
911 *((pa_usec_t*) data) = wi > ri ? wi - ri : 0;
914 *((pa_usec_t*) data) += u->sink->thread_info.fixed_latency;
919 r = pa_sink_process_msg(o, code, data, offset, chunk);
921 return (r < 0 || !failed) ? r : -1;
924 /* Run from IO thread */
925 static int source_process_msg(pa_msgobject *o, int code, void *data, int64_t offset, pa_memchunk *chunk) {
926 struct userdata *u = PA_SOURCE(o)->userdata;
927 pa_bool_t failed = FALSE;
930 pa_assert(u->source == PA_SOURCE(o));
934 case PA_SOURCE_MESSAGE_SET_STATE:
936 switch ((pa_source_state_t) PA_PTR_TO_UINT(data)) {
938 case PA_SOURCE_SUSPENDED:
939 pa_assert(PA_SOURCE_IS_OPENED(u->source->thread_info.state));
941 /* Stop the device if the sink is suspended as well */
942 if (!u->sink || u->sink->state == PA_SINK_SUSPENDED)
945 if (u->read_smoother)
946 pa_smoother_pause(u->read_smoother, pa_rtclock_now());
950 case PA_SOURCE_RUNNING:
951 if (u->source->thread_info.state != PA_SOURCE_SUSPENDED)
954 /* Resume the device if the sink was suspended as well */
955 if (!u->sink || u->sink->thread_info.state == PA_SINK_SUSPENDED)
956 if (start_stream_fd(u) < 0)
959 /* We don't resume the smoother here. Instead we
960 * wait until the first packet arrives */
963 case PA_SOURCE_UNLINKED:
965 case PA_SOURCE_INVALID_STATE:
970 case PA_SOURCE_MESSAGE_GET_LATENCY: {
973 wi = pa_smoother_get(u->read_smoother, pa_rtclock_now());
974 ri = pa_bytes_to_usec(u->read_index, &u->sample_spec);
976 *((pa_usec_t*) data) = (wi > ri ? wi - ri : 0) + u->source->thread_info.fixed_latency;
982 r = pa_source_process_msg(o, code, data, offset, chunk);
984 return (r < 0 || !failed) ? r : -1;
987 /* Run from IO thread */
988 static int hsp_process_render(struct userdata *u) {
992 pa_assert(u->profile == PROFILE_HSP);
995 /* First, render some data */
996 if (!u->write_memchunk.memblock)
997 pa_sink_render_full(u->sink, u->block_size, &u->write_memchunk);
999 pa_assert(u->write_memchunk.length == u->block_size);
1005 /* Now write that data to the socket. The socket is of type
1006 * SEQPACKET, and we generated the data of the MTU size, so this
1007 * should just work. */
1009 p = (const uint8_t*) pa_memblock_acquire(u->write_memchunk.memblock) + u->write_memchunk.index;
1010 l = pa_write(u->stream_fd, p, u->write_memchunk.length, &u->stream_write_type);
1011 pa_memblock_release(u->write_memchunk.memblock);
1018 /* Retry right away if we got interrupted */
1021 else if (errno == EAGAIN)
1022 /* Hmm, apparently the socket was not writable, give up for now */
1025 pa_log_error("Failed to write data to SCO socket: %s", pa_cstrerror(errno));
1030 pa_assert((size_t) l <= u->write_memchunk.length);
1032 if ((size_t) l != u->write_memchunk.length) {
1033 pa_log_error("Wrote memory block to socket only partially! %llu written, wanted to write %llu.",
1034 (unsigned long long) l,
1035 (unsigned long long) u->write_memchunk.length);
1040 u->write_index += (uint64_t) u->write_memchunk.length;
1041 pa_memblock_unref(u->write_memchunk.memblock);
1042 pa_memchunk_reset(&u->write_memchunk);
1051 /* Run from IO thread */
1052 static int hsp_process_push(struct userdata *u) {
1054 pa_memchunk memchunk;
1057 pa_assert(u->profile == PROFILE_HSP);
1058 pa_assert(u->source);
1059 pa_assert(u->read_smoother);
1061 memchunk.memblock = pa_memblock_new(u->core->mempool, u->block_size);
1062 memchunk.index = memchunk.length = 0;
1071 pa_bool_t found_tstamp = FALSE;
1074 memset(&m, 0, sizeof(m));
1075 memset(&aux, 0, sizeof(aux));
1076 memset(&iov, 0, sizeof(iov));
1080 m.msg_control = aux;
1081 m.msg_controllen = sizeof(aux);
1083 p = pa_memblock_acquire(memchunk.memblock);
1085 iov.iov_len = pa_memblock_get_length(memchunk.memblock);
1086 l = recvmsg(u->stream_fd, &m, 0);
1087 pa_memblock_release(memchunk.memblock);
1091 if (l < 0 && errno == EINTR)
1092 /* Retry right away if we got interrupted */
1095 else if (l < 0 && errno == EAGAIN)
1096 /* Hmm, apparently the socket was not readable, give up for now. */
1099 pa_log_error("Failed to read data from SCO socket: %s", l < 0 ? pa_cstrerror(errno) : "EOF");
1104 pa_assert((size_t) l <= pa_memblock_get_length(memchunk.memblock));
1106 memchunk.length = (size_t) l;
1107 u->read_index += (uint64_t) l;
1109 for (cm = CMSG_FIRSTHDR(&m); cm; cm = CMSG_NXTHDR(&m, cm))
1110 if (cm->cmsg_level == SOL_SOCKET && cm->cmsg_type == SO_TIMESTAMP) {
1111 struct timeval *tv = (struct timeval*) CMSG_DATA(cm);
1112 pa_rtclock_from_wallclock(tv);
1113 tstamp = pa_timeval_load(tv);
1114 found_tstamp = TRUE;
1118 if (!found_tstamp) {
1119 pa_log_warn("Couldn't find SO_TIMESTAMP data in auxiliary recvmsg() data!");
1120 tstamp = pa_rtclock_now();
1123 pa_smoother_put(u->read_smoother, tstamp, pa_bytes_to_usec(u->read_index, &u->sample_spec));
1124 pa_smoother_resume(u->read_smoother, tstamp, TRUE);
1126 pa_source_post(u->source, &memchunk);
1132 pa_memblock_unref(memchunk.memblock);
1137 /* Run from IO thread */
1138 static void a2dp_prepare_buffer(struct userdata *u) {
1141 if (u->a2dp.buffer_size >= u->link_mtu)
1144 u->a2dp.buffer_size = 2 * u->link_mtu;
1145 pa_xfree(u->a2dp.buffer);
1146 u->a2dp.buffer = pa_xmalloc(u->a2dp.buffer_size);
1149 /* Run from IO thread */
1150 static int a2dp_process_render(struct userdata *u) {
1151 struct a2dp_info *a2dp;
1152 struct rtp_header *header;
1153 struct rtp_payload *payload;
1157 size_t to_write, to_encode;
1158 unsigned frame_count;
1162 pa_assert(u->profile == PROFILE_A2DP);
1165 /* First, render some data */
1166 if (!u->write_memchunk.memblock)
1167 pa_sink_render_full(u->sink, u->block_size, &u->write_memchunk);
1169 pa_assert(u->write_memchunk.length == u->block_size);
1171 a2dp_prepare_buffer(u);
1174 header = a2dp->buffer;
1175 payload = (struct rtp_payload*) ((uint8_t*) a2dp->buffer + sizeof(*header));
1179 /* Try to create a packet of the full MTU */
1181 p = (const uint8_t*) pa_memblock_acquire(u->write_memchunk.memblock) + u->write_memchunk.index;
1182 to_encode = u->write_memchunk.length;
1184 d = (uint8_t*) a2dp->buffer + sizeof(*header) + sizeof(*payload);
1185 to_write = a2dp->buffer_size - sizeof(*header) - sizeof(*payload);
1187 while (PA_LIKELY(to_encode > 0 && to_write > 0)) {
1191 encoded = sbc_encode(&a2dp->sbc,
1196 if (PA_UNLIKELY(encoded <= 0)) {
1197 pa_log_error("SBC encoding error (%li)", (long) encoded);
1198 pa_memblock_release(u->write_memchunk.memblock);
1202 /* pa_log_debug("SBC: encoded: %lu; written: %lu", (unsigned long) encoded, (unsigned long) written); */
1203 /* pa_log_debug("SBC: codesize: %lu; frame_length: %lu", (unsigned long) a2dp->codesize, (unsigned long) a2dp->frame_length); */
1205 pa_assert_fp((size_t) encoded <= to_encode);
1206 pa_assert_fp((size_t) encoded == a2dp->codesize);
1208 pa_assert_fp((size_t) written <= to_write);
1209 pa_assert_fp((size_t) written == a2dp->frame_length);
1211 p = (const uint8_t*) p + encoded;
1212 to_encode -= encoded;
1214 d = (uint8_t*) d + written;
1215 to_write -= written;
1220 pa_memblock_release(u->write_memchunk.memblock);
1222 pa_assert(to_encode == 0);
1225 pa_log_debug("Using SBC encoder implementation: %s", pa_strnull(sbc_get_implementation_info(&a2dp->sbc)));
1228 /* write it to the fifo */
1229 memset(a2dp->buffer, 0, sizeof(*header) + sizeof(*payload));
1232 header->sequence_number = htons(a2dp->seq_num++);
1233 header->timestamp = htonl(u->write_index / pa_frame_size(&u->sample_spec));
1234 header->ssrc = htonl(1);
1235 payload->frame_count = frame_count;
1237 nbytes = (uint8_t*) d - (uint8_t*) a2dp->buffer;
1242 l = pa_write(u->stream_fd, a2dp->buffer, nbytes, &u->stream_write_type);
1249 /* Retry right away if we got interrupted */
1252 else if (errno == EAGAIN)
1253 /* Hmm, apparently the socket was not writable, give up for now */
1256 pa_log_error("Failed to write data to socket: %s", pa_cstrerror(errno));
1261 pa_assert((size_t) l <= nbytes);
1263 if ((size_t) l != nbytes) {
1264 pa_log_warn("Wrote memory block to socket only partially! %llu written, wanted to write %llu.",
1265 (unsigned long long) l,
1266 (unsigned long long) nbytes);
1271 u->write_index += (uint64_t) u->write_memchunk.length;
1272 pa_memblock_unref(u->write_memchunk.memblock);
1273 pa_memchunk_reset(&u->write_memchunk);
1283 static int a2dp_process_push(struct userdata *u) {
1285 pa_memchunk memchunk;
1288 pa_assert(u->profile == PROFILE_A2DP_SOURCE);
1289 pa_assert(u->source);
1290 pa_assert(u->read_smoother);
1292 memchunk.memblock = pa_memblock_new(u->core->mempool, u->block_size);
1293 memchunk.index = memchunk.length = 0;
1296 pa_bool_t found_tstamp = FALSE;
1298 struct a2dp_info *a2dp;
1299 struct rtp_header *header;
1300 struct rtp_payload *payload;
1304 size_t to_write, to_decode;
1305 unsigned frame_count;
1307 a2dp_prepare_buffer(u);
1310 header = a2dp->buffer;
1311 payload = (struct rtp_payload*) ((uint8_t*) a2dp->buffer + sizeof(*header));
1313 l = pa_read(u->stream_fd, a2dp->buffer, a2dp->buffer_size, &u->stream_write_type);
1317 if (l < 0 && errno == EINTR)
1318 /* Retry right away if we got interrupted */
1321 else if (l < 0 && errno == EAGAIN)
1322 /* Hmm, apparently the socket was not readable, give up for now. */
1325 pa_log_error("Failed to read data from socket: %s", l < 0 ? pa_cstrerror(errno) : "EOF");
1330 pa_assert((size_t) l <= a2dp->buffer_size);
1332 u->read_index += (uint64_t) l;
1334 /* TODO: get timestamp from rtp */
1335 if (!found_tstamp) {
1336 /* pa_log_warn("Couldn't find SO_TIMESTAMP data in auxiliary recvmsg() data!"); */
1337 tstamp = pa_rtclock_now();
1340 pa_smoother_put(u->read_smoother, tstamp, pa_bytes_to_usec(u->read_index, &u->sample_spec));
1341 pa_smoother_resume(u->read_smoother, tstamp, TRUE);
1343 p = (uint8_t*) a2dp->buffer + sizeof(*header) + sizeof(*payload);
1344 to_decode = l - sizeof(*header) - sizeof(*payload);
1346 d = pa_memblock_acquire(memchunk.memblock);
1347 to_write = memchunk.length = pa_memblock_get_length(memchunk.memblock);
1349 while (PA_LIKELY(to_decode > 0 && to_write > 0)) {
1353 decoded = sbc_decode(&a2dp->sbc,
1358 if (PA_UNLIKELY(decoded <= 0)) {
1359 pa_log_error("SBC decoding error (%li)", (long) decoded);
1360 pa_memblock_release(memchunk.memblock);
1361 pa_memblock_unref(memchunk.memblock);
1365 /* pa_log_debug("SBC: decoded: %lu; written: %lu", (unsigned long) decoded, (unsigned long) written); */
1366 /* pa_log_debug("SBC: frame_length: %lu; codesize: %lu", (unsigned long) a2dp->frame_length, (unsigned long) a2dp->codesize); */
1368 pa_assert_fp((size_t) decoded <= to_decode);
1369 pa_assert_fp((size_t) decoded == a2dp->frame_length);
1371 pa_assert_fp((size_t) written <= to_write);
1372 pa_assert_fp((size_t) written == a2dp->codesize);
1374 p = (const uint8_t*) p + decoded;
1375 to_decode -= decoded;
1377 d = (uint8_t*) d + written;
1378 to_write -= written;
1383 pa_memblock_release(memchunk.memblock);
1385 pa_source_post(u->source, &memchunk);
1391 pa_memblock_unref(memchunk.memblock);
1396 static void thread_func(void *userdata) {
1397 struct userdata *u = userdata;
1398 unsigned do_write = 0;
1399 pa_bool_t writable = FALSE;
1403 pa_log_debug("IO Thread starting up");
1405 if (u->core->realtime_scheduling)
1406 pa_make_realtime(u->core->realtime_priority);
1408 pa_thread_mq_install(&u->thread_mq);
1410 if (start_stream_fd(u) < 0)
1414 struct pollfd *pollfd;
1416 pa_bool_t disable_timer = TRUE;
1418 pollfd = u->rtpoll_item ? pa_rtpoll_item_get_pollfd(u->rtpoll_item, NULL) : NULL;
1420 if (u->source && PA_SOURCE_IS_LINKED(u->source->thread_info.state)) {
1422 /* We should send two blocks to the device before we expect
1425 if (u->write_index == 0 && u->read_index <= 0)
1428 if (pollfd && (pollfd->revents & POLLIN)) {
1431 if (u->profile == PROFILE_HSP)
1432 n_read = hsp_process_push(u);
1434 n_read = a2dp_process_push(u);
1439 /* We just read something, so we are supposed to write something, too */
1444 if (u->sink && PA_SINK_IS_LINKED(u->sink->thread_info.state)) {
1446 if (u->sink->thread_info.rewind_requested)
1447 pa_sink_process_rewind(u->sink, 0);
1450 if (pollfd->revents & POLLOUT)
1453 if ((!u->source || !PA_SOURCE_IS_LINKED(u->source->thread_info.state)) && do_write <= 0 && writable) {
1454 pa_usec_t time_passed;
1455 pa_usec_t audio_sent;
1457 /* Hmm, there is no input stream we could synchronize
1458 * to. So let's do things by time */
1460 time_passed = pa_rtclock_now() - u->started_at;
1461 audio_sent = pa_bytes_to_usec(u->write_index, &u->sample_spec);
1463 if (audio_sent <= time_passed) {
1464 pa_usec_t audio_to_send = time_passed - audio_sent;
1466 /* Never try to catch up for more than 100ms */
1467 if (u->write_index > 0 && audio_to_send > MAX_PLAYBACK_CATCH_UP_USEC) {
1468 pa_usec_t skip_usec;
1469 uint64_t skip_bytes;
1471 skip_usec = audio_to_send - MAX_PLAYBACK_CATCH_UP_USEC;
1472 skip_bytes = pa_usec_to_bytes(skip_usec, &u->sample_spec);
1474 if (skip_bytes > 0) {
1477 pa_log_warn("Skipping %llu us (= %llu bytes) in audio stream",
1478 (unsigned long long) skip_usec,
1479 (unsigned long long) skip_bytes);
1481 pa_sink_render_full(u->sink, skip_bytes, &tmp);
1482 pa_memblock_unref(tmp.memblock);
1483 u->write_index += skip_bytes;
1491 if (writable && do_write > 0) {
1494 if (u->write_index <= 0)
1495 u->started_at = pa_rtclock_now();
1497 if (u->profile == PROFILE_A2DP) {
1498 if ((n_written = a2dp_process_render(u)) < 0)
1501 if ((n_written = hsp_process_render(u)) < 0)
1506 pa_log("Broken kernel: we got EAGAIN on write() after POLLOUT!");
1508 do_write -= n_written;
1512 if ((!u->source || !PA_SOURCE_IS_LINKED(u->source->thread_info.state)) && do_write <= 0 && writable) {
1513 pa_usec_t time_passed, next_write_at, sleep_for;
1515 /* Hmm, there is no input stream we could synchronize
1516 * to. So let's estimate when we need to wake up the latest */
1518 time_passed = pa_rtclock_now() - u->started_at;
1519 next_write_at = pa_bytes_to_usec(u->write_index, &u->sample_spec);
1520 sleep_for = time_passed < next_write_at ? next_write_at - time_passed : 0;
1522 /* pa_log("Sleeping for %lu; time passed %lu, next write at %lu", (unsigned long) sleep_for, (unsigned long) time_passed, (unsigned long)next_write_at); */
1524 pa_rtpoll_set_timer_relative(u->rtpoll, sleep_for);
1525 disable_timer = FALSE;
1531 pa_rtpoll_set_timer_disabled(u->rtpoll);
1533 /* Hmm, nothing to do. Let's sleep */
1535 pollfd->events = (short) (((u->sink && PA_SINK_IS_LINKED(u->sink->thread_info.state) && !writable) ? POLLOUT : 0) |
1536 (u->source && PA_SOURCE_IS_LINKED(u->source->thread_info.state) ? POLLIN : 0));
1538 if ((ret = pa_rtpoll_run(u->rtpoll, TRUE)) < 0)
1544 pollfd = u->rtpoll_item ? pa_rtpoll_item_get_pollfd(u->rtpoll_item, NULL) : NULL;
1546 if (pollfd && (pollfd->revents & ~(POLLOUT|POLLIN))) {
1547 pa_log_info("FD error: %s%s%s%s",
1548 pollfd->revents & POLLERR ? "POLLERR " :"",
1549 pollfd->revents & POLLHUP ? "POLLHUP " :"",
1550 pollfd->revents & POLLPRI ? "POLLPRI " :"",
1551 pollfd->revents & POLLNVAL ? "POLLNVAL " :"");
1557 /* If this was no regular exit from the loop we have to continue processing messages until we receive PA_MESSAGE_SHUTDOWN */
1558 pa_log_debug("IO thread failed");
1559 pa_asyncmsgq_post(u->thread_mq.outq, PA_MSGOBJECT(u->core), PA_CORE_MESSAGE_UNLOAD_MODULE, u->module, 0, NULL, NULL);
1560 pa_asyncmsgq_wait_for(u->thread_mq.inq, PA_MESSAGE_SHUTDOWN);
1563 pa_log_debug("IO thread shutting down");
1566 /* Run from main thread */
1567 static DBusHandlerResult filter_cb(DBusConnection *bus, DBusMessage *m, void *userdata) {
1573 pa_assert_se(u = userdata);
1575 dbus_error_init(&err);
1577 pa_log_debug("dbus: interface=%s, path=%s, member=%s\n",
1578 dbus_message_get_interface(m),
1579 dbus_message_get_path(m),
1580 dbus_message_get_member(m));
1582 if (!dbus_message_has_path(m, u->path))
1585 if (dbus_message_is_signal(m, "org.bluez.Headset", "SpeakerGainChanged") ||
1586 dbus_message_is_signal(m, "org.bluez.Headset", "MicrophoneGainChanged")) {
1591 if (!dbus_message_get_args(m, &err, DBUS_TYPE_UINT16, &gain, DBUS_TYPE_INVALID) || gain > 15) {
1592 pa_log("Failed to parse org.bluez.Headset.{Speaker|Microphone}GainChanged: %s", err.message);
1596 if (u->profile == PROFILE_HSP) {
1597 if (u->sink && dbus_message_is_signal(m, "org.bluez.Headset", "SpeakerGainChanged")) {
1599 pa_cvolume_set(&v, u->sample_spec.channels, (pa_volume_t) (gain * PA_VOLUME_NORM / 15));
1600 pa_sink_volume_changed(u->sink, &v);
1602 } else if (u->source && dbus_message_is_signal(m, "org.bluez.Headset", "MicrophoneGainChanged")) {
1604 pa_cvolume_set(&v, u->sample_spec.channels, (pa_volume_t) (gain * PA_VOLUME_NORM / 15));
1605 pa_source_volume_changed(u->source, &v);
1611 dbus_error_free(&err);
1613 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1616 /* Run from main thread */
1617 static void sink_set_volume_cb(pa_sink *s) {
1618 struct userdata *u = s->userdata;
1624 if (u->profile != PROFILE_HSP)
1627 gain = (pa_cvolume_max(&s->real_volume) * 15) / PA_VOLUME_NORM;
1632 pa_cvolume_set(&s->real_volume, u->sample_spec.channels, (pa_volume_t) (gain * PA_VOLUME_NORM / 15));
1634 pa_assert_se(m = dbus_message_new_method_call("org.bluez", u->path, "org.bluez.Headset", "SetSpeakerGain"));
1635 pa_assert_se(dbus_message_append_args(m, DBUS_TYPE_UINT16, &gain, DBUS_TYPE_INVALID));
1636 pa_assert_se(dbus_connection_send(pa_dbus_connection_get(u->connection), m, NULL));
1637 dbus_message_unref(m);
1640 /* Run from main thread */
1641 static void source_set_volume_cb(pa_source *s) {
1642 struct userdata *u = s->userdata;
1648 if (u->profile != PROFILE_HSP)
1651 gain = (pa_cvolume_max(&s->volume) * 15) / PA_VOLUME_NORM;
1656 pa_cvolume_set(&s->volume, u->sample_spec.channels, (pa_volume_t) (gain * PA_VOLUME_NORM / 15));
1658 pa_assert_se(m = dbus_message_new_method_call("org.bluez", u->path, "org.bluez.Headset", "SetMicrophoneGain"));
1659 pa_assert_se(dbus_message_append_args(m, DBUS_TYPE_UINT16, &gain, DBUS_TYPE_INVALID));
1660 pa_assert_se(dbus_connection_send(pa_dbus_connection_get(u->connection), m, NULL));
1661 dbus_message_unref(m);
1664 /* Run from main thread */
1665 static char *get_name(const char *type, pa_modargs *ma, const char *device_id, pa_bool_t *namereg_fail) {
1671 pa_assert(device_id);
1672 pa_assert(namereg_fail);
1674 t = pa_sprintf_malloc("%s_name", type);
1675 n = pa_modargs_get_value(ma, t, NULL);
1679 *namereg_fail = TRUE;
1680 return pa_xstrdup(n);
1683 if ((n = pa_modargs_get_value(ma, "name", NULL)))
1684 *namereg_fail = TRUE;
1687 *namereg_fail = FALSE;
1690 return pa_sprintf_malloc("bluez_%s.%s", type, n);
1695 static void sco_over_pcm_state_update(struct userdata *u) {
1697 pa_assert(USE_SCO_OVER_PCM(u));
1699 if (PA_SINK_IS_OPENED(pa_sink_get_state(u->hsp.sco_sink)) ||
1700 PA_SOURCE_IS_OPENED(pa_source_get_state(u->hsp.sco_source))) {
1702 if (u->service_fd >= 0)
1705 pa_log_debug("Resuming SCO over PCM");
1706 if ((init_bt(u) < 0) || (init_profile(u) < 0))
1707 pa_log("Can't resume SCO over PCM");
1712 if (u->service_fd < 0)
1717 pa_log_debug("Closing SCO over PCM");
1718 pa_close(u->service_fd);
1723 static pa_hook_result_t sink_state_changed_cb(pa_core *c, pa_sink *s, struct userdata *u) {
1725 pa_sink_assert_ref(s);
1728 if (s != u->hsp.sco_sink)
1731 sco_over_pcm_state_update(u);
1736 static pa_hook_result_t source_state_changed_cb(pa_core *c, pa_source *s, struct userdata *u) {
1738 pa_source_assert_ref(s);
1741 if (s != u->hsp.sco_source)
1744 sco_over_pcm_state_update(u);
1751 /* Run from main thread */
1752 static int add_sink(struct userdata *u) {
1755 if (USE_SCO_OVER_PCM(u)) {
1758 u->sink = u->hsp.sco_sink;
1759 p = pa_proplist_new();
1760 pa_proplist_sets(p, "bluetooth.protocol", "sco");
1761 pa_proplist_update(u->sink->proplist, PA_UPDATE_MERGE, p);
1762 pa_proplist_free(p);
1764 if (!u->hsp.sink_state_changed_slot)
1765 u->hsp.sink_state_changed_slot = pa_hook_connect(&u->core->hooks[PA_CORE_HOOK_SINK_STATE_CHANGED], PA_HOOK_NORMAL, (pa_hook_cb_t) sink_state_changed_cb, u);
1771 pa_sink_new_data data;
1774 pa_sink_new_data_init(&data);
1775 data.driver = __FILE__;
1776 data.module = u->module;
1777 pa_sink_new_data_set_sample_spec(&data, &u->sample_spec);
1778 pa_proplist_sets(data.proplist, "bluetooth.protocol", u->profile == PROFILE_A2DP ? "a2dp" : "sco");
1779 if (u->profile == PROFILE_HSP)
1780 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_INTENDED_ROLES, "phone");
1781 data.card = u->card;
1782 data.name = get_name("sink", u->modargs, u->address, &b);
1783 data.namereg_fail = b;
1785 if (pa_modargs_get_proplist(u->modargs, "sink_properties", data.proplist, PA_UPDATE_REPLACE) < 0) {
1786 pa_log("Invalid properties");
1787 pa_sink_new_data_done(&data);
1791 u->sink = pa_sink_new(u->core, &data, PA_SINK_HARDWARE|PA_SINK_LATENCY | (u->profile == PROFILE_HSP ? PA_SINK_HW_VOLUME_CTRL : 0));
1792 pa_sink_new_data_done(&data);
1795 pa_log_error("Failed to create sink");
1799 u->sink->userdata = u;
1800 u->sink->parent.process_msg = sink_process_msg;
1802 pa_sink_set_max_request(u->sink, u->block_size);
1803 pa_sink_set_fixed_latency(u->sink,
1804 (u->profile == PROFILE_A2DP ? FIXED_LATENCY_PLAYBACK_A2DP : FIXED_LATENCY_PLAYBACK_HSP) +
1805 pa_bytes_to_usec(u->block_size, &u->sample_spec));
1808 if (u->profile == PROFILE_HSP) {
1809 u->sink->set_volume = sink_set_volume_cb;
1810 u->sink->n_volume_steps = 16;
1816 /* Run from main thread */
1817 static int add_source(struct userdata *u) {
1820 if (USE_SCO_OVER_PCM(u)) {
1821 u->source = u->hsp.sco_source;
1822 pa_proplist_sets(u->source->proplist, "bluetooth.protocol", "hsp");
1824 if (!u->hsp.source_state_changed_slot)
1825 u->hsp.source_state_changed_slot = pa_hook_connect(&u->core->hooks[PA_CORE_HOOK_SOURCE_STATE_CHANGED], PA_HOOK_NORMAL, (pa_hook_cb_t) source_state_changed_cb, u);
1831 pa_source_new_data data;
1834 pa_source_new_data_init(&data);
1835 data.driver = __FILE__;
1836 data.module = u->module;
1837 pa_source_new_data_set_sample_spec(&data, &u->sample_spec);
1838 pa_proplist_sets(data.proplist, "bluetooth.protocol", u->profile == PROFILE_A2DP_SOURCE ? "a2dp_source" : "hsp");
1839 if (u->profile == PROFILE_HSP)
1840 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_INTENDED_ROLES, "phone");
1841 data.card = u->card;
1842 data.name = get_name("source", u->modargs, u->address, &b);
1843 data.namereg_fail = b;
1845 if (pa_modargs_get_proplist(u->modargs, "source_properties", data.proplist, PA_UPDATE_REPLACE) < 0) {
1846 pa_log("Invalid properties");
1847 pa_source_new_data_done(&data);
1851 u->source = pa_source_new(u->core, &data, PA_SOURCE_HARDWARE|PA_SOURCE_LATENCY | (u->profile == PROFILE_HSP ? PA_SOURCE_HW_VOLUME_CTRL : 0));
1852 pa_source_new_data_done(&data);
1855 pa_log_error("Failed to create source");
1859 u->source->userdata = u;
1860 u->source->parent.process_msg = source_process_msg;
1862 pa_source_set_fixed_latency(u->source,
1863 (u->profile == PROFILE_A2DP_SOURCE ? FIXED_LATENCY_RECORD_A2DP : FIXED_LATENCY_RECORD_HSP) +
1864 pa_bytes_to_usec(u->block_size, &u->sample_spec));
1867 if (u->profile == PROFILE_HSP) {
1868 pa_proplist_sets(u->source->proplist, "bluetooth.nrec", (u->hsp.pcm_capabilities.flags & BT_PCM_FLAG_NREC) ? "1" : "0");
1869 u->source->set_volume = source_set_volume_cb;
1870 u->source->n_volume_steps = 16;
1876 /* Run from main thread */
1877 static void shutdown_bt(struct userdata *u) {
1880 if (u->stream_fd >= 0) {
1881 pa_close(u->stream_fd);
1884 u->stream_write_type = 0;
1887 if (u->service_fd >= 0) {
1888 pa_close(u->service_fd);
1890 u->service_write_type = 0;
1891 u->service_read_type = 0;
1894 if (u->write_memchunk.memblock) {
1895 pa_memblock_unref(u->write_memchunk.memblock);
1896 pa_memchunk_reset(&u->write_memchunk);
1900 /* Run from main thread */
1901 static int init_bt(struct userdata *u) {
1906 u->stream_write_type = 0;
1907 u->service_write_type = 0;
1908 u->service_read_type = 0;
1910 if ((u->service_fd = bt_audio_service_open()) < 0) {
1911 pa_log_error("Couldn't connect to bluetooth audio service");
1915 pa_log_debug("Connected to the bluetooth audio service");
1920 /* Run from main thread */
1921 static int setup_bt(struct userdata *u) {
1924 if (get_caps(u, 0) < 0)
1927 pa_log_debug("Got device capabilities");
1929 if (set_conf(u) < 0)
1932 pa_log_debug("Connection to the device configured");
1935 if (USE_SCO_OVER_PCM(u)) {
1936 pa_log_debug("Configured to use SCO over PCM");
1941 pa_log_debug("Got the stream socket");
1946 /* Run from main thread */
1947 static int init_profile(struct userdata *u) {
1950 pa_assert(u->profile != PROFILE_OFF);
1952 if (setup_bt(u) < 0)
1955 if (u->profile == PROFILE_A2DP ||
1956 u->profile == PROFILE_HSP)
1957 if (add_sink(u) < 0)
1960 if (u->profile == PROFILE_HSP ||
1961 u->profile == PROFILE_A2DP_SOURCE)
1962 if (add_source(u) < 0)
1968 /* Run from main thread */
1969 static void stop_thread(struct userdata *u) {
1973 pa_asyncmsgq_send(u->thread_mq.inq, NULL, PA_MESSAGE_SHUTDOWN, NULL, 0, NULL);
1974 pa_thread_free(u->thread);
1978 if (u->rtpoll_item) {
1979 pa_rtpoll_item_free(u->rtpoll_item);
1980 u->rtpoll_item = NULL;
1983 if (u->hsp.sink_state_changed_slot) {
1984 pa_hook_slot_free(u->hsp.sink_state_changed_slot);
1985 u->hsp.sink_state_changed_slot = NULL;
1988 if (u->hsp.source_state_changed_slot) {
1989 pa_hook_slot_free(u->hsp.source_state_changed_slot);
1990 u->hsp.source_state_changed_slot = NULL;
1994 pa_sink_unref(u->sink);
1999 pa_source_unref(u->source);
2004 pa_thread_mq_done(&u->thread_mq);
2006 pa_rtpoll_free(u->rtpoll);
2010 if (u->read_smoother) {
2011 pa_smoother_free(u->read_smoother);
2012 u->read_smoother = NULL;
2016 /* Run from main thread */
2017 static int start_thread(struct userdata *u) {
2019 pa_assert(!u->thread);
2020 pa_assert(!u->rtpoll);
2021 pa_assert(!u->rtpoll_item);
2023 u->rtpoll = pa_rtpoll_new();
2024 pa_thread_mq_init(&u->thread_mq, u->core->mainloop, u->rtpoll);
2027 if (USE_SCO_OVER_PCM(u)) {
2028 if (start_stream_fd(u) < 0)
2031 pa_sink_ref(u->sink);
2032 pa_source_ref(u->source);
2033 /* FIXME: monitor stream_fd error */
2038 if (!(u->thread = pa_thread_new(thread_func, u))) {
2039 pa_log_error("Failed to create IO thread");
2045 pa_sink_set_asyncmsgq(u->sink, u->thread_mq.inq);
2046 pa_sink_set_rtpoll(u->sink, u->rtpoll);
2047 pa_sink_put(u->sink);
2049 if (u->sink->set_volume)
2050 u->sink->set_volume(u->sink);
2054 pa_source_set_asyncmsgq(u->source, u->thread_mq.inq);
2055 pa_source_set_rtpoll(u->source, u->rtpoll);
2056 pa_source_put(u->source);
2058 if (u->source->set_volume)
2059 u->source->set_volume(u->source);
2065 /* Run from main thread */
2066 static int card_set_profile(pa_card *c, pa_card_profile *new_profile) {
2069 pa_queue *inputs = NULL, *outputs = NULL;
2070 const pa_bluetooth_device *device;
2073 pa_assert(new_profile);
2074 pa_assert_se(u = c->userdata);
2076 d = PA_CARD_PROFILE_DATA(new_profile);
2078 if (!(device = pa_bluetooth_discovery_get_by_path(u->discovery, u->path))) {
2079 pa_log_error("Failed to get device object.");
2083 /* The state signal is sent by bluez, so it is racy to check
2084 strictly for CONNECTED, we should also accept STREAMING state
2085 as being good enough. However, if the profile is used
2086 concurrently (which is unlikely), ipc will fail later on, and
2087 module will be unloaded. */
2088 if (device->headset_state < PA_BT_AUDIO_STATE_CONNECTED && *d == PROFILE_HSP) {
2089 pa_log_warn("HSP is not connected, refused to switch profile");
2092 else if (device->audio_sink_state < PA_BT_AUDIO_STATE_CONNECTED && *d == PROFILE_A2DP) {
2093 pa_log_warn("A2DP is not connected, refused to switch profile");
2098 inputs = pa_sink_move_all_start(u->sink, NULL);
2100 if (!USE_SCO_OVER_PCM(u))
2102 pa_sink_unlink(u->sink);
2106 outputs = pa_source_move_all_start(u->source, NULL);
2108 if (!USE_SCO_OVER_PCM(u))
2110 pa_source_unlink(u->source);
2117 u->sample_spec = u->requested_sample_spec;
2121 if (u->profile != PROFILE_OFF)
2124 if (u->sink || u->source)
2129 pa_sink_move_all_finish(u->sink, inputs, FALSE);
2131 pa_sink_move_all_fail(inputs);
2136 pa_source_move_all_finish(u->source, outputs, FALSE);
2138 pa_source_move_all_fail(outputs);
2144 /* Run from main thread */
2145 static int add_card(struct userdata *u, const pa_bluetooth_device *device) {
2146 pa_card_new_data data;
2152 const char *default_profile;
2157 pa_card_new_data_init(&data);
2158 data.driver = __FILE__;
2159 data.module = u->module;
2161 n = pa_bluetooth_cleanup_name(device->name);
2162 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_DESCRIPTION, n);
2164 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_STRING, device->address);
2165 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_API, "bluez");
2166 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_CLASS, "sound");
2167 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_BUS, "bluetooth");
2168 if ((ff = pa_bluetooth_get_form_factor(device->class)))
2169 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_FORM_FACTOR, ff);
2170 pa_proplist_sets(data.proplist, "bluez.path", device->path);
2171 pa_proplist_setf(data.proplist, "bluez.class", "0x%06x", (unsigned) device->class);
2172 pa_proplist_sets(data.proplist, "bluez.name", device->name);
2173 data.name = get_name("card", u->modargs, device->address, &b);
2174 data.namereg_fail = b;
2176 if (pa_modargs_get_proplist(u->modargs, "card_properties", data.proplist, PA_UPDATE_REPLACE) < 0) {
2177 pa_log("Invalid properties");
2178 pa_card_new_data_done(&data);
2182 data.profiles = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
2184 /* we base hsp/a2dp availability on UUIDs.
2185 Ideally, it would be based on "Connected" state, but
2186 we can't afford to wait for this information when
2187 we are loaded with profile="hsp", for instance */
2188 if (pa_bluetooth_uuid_has(device->uuids, A2DP_SINK_UUID)) {
2189 p = pa_card_profile_new("a2dp", _("High Fidelity Playback (A2DP)"), sizeof(enum profile));
2193 p->max_sink_channels = 2;
2194 p->max_source_channels = 0;
2196 d = PA_CARD_PROFILE_DATA(p);
2199 pa_hashmap_put(data.profiles, p->name, p);
2202 if (pa_bluetooth_uuid_has(device->uuids, A2DP_SOURCE_UUID)) {
2203 p = pa_card_profile_new("a2dp_source", _("High Fidelity Capture (A2DP)"), sizeof(enum profile));
2207 p->max_sink_channels = 0;
2208 p->max_source_channels = 2;
2210 d = PA_CARD_PROFILE_DATA(p);
2211 *d = PROFILE_A2DP_SOURCE;
2213 pa_hashmap_put(data.profiles, p->name, p);
2216 if (pa_bluetooth_uuid_has(device->uuids, HSP_HS_UUID) ||
2217 pa_bluetooth_uuid_has(device->uuids, HFP_HS_UUID)) {
2218 p = pa_card_profile_new("hsp", _("Telephony Duplex (HSP/HFP)"), sizeof(enum profile));
2222 p->max_sink_channels = 1;
2223 p->max_source_channels = 1;
2225 d = PA_CARD_PROFILE_DATA(p);
2228 pa_hashmap_put(data.profiles, p->name, p);
2231 pa_assert(!pa_hashmap_isempty(data.profiles));
2233 p = pa_card_profile_new("off", _("Off"), sizeof(enum profile));
2234 d = PA_CARD_PROFILE_DATA(p);
2236 pa_hashmap_put(data.profiles, p->name, p);
2238 if ((default_profile = pa_modargs_get_value(u->modargs, "profile", NULL))) {
2239 if (pa_hashmap_get(data.profiles, default_profile))
2240 pa_card_new_data_set_profile(&data, default_profile);
2242 pa_log_warn("Profile '%s' not valid or not supported by device.", default_profile);
2245 u->card = pa_card_new(u->core, &data);
2246 pa_card_new_data_done(&data);
2249 pa_log("Failed to allocate card.");
2253 u->card->userdata = u;
2254 u->card->set_profile = card_set_profile;
2256 d = PA_CARD_PROFILE_DATA(u->card->active_profile);
2258 if ((device->headset_state < PA_BT_AUDIO_STATE_CONNECTED && *d == PROFILE_HSP) ||
2259 (device->audio_sink_state < PA_BT_AUDIO_STATE_CONNECTED && *d == PROFILE_A2DP)) {
2260 pa_log_warn("Default profile not connected, selecting off profile");
2261 u->card->active_profile = pa_hashmap_get(u->card->profiles, "off");
2262 u->card->save_profile = FALSE;
2265 d = PA_CARD_PROFILE_DATA(u->card->active_profile);
2271 /* Run from main thread */
2272 static const pa_bluetooth_device* find_device(struct userdata *u, const char *address, const char *path) {
2273 const pa_bluetooth_device *d = NULL;
2277 if (!address && !path) {
2278 pa_log_error("Failed to get device address/path from module arguments.");
2283 if (!(d = pa_bluetooth_discovery_get_by_path(u->discovery, path))) {
2284 pa_log_error("%s is not a valid BlueZ audio device.", path);
2288 if (address && !(pa_streq(d->address, address))) {
2289 pa_log_error("Passed path %s and address %s don't match.", path, address);
2294 if (!(d = pa_bluetooth_discovery_get_by_address(u->discovery, address))) {
2295 pa_log_error("%s is not known.", address);
2301 u->address = pa_xstrdup(d->address);
2302 u->path = pa_xstrdup(d->path);
2308 /* Run from main thread */
2309 static int setup_dbus(struct userdata *u) {
2312 dbus_error_init(&err);
2314 u->connection = pa_dbus_bus_get(u->core, DBUS_BUS_SYSTEM, &err);
2316 if (dbus_error_is_set(&err) || !u->connection) {
2317 pa_log("Failed to get D-Bus connection: %s", err.message);
2318 dbus_error_free(&err);
2325 int pa__init(pa_module* m) {
2329 const char *address, *path;
2331 char *mike, *speaker;
2332 const pa_bluetooth_device *device;
2336 dbus_error_init(&err);
2338 if (!(ma = pa_modargs_new(m->argument, valid_modargs))) {
2339 pa_log_error("Failed to parse module arguments");
2343 m->userdata = u = pa_xnew0(struct userdata, 1);
2348 u->sample_spec = m->core->default_sample_spec;
2352 if (pa_modargs_get_value(ma, "sco_sink", NULL) &&
2353 !(u->hsp.sco_sink = pa_namereg_get(m->core, pa_modargs_get_value(ma, "sco_sink", NULL), PA_NAMEREG_SINK))) {
2354 pa_log("SCO sink not found");
2358 if (pa_modargs_get_value(ma, "sco_source", NULL) &&
2359 !(u->hsp.sco_source = pa_namereg_get(m->core, pa_modargs_get_value(ma, "sco_source", NULL), PA_NAMEREG_SOURCE))) {
2360 pa_log("SCO source not found");
2365 if (pa_modargs_get_value_u32(ma, "rate", &u->sample_spec.rate) < 0 ||
2366 u->sample_spec.rate <= 0 || u->sample_spec.rate > PA_RATE_MAX) {
2367 pa_log_error("Failed to get rate from module arguments");
2371 u->auto_connect = TRUE;
2372 if (pa_modargs_get_value_boolean(ma, "auto_connect", &u->auto_connect)) {
2373 pa_log("Failed to parse auto_connect= argument");
2377 channels = u->sample_spec.channels;
2378 if (pa_modargs_get_value_u32(ma, "channels", &channels) < 0 ||
2379 channels <= 0 || channels > PA_CHANNELS_MAX) {
2380 pa_log_error("Failed to get channels from module arguments");
2383 u->sample_spec.channels = (uint8_t) channels;
2384 u->requested_sample_spec = u->sample_spec;
2386 address = pa_modargs_get_value(ma, "address", NULL);
2387 path = pa_modargs_get_value(ma, "path", NULL);
2389 if (setup_dbus(u) < 0)
2392 if (!(u->discovery = pa_bluetooth_discovery_get(m->core)))
2395 if (!(device = find_device(u, address, path)))
2398 /* Add the card structure. This will also initialize the default profile */
2399 if (add_card(u, device) < 0)
2402 /* Connect to the BT service and query capabilities */
2406 if (!dbus_connection_add_filter(pa_dbus_connection_get(u->connection), filter_cb, u, NULL)) {
2407 pa_log_error("Failed to add filter function");
2410 u->filter_added = TRUE;
2412 speaker = pa_sprintf_malloc("type='signal',sender='org.bluez',interface='org.bluez.Headset',member='SpeakerGainChanged',path='%s'", u->path);
2413 mike = pa_sprintf_malloc("type='signal',sender='org.bluez',interface='org.bluez.Headset',member='MicrophoneGainChanged',path='%s'", u->path);
2415 if (pa_dbus_add_matches(
2416 pa_dbus_connection_get(u->connection), &err,
2424 pa_log("Failed to add D-Bus matches: %s", err.message);
2431 if (u->profile != PROFILE_OFF)
2432 if (init_profile(u) < 0)
2435 if (u->sink || u->source)
2436 if (start_thread(u) < 0)
2445 dbus_error_free(&err);
2450 int pa__get_n_used(pa_module *m) {
2454 pa_assert_se(u = m->userdata);
2457 (u->sink ? pa_sink_linked_by(u->sink) : 0) +
2458 (u->source ? pa_source_linked_by(u->source) : 0);
2461 void pa__done(pa_module *m) {
2465 if (!(u = m->userdata))
2470 && !USE_SCO_OVER_PCM(u)
2473 pa_sink_unlink(u->sink);
2477 && !USE_SCO_OVER_PCM(u)
2480 pa_source_unlink(u->source);
2484 if (u->connection) {
2487 char *speaker, *mike;
2488 speaker = pa_sprintf_malloc("type='signal',sender='org.bluez',interface='org.bluez.Headset',member='SpeakerGainChanged',path='%s'", u->path);
2489 mike = pa_sprintf_malloc("type='signal',sender='org.bluez',interface='org.bluez.Headset',member='MicrophoneGainChanged',path='%s'", u->path);
2491 pa_dbus_remove_matches(pa_dbus_connection_get(u->connection),
2500 if (u->filter_added)
2501 dbus_connection_remove_filter(pa_dbus_connection_get(u->connection), filter_cb, u);
2503 pa_dbus_connection_unref(u->connection);
2507 pa_card_free(u->card);
2509 if (u->read_smoother)
2510 pa_smoother_free(u->read_smoother);
2515 pa_xfree(u->a2dp.buffer);
2517 sbc_finish(&u->a2dp.sbc);
2520 pa_modargs_free(u->modargs);
2522 pa_xfree(u->address);
2526 pa_bluetooth_discovery_unref(u->discovery);