2 This file is part of PulseAudio.
4 Copyright 2008 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/xmalloc.h>
34 #include <pulse/timeval.h>
35 #include <pulse/sample.h>
36 #include <pulse/i18n.h>
38 #include <pulsecore/module.h>
39 #include <pulsecore/modargs.h>
40 #include <pulsecore/core-util.h>
41 #include <pulsecore/core-error.h>
42 #include <pulsecore/socket-util.h>
43 #include <pulsecore/thread.h>
44 #include <pulsecore/thread-mq.h>
45 #include <pulsecore/rtpoll.h>
46 #include <pulsecore/time-smoother.h>
47 #include <pulsecore/rtclock.h>
48 #include <pulsecore/namereg.h>
49 #include <pulsecore/dbus-shared.h>
51 #include "module-bluetooth-device-symdef.h"
55 #include "bluetooth-util.h"
57 #define MAX_BITPOOL 64
58 #define MIN_BITPOOL 2U
60 PA_MODULE_AUTHOR("Joao Paulo Rechi Vita");
61 PA_MODULE_DESCRIPTION("Bluetooth audio sink and source");
62 PA_MODULE_VERSION(PACKAGE_VERSION);
63 PA_MODULE_LOAD_ONCE(FALSE);
65 "name=<name for the card/sink/source, to be prefixed> "
66 "card_name=<name for the card> "
67 "sink_name=<name for the sink> "
68 "source_name=<name for the source> "
69 "address=<address of the device> "
72 "channels=<number of channels> "
73 "path=<device object path>");
77 "sco_sink=<SCO over PCM sink name> "
78 "sco_source=<SCO over PCM source name>"
82 /* TODO: not close fd when entering suspend mode in a2dp */
84 static const char* const valid_modargs[] = {
102 sbc_capabilities_t sbc_capabilities;
103 sbc_t sbc; /* Codec data */
104 pa_bool_t sbc_initialized; /* Keep track if the encoder is initialized */
105 size_t codesize, frame_length; /* SBC Codesize, frame_length. We simply cache those values here */
107 void* buffer; /* Codec transfer buffer */
108 size_t buffer_size; /* Size of the buffer */
110 uint16_t seq_num; /* Cumulative packet sequence */
114 pcm_capabilities_t pcm_capabilities;
117 pa_source *sco_source;
119 pa_hook_slot *sink_state_changed_slot;
120 pa_hook_slot *source_state_changed_slot;
135 pa_bluetooth_discovery *discovery;
137 pa_dbus_connection *connection;
143 pa_thread_mq thread_mq;
145 pa_rtpoll_item *rtpoll_item;
148 uint64_t read_index, write_index;
149 pa_usec_t started_at;
150 pa_smoother *read_smoother;
152 pa_memchunk write_memchunk;
154 pa_sample_spec sample_spec, requested_sample_spec;
162 struct a2dp_info a2dp;
165 enum profile profile;
169 int stream_write_type, stream_read_type;
170 int service_write_type, service_read_type;
174 #define USE_SCO_OVER_PCM(u) (u->profile == PROFILE_HSP && (u->hsp.sco_sink && u->hsp.sco_source))
177 static int init_bt(struct userdata *u);
178 static int init_profile(struct userdata *u);
180 static int service_send(struct userdata *u, const bt_audio_msg_header_t *msg) {
184 pa_assert(u->service_fd >= 0);
186 pa_assert(msg->length > 0);
188 pa_log_debug("Sending %s -> %s",
189 pa_strnull(bt_audio_strtype(msg->type)),
190 pa_strnull(bt_audio_strname(msg->name)));
192 if ((r = pa_loop_write(u->service_fd, msg, msg->length, &u->service_write_type)) == (ssize_t) msg->length)
196 pa_log_error("Error sending data to audio service: %s", pa_cstrerror(errno));
198 pa_log_error("Short write()");
203 static int service_recv(struct userdata *u, bt_audio_msg_header_t *msg, size_t room) {
207 pa_assert(u->service_fd >= 0);
211 room = BT_SUGGESTED_BUFFER_SIZE;
213 pa_log_debug("Trying to receive message from audio service...");
215 /* First, read the header */
216 if ((r = pa_loop_read(u->service_fd, msg, sizeof(*msg), &u->service_read_type)) != sizeof(*msg))
219 if (msg->length < sizeof(*msg)) {
220 pa_log_error("Invalid message size.");
224 /* Secondly, read the payload */
225 if (msg->length > sizeof(*msg)) {
227 size_t remains = msg->length - sizeof(*msg);
229 if ((r = pa_loop_read(u->service_fd,
230 (uint8_t*) msg + sizeof(*msg),
232 &u->service_read_type)) != (ssize_t) remains)
236 pa_log_debug("Received %s <- %s",
237 pa_strnull(bt_audio_strtype(msg->type)),
238 pa_strnull(bt_audio_strname(msg->name)));
245 pa_log_error("Error receiving data from audio service: %s", pa_cstrerror(errno));
247 pa_log_error("Short read()");
252 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) {
256 pa_assert(u->service_fd >= 0);
259 if ((r = service_recv(u, rsp, room)) < 0)
262 if ((rsp->type != BT_INDICATION && rsp->type != BT_RESPONSE) ||
263 rsp->name != expected_name ||
264 (expected_size > 0 && rsp->length != expected_size)) {
266 if (rsp->type == BT_ERROR && rsp->length == sizeof(bt_audio_error_t))
267 pa_log_error("Received error condition: %s", pa_cstrerror(((bt_audio_error_t*) rsp)->posix_errno));
269 pa_log_error("Bogus message %s received while %s was expected",
270 pa_strnull(bt_audio_strname(rsp->name)),
271 pa_strnull(bt_audio_strname(expected_name)));
278 static int parse_caps(struct userdata *u, uint8_t seid, const struct bt_get_capabilities_rsp *rsp) {
280 const codec_capabilities_t *codec;
285 bytes_left = rsp->h.length - sizeof(*rsp);
287 if (bytes_left < sizeof(codec_capabilities_t)) {
288 pa_log_error("Packet too small to store codec information.");
292 codec = (codec_capabilities_t *) rsp->data; /** ALIGNMENT? **/
294 pa_log_debug("Payload size is %lu %lu", (unsigned long) bytes_left, (unsigned long) sizeof(*codec));
296 if ((u->profile == PROFILE_A2DP && codec->transport != BT_CAPABILITIES_TRANSPORT_A2DP) ||
297 (u->profile == PROFILE_HSP && codec->transport != BT_CAPABILITIES_TRANSPORT_SCO)) {
298 pa_log_error("Got capabilities for wrong codec.");
302 if (u->profile == PROFILE_HSP) {
304 if (bytes_left <= 0 || codec->length != sizeof(u->hsp.pcm_capabilities))
307 pa_assert(codec->type == BT_HFP_CODEC_PCM);
309 if (codec->configured && seid == 0)
312 memcpy(&u->hsp.pcm_capabilities, codec, sizeof(u->hsp.pcm_capabilities));
314 } else if (u->profile == PROFILE_A2DP) {
316 while (bytes_left > 0) {
317 if ((codec->type == BT_A2DP_SBC_SINK) && !codec->lock)
320 bytes_left -= codec->length;
321 codec = (const codec_capabilities_t*) ((const uint8_t*) codec + codec->length);
324 if (bytes_left <= 0 || codec->length != sizeof(u->a2dp.sbc_capabilities))
327 pa_assert(codec->type == BT_A2DP_SBC_SINK);
329 if (codec->configured && seid == 0)
332 memcpy(&u->a2dp.sbc_capabilities, codec, sizeof(u->a2dp.sbc_capabilities));
338 static int get_caps(struct userdata *u, uint8_t seid) {
340 struct bt_get_capabilities_req getcaps_req;
341 struct bt_get_capabilities_rsp getcaps_rsp;
342 bt_audio_error_t error;
343 uint8_t buf[BT_SUGGESTED_BUFFER_SIZE];
349 memset(&msg, 0, sizeof(msg));
350 msg.getcaps_req.h.type = BT_REQUEST;
351 msg.getcaps_req.h.name = BT_GET_CAPABILITIES;
352 msg.getcaps_req.h.length = sizeof(msg.getcaps_req);
353 msg.getcaps_req.seid = seid;
355 pa_strlcpy(msg.getcaps_req.object, u->path, sizeof(msg.getcaps_req.object));
356 if (u->profile == PROFILE_A2DP)
357 msg.getcaps_req.transport = BT_CAPABILITIES_TRANSPORT_A2DP;
359 pa_assert(u->profile == PROFILE_HSP);
360 msg.getcaps_req.transport = BT_CAPABILITIES_TRANSPORT_SCO;
362 msg.getcaps_req.flags = BT_FLAG_AUTOCONNECT;
364 if (service_send(u, &msg.getcaps_req.h) < 0)
367 if (service_expect(u, &msg.getcaps_rsp.h, sizeof(msg), BT_GET_CAPABILITIES, 0) < 0)
370 ret = parse_caps(u, seid, &msg.getcaps_rsp);
374 return get_caps(u, ret);
377 static uint8_t a2dp_default_bitpool(uint8_t freq, uint8_t mode) {
380 case BT_SBC_SAMPLING_FREQ_16000:
381 case BT_SBC_SAMPLING_FREQ_32000:
384 case BT_SBC_SAMPLING_FREQ_44100:
387 case BT_A2DP_CHANNEL_MODE_MONO:
388 case BT_A2DP_CHANNEL_MODE_DUAL_CHANNEL:
391 case BT_A2DP_CHANNEL_MODE_STEREO:
392 case BT_A2DP_CHANNEL_MODE_JOINT_STEREO:
396 pa_log_warn("Invalid channel mode %u", mode);
400 case BT_SBC_SAMPLING_FREQ_48000:
403 case BT_A2DP_CHANNEL_MODE_MONO:
404 case BT_A2DP_CHANNEL_MODE_DUAL_CHANNEL:
407 case BT_A2DP_CHANNEL_MODE_STEREO:
408 case BT_A2DP_CHANNEL_MODE_JOINT_STEREO:
412 pa_log_warn("Invalid channel mode %u", mode);
417 pa_log_warn("Invalid sampling freq %u", freq);
422 static int setup_a2dp(struct userdata *u) {
423 sbc_capabilities_t *cap;
426 static const struct {
430 { 16000U, BT_SBC_SAMPLING_FREQ_16000 },
431 { 32000U, BT_SBC_SAMPLING_FREQ_32000 },
432 { 44100U, BT_SBC_SAMPLING_FREQ_44100 },
433 { 48000U, BT_SBC_SAMPLING_FREQ_48000 }
437 pa_assert(u->profile == PROFILE_A2DP);
439 cap = &u->a2dp.sbc_capabilities;
441 /* Find the lowest freq that is at least as high as the requested
443 for (i = 0; (unsigned) i < PA_ELEMENTSOF(freq_table); i++)
444 if (freq_table[i].rate >= u->sample_spec.rate && (cap->frequency & freq_table[i].cap)) {
445 u->sample_spec.rate = freq_table[i].rate;
446 cap->frequency = freq_table[i].cap;
450 if ((unsigned) i == PA_ELEMENTSOF(freq_table)) {
451 for (--i; i >= 0; i--) {
452 if (cap->frequency & freq_table[i].cap) {
453 u->sample_spec.rate = freq_table[i].rate;
454 cap->frequency = freq_table[i].cap;
460 pa_log("Not suitable sample rate");
465 pa_assert((unsigned) i < PA_ELEMENTSOF(freq_table));
467 if (cap->capability.configured)
470 if (u->sample_spec.channels <= 1) {
471 if (cap->channel_mode & BT_A2DP_CHANNEL_MODE_MONO) {
472 cap->channel_mode = BT_A2DP_CHANNEL_MODE_MONO;
473 u->sample_spec.channels = 1;
475 u->sample_spec.channels = 2;
478 if (u->sample_spec.channels >= 2) {
479 u->sample_spec.channels = 2;
481 if (cap->channel_mode & BT_A2DP_CHANNEL_MODE_JOINT_STEREO)
482 cap->channel_mode = BT_A2DP_CHANNEL_MODE_JOINT_STEREO;
483 else if (cap->channel_mode & BT_A2DP_CHANNEL_MODE_STEREO)
484 cap->channel_mode = BT_A2DP_CHANNEL_MODE_STEREO;
485 else if (cap->channel_mode & BT_A2DP_CHANNEL_MODE_DUAL_CHANNEL)
486 cap->channel_mode = BT_A2DP_CHANNEL_MODE_DUAL_CHANNEL;
487 else if (cap->channel_mode & BT_A2DP_CHANNEL_MODE_MONO) {
488 cap->channel_mode = BT_A2DP_CHANNEL_MODE_MONO;
489 u->sample_spec.channels = 1;
491 pa_log("No supported channel modes");
496 if (cap->block_length & BT_A2DP_BLOCK_LENGTH_16)
497 cap->block_length = BT_A2DP_BLOCK_LENGTH_16;
498 else if (cap->block_length & BT_A2DP_BLOCK_LENGTH_12)
499 cap->block_length = BT_A2DP_BLOCK_LENGTH_12;
500 else if (cap->block_length & BT_A2DP_BLOCK_LENGTH_8)
501 cap->block_length = BT_A2DP_BLOCK_LENGTH_8;
502 else if (cap->block_length & BT_A2DP_BLOCK_LENGTH_4)
503 cap->block_length = BT_A2DP_BLOCK_LENGTH_4;
505 pa_log_error("No supported block lengths");
509 if (cap->subbands & BT_A2DP_SUBBANDS_8)
510 cap->subbands = BT_A2DP_SUBBANDS_8;
511 else if (cap->subbands & BT_A2DP_SUBBANDS_4)
512 cap->subbands = BT_A2DP_SUBBANDS_4;
514 pa_log_error("No supported subbands");
518 if (cap->allocation_method & BT_A2DP_ALLOCATION_LOUDNESS)
519 cap->allocation_method = BT_A2DP_ALLOCATION_LOUDNESS;
520 else if (cap->allocation_method & BT_A2DP_ALLOCATION_SNR)
521 cap->allocation_method = BT_A2DP_ALLOCATION_SNR;
523 cap->min_bitpool = (uint8_t) PA_MAX(MIN_BITPOOL, cap->min_bitpool);
524 cap->max_bitpool = (uint8_t) PA_MIN(a2dp_default_bitpool(cap->frequency, cap->channel_mode), cap->max_bitpool);
529 static void setup_sbc(struct a2dp_info *a2dp) {
530 sbc_capabilities_t *active_capabilities;
534 active_capabilities = &a2dp->sbc_capabilities;
536 if (a2dp->sbc_initialized)
537 sbc_reinit(&a2dp->sbc, 0);
539 sbc_init(&a2dp->sbc, 0);
540 a2dp->sbc_initialized = TRUE;
542 switch (active_capabilities->frequency) {
543 case BT_SBC_SAMPLING_FREQ_16000:
544 a2dp->sbc.frequency = SBC_FREQ_16000;
546 case BT_SBC_SAMPLING_FREQ_32000:
547 a2dp->sbc.frequency = SBC_FREQ_32000;
549 case BT_SBC_SAMPLING_FREQ_44100:
550 a2dp->sbc.frequency = SBC_FREQ_44100;
552 case BT_SBC_SAMPLING_FREQ_48000:
553 a2dp->sbc.frequency = SBC_FREQ_48000;
556 pa_assert_not_reached();
559 switch (active_capabilities->channel_mode) {
560 case BT_A2DP_CHANNEL_MODE_MONO:
561 a2dp->sbc.mode = SBC_MODE_MONO;
563 case BT_A2DP_CHANNEL_MODE_DUAL_CHANNEL:
564 a2dp->sbc.mode = SBC_MODE_DUAL_CHANNEL;
566 case BT_A2DP_CHANNEL_MODE_STEREO:
567 a2dp->sbc.mode = SBC_MODE_STEREO;
569 case BT_A2DP_CHANNEL_MODE_JOINT_STEREO:
570 a2dp->sbc.mode = SBC_MODE_JOINT_STEREO;
573 pa_assert_not_reached();
576 switch (active_capabilities->allocation_method) {
577 case BT_A2DP_ALLOCATION_SNR:
578 a2dp->sbc.allocation = SBC_AM_SNR;
580 case BT_A2DP_ALLOCATION_LOUDNESS:
581 a2dp->sbc.allocation = SBC_AM_LOUDNESS;
584 pa_assert_not_reached();
587 switch (active_capabilities->subbands) {
588 case BT_A2DP_SUBBANDS_4:
589 a2dp->sbc.subbands = SBC_SB_4;
591 case BT_A2DP_SUBBANDS_8:
592 a2dp->sbc.subbands = SBC_SB_8;
595 pa_assert_not_reached();
598 switch (active_capabilities->block_length) {
599 case BT_A2DP_BLOCK_LENGTH_4:
600 a2dp->sbc.blocks = SBC_BLK_4;
602 case BT_A2DP_BLOCK_LENGTH_8:
603 a2dp->sbc.blocks = SBC_BLK_8;
605 case BT_A2DP_BLOCK_LENGTH_12:
606 a2dp->sbc.blocks = SBC_BLK_12;
608 case BT_A2DP_BLOCK_LENGTH_16:
609 a2dp->sbc.blocks = SBC_BLK_16;
612 pa_assert_not_reached();
615 a2dp->sbc.bitpool = active_capabilities->max_bitpool;
616 a2dp->codesize = sbc_get_codesize(&a2dp->sbc);
617 a2dp->frame_length = sbc_get_frame_length(&a2dp->sbc);
620 static int set_conf(struct userdata *u) {
622 struct bt_open_req open_req;
623 struct bt_open_rsp open_rsp;
624 struct bt_set_configuration_req setconf_req;
625 struct bt_set_configuration_rsp setconf_rsp;
626 bt_audio_error_t error;
627 uint8_t buf[BT_SUGGESTED_BUFFER_SIZE];
630 memset(&msg, 0, sizeof(msg));
631 msg.open_req.h.type = BT_REQUEST;
632 msg.open_req.h.name = BT_OPEN;
633 msg.open_req.h.length = sizeof(msg.open_req);
635 pa_strlcpy(msg.open_req.object, u->path, sizeof(msg.open_req.object));
636 msg.open_req.seid = u->profile == PROFILE_A2DP ? u->a2dp.sbc_capabilities.capability.seid : BT_A2DP_SEID_RANGE + 1;
637 msg.open_req.lock = u->profile == PROFILE_A2DP ? BT_WRITE_LOCK : BT_READ_LOCK | BT_WRITE_LOCK;
639 if (service_send(u, &msg.open_req.h) < 0)
642 if (service_expect(u, &msg.open_rsp.h, sizeof(msg), BT_OPEN, sizeof(msg.open_rsp)) < 0)
645 if (u->profile == PROFILE_A2DP ) {
646 u->sample_spec.format = PA_SAMPLE_S16LE;
648 if (setup_a2dp(u) < 0)
651 pa_assert(u->profile == PROFILE_HSP);
653 u->sample_spec.format = PA_SAMPLE_S16LE;
654 u->sample_spec.channels = 1;
655 u->sample_spec.rate = 8000;
658 memset(&msg, 0, sizeof(msg));
659 msg.setconf_req.h.type = BT_REQUEST;
660 msg.setconf_req.h.name = BT_SET_CONFIGURATION;
661 msg.setconf_req.h.length = sizeof(msg.setconf_req);
663 if (u->profile == PROFILE_A2DP) {
664 memcpy(&msg.setconf_req.codec, &u->a2dp.sbc_capabilities, sizeof(u->a2dp.sbc_capabilities));
666 msg.setconf_req.codec.transport = BT_CAPABILITIES_TRANSPORT_SCO;
667 msg.setconf_req.codec.seid = BT_A2DP_SEID_RANGE + 1;
668 msg.setconf_req.codec.length = sizeof(pcm_capabilities_t);
670 msg.setconf_req.h.length += msg.setconf_req.codec.length - sizeof(msg.setconf_req.codec);
672 if (service_send(u, &msg.setconf_req.h) < 0)
675 if (service_expect(u, &msg.setconf_rsp.h, sizeof(msg), BT_SET_CONFIGURATION, sizeof(msg.setconf_rsp)) < 0)
678 u->link_mtu = msg.setconf_rsp.link_mtu;
680 /* setup SBC encoder now we agree on parameters */
681 if (u->profile == PROFILE_A2DP) {
685 ((u->link_mtu - sizeof(struct rtp_header) - sizeof(struct rtp_payload))
686 / u->a2dp.frame_length
689 pa_log_info("SBC parameters:\n\tallocation=%u\n\tsubbands=%u\n\tblocks=%u\n\tbitpool=%u\n",
690 u->a2dp.sbc.allocation, u->a2dp.sbc.subbands, u->a2dp.sbc.blocks, u->a2dp.sbc.bitpool);
692 u->block_size = u->link_mtu;
697 /* from IO thread, except in SCO over PCM */
698 static int start_stream_fd(struct userdata *u) {
700 bt_audio_msg_header_t rsp;
701 struct bt_start_stream_req start_req;
702 struct bt_start_stream_rsp start_rsp;
703 struct bt_new_stream_ind streamfd_ind;
704 bt_audio_error_t error;
705 uint8_t buf[BT_SUGGESTED_BUFFER_SIZE];
707 struct pollfd *pollfd;
710 pa_assert(u->rtpoll);
711 pa_assert(!u->rtpoll_item);
712 pa_assert(u->stream_fd < 0);
714 memset(msg.buf, 0, BT_SUGGESTED_BUFFER_SIZE);
715 msg.start_req.h.type = BT_REQUEST;
716 msg.start_req.h.name = BT_START_STREAM;
717 msg.start_req.h.length = sizeof(msg.start_req);
719 if (service_send(u, &msg.start_req.h) < 0)
722 if (service_expect(u, &msg.rsp, sizeof(msg), BT_START_STREAM, sizeof(msg.start_rsp)) < 0)
725 if (service_expect(u, &msg.rsp, sizeof(msg), BT_NEW_STREAM, sizeof(msg.streamfd_ind)) < 0)
728 if ((u->stream_fd = bt_audio_service_get_data_fd(u->service_fd)) < 0) {
729 pa_log("Failed to get stream fd from audio service.");
733 pa_make_fd_nonblock(u->stream_fd);
734 pa_make_socket_low_delay(u->stream_fd);
736 u->rtpoll_item = pa_rtpoll_item_new(u->rtpoll, PA_RTPOLL_NEVER, 1);
737 pollfd = pa_rtpoll_item_get_pollfd(u->rtpoll_item, NULL);
738 pollfd->fd = u->stream_fd;
739 pollfd->events = pollfd->revents = 0;
748 static int stop_stream_fd(struct userdata *u) {
750 bt_audio_msg_header_t rsp;
751 struct bt_stop_stream_req start_req;
752 struct bt_stop_stream_rsp start_rsp;
753 bt_audio_error_t error;
754 uint8_t buf[BT_SUGGESTED_BUFFER_SIZE];
759 pa_assert(u->rtpoll);
760 pa_assert(u->rtpoll_item);
761 pa_assert(u->stream_fd >= 0);
763 pa_rtpoll_item_free(u->rtpoll_item);
764 u->rtpoll_item = NULL;
766 memset(msg.buf, 0, BT_SUGGESTED_BUFFER_SIZE);
767 msg.start_req.h.type = BT_REQUEST;
768 msg.start_req.h.name = BT_STOP_STREAM;
769 msg.start_req.h.length = sizeof(msg.start_req);
771 if (service_send(u, &msg.start_req.h) < 0 ||
772 service_expect(u, &msg.rsp, sizeof(msg), BT_STOP_STREAM, sizeof(msg.start_rsp)) < 0)
775 pa_close(u->stream_fd);
781 static int sink_process_msg(pa_msgobject *o, int code, void *data, int64_t offset, pa_memchunk *chunk) {
782 struct userdata *u = PA_SINK(o)->userdata;
783 pa_bool_t failed = FALSE;
786 pa_assert(u->sink == PA_SINK(o));
788 pa_log_debug("got message: %d", code);
791 case PA_SINK_MESSAGE_SET_STATE:
793 switch ((pa_sink_state_t) PA_PTR_TO_UINT(data)) {
795 case PA_SINK_SUSPENDED:
796 pa_assert(PA_SINK_IS_OPENED(u->sink->thread_info.state));
798 /* Stop the device if the source is suspended as well */
799 if (!u->source || u->source->state == PA_SOURCE_SUSPENDED)
800 /* We deliberately ignore whether stopping
801 * actually worked. Since the stream_fd is
802 * closed it doesn't really matter */
808 case PA_SINK_RUNNING:
809 if (u->sink->thread_info.state != PA_SINK_SUSPENDED)
812 /* Resume the device if the source was suspended as well */
813 if (!u->source || u->source->state == PA_SOURCE_SUSPENDED)
814 if (start_stream_fd(u) < 0)
817 u->started_at = pa_rtclock_usec();
820 case PA_SINK_UNLINKED:
822 case PA_SINK_INVALID_STATE:
827 case PA_SINK_MESSAGE_GET_LATENCY: {
828 *((pa_usec_t*) data) = 0;
833 r = pa_sink_process_msg(o, code, data, offset, chunk);
835 return (r < 0 || !failed) ? r : -1;
838 static int source_process_msg(pa_msgobject *o, int code, void *data, int64_t offset, pa_memchunk *chunk) {
839 struct userdata *u = PA_SOURCE(o)->userdata;
840 pa_bool_t failed = FALSE;
843 pa_assert(u->source == PA_SOURCE(o));
845 pa_log_debug("got message: %d", code);
848 case PA_SOURCE_MESSAGE_SET_STATE:
850 switch ((pa_source_state_t) PA_PTR_TO_UINT(data)) {
852 case PA_SOURCE_SUSPENDED:
853 pa_assert(PA_SOURCE_IS_OPENED(u->source->thread_info.state));
855 /* Stop the device if the sink is suspended as well */
856 if (!u->sink || u->sink->state == PA_SINK_SUSPENDED)
859 pa_smoother_pause(u->read_smoother, pa_rtclock_usec());
863 case PA_SOURCE_RUNNING:
864 if (u->source->thread_info.state != PA_SOURCE_SUSPENDED)
867 /* Resume the device if the sink was suspended as well */
868 if (!u->sink || u->sink->thread_info.state == PA_SINK_SUSPENDED)
869 if (start_stream_fd(u) < 0)
872 pa_smoother_resume(u->read_smoother, pa_rtclock_usec(), TRUE);
875 case PA_SOURCE_UNLINKED:
877 case PA_SOURCE_INVALID_STATE:
882 case PA_SOURCE_MESSAGE_GET_LATENCY: {
883 *((pa_usec_t*) data) = 0;
889 r = pa_source_process_msg(o, code, data, offset, chunk);
891 return (r < 0 || !failed) ? r : -1;
894 static int hsp_process_render(struct userdata *u) {
898 pa_assert(u->profile == PROFILE_HSP);
901 /* First, render some data */
902 if (!u->write_memchunk.memblock)
903 pa_sink_render_full(u->sink, u->block_size, &u->write_memchunk);
905 pa_assert(u->write_memchunk.length == u->block_size);
911 /* Now write that data to the socket. The socket is of type
912 * SEQPACKET, and we generated the data of the MTU size, so this
913 * should just work. */
915 p = (const uint8_t*) pa_memblock_acquire(u->write_memchunk.memblock) + u->write_memchunk.index;
916 l = pa_write(u->stream_fd, p, u->write_memchunk.length, &u->stream_write_type);
917 pa_memblock_release(u->write_memchunk.memblock);
924 /* Retry right away if we got interrupted */
927 else if (errno == EAGAIN)
928 /* Hmm, apparently the socket was not writable, give up for now */
931 pa_log_error("Failed to write data to SCO socket: %s", pa_cstrerror(errno));
936 pa_assert((size_t) l <= u->write_memchunk.length);
938 if ((size_t) l != u->write_memchunk.length) {
939 pa_log_error("Wrote memory block to socket only partially! %llu written, wanted to write %llu.",
940 (unsigned long long) l,
941 (unsigned long long) u->write_memchunk.length);
946 u->write_index += (uint64_t) u->write_memchunk.length;
947 pa_memblock_unref(u->write_memchunk.memblock);
948 pa_memchunk_reset(&u->write_memchunk);
956 static int hsp_process_push(struct userdata *u) {
958 pa_memchunk memchunk;
961 pa_assert(u->profile == PROFILE_HSP);
962 pa_assert(u->source);
964 memchunk.memblock = pa_memblock_new(u->core->mempool, u->block_size);
965 memchunk.index = memchunk.length = 0;
971 p = pa_memblock_acquire(memchunk.memblock);
972 l = pa_read(u->stream_fd, p, pa_memblock_get_length(memchunk.memblock), &u->stream_read_type);
973 pa_memblock_release(memchunk.memblock);
977 if (l < 0 && errno == EINTR)
978 /* Retry right away if we got interrupted */
981 else if (l < 0 && errno == EAGAIN)
982 /* Hmm, apparently the socket was not readable, give up for now. */
985 pa_log_error("Failed to read data from SCO socket: %s", l < 0 ? pa_cstrerror(errno) : "EOF");
990 pa_assert((size_t) l <= pa_memblock_get_length(memchunk.memblock));
992 memchunk.length = (size_t) l;
993 u->read_index += (uint64_t) l;
995 pa_source_post(u->source, &memchunk);
999 pa_memblock_unref(memchunk.memblock);
1004 static void a2dp_prepare_buffer(struct userdata *u) {
1007 if (u->a2dp.buffer_size >= u->link_mtu)
1010 u->a2dp.buffer_size = 2 * u->link_mtu;
1011 pa_xfree(u->a2dp.buffer);
1012 u->a2dp.buffer = pa_xmalloc(u->a2dp.buffer_size);
1015 static int a2dp_process_render(struct userdata *u) {
1016 struct a2dp_info *a2dp;
1017 struct rtp_header *header;
1018 struct rtp_payload *payload;
1022 size_t to_write, to_encode;
1023 unsigned frame_count;
1027 pa_assert(u->profile == PROFILE_A2DP);
1030 /* First, render some data */
1031 if (!u->write_memchunk.memblock)
1032 pa_sink_render_full(u->sink, u->block_size, &u->write_memchunk);
1034 pa_assert(u->write_memchunk.length == u->block_size);
1036 a2dp_prepare_buffer(u);
1039 header = a2dp->buffer;
1040 payload = (struct rtp_payload*) ((uint8_t*) a2dp->buffer + sizeof(*header));
1044 /* Try to create a packet of the full MTU */
1046 p = (const uint8_t*) pa_memblock_acquire(u->write_memchunk.memblock) + u->write_memchunk.index;
1047 to_encode = u->write_memchunk.length;
1049 d = (uint8_t*) a2dp->buffer + sizeof(*header) + sizeof(*payload);
1050 to_write = a2dp->buffer_size - sizeof(*header) - sizeof(*payload);
1052 while (PA_LIKELY(to_encode > 0 && to_write > 0)) {
1056 encoded = sbc_encode(&a2dp->sbc,
1061 if (PA_UNLIKELY(encoded <= 0)) {
1062 pa_log_error("SBC encoding error (%li)", (long) encoded);
1063 pa_memblock_release(u->write_memchunk.memblock);
1067 /* pa_log_debug("SBC: encoded: %lu; written: %lu", (unsigned long) encoded, (unsigned long) written); */
1068 /* pa_log_debug("SBC: codesize: %lu; frame_length: %lu", (unsigned long) a2dp->codesize, (unsigned long) a2dp->frame_length); */
1070 pa_assert_fp((size_t) encoded <= to_encode);
1071 pa_assert_fp((size_t) encoded == a2dp->codesize);
1073 pa_assert_fp((size_t) written <= to_write);
1074 pa_assert_fp((size_t) written == a2dp->frame_length);
1076 p = (const uint8_t*) p + encoded;
1077 to_encode -= encoded;
1079 d = (uint8_t*) d + written;
1080 to_write -= written;
1085 pa_memblock_release(u->write_memchunk.memblock);
1087 pa_assert(to_encode == 0);
1090 pa_log_debug("Using SBC encoder implementation: %s", pa_strnull(sbc_get_implementation_info(&a2dp->sbc)));
1093 /* write it to the fifo */
1094 memset(a2dp->buffer, 0, sizeof(*header) + sizeof(*payload));
1097 header->sequence_number = htons(a2dp->seq_num++);
1098 header->timestamp = htonl(u->write_index / pa_frame_size(&u->sink->sample_spec));
1099 header->ssrc = htonl(1);
1100 payload->frame_count = frame_count;
1102 nbytes = (uint8_t*) d - (uint8_t*) a2dp->buffer;
1107 l = pa_write(u->stream_fd, a2dp->buffer, nbytes, &u->stream_write_type);
1114 /* Retry right away if we got interrupted */
1117 else if (errno == EAGAIN)
1118 /* Hmm, apparently the socket was not writable, give up for now */
1121 pa_log_error("Failed to write data to socket: %s", pa_cstrerror(errno));
1126 pa_assert((size_t) l <= nbytes);
1128 if ((size_t) l != nbytes) {
1129 pa_log_warn("Wrote memory block to socket only partially! %llu written, wanted to write %llu.",
1130 (unsigned long long) l,
1131 (unsigned long long) nbytes);
1136 u->write_index += (uint64_t) u->write_memchunk.length;
1137 pa_memblock_unref(u->write_memchunk.memblock);
1138 pa_memchunk_reset(&u->write_memchunk);
1146 static void thread_func(void *userdata) {
1147 struct userdata *u = userdata;
1148 pa_bool_t do_write = FALSE, writable = FALSE;
1152 pa_log_debug("IO Thread starting up");
1154 if (u->core->realtime_scheduling)
1155 pa_make_realtime(u->core->realtime_priority);
1157 if (start_stream_fd(u) < 0)
1160 pa_thread_mq_install(&u->thread_mq);
1161 pa_rtpoll_install(u->rtpoll);
1163 pa_smoother_set_time_offset(u->read_smoother, pa_rtclock_usec());
1166 struct pollfd *pollfd;
1168 pa_bool_t disable_timer = TRUE;
1170 pollfd = u->rtpoll_item ? pa_rtpoll_item_get_pollfd(u->rtpoll_item, NULL) : NULL;
1172 if (u->source && PA_SOURCE_IS_LINKED(u->source->thread_info.state)) {
1174 if (pollfd && (pollfd->revents & POLLIN)) {
1176 if (hsp_process_push(u) < 0)
1179 /* We just read something, so we are supposed to write something, too */
1184 if (u->sink && PA_SINK_IS_LINKED(u->sink->thread_info.state)) {
1186 if (u->sink->thread_info.rewind_requested)
1187 pa_sink_process_rewind(u->sink, 0);
1190 if (pollfd->revents & POLLOUT)
1193 if ((!u->source || !PA_SOURCE_IS_LINKED(u->source->thread_info.state)) && !do_write && writable) {
1194 pa_usec_t time_passed;
1195 uint64_t should_have_written;
1197 /* Hmm, there is no input stream we could synchronize
1198 * to. So let's do things by time */
1200 time_passed = pa_rtclock_usec() - u->started_at;
1201 should_have_written = pa_usec_to_bytes(time_passed, &u->sink->sample_spec);
1203 do_write = u->write_index <= should_have_written ;
1204 /* pa_log_debug("Time has come: %s", pa_yes_no(do_write)); */
1207 if (writable && do_write) {
1208 if (u->write_index == 0)
1209 u->started_at = pa_rtclock_usec();
1211 if (u->profile == PROFILE_A2DP) {
1212 if (a2dp_process_render(u) < 0)
1215 if (hsp_process_render(u) < 0)
1223 if ((!u->source || !PA_SOURCE_IS_LINKED(u->source->thread_info.state)) && !do_write) {
1224 pa_usec_t time_passed, next_write_at, sleep_for;
1226 /* Hmm, there is no input stream we could synchronize
1227 * to. So let's estimate when we need to wake up the latest */
1229 time_passed = pa_rtclock_usec() - u->started_at;
1230 next_write_at = pa_bytes_to_usec(u->write_index, &u->sink->sample_spec);
1231 sleep_for = time_passed < next_write_at ? next_write_at - time_passed : 0;
1233 /* 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); */
1235 pa_rtpoll_set_timer_relative(u->rtpoll, sleep_for);
1236 disable_timer = FALSE;
1242 pa_rtpoll_set_timer_disabled(u->rtpoll);
1244 /* Hmm, nothing to do. Let's sleep */
1246 pollfd->events = (short) (((u->sink && PA_SINK_IS_LINKED(u->sink->thread_info.state) && !writable) ? POLLOUT : 0) |
1247 (u->source && PA_SOURCE_IS_LINKED(u->source->thread_info.state) ? POLLIN : 0));
1249 if ((ret = pa_rtpoll_run(u->rtpoll, TRUE)) < 0)
1255 pollfd = u->rtpoll_item ? pa_rtpoll_item_get_pollfd(u->rtpoll_item, NULL) : NULL;
1257 if (pollfd && (pollfd->revents & ~(POLLOUT|POLLIN))) {
1258 pa_log_error("FD error.");
1264 /* If this was no regular exit from the loop we have to continue processing messages until we receive PA_MESSAGE_SHUTDOWN */
1265 pa_log_debug("IO thread failed");
1266 pa_asyncmsgq_post(u->thread_mq.outq, PA_MSGOBJECT(u->core), PA_CORE_MESSAGE_UNLOAD_MODULE, u->module, 0, NULL, NULL);
1267 pa_asyncmsgq_wait_for(u->thread_mq.inq, PA_MESSAGE_SHUTDOWN);
1270 pa_log_debug("IO thread shutting down");
1273 static DBusHandlerResult filter_cb(DBusConnection *bus, DBusMessage *m, void *userdata) {
1279 pa_assert_se(u = userdata);
1281 dbus_error_init(&err);
1283 pa_log_debug("dbus: interface=%s, path=%s, member=%s\n",
1284 dbus_message_get_interface(m),
1285 dbus_message_get_path(m),
1286 dbus_message_get_member(m));
1288 if (!dbus_message_has_path(m, u->path))
1291 if (dbus_message_is_signal(m, "org.bluez.Headset", "SpeakerGainChanged") ||
1292 dbus_message_is_signal(m, "org.bluez.Headset", "MicrophoneGainChanged")) {
1297 if (!dbus_message_get_args(m, &err, DBUS_TYPE_UINT16, &gain, DBUS_TYPE_INVALID) || gain > 15) {
1298 pa_log("Failed to parse org.bluez.Headset.{Speaker|Microphone}GainChanged: %s", err.message);
1302 if (u->profile == PROFILE_HSP) {
1303 if (u->sink && dbus_message_is_signal(m, "org.bluez.Headset", "SpeakerGainChanged")) {
1305 pa_cvolume_set(&v, u->sink->sample_spec.channels, (pa_volume_t) (gain * PA_VOLUME_NORM / 15));
1306 pa_sink_volume_changed(u->sink, &v);
1308 } else if (u->source && dbus_message_is_signal(m, "org.bluez.Headset", "MicrophoneGainChanged")) {
1310 pa_cvolume_set(&v, u->sink->sample_spec.channels, (pa_volume_t) (gain * PA_VOLUME_NORM / 15));
1311 pa_source_volume_changed(u->source, &v);
1317 dbus_error_free(&err);
1319 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1322 static void sink_set_volume_cb(pa_sink *s) {
1323 struct userdata *u = s->userdata;
1329 if (u->profile != PROFILE_HSP)
1332 gain = (pa_cvolume_max(&s->virtual_volume) * 15) / PA_VOLUME_NORM;
1337 pa_cvolume_set(&s->virtual_volume, u->sink->sample_spec.channels, (pa_volume_t) (gain * PA_VOLUME_NORM / 15));
1339 pa_assert_se(m = dbus_message_new_method_call("org.bluez", u->path, "org.bluez.Headset", "SetSpeakerGain"));
1340 pa_assert_se(dbus_message_append_args(m, DBUS_TYPE_UINT16, &gain, DBUS_TYPE_INVALID));
1341 pa_assert_se(dbus_connection_send(pa_dbus_connection_get(u->connection), m, NULL));
1342 dbus_message_unref(m);
1345 static void source_set_volume_cb(pa_source *s) {
1346 struct userdata *u = s->userdata;
1352 if (u->profile != PROFILE_HSP)
1355 gain = (pa_cvolume_max(&s->virtual_volume) * 15) / PA_VOLUME_NORM;
1360 pa_cvolume_set(&s->virtual_volume, u->source->sample_spec.channels, (pa_volume_t) (gain * PA_VOLUME_NORM / 15));
1362 pa_assert_se(m = dbus_message_new_method_call("org.bluez", u->path, "org.bluez.Headset", "SetMicrophoneGain"));
1363 pa_assert_se(dbus_message_append_args(m, DBUS_TYPE_UINT16, &gain, DBUS_TYPE_INVALID));
1364 pa_assert_se(dbus_connection_send(pa_dbus_connection_get(u->connection), m, NULL));
1365 dbus_message_unref(m);
1368 static char *get_name(const char *type, pa_modargs *ma, const char *device_id, pa_bool_t *namereg_fail) {
1374 pa_assert(device_id);
1375 pa_assert(namereg_fail);
1377 t = pa_sprintf_malloc("%s_name", type);
1378 n = pa_modargs_get_value(ma, t, NULL);
1382 *namereg_fail = TRUE;
1383 return pa_xstrdup(n);
1386 if ((n = pa_modargs_get_value(ma, "name", NULL)))
1387 *namereg_fail = TRUE;
1390 *namereg_fail = FALSE;
1393 return pa_sprintf_malloc("bluez_%s.%s", type, n);
1398 static void sco_over_pcm_state_update(struct userdata *u) {
1400 pa_assert(USE_SCO_OVER_PCM(u));
1402 if (PA_SINK_IS_OPENED(pa_sink_get_state(u->hsp.sco_sink)) ||
1403 PA_SOURCE_IS_OPENED(pa_source_get_state(u->hsp.sco_source))) {
1405 if (u->service_fd >= 0)
1408 pa_log_debug("Resuming SCO over PCM");
1409 if ((init_bt(u) < 0) || (init_profile(u) < 0))
1410 pa_log("Can't resume SCO over PCM");
1415 if (u->service_fd < 0)
1420 pa_log_debug("Closing SCO over PCM");
1421 pa_close(u->service_fd);
1426 static pa_hook_result_t sink_state_changed_cb(pa_core *c, pa_sink *s, struct userdata *u) {
1428 pa_sink_assert_ref(s);
1431 if (s != u->hsp.sco_sink)
1434 sco_over_pcm_state_update(u);
1439 static pa_hook_result_t source_state_changed_cb(pa_core *c, pa_source *s, struct userdata *u) {
1441 pa_source_assert_ref(s);
1444 if (s != u->hsp.sco_source)
1447 sco_over_pcm_state_update(u);
1454 static int add_sink(struct userdata *u) {
1457 if (USE_SCO_OVER_PCM(u)) {
1460 u->sink = u->hsp.sco_sink;
1461 p = pa_proplist_new();
1462 pa_proplist_sets(p, "bluetooth.protocol", "sco");
1463 pa_proplist_update(u->sink->proplist, PA_UPDATE_MERGE, p);
1464 pa_proplist_free(p);
1466 if (!u->hsp.sink_state_changed_slot)
1467 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);
1473 pa_sink_new_data data;
1476 pa_sink_new_data_init(&data);
1477 data.driver = __FILE__;
1478 data.module = u->module;
1479 pa_sink_new_data_set_sample_spec(&data, &u->sample_spec);
1480 pa_proplist_sets(data.proplist, "bluetooth.protocol", u->profile == PROFILE_A2DP ? "a2dp" : "sco");
1481 data.card = u->card;
1482 data.name = get_name("sink", u->modargs, u->address, &b);
1483 data.namereg_fail = b;
1485 u->sink = pa_sink_new(u->core, &data, PA_SINK_HARDWARE|PA_SINK_LATENCY | (u->profile == PROFILE_HSP ? PA_SINK_HW_VOLUME_CTRL : 0));
1486 pa_sink_new_data_done(&data);
1489 pa_log_error("Failed to create sink");
1493 u->sink->userdata = u;
1494 u->sink->parent.process_msg = sink_process_msg;
1497 if (u->profile == PROFILE_HSP) {
1498 u->sink->set_volume = sink_set_volume_cb;
1499 u->sink->n_volume_steps = 16;
1505 static int add_source(struct userdata *u) {
1508 if (USE_SCO_OVER_PCM(u)) {
1509 u->source = u->hsp.sco_source;
1510 pa_proplist_sets(u->source->proplist, "bluetooth.protocol", "sco");
1512 if (!u->hsp.source_state_changed_slot)
1513 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);
1519 pa_source_new_data data;
1522 pa_source_new_data_init(&data);
1523 data.driver = __FILE__;
1524 data.module = u->module;
1525 pa_source_new_data_set_sample_spec(&data, &u->sample_spec);
1526 pa_proplist_sets(data.proplist, "bluetooth.protocol", u->profile == PROFILE_A2DP ? "a2dp" : "sco");
1527 data.card = u->card;
1528 data.name = get_name("source", u->modargs, u->address, &b);
1529 data.namereg_fail = b;
1531 u->source = pa_source_new(u->core, &data, PA_SOURCE_HARDWARE|PA_SOURCE_LATENCY | (u->profile == PROFILE_HSP ? PA_SOURCE_HW_VOLUME_CTRL : 0));
1532 pa_source_new_data_done(&data);
1535 pa_log_error("Failed to create source");
1539 u->source->userdata = u;
1540 u->source->parent.process_msg = source_process_msg;
1543 if (u->profile == PROFILE_HSP) {
1544 pa_proplist_sets(u->source->proplist, "bluetooth.nrec", (u->hsp.pcm_capabilities.flags & BT_PCM_FLAG_NREC) ? "1" : "0");
1545 u->source->set_volume = source_set_volume_cb;
1546 u->source->n_volume_steps = 16;
1552 static void shutdown_bt(struct userdata *u) {
1555 if (u->stream_fd >= 0) {
1556 pa_close(u->stream_fd);
1559 u->stream_write_type = 0;
1560 u->stream_read_type = 0;
1563 if (u->service_fd >= 0) {
1564 pa_close(u->service_fd);
1568 if (u->write_memchunk.memblock) {
1569 pa_memblock_unref(u->write_memchunk.memblock);
1570 pa_memchunk_reset(&u->write_memchunk);
1574 static int init_bt(struct userdata *u) {
1579 u->stream_write_type = u->stream_read_type = 0;
1580 u->service_write_type = u->service_write_type = 0;
1582 if ((u->service_fd = bt_audio_service_open()) < 0) {
1583 pa_log_error("Couldn't connect to bluetooth audio service");
1587 pa_log_debug("Connected to the bluetooth audio service");
1592 static int setup_bt(struct userdata *u) {
1595 if (get_caps(u, 0) < 0)
1598 pa_log_debug("Got device capabilities");
1600 if (set_conf(u) < 0)
1603 pa_log_debug("Connection to the device configured");
1606 if (USE_SCO_OVER_PCM(u)) {
1607 pa_log_debug("Configured to use SCO over PCM");
1612 pa_log_debug("Got the stream socket");
1617 static int init_profile(struct userdata *u) {
1620 pa_assert(u->profile != PROFILE_OFF);
1622 if (setup_bt(u) < 0)
1625 if (u->profile == PROFILE_A2DP ||
1626 u->profile == PROFILE_HSP)
1627 if (add_sink(u) < 0)
1630 if (u->profile == PROFILE_HSP)
1631 if (add_source(u) < 0)
1637 static void stop_thread(struct userdata *u) {
1641 pa_asyncmsgq_send(u->thread_mq.inq, NULL, PA_MESSAGE_SHUTDOWN, NULL, 0, NULL);
1642 pa_thread_free(u->thread);
1646 if (u->rtpoll_item) {
1647 pa_rtpoll_item_free(u->rtpoll_item);
1648 u->rtpoll_item = NULL;
1651 if (u->hsp.sink_state_changed_slot) {
1652 pa_hook_slot_free(u->hsp.sink_state_changed_slot);
1653 u->hsp.sink_state_changed_slot = NULL;
1656 if (u->hsp.source_state_changed_slot) {
1657 pa_hook_slot_free(u->hsp.source_state_changed_slot);
1658 u->hsp.source_state_changed_slot = NULL;
1662 pa_sink_unref(u->sink);
1667 pa_source_unref(u->source);
1672 pa_thread_mq_done(&u->thread_mq);
1674 pa_rtpoll_free(u->rtpoll);
1679 static int start_thread(struct userdata *u) {
1681 pa_assert(!u->thread);
1682 pa_assert(!u->rtpoll);
1683 pa_assert(!u->rtpoll_item);
1685 u->rtpoll = pa_rtpoll_new();
1686 pa_thread_mq_init(&u->thread_mq, u->core->mainloop, u->rtpoll);
1689 if (USE_SCO_OVER_PCM(u)) {
1690 if (start_stream_fd(u) < 0)
1693 pa_sink_ref(u->sink);
1694 pa_source_ref(u->source);
1695 /* FIXME: monitor stream_fd error */
1700 if (!(u->thread = pa_thread_new(thread_func, u))) {
1701 pa_log_error("Failed to create IO thread");
1707 pa_sink_set_asyncmsgq(u->sink, u->thread_mq.inq);
1708 pa_sink_set_rtpoll(u->sink, u->rtpoll);
1709 pa_sink_put(u->sink);
1711 if (u->sink->set_volume)
1712 u->sink->set_volume(u->sink);
1716 pa_source_set_asyncmsgq(u->source, u->thread_mq.inq);
1717 pa_source_set_rtpoll(u->source, u->rtpoll);
1718 pa_source_put(u->source);
1720 if (u->source->set_volume)
1721 u->source->set_volume(u->source);
1727 static int card_set_profile(pa_card *c, pa_card_profile *new_profile) {
1730 pa_queue *inputs = NULL, *outputs = NULL;
1731 const pa_bluetooth_device *device;
1734 pa_assert(new_profile);
1735 pa_assert_se(u = c->userdata);
1737 d = PA_CARD_PROFILE_DATA(new_profile);
1739 if (!(device = pa_bluetooth_discovery_get_by_path(u->discovery, u->path))) {
1740 pa_log_error("Failed to get device object.");
1744 if (device->headset_state != PA_BT_AUDIO_STATE_CONNECTED && *d == PROFILE_HSP) {
1745 pa_log_warn("HSP is not connected, refused to switch profile");
1748 else if (device->audio_sink_state != PA_BT_AUDIO_STATE_CONNECTED && *d == PROFILE_A2DP) {
1749 pa_log_warn("A2DP is not connected, refused to switch profile");
1754 inputs = pa_sink_move_all_start(u->sink);
1756 if (!USE_SCO_OVER_PCM(u))
1758 pa_sink_unlink(u->sink);
1762 outputs = pa_source_move_all_start(u->source);
1764 if (!USE_SCO_OVER_PCM(u))
1766 pa_source_unlink(u->source);
1773 u->sample_spec = u->requested_sample_spec;
1777 if (u->profile != PROFILE_OFF)
1780 if (u->sink || u->source)
1785 pa_sink_move_all_finish(u->sink, inputs, FALSE);
1787 pa_sink_move_all_fail(inputs);
1792 pa_source_move_all_finish(u->source, outputs, FALSE);
1794 pa_source_move_all_fail(outputs);
1800 static int add_card(struct userdata *u, const char *default_profile, const pa_bluetooth_device *device) {
1801 pa_card_new_data data;
1808 pa_card_new_data_init(&data);
1809 data.driver = __FILE__;
1810 data.module = u->module;
1812 n = pa_bluetooth_cleanup_name(device->name);
1813 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_DESCRIPTION, n);
1815 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_STRING, device->address);
1816 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_API, "bluez");
1817 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_CLASS, "sound");
1818 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_BUS, "bluetooth");
1819 if ((ff = pa_bluetooth_get_form_factor(device->class)))
1820 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_FORM_FACTOR, ff);
1821 pa_proplist_sets(data.proplist, "bluez.path", device->path);
1822 pa_proplist_setf(data.proplist, "bluez.class", "0x%06x", (unsigned) device->class);
1823 pa_proplist_sets(data.proplist, "bluez.name", device->name);
1824 data.name = get_name("card", u->modargs, device->address, &b);
1825 data.namereg_fail = b;
1827 data.profiles = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
1829 /* we base hsp/a2dp availability on UUIDs.
1830 Ideally, it would be based on "Connected" state, but
1831 we can't afford to wait for this information when
1832 we are loaded with profile="hsp", for instance */
1833 if (pa_bluetooth_uuid_has(device->uuids, A2DP_SINK_UUID)) {
1834 p = pa_card_profile_new("a2dp", _("High Fidelity Playback (A2DP)"), sizeof(enum profile));
1838 p->max_sink_channels = 2;
1839 p->max_source_channels = 0;
1841 d = PA_CARD_PROFILE_DATA(p);
1844 pa_hashmap_put(data.profiles, p->name, p);
1847 if (pa_bluetooth_uuid_has(device->uuids, HSP_HS_UUID) ||
1848 pa_bluetooth_uuid_has(device->uuids, HFP_HS_UUID)) {
1849 p = pa_card_profile_new("hsp", _("Telephony Duplex (HSP/HFP)"), sizeof(enum profile));
1853 p->max_sink_channels = 1;
1854 p->max_source_channels = 1;
1856 d = PA_CARD_PROFILE_DATA(p);
1859 pa_hashmap_put(data.profiles, p->name, p);
1862 pa_assert(!pa_hashmap_isempty(data.profiles));
1864 p = pa_card_profile_new("off", _("Off"), sizeof(enum profile));
1865 d = PA_CARD_PROFILE_DATA(p);
1867 pa_hashmap_put(data.profiles, p->name, p);
1869 if (default_profile) {
1870 if (pa_hashmap_get(data.profiles, default_profile))
1871 pa_card_new_data_set_profile(&data, default_profile);
1873 pa_log_warn("Profile '%s' not valid or not supported by device.", default_profile);
1876 u->card = pa_card_new(u->core, &data);
1877 pa_card_new_data_done(&data);
1880 pa_log("Failed to allocate card.");
1884 u->card->userdata = u;
1885 u->card->set_profile = card_set_profile;
1887 d = PA_CARD_PROFILE_DATA(u->card->active_profile);
1893 static const pa_bluetooth_device* find_device(struct userdata *u, const char *address, const char *path) {
1894 const pa_bluetooth_device *d = NULL;
1898 if (!address && !path) {
1899 pa_log_error("Failed to get device address/path from module arguments.");
1904 if (!(d = pa_bluetooth_discovery_get_by_path(u->discovery, path))) {
1905 pa_log_error("%s is not a valid BlueZ audio device.", path);
1909 if (address && !(pa_streq(d->address, address))) {
1910 pa_log_error("Passed path %s and address %s don't match.", path, address);
1915 if (!(d = pa_bluetooth_discovery_get_by_address(u->discovery, address))) {
1916 pa_log_error("%s is not known.", address);
1922 u->address = pa_xstrdup(d->address);
1923 u->path = pa_xstrdup(d->path);
1929 static int setup_dbus(struct userdata *u) {
1932 dbus_error_init(&err);
1934 u->connection = pa_dbus_bus_get(u->core, DBUS_BUS_SYSTEM, &err);
1936 if (dbus_error_is_set(&err) || !u->connection) {
1937 pa_log("Failed to get D-Bus connection: %s", err.message);
1938 dbus_error_free(&err);
1945 int pa__init(pa_module* m) {
1949 const char *address, *path;
1951 char *mike, *speaker;
1952 const pa_bluetooth_device *device;
1956 dbus_error_init(&err);
1958 if (!(ma = pa_modargs_new(m->argument, valid_modargs))) {
1959 pa_log_error("Failed to parse module arguments");
1963 m->userdata = u = pa_xnew0(struct userdata, 1);
1968 u->read_smoother = pa_smoother_new(
1976 u->sample_spec = m->core->default_sample_spec;
1980 if (pa_modargs_get_value(ma, "sco_sink", NULL) &&
1981 !(u->hsp.sco_sink = pa_namereg_get(m->core, pa_modargs_get_value(ma, "sco_sink", NULL), PA_NAMEREG_SINK))) {
1982 pa_log("SCO sink not found");
1986 if (pa_modargs_get_value(ma, "sco_source", NULL) &&
1987 !(u->hsp.sco_source = pa_namereg_get(m->core, pa_modargs_get_value(ma, "sco_source", NULL), PA_NAMEREG_SOURCE))) {
1988 pa_log("SCO source not found");
1993 if (pa_modargs_get_value_u32(ma, "rate", &u->sample_spec.rate) < 0 ||
1994 u->sample_spec.rate <= 0 || u->sample_spec.rate > PA_RATE_MAX) {
1995 pa_log_error("Failed to get rate from module arguments");
1999 channels = u->sample_spec.channels;
2000 if (pa_modargs_get_value_u32(ma, "channels", &channels) < 0 ||
2001 channels <= 0 || channels > PA_CHANNELS_MAX) {
2002 pa_log_error("Failed to get channels from module arguments");
2005 u->sample_spec.channels = (uint8_t) channels;
2006 u->requested_sample_spec = u->sample_spec;
2008 address = pa_modargs_get_value(ma, "address", NULL);
2009 path = pa_modargs_get_value(ma, "path", NULL);
2011 if (setup_dbus(u) < 0)
2014 if (!(u->discovery = pa_bluetooth_discovery_get(m->core)))
2017 if (!(device = find_device(u, address, path)))
2020 /* Add the card structure. This will also initialize the default profile */
2021 if (add_card(u, pa_modargs_get_value(ma, "profile", NULL), device) < 0)
2024 /* Connect to the BT service and query capabilities */
2028 if (!dbus_connection_add_filter(pa_dbus_connection_get(u->connection), filter_cb, u, NULL)) {
2029 pa_log_error("Failed to add filter function");
2033 speaker = pa_sprintf_malloc("type='signal',sender='org.bluez',interface='org.bluez.Headset',member='SpeakerGainChanged',path='%s'", u->path);
2034 mike = pa_sprintf_malloc("type='signal',sender='org.bluez',interface='org.bluez.Headset',member='MicrophoneGainChanged',path='%s'", u->path);
2036 if (pa_dbus_add_matches(
2037 pa_dbus_connection_get(u->connection), &err,
2045 pa_log("Failed to add D-Bus matches: %s", err.message);
2052 if (u->profile != PROFILE_OFF)
2053 if (init_profile(u) < 0)
2056 if (u->sink || u->source)
2057 if (start_thread(u) < 0)
2066 dbus_error_free(&err);
2071 int pa__get_n_used(pa_module *m) {
2075 pa_assert_se(u = m->userdata);
2078 (u->sink ? pa_sink_linked_by(u->sink) : 0) +
2079 (u->source ? pa_source_linked_by(u->source) : 0);
2082 void pa__done(pa_module *m) {
2086 if (!(u = m->userdata))
2091 && !USE_SCO_OVER_PCM(u)
2094 pa_sink_unlink(u->sink);
2098 && !USE_SCO_OVER_PCM(u)
2101 pa_source_unlink(u->source);
2105 if (u->connection) {
2108 char *speaker, *mike;
2109 speaker = pa_sprintf_malloc("type='signal',sender='org.bluez',interface='org.bluez.Headset',member='SpeakerGainChanged',path='%s'", u->path);
2110 mike = pa_sprintf_malloc("type='signal',sender='org.bluez',interface='org.bluez.Headset',member='MicrophoneGainChanged',path='%s'", u->path);
2112 pa_dbus_remove_matches(pa_dbus_connection_get(u->connection),
2121 dbus_connection_remove_filter(pa_dbus_connection_get(u->connection), filter_cb, u);
2122 pa_dbus_connection_unref(u->connection);
2126 pa_card_free(u->card);
2128 if (u->read_smoother)
2129 pa_smoother_free(u->read_smoother);
2134 pa_xfree(u->a2dp.buffer);
2136 sbc_finish(&u->a2dp.sbc);
2139 pa_modargs_free(u->modargs);
2141 pa_xfree(u->address);
2145 pa_bluetooth_discovery_unref(u->discovery);