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
28 #include <linux/sockios.h>
29 #include <arpa/inet.h>
31 #include <pulse/i18n.h>
32 #include <pulse/rtclock.h>
33 #include <pulse/sample.h>
34 #include <pulse/timeval.h>
35 #include <pulse/xmalloc.h>
37 #include <pulsecore/module.h>
38 #include <pulsecore/modargs.h>
39 #include <pulsecore/core-rtclock.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/poll.h>
46 #include <pulsecore/rtpoll.h>
47 #include <pulsecore/time-smoother.h>
48 #include <pulsecore/namereg.h>
49 #include <pulsecore/dbus-shared.h>
50 #include <pulsecore/llist.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> "
74 "profile=<a2dp|hsp|hfgw> "
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;
141 pa_bluetooth_discovery *discovery;
142 pa_bool_t auto_connect;
144 pa_dbus_connection *connection;
150 pa_thread_mq thread_mq;
152 pa_rtpoll_item *rtpoll_item;
155 uint64_t read_index, write_index;
156 pa_usec_t started_at;
157 pa_smoother *read_smoother;
159 pa_memchunk write_memchunk;
161 pa_sample_spec sample_spec, requested_sample_spec;
169 struct a2dp_info a2dp;
172 enum profile profile;
176 int stream_write_type;
177 int service_write_type, service_read_type;
179 pa_bool_t filter_added;
182 #define FIXED_LATENCY_PLAYBACK_A2DP (25*PA_USEC_PER_MSEC)
183 #define FIXED_LATENCY_RECORD_A2DP (25*PA_USEC_PER_MSEC)
184 #define FIXED_LATENCY_PLAYBACK_HSP (125*PA_USEC_PER_MSEC)
185 #define FIXED_LATENCY_RECORD_HSP (25*PA_USEC_PER_MSEC)
187 #define MAX_PLAYBACK_CATCH_UP_USEC (100*PA_USEC_PER_MSEC)
190 #define USE_SCO_OVER_PCM(u) (u->profile == PROFILE_HSP && (u->hsp.sco_sink && u->hsp.sco_source))
193 static int init_bt(struct userdata *u);
194 static int init_profile(struct userdata *u);
196 static int service_send(struct userdata *u, const bt_audio_msg_header_t *msg) {
201 pa_assert(msg->length > 0);
203 if (u->service_fd < 0) {
204 pa_log_warn("Service not connected");
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 || u->profile == PROFILE_HFGW) && codec->transport != BT_CAPABILITIES_TRANSPORT_SCO)) {
322 pa_log_error("Got capabilities for wrong codec.");
326 if (u->profile == PROFILE_HSP || u->profile == PROFILE_HFGW) {
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 || u->profile == PROFILE_HFGW);
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 || u->profile == PROFILE_HFGW);
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 */
748 static int setup_stream(struct userdata *u) {
749 struct pollfd *pollfd;
752 pa_make_fd_nonblock(u->stream_fd);
753 pa_make_socket_low_delay(u->stream_fd);
756 if (setsockopt(u->stream_fd, SOL_SOCKET, SO_TIMESTAMP, &one, sizeof(one)) < 0)
757 pa_log_warn("Failed to enable SO_TIMESTAMP: %s", pa_cstrerror(errno));
759 pa_log_debug("Stream properly set up, we're ready to roll!");
761 u->rtpoll_item = pa_rtpoll_item_new(u->rtpoll, PA_RTPOLL_NEVER, 1);
762 pollfd = pa_rtpoll_item_get_pollfd(u->rtpoll_item, NULL);
763 pollfd->fd = u->stream_fd;
764 pollfd->events = pollfd->revents = 0;
766 u->read_index = u->write_index = 0;
770 u->read_smoother = pa_smoother_new(
782 static int start_stream_fd(struct userdata *u) {
784 bt_audio_msg_header_t rsp;
785 struct bt_start_stream_req start_req;
786 struct bt_start_stream_rsp start_rsp;
787 struct bt_new_stream_ind streamfd_ind;
788 bt_audio_error_t error;
789 uint8_t buf[BT_SUGGESTED_BUFFER_SIZE];
793 pa_assert(u->rtpoll);
794 pa_assert(!u->rtpoll_item);
795 pa_assert(u->stream_fd < 0);
797 memset(msg.buf, 0, BT_SUGGESTED_BUFFER_SIZE);
798 msg.start_req.h.type = BT_REQUEST;
799 msg.start_req.h.name = BT_START_STREAM;
800 msg.start_req.h.length = sizeof(msg.start_req);
802 if (service_send(u, &msg.start_req.h) < 0)
805 if (service_expect(u, &msg.rsp, sizeof(msg), BT_START_STREAM, sizeof(msg.start_rsp)) < 0)
808 if (service_expect(u, &msg.rsp, sizeof(msg), BT_NEW_STREAM, sizeof(msg.streamfd_ind)) < 0)
811 if ((u->stream_fd = bt_audio_service_get_data_fd(u->service_fd)) < 0) {
812 pa_log("Failed to get stream fd from audio service.");
816 return setup_stream(u);
820 static int stop_stream_fd(struct userdata *u) {
822 bt_audio_msg_header_t rsp;
823 struct bt_stop_stream_req start_req;
824 struct bt_stop_stream_rsp start_rsp;
825 bt_audio_error_t error;
826 uint8_t buf[BT_SUGGESTED_BUFFER_SIZE];
831 pa_assert(u->rtpoll);
833 if (u->rtpoll_item) {
834 pa_rtpoll_item_free(u->rtpoll_item);
835 u->rtpoll_item = NULL;
838 if (u->stream_fd >= 0) {
839 memset(msg.buf, 0, BT_SUGGESTED_BUFFER_SIZE);
840 msg.start_req.h.type = BT_REQUEST;
841 msg.start_req.h.name = BT_STOP_STREAM;
842 msg.start_req.h.length = sizeof(msg.start_req);
844 if (service_send(u, &msg.start_req.h) < 0 ||
845 service_expect(u, &msg.rsp, sizeof(msg), BT_STOP_STREAM, sizeof(msg.start_rsp)) < 0)
848 pa_close(u->stream_fd);
852 if (u->read_smoother) {
853 pa_smoother_free(u->read_smoother);
854 u->read_smoother = NULL;
860 static void bt_transport_release(struct userdata *u) {
861 const char *accesstype = "rw";
862 const pa_bluetooth_transport *t;
864 /* Ignore if already released */
868 pa_log_debug("Releasing transport %s", u->transport);
870 t = pa_bluetooth_discovery_get_transport(u->discovery, u->transport);
872 pa_bluetooth_transport_release(t, accesstype);
874 pa_xfree(u->accesstype);
875 u->accesstype = NULL;
877 if (u->rtpoll_item) {
878 pa_rtpoll_item_free(u->rtpoll_item);
879 u->rtpoll_item = NULL;
882 if (u->stream_fd >= 0) {
883 pa_close(u->stream_fd);
887 if (u->read_smoother) {
888 pa_smoother_free(u->read_smoother);
889 u->read_smoother = NULL;
893 static int bt_transport_acquire(struct userdata *u, pa_bool_t start) {
894 const char *accesstype = "rw";
895 const pa_bluetooth_transport *t;
903 pa_log_debug("Acquiring transport %s", u->transport);
905 t = pa_bluetooth_discovery_get_transport(u->discovery, u->transport);
907 pa_log("Transport %s no longer available", u->transport);
908 pa_xfree(u->transport);
913 /* FIXME: Handle in/out MTU properly when unix socket is not longer supported */
914 u->stream_fd = pa_bluetooth_transport_acquire(t, accesstype, NULL, &u->link_mtu);
915 if (u->stream_fd < 0)
918 u->accesstype = pa_xstrdup(accesstype);
919 pa_log_info("Transport %s acquired: fd %d", u->transport, u->stream_fd);
925 pa_log_info("Transport %s resuming", u->transport);
926 return setup_stream(u);
929 /* Run from IO thread */
930 static int sink_process_msg(pa_msgobject *o, int code, void *data, int64_t offset, pa_memchunk *chunk) {
931 struct userdata *u = PA_SINK(o)->userdata;
932 pa_bool_t failed = FALSE;
935 pa_assert(u->sink == PA_SINK(o));
939 case PA_SINK_MESSAGE_SET_STATE:
941 switch ((pa_sink_state_t) PA_PTR_TO_UINT(data)) {
943 case PA_SINK_SUSPENDED:
944 pa_assert(PA_SINK_IS_OPENED(u->sink->thread_info.state));
946 /* Stop the device if the source is suspended as well */
947 if (!u->source || u->source->state == PA_SOURCE_SUSPENDED) {
948 /* We deliberately ignore whether stopping
949 * actually worked. Since the stream_fd is
950 * closed it doesn't really matter */
952 bt_transport_release(u);
960 case PA_SINK_RUNNING:
961 if (u->sink->thread_info.state != PA_SINK_SUSPENDED)
964 /* Resume the device if the source was suspended as well */
965 if (!u->source || u->source->state == PA_SOURCE_SUSPENDED) {
967 if (bt_transport_acquire(u, TRUE) < 0)
969 } else if (start_stream_fd(u) < 0)
974 case PA_SINK_UNLINKED:
976 case PA_SINK_INVALID_STATE:
981 case PA_SINK_MESSAGE_GET_LATENCY: {
983 if (u->read_smoother) {
986 ri = pa_smoother_get(u->read_smoother, pa_rtclock_now());
987 wi = pa_bytes_to_usec(u->write_index + u->block_size, &u->sample_spec);
989 *((pa_usec_t*) data) = wi > ri ? wi - ri : 0;
993 ri = pa_rtclock_now() - u->started_at;
994 wi = pa_bytes_to_usec(u->write_index, &u->sample_spec);
996 *((pa_usec_t*) data) = wi > ri ? wi - ri : 0;
999 *((pa_usec_t*) data) += u->sink->thread_info.fixed_latency;
1004 r = pa_sink_process_msg(o, code, data, offset, chunk);
1006 return (r < 0 || !failed) ? r : -1;
1009 /* Run from IO thread */
1010 static int source_process_msg(pa_msgobject *o, int code, void *data, int64_t offset, pa_memchunk *chunk) {
1011 struct userdata *u = PA_SOURCE(o)->userdata;
1012 pa_bool_t failed = FALSE;
1015 pa_assert(u->source == PA_SOURCE(o));
1019 case PA_SOURCE_MESSAGE_SET_STATE:
1021 switch ((pa_source_state_t) PA_PTR_TO_UINT(data)) {
1023 case PA_SOURCE_SUSPENDED:
1024 pa_assert(PA_SOURCE_IS_OPENED(u->source->thread_info.state));
1026 /* Stop the device if the sink is suspended as well */
1027 if (!u->sink || u->sink->state == PA_SINK_SUSPENDED) {
1029 bt_transport_release(u);
1034 if (u->read_smoother)
1035 pa_smoother_pause(u->read_smoother, pa_rtclock_now());
1038 case PA_SOURCE_IDLE:
1039 case PA_SOURCE_RUNNING:
1040 if (u->source->thread_info.state != PA_SOURCE_SUSPENDED)
1043 /* Resume the device if the sink was suspended as well */
1044 if (!u->sink || u->sink->thread_info.state == PA_SINK_SUSPENDED) {
1046 if (bt_transport_acquire(u, TRUE) < 0)
1048 } else if (start_stream_fd(u) < 0)
1051 /* We don't resume the smoother here. Instead we
1052 * wait until the first packet arrives */
1055 case PA_SOURCE_UNLINKED:
1056 case PA_SOURCE_INIT:
1057 case PA_SOURCE_INVALID_STATE:
1062 case PA_SOURCE_MESSAGE_GET_LATENCY: {
1065 if (u->read_smoother) {
1066 wi = pa_smoother_get(u->read_smoother, pa_rtclock_now());
1067 ri = pa_bytes_to_usec(u->read_index, &u->sample_spec);
1069 *((pa_usec_t*) data) = (wi > ri ? wi - ri : 0) + u->source->thread_info.fixed_latency;
1071 *((pa_usec_t*) data) = 0;
1078 r = pa_source_process_msg(o, code, data, offset, chunk);
1080 return (r < 0 || !failed) ? r : -1;
1083 /* Run from IO thread */
1084 static int hsp_process_render(struct userdata *u) {
1088 pa_assert(u->profile == PROFILE_HSP || u->profile == PROFILE_HFGW);
1091 /* First, render some data */
1092 if (!u->write_memchunk.memblock)
1093 pa_sink_render_full(u->sink, u->block_size, &u->write_memchunk);
1095 pa_assert(u->write_memchunk.length == u->block_size);
1101 /* Now write that data to the socket. The socket is of type
1102 * SEQPACKET, and we generated the data of the MTU size, so this
1103 * should just work. */
1105 p = (const uint8_t*) pa_memblock_acquire(u->write_memchunk.memblock) + u->write_memchunk.index;
1106 l = pa_write(u->stream_fd, p, u->write_memchunk.length, &u->stream_write_type);
1107 pa_memblock_release(u->write_memchunk.memblock);
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 SCO socket: %s", pa_cstrerror(errno));
1126 pa_assert((size_t) l <= u->write_memchunk.length);
1128 if ((size_t) l != u->write_memchunk.length) {
1129 pa_log_error("Wrote memory block to socket only partially! %llu written, wanted to write %llu.",
1130 (unsigned long long) l,
1131 (unsigned long long) u->write_memchunk.length);
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);
1147 /* Run from IO thread */
1148 static int hsp_process_push(struct userdata *u) {
1150 pa_memchunk memchunk;
1153 pa_assert(u->profile == PROFILE_HSP || u->profile == PROFILE_HFGW);
1154 pa_assert(u->source);
1155 pa_assert(u->read_smoother);
1157 memchunk.memblock = pa_memblock_new(u->core->mempool, u->block_size);
1158 memchunk.index = memchunk.length = 0;
1167 pa_bool_t found_tstamp = FALSE;
1170 memset(&m, 0, sizeof(m));
1171 memset(&aux, 0, sizeof(aux));
1172 memset(&iov, 0, sizeof(iov));
1176 m.msg_control = aux;
1177 m.msg_controllen = sizeof(aux);
1179 p = pa_memblock_acquire(memchunk.memblock);
1181 iov.iov_len = pa_memblock_get_length(memchunk.memblock);
1182 l = recvmsg(u->stream_fd, &m, 0);
1183 pa_memblock_release(memchunk.memblock);
1187 if (l < 0 && errno == EINTR)
1188 /* Retry right away if we got interrupted */
1191 else if (l < 0 && errno == EAGAIN)
1192 /* Hmm, apparently the socket was not readable, give up for now. */
1195 pa_log_error("Failed to read data from SCO socket: %s", l < 0 ? pa_cstrerror(errno) : "EOF");
1200 pa_assert((size_t) l <= pa_memblock_get_length(memchunk.memblock));
1202 memchunk.length = (size_t) l;
1203 u->read_index += (uint64_t) l;
1205 for (cm = CMSG_FIRSTHDR(&m); cm; cm = CMSG_NXTHDR(&m, cm))
1206 if (cm->cmsg_level == SOL_SOCKET && cm->cmsg_type == SO_TIMESTAMP) {
1207 struct timeval *tv = (struct timeval*) CMSG_DATA(cm);
1208 pa_rtclock_from_wallclock(tv);
1209 tstamp = pa_timeval_load(tv);
1210 found_tstamp = TRUE;
1214 if (!found_tstamp) {
1215 pa_log_warn("Couldn't find SO_TIMESTAMP data in auxiliary recvmsg() data!");
1216 tstamp = pa_rtclock_now();
1219 pa_smoother_put(u->read_smoother, tstamp, pa_bytes_to_usec(u->read_index, &u->sample_spec));
1220 pa_smoother_resume(u->read_smoother, tstamp, TRUE);
1222 pa_source_post(u->source, &memchunk);
1228 pa_memblock_unref(memchunk.memblock);
1233 /* Run from IO thread */
1234 static void a2dp_prepare_buffer(struct userdata *u) {
1237 if (u->a2dp.buffer_size >= u->link_mtu)
1240 u->a2dp.buffer_size = 2 * u->link_mtu;
1241 pa_xfree(u->a2dp.buffer);
1242 u->a2dp.buffer = pa_xmalloc(u->a2dp.buffer_size);
1245 /* Run from IO thread */
1246 static int a2dp_process_render(struct userdata *u) {
1247 struct a2dp_info *a2dp;
1248 struct rtp_header *header;
1249 struct rtp_payload *payload;
1253 size_t to_write, to_encode;
1254 unsigned frame_count;
1258 pa_assert(u->profile == PROFILE_A2DP);
1261 /* First, render some data */
1262 if (!u->write_memchunk.memblock)
1263 pa_sink_render_full(u->sink, u->block_size, &u->write_memchunk);
1265 pa_assert(u->write_memchunk.length == u->block_size);
1267 a2dp_prepare_buffer(u);
1270 header = a2dp->buffer;
1271 payload = (struct rtp_payload*) ((uint8_t*) a2dp->buffer + sizeof(*header));
1275 /* Try to create a packet of the full MTU */
1277 p = (const uint8_t*) pa_memblock_acquire(u->write_memchunk.memblock) + u->write_memchunk.index;
1278 to_encode = u->write_memchunk.length;
1280 d = (uint8_t*) a2dp->buffer + sizeof(*header) + sizeof(*payload);
1281 to_write = a2dp->buffer_size - sizeof(*header) - sizeof(*payload);
1283 while (PA_LIKELY(to_encode > 0 && to_write > 0)) {
1287 encoded = sbc_encode(&a2dp->sbc,
1292 if (PA_UNLIKELY(encoded <= 0)) {
1293 pa_log_error("SBC encoding error (%li)", (long) encoded);
1294 pa_memblock_release(u->write_memchunk.memblock);
1298 /* pa_log_debug("SBC: encoded: %lu; written: %lu", (unsigned long) encoded, (unsigned long) written); */
1299 /* pa_log_debug("SBC: codesize: %lu; frame_length: %lu", (unsigned long) a2dp->codesize, (unsigned long) a2dp->frame_length); */
1301 pa_assert_fp((size_t) encoded <= to_encode);
1302 pa_assert_fp((size_t) encoded == a2dp->codesize);
1304 pa_assert_fp((size_t) written <= to_write);
1305 pa_assert_fp((size_t) written == a2dp->frame_length);
1307 p = (const uint8_t*) p + encoded;
1308 to_encode -= encoded;
1310 d = (uint8_t*) d + written;
1311 to_write -= written;
1316 pa_memblock_release(u->write_memchunk.memblock);
1318 pa_assert(to_encode == 0);
1321 pa_log_debug("Using SBC encoder implementation: %s", pa_strnull(sbc_get_implementation_info(&a2dp->sbc)));
1324 /* write it to the fifo */
1325 memset(a2dp->buffer, 0, sizeof(*header) + sizeof(*payload));
1328 header->sequence_number = htons(a2dp->seq_num++);
1329 header->timestamp = htonl(u->write_index / pa_frame_size(&u->sample_spec));
1330 header->ssrc = htonl(1);
1331 payload->frame_count = frame_count;
1333 nbytes = (uint8_t*) d - (uint8_t*) a2dp->buffer;
1338 l = pa_write(u->stream_fd, a2dp->buffer, nbytes, &u->stream_write_type);
1345 /* Retry right away if we got interrupted */
1348 else if (errno == EAGAIN)
1349 /* Hmm, apparently the socket was not writable, give up for now */
1352 pa_log_error("Failed to write data to socket: %s", pa_cstrerror(errno));
1357 pa_assert((size_t) l <= nbytes);
1359 if ((size_t) l != nbytes) {
1360 pa_log_warn("Wrote memory block to socket only partially! %llu written, wanted to write %llu.",
1361 (unsigned long long) l,
1362 (unsigned long long) nbytes);
1367 u->write_index += (uint64_t) u->write_memchunk.length;
1368 pa_memblock_unref(u->write_memchunk.memblock);
1369 pa_memchunk_reset(&u->write_memchunk);
1379 static int a2dp_process_push(struct userdata *u) {
1381 pa_memchunk memchunk;
1384 pa_assert(u->profile == PROFILE_A2DP_SOURCE);
1385 pa_assert(u->source);
1386 pa_assert(u->read_smoother);
1388 memchunk.memblock = pa_memblock_new(u->core->mempool, u->block_size);
1389 memchunk.index = memchunk.length = 0;
1392 pa_bool_t found_tstamp = FALSE;
1394 struct a2dp_info *a2dp;
1395 struct rtp_header *header;
1396 struct rtp_payload *payload;
1400 size_t to_write, to_decode;
1401 unsigned frame_count;
1403 a2dp_prepare_buffer(u);
1406 header = a2dp->buffer;
1407 payload = (struct rtp_payload*) ((uint8_t*) a2dp->buffer + sizeof(*header));
1409 l = pa_read(u->stream_fd, a2dp->buffer, a2dp->buffer_size, &u->stream_write_type);
1413 if (l < 0 && errno == EINTR)
1414 /* Retry right away if we got interrupted */
1417 else if (l < 0 && errno == EAGAIN)
1418 /* Hmm, apparently the socket was not readable, give up for now. */
1421 pa_log_error("Failed to read data from socket: %s", l < 0 ? pa_cstrerror(errno) : "EOF");
1426 pa_assert((size_t) l <= a2dp->buffer_size);
1428 u->read_index += (uint64_t) l;
1430 /* TODO: get timestamp from rtp */
1431 if (!found_tstamp) {
1432 /* pa_log_warn("Couldn't find SO_TIMESTAMP data in auxiliary recvmsg() data!"); */
1433 tstamp = pa_rtclock_now();
1436 pa_smoother_put(u->read_smoother, tstamp, pa_bytes_to_usec(u->read_index, &u->sample_spec));
1437 pa_smoother_resume(u->read_smoother, tstamp, TRUE);
1439 p = (uint8_t*) a2dp->buffer + sizeof(*header) + sizeof(*payload);
1440 to_decode = l - sizeof(*header) - sizeof(*payload);
1442 d = pa_memblock_acquire(memchunk.memblock);
1443 to_write = memchunk.length = pa_memblock_get_length(memchunk.memblock);
1445 while (PA_LIKELY(to_decode > 0 && to_write > 0)) {
1449 decoded = sbc_decode(&a2dp->sbc,
1454 if (PA_UNLIKELY(decoded <= 0)) {
1455 pa_log_error("SBC decoding error (%li)", (long) decoded);
1456 pa_memblock_release(memchunk.memblock);
1457 pa_memblock_unref(memchunk.memblock);
1461 /* pa_log_debug("SBC: decoded: %lu; written: %lu", (unsigned long) decoded, (unsigned long) written); */
1462 /* pa_log_debug("SBC: frame_length: %lu; codesize: %lu", (unsigned long) a2dp->frame_length, (unsigned long) a2dp->codesize); */
1464 pa_assert_fp((size_t) decoded <= to_decode);
1465 pa_assert_fp((size_t) decoded == a2dp->frame_length);
1467 pa_assert_fp((size_t) written <= to_write);
1468 pa_assert_fp((size_t) written == a2dp->codesize);
1470 p = (const uint8_t*) p + decoded;
1471 to_decode -= decoded;
1473 d = (uint8_t*) d + written;
1474 to_write -= written;
1479 pa_memblock_release(memchunk.memblock);
1481 pa_source_post(u->source, &memchunk);
1487 pa_memblock_unref(memchunk.memblock);
1492 static void thread_func(void *userdata) {
1493 struct userdata *u = userdata;
1494 unsigned do_write = 0;
1495 pa_bool_t writable = FALSE;
1499 pa_log_debug("IO Thread starting up");
1501 if (u->core->realtime_scheduling)
1502 pa_make_realtime(u->core->realtime_priority);
1504 pa_thread_mq_install(&u->thread_mq);
1507 if (bt_transport_acquire(u, TRUE) < 0)
1509 } else if (start_stream_fd(u) < 0)
1513 struct pollfd *pollfd;
1515 pa_bool_t disable_timer = TRUE;
1517 pollfd = u->rtpoll_item ? pa_rtpoll_item_get_pollfd(u->rtpoll_item, NULL) : NULL;
1519 if (u->source && PA_SOURCE_IS_LINKED(u->source->thread_info.state)) {
1521 /* We should send two blocks to the device before we expect
1524 if (u->write_index == 0 && u->read_index <= 0)
1527 if (pollfd && (pollfd->revents & POLLIN)) {
1530 if (u->profile == PROFILE_HSP || u->profile == PROFILE_HFGW)
1531 n_read = hsp_process_push(u);
1533 n_read = a2dp_process_push(u);
1538 /* We just read something, so we are supposed to write something, too */
1543 if (u->sink && PA_SINK_IS_LINKED(u->sink->thread_info.state)) {
1545 if (u->sink->thread_info.rewind_requested)
1546 pa_sink_process_rewind(u->sink, 0);
1549 if (pollfd->revents & POLLOUT)
1552 if ((!u->source || !PA_SOURCE_IS_LINKED(u->source->thread_info.state)) && do_write <= 0 && writable) {
1553 pa_usec_t time_passed;
1554 pa_usec_t audio_sent;
1556 /* Hmm, there is no input stream we could synchronize
1557 * to. So let's do things by time */
1559 time_passed = pa_rtclock_now() - u->started_at;
1560 audio_sent = pa_bytes_to_usec(u->write_index, &u->sample_spec);
1562 if (audio_sent <= time_passed) {
1563 pa_usec_t audio_to_send = time_passed - audio_sent;
1565 /* Never try to catch up for more than 100ms */
1566 if (u->write_index > 0 && audio_to_send > MAX_PLAYBACK_CATCH_UP_USEC) {
1567 pa_usec_t skip_usec;
1568 uint64_t skip_bytes;
1570 skip_usec = audio_to_send - MAX_PLAYBACK_CATCH_UP_USEC;
1571 skip_bytes = pa_usec_to_bytes(skip_usec, &u->sample_spec);
1573 if (skip_bytes > 0) {
1576 pa_log_warn("Skipping %llu us (= %llu bytes) in audio stream",
1577 (unsigned long long) skip_usec,
1578 (unsigned long long) skip_bytes);
1580 pa_sink_render_full(u->sink, skip_bytes, &tmp);
1581 pa_memblock_unref(tmp.memblock);
1582 u->write_index += skip_bytes;
1590 if (writable && do_write > 0) {
1593 if (u->write_index <= 0)
1594 u->started_at = pa_rtclock_now();
1596 if (u->profile == PROFILE_A2DP) {
1597 if ((n_written = a2dp_process_render(u)) < 0)
1600 if ((n_written = hsp_process_render(u)) < 0)
1605 pa_log("Broken kernel: we got EAGAIN on write() after POLLOUT!");
1607 do_write -= n_written;
1611 if ((!u->source || !PA_SOURCE_IS_LINKED(u->source->thread_info.state)) && do_write <= 0 && writable) {
1612 pa_usec_t time_passed, next_write_at, sleep_for;
1614 /* Hmm, there is no input stream we could synchronize
1615 * to. So let's estimate when we need to wake up the latest */
1617 time_passed = pa_rtclock_now() - u->started_at;
1618 next_write_at = pa_bytes_to_usec(u->write_index, &u->sample_spec);
1619 sleep_for = time_passed < next_write_at ? next_write_at - time_passed : 0;
1621 /* 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); */
1623 pa_rtpoll_set_timer_relative(u->rtpoll, sleep_for);
1624 disable_timer = FALSE;
1630 pa_rtpoll_set_timer_disabled(u->rtpoll);
1632 /* Hmm, nothing to do. Let's sleep */
1634 pollfd->events = (short) (((u->sink && PA_SINK_IS_LINKED(u->sink->thread_info.state) && !writable) ? POLLOUT : 0) |
1635 (u->source && PA_SOURCE_IS_LINKED(u->source->thread_info.state) ? POLLIN : 0));
1637 if ((ret = pa_rtpoll_run(u->rtpoll, TRUE)) < 0)
1643 pollfd = u->rtpoll_item ? pa_rtpoll_item_get_pollfd(u->rtpoll_item, NULL) : NULL;
1645 if (pollfd && (pollfd->revents & ~(POLLOUT|POLLIN))) {
1646 pa_log_info("FD error: %s%s%s%s",
1647 pollfd->revents & POLLERR ? "POLLERR " :"",
1648 pollfd->revents & POLLHUP ? "POLLHUP " :"",
1649 pollfd->revents & POLLPRI ? "POLLPRI " :"",
1650 pollfd->revents & POLLNVAL ? "POLLNVAL " :"");
1656 /* If this was no regular exit from the loop we have to continue processing messages until we receive PA_MESSAGE_SHUTDOWN */
1657 pa_log_debug("IO thread failed");
1658 pa_asyncmsgq_post(u->thread_mq.outq, PA_MSGOBJECT(u->core), PA_CORE_MESSAGE_UNLOAD_MODULE, u->module, 0, NULL, NULL);
1659 pa_asyncmsgq_wait_for(u->thread_mq.inq, PA_MESSAGE_SHUTDOWN);
1662 pa_log_debug("IO thread shutting down");
1665 /* Run from main thread */
1666 static DBusHandlerResult filter_cb(DBusConnection *bus, DBusMessage *m, void *userdata) {
1672 pa_assert_se(u = userdata);
1674 dbus_error_init(&err);
1676 pa_log_debug("dbus: interface=%s, path=%s, member=%s\n",
1677 dbus_message_get_interface(m),
1678 dbus_message_get_path(m),
1679 dbus_message_get_member(m));
1681 if (!dbus_message_has_path(m, u->path))
1684 if (dbus_message_is_signal(m, "org.bluez.Headset", "SpeakerGainChanged") ||
1685 dbus_message_is_signal(m, "org.bluez.Headset", "MicrophoneGainChanged")) {
1690 if (!dbus_message_get_args(m, &err, DBUS_TYPE_UINT16, &gain, DBUS_TYPE_INVALID) || gain > 15) {
1691 pa_log("Failed to parse org.bluez.Headset.{Speaker|Microphone}GainChanged: %s", err.message);
1695 if (u->profile == PROFILE_HSP) {
1696 if (u->sink && dbus_message_is_signal(m, "org.bluez.Headset", "SpeakerGainChanged")) {
1698 pa_cvolume_set(&v, u->sample_spec.channels, (pa_volume_t) (gain * PA_VOLUME_NORM / 15));
1699 pa_sink_volume_changed(u->sink, &v);
1701 } else if (u->source && dbus_message_is_signal(m, "org.bluez.Headset", "MicrophoneGainChanged")) {
1703 pa_cvolume_set(&v, u->sample_spec.channels, (pa_volume_t) (gain * PA_VOLUME_NORM / 15));
1704 pa_source_volume_changed(u->source, &v);
1710 dbus_error_free(&err);
1712 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1715 /* Run from main thread */
1716 static void sink_set_volume_cb(pa_sink *s) {
1717 struct userdata *u = s->userdata;
1723 if (u->profile != PROFILE_HSP)
1726 gain = (pa_cvolume_max(&s->real_volume) * 15) / PA_VOLUME_NORM;
1731 pa_cvolume_set(&s->real_volume, u->sample_spec.channels, (pa_volume_t) (gain * PA_VOLUME_NORM / 15));
1733 pa_assert_se(m = dbus_message_new_method_call("org.bluez", u->path, "org.bluez.Headset", "SetSpeakerGain"));
1734 pa_assert_se(dbus_message_append_args(m, DBUS_TYPE_UINT16, &gain, DBUS_TYPE_INVALID));
1735 pa_assert_se(dbus_connection_send(pa_dbus_connection_get(u->connection), m, NULL));
1736 dbus_message_unref(m);
1739 /* Run from main thread */
1740 static void source_set_volume_cb(pa_source *s) {
1741 struct userdata *u = s->userdata;
1747 if (u->profile != PROFILE_HSP)
1750 gain = (pa_cvolume_max(&s->volume) * 15) / PA_VOLUME_NORM;
1755 pa_cvolume_set(&s->volume, u->sample_spec.channels, (pa_volume_t) (gain * PA_VOLUME_NORM / 15));
1757 pa_assert_se(m = dbus_message_new_method_call("org.bluez", u->path, "org.bluez.Headset", "SetMicrophoneGain"));
1758 pa_assert_se(dbus_message_append_args(m, DBUS_TYPE_UINT16, &gain, DBUS_TYPE_INVALID));
1759 pa_assert_se(dbus_connection_send(pa_dbus_connection_get(u->connection), m, NULL));
1760 dbus_message_unref(m);
1763 /* Run from main thread */
1764 static char *get_name(const char *type, pa_modargs *ma, const char *device_id, pa_bool_t *namereg_fail) {
1770 pa_assert(device_id);
1771 pa_assert(namereg_fail);
1773 t = pa_sprintf_malloc("%s_name", type);
1774 n = pa_modargs_get_value(ma, t, NULL);
1778 *namereg_fail = TRUE;
1779 return pa_xstrdup(n);
1782 if ((n = pa_modargs_get_value(ma, "name", NULL)))
1783 *namereg_fail = TRUE;
1786 *namereg_fail = FALSE;
1789 return pa_sprintf_malloc("bluez_%s.%s", type, n);
1794 static void sco_over_pcm_state_update(struct userdata *u) {
1796 pa_assert(USE_SCO_OVER_PCM(u));
1798 if (PA_SINK_IS_OPENED(pa_sink_get_state(u->hsp.sco_sink)) ||
1799 PA_SOURCE_IS_OPENED(pa_source_get_state(u->hsp.sco_source))) {
1801 if (u->service_fd >= 0)
1806 pa_log_debug("Resuming SCO over PCM");
1807 if (init_profile(u) < 0)
1808 pa_log("Can't resume SCO over PCM");
1811 bt_transport_acquire(u, TRUE);
1816 if (u->service_fd < 0)
1820 bt_transport_release(u);
1824 pa_log_debug("Closing SCO over PCM");
1825 pa_close(u->service_fd);
1830 static pa_hook_result_t sink_state_changed_cb(pa_core *c, pa_sink *s, struct userdata *u) {
1832 pa_sink_assert_ref(s);
1835 if (s != u->hsp.sco_sink)
1838 sco_over_pcm_state_update(u);
1843 static pa_hook_result_t source_state_changed_cb(pa_core *c, pa_source *s, struct userdata *u) {
1845 pa_source_assert_ref(s);
1848 if (s != u->hsp.sco_source)
1851 sco_over_pcm_state_update(u);
1858 /* Run from main thread */
1859 static int add_sink(struct userdata *u) {
1862 if (USE_SCO_OVER_PCM(u)) {
1865 u->sink = u->hsp.sco_sink;
1866 p = pa_proplist_new();
1867 pa_proplist_sets(p, "bluetooth.protocol", "sco");
1868 pa_proplist_update(u->sink->proplist, PA_UPDATE_MERGE, p);
1869 pa_proplist_free(p);
1871 if (!u->hsp.sink_state_changed_slot)
1872 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);
1878 pa_sink_new_data data;
1881 pa_sink_new_data_init(&data);
1882 data.driver = __FILE__;
1883 data.module = u->module;
1884 pa_sink_new_data_set_sample_spec(&data, &u->sample_spec);
1885 pa_proplist_sets(data.proplist, "bluetooth.protocol", u->profile == PROFILE_A2DP ? "a2dp" : "sco");
1886 if (u->profile == PROFILE_HSP)
1887 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_INTENDED_ROLES, "phone");
1888 data.card = u->card;
1889 data.name = get_name("sink", u->modargs, u->address, &b);
1890 data.namereg_fail = b;
1892 if (pa_modargs_get_proplist(u->modargs, "sink_properties", data.proplist, PA_UPDATE_REPLACE) < 0) {
1893 pa_log("Invalid properties");
1894 pa_sink_new_data_done(&data);
1898 u->sink = pa_sink_new(u->core, &data, PA_SINK_HARDWARE|PA_SINK_LATENCY | (u->profile == PROFILE_HSP ? PA_SINK_HW_VOLUME_CTRL : 0));
1899 pa_sink_new_data_done(&data);
1902 pa_log_error("Failed to create sink");
1906 u->sink->userdata = u;
1907 u->sink->parent.process_msg = sink_process_msg;
1909 pa_sink_set_max_request(u->sink, u->block_size);
1910 pa_sink_set_fixed_latency(u->sink,
1911 (u->profile == PROFILE_A2DP ? FIXED_LATENCY_PLAYBACK_A2DP : FIXED_LATENCY_PLAYBACK_HSP) +
1912 pa_bytes_to_usec(u->block_size, &u->sample_spec));
1915 if (u->profile == PROFILE_HSP) {
1916 u->sink->set_volume = sink_set_volume_cb;
1917 u->sink->n_volume_steps = 16;
1923 /* Run from main thread */
1924 static int add_source(struct userdata *u) {
1927 if (USE_SCO_OVER_PCM(u)) {
1928 u->source = u->hsp.sco_source;
1929 pa_proplist_sets(u->source->proplist, "bluetooth.protocol", "hsp");
1931 if (!u->hsp.source_state_changed_slot)
1932 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);
1938 pa_source_new_data data;
1941 pa_source_new_data_init(&data);
1942 data.driver = __FILE__;
1943 data.module = u->module;
1944 pa_source_new_data_set_sample_spec(&data, &u->sample_spec);
1945 pa_proplist_sets(data.proplist, "bluetooth.protocol", u->profile == PROFILE_A2DP_SOURCE ? "a2dp_source" : "hsp");
1946 if ((u->profile == PROFILE_HSP) || (u->profile == PROFILE_HFGW))
1947 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_INTENDED_ROLES, "phone");
1948 data.card = u->card;
1949 data.name = get_name("source", u->modargs, u->address, &b);
1950 data.namereg_fail = b;
1952 if (pa_modargs_get_proplist(u->modargs, "source_properties", data.proplist, PA_UPDATE_REPLACE) < 0) {
1953 pa_log("Invalid properties");
1954 pa_source_new_data_done(&data);
1958 u->source = pa_source_new(u->core, &data, PA_SOURCE_HARDWARE|PA_SOURCE_LATENCY | (u->profile == PROFILE_HSP ? PA_SOURCE_HW_VOLUME_CTRL : 0));
1959 pa_source_new_data_done(&data);
1962 pa_log_error("Failed to create source");
1966 u->source->userdata = u;
1967 u->source->parent.process_msg = source_process_msg;
1969 pa_source_set_fixed_latency(u->source,
1970 (u->profile == PROFILE_A2DP_SOURCE ? FIXED_LATENCY_RECORD_A2DP : FIXED_LATENCY_RECORD_HSP) +
1971 pa_bytes_to_usec(u->block_size, &u->sample_spec));
1974 if (u->profile == PROFILE_HSP || u->profile == PROFILE_HFGW)
1975 pa_proplist_sets(u->source->proplist, "bluetooth.nrec", (u->hsp.pcm_capabilities.flags & BT_PCM_FLAG_NREC) ? "1" : "0");
1977 if (u->profile == PROFILE_HSP) {
1978 u->source->set_volume = source_set_volume_cb;
1979 u->source->n_volume_steps = 16;
1985 /* Run from main thread */
1986 static void shutdown_bt(struct userdata *u) {
1989 if (u->stream_fd >= 0) {
1990 pa_close(u->stream_fd);
1993 u->stream_write_type = 0;
1996 if (u->service_fd >= 0) {
1997 pa_close(u->service_fd);
1999 u->service_write_type = 0;
2000 u->service_read_type = 0;
2003 if (u->write_memchunk.memblock) {
2004 pa_memblock_unref(u->write_memchunk.memblock);
2005 pa_memchunk_reset(&u->write_memchunk);
2009 static int bt_transport_config_a2dp(struct userdata *u) {
2010 const pa_bluetooth_transport *t;
2011 struct a2dp_info *a2dp = &u->a2dp;
2012 sbc_capabilities_raw_t *config;
2014 t = pa_bluetooth_discovery_get_transport(u->discovery, u->transport);
2017 config = (sbc_capabilities_raw_t *) t->config;
2019 if (a2dp->sbc_initialized)
2020 sbc_reinit(&a2dp->sbc, 0);
2022 sbc_init(&a2dp->sbc, 0);
2023 a2dp->sbc_initialized = TRUE;
2025 switch (config->frequency) {
2026 case BT_SBC_SAMPLING_FREQ_16000:
2027 a2dp->sbc.frequency = SBC_FREQ_16000;
2029 case BT_SBC_SAMPLING_FREQ_32000:
2030 a2dp->sbc.frequency = SBC_FREQ_32000;
2032 case BT_SBC_SAMPLING_FREQ_44100:
2033 a2dp->sbc.frequency = SBC_FREQ_44100;
2035 case BT_SBC_SAMPLING_FREQ_48000:
2036 a2dp->sbc.frequency = SBC_FREQ_48000;
2039 pa_assert_not_reached();
2042 switch (config->channel_mode) {
2043 case BT_A2DP_CHANNEL_MODE_MONO:
2044 a2dp->sbc.mode = SBC_MODE_MONO;
2046 case BT_A2DP_CHANNEL_MODE_DUAL_CHANNEL:
2047 a2dp->sbc.mode = SBC_MODE_DUAL_CHANNEL;
2049 case BT_A2DP_CHANNEL_MODE_STEREO:
2050 a2dp->sbc.mode = SBC_MODE_STEREO;
2052 case BT_A2DP_CHANNEL_MODE_JOINT_STEREO:
2053 a2dp->sbc.mode = SBC_MODE_JOINT_STEREO;
2056 pa_assert_not_reached();
2059 switch (config->allocation_method) {
2060 case BT_A2DP_ALLOCATION_SNR:
2061 a2dp->sbc.allocation = SBC_AM_SNR;
2063 case BT_A2DP_ALLOCATION_LOUDNESS:
2064 a2dp->sbc.allocation = SBC_AM_LOUDNESS;
2067 pa_assert_not_reached();
2070 switch (config->subbands) {
2071 case BT_A2DP_SUBBANDS_4:
2072 a2dp->sbc.subbands = SBC_SB_4;
2074 case BT_A2DP_SUBBANDS_8:
2075 a2dp->sbc.subbands = SBC_SB_8;
2078 pa_assert_not_reached();
2081 switch (config->block_length) {
2082 case BT_A2DP_BLOCK_LENGTH_4:
2083 a2dp->sbc.blocks = SBC_BLK_4;
2085 case BT_A2DP_BLOCK_LENGTH_8:
2086 a2dp->sbc.blocks = SBC_BLK_8;
2088 case BT_A2DP_BLOCK_LENGTH_12:
2089 a2dp->sbc.blocks = SBC_BLK_12;
2091 case BT_A2DP_BLOCK_LENGTH_16:
2092 a2dp->sbc.blocks = SBC_BLK_16;
2095 pa_assert_not_reached();
2098 a2dp->sbc.bitpool = config->max_bitpool;
2099 a2dp->codesize = sbc_get_codesize(&a2dp->sbc);
2100 a2dp->frame_length = sbc_get_frame_length(&a2dp->sbc);
2103 ((u->link_mtu - sizeof(struct rtp_header) - sizeof(struct rtp_payload))
2104 / a2dp->frame_length
2107 pa_log_info("SBC parameters:\n\tallocation=%u\n\tsubbands=%u\n\tblocks=%u\n\tbitpool=%u\n",
2108 a2dp->sbc.allocation, a2dp->sbc.subbands, a2dp->sbc.blocks, a2dp->sbc.bitpool);
2113 static int bt_transport_config(struct userdata *u) {
2114 if (u->profile == PROFILE_HSP || u->profile == PROFILE_HFGW) {
2115 u->block_size = u->link_mtu;
2119 return bt_transport_config_a2dp(u);
2122 static int parse_transport_property(struct userdata *u, DBusMessageIter *i) {
2124 DBusMessageIter variant_i;
2129 if (dbus_message_iter_get_arg_type(i) != DBUS_TYPE_STRING) {
2130 pa_log("Property name not a string.");
2134 dbus_message_iter_get_basic(i, &key);
2136 if (!dbus_message_iter_next(i)) {
2137 pa_log("Property value missing");
2141 if (dbus_message_iter_get_arg_type(i) != DBUS_TYPE_VARIANT) {
2142 pa_log("Property value not a variant.");
2146 dbus_message_iter_recurse(i, &variant_i);
2148 switch (dbus_message_iter_get_arg_type(&variant_i)) {
2150 case DBUS_TYPE_UINT16: {
2153 dbus_message_iter_get_basic(&variant_i, &value);
2155 if (pa_streq(key, "OMTU"))
2156 u->link_mtu = value;
2166 /* Run from main thread */
2167 static int bt_transport_open(struct userdata *u) {
2168 if (bt_transport_acquire(u, FALSE) < 0)
2171 return bt_transport_config(u);
2174 /* Run from main thread */
2175 static int init_bt(struct userdata *u) {
2180 u->stream_write_type = 0;
2181 u->service_write_type = 0;
2182 u->service_read_type = 0;
2184 if ((u->service_fd = bt_audio_service_open()) < 0) {
2185 pa_log_warn("Bluetooth audio service not available");
2189 pa_log_debug("Connected to the bluetooth audio service");
2194 /* Run from main thread */
2195 static int setup_bt(struct userdata *u) {
2196 const pa_bluetooth_device *d;
2197 const pa_bluetooth_transport *t;
2201 if (!(d = pa_bluetooth_discovery_get_by_path(u->discovery, u->path))) {
2202 pa_log_error("Failed to get device object.");
2206 /* release transport if exist */
2208 bt_transport_release(u);
2209 pa_xfree(u->transport);
2210 u->transport = NULL;
2213 /* check if profile has a transport */
2214 t = pa_bluetooth_device_get_transport(d, u->profile);
2216 u->transport = pa_xstrdup(t->path);
2217 return bt_transport_open(u);
2220 if (get_caps(u, 0) < 0)
2223 pa_log_debug("Got device capabilities");
2225 if (set_conf(u) < 0)
2228 pa_log_debug("Connection to the device configured");
2231 if (USE_SCO_OVER_PCM(u)) {
2232 pa_log_debug("Configured to use SCO over PCM");
2237 pa_log_debug("Got the stream socket");
2242 /* Run from main thread */
2243 static int init_profile(struct userdata *u) {
2246 pa_assert(u->profile != PROFILE_OFF);
2248 if (setup_bt(u) < 0)
2251 if (u->profile == PROFILE_A2DP ||
2252 u->profile == PROFILE_HSP ||
2253 u->profile == PROFILE_HFGW)
2254 if (add_sink(u) < 0)
2257 if (u->profile == PROFILE_HSP ||
2258 u->profile == PROFILE_A2DP_SOURCE ||
2259 u->profile == PROFILE_HFGW)
2260 if (add_source(u) < 0)
2266 /* Run from main thread */
2267 static void stop_thread(struct userdata *u) {
2271 pa_asyncmsgq_send(u->thread_mq.inq, NULL, PA_MESSAGE_SHUTDOWN, NULL, 0, NULL);
2272 pa_thread_free(u->thread);
2276 if (u->rtpoll_item) {
2277 pa_rtpoll_item_free(u->rtpoll_item);
2278 u->rtpoll_item = NULL;
2281 if (u->hsp.sink_state_changed_slot) {
2282 pa_hook_slot_free(u->hsp.sink_state_changed_slot);
2283 u->hsp.sink_state_changed_slot = NULL;
2286 if (u->hsp.source_state_changed_slot) {
2287 pa_hook_slot_free(u->hsp.source_state_changed_slot);
2288 u->hsp.source_state_changed_slot = NULL;
2292 pa_sink_unref(u->sink);
2297 pa_source_unref(u->source);
2302 pa_thread_mq_done(&u->thread_mq);
2304 pa_rtpoll_free(u->rtpoll);
2308 if (u->read_smoother) {
2309 pa_smoother_free(u->read_smoother);
2310 u->read_smoother = NULL;
2314 /* Run from main thread */
2315 static int start_thread(struct userdata *u) {
2317 pa_assert(!u->thread);
2318 pa_assert(!u->rtpoll);
2319 pa_assert(!u->rtpoll_item);
2321 u->rtpoll = pa_rtpoll_new();
2322 pa_thread_mq_init(&u->thread_mq, u->core->mainloop, u->rtpoll);
2325 if (USE_SCO_OVER_PCM(u)) {
2327 if (bt_transport_acquire(u, TRUE) < 0)
2329 } else if (start_stream_fd(u) < 0)
2332 pa_sink_ref(u->sink);
2333 pa_source_ref(u->source);
2334 /* FIXME: monitor stream_fd error */
2339 if (!(u->thread = pa_thread_new("bluetooth", thread_func, u))) {
2340 pa_log_error("Failed to create IO thread");
2346 pa_sink_set_asyncmsgq(u->sink, u->thread_mq.inq);
2347 pa_sink_set_rtpoll(u->sink, u->rtpoll);
2348 pa_sink_put(u->sink);
2350 if (u->sink->set_volume)
2351 u->sink->set_volume(u->sink);
2355 pa_source_set_asyncmsgq(u->source, u->thread_mq.inq);
2356 pa_source_set_rtpoll(u->source, u->rtpoll);
2357 pa_source_put(u->source);
2359 if (u->source->set_volume)
2360 u->source->set_volume(u->source);
2366 /* Run from main thread */
2367 static int card_set_profile(pa_card *c, pa_card_profile *new_profile) {
2370 pa_queue *inputs = NULL, *outputs = NULL;
2371 const pa_bluetooth_device *device;
2374 pa_assert(new_profile);
2375 pa_assert_se(u = c->userdata);
2377 d = PA_CARD_PROFILE_DATA(new_profile);
2379 if (!(device = pa_bluetooth_discovery_get_by_path(u->discovery, u->path))) {
2380 pa_log_error("Failed to get device object.");
2384 /* The state signal is sent by bluez, so it is racy to check
2385 strictly for CONNECTED, we should also accept STREAMING state
2386 as being good enough. However, if the profile is used
2387 concurrently (which is unlikely), ipc will fail later on, and
2388 module will be unloaded. */
2389 if (device->headset_state < PA_BT_AUDIO_STATE_CONNECTED && *d == PROFILE_HSP) {
2390 pa_log_warn("HSP is not connected, refused to switch profile");
2393 else if (device->audio_sink_state < PA_BT_AUDIO_STATE_CONNECTED && *d == PROFILE_A2DP) {
2394 pa_log_warn("A2DP is not connected, refused to switch profile");
2397 else if (device->hfgw_state <= PA_BT_AUDIO_STATE_CONNECTED && *d == PROFILE_HFGW) {
2398 pa_log_warn("HandsfreeGateway is not connected, refused to switch profile");
2403 inputs = pa_sink_move_all_start(u->sink, NULL);
2405 if (!USE_SCO_OVER_PCM(u))
2407 pa_sink_unlink(u->sink);
2411 outputs = pa_source_move_all_start(u->source, NULL);
2413 if (!USE_SCO_OVER_PCM(u))
2415 pa_source_unlink(u->source);
2422 u->sample_spec = u->requested_sample_spec;
2426 if (u->profile != PROFILE_OFF)
2429 if (u->sink || u->source)
2434 pa_sink_move_all_finish(u->sink, inputs, FALSE);
2436 pa_sink_move_all_fail(inputs);
2441 pa_source_move_all_finish(u->source, outputs, FALSE);
2443 pa_source_move_all_fail(outputs);
2449 /* Run from main thread */
2450 static int add_card(struct userdata *u, const pa_bluetooth_device *device) {
2451 pa_card_new_data data;
2457 const char *default_profile;
2462 pa_card_new_data_init(&data);
2463 data.driver = __FILE__;
2464 data.module = u->module;
2466 n = pa_bluetooth_cleanup_name(device->name);
2467 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_DESCRIPTION, n);
2469 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_STRING, device->address);
2470 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_API, "bluez");
2471 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_CLASS, "sound");
2472 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_BUS, "bluetooth");
2473 if ((ff = pa_bluetooth_get_form_factor(device->class)))
2474 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_FORM_FACTOR, ff);
2475 pa_proplist_sets(data.proplist, "bluez.path", device->path);
2476 pa_proplist_setf(data.proplist, "bluez.class", "0x%06x", (unsigned) device->class);
2477 pa_proplist_sets(data.proplist, "bluez.name", device->name);
2478 data.name = get_name("card", u->modargs, device->address, &b);
2479 data.namereg_fail = b;
2481 if (pa_modargs_get_proplist(u->modargs, "card_properties", data.proplist, PA_UPDATE_REPLACE) < 0) {
2482 pa_log("Invalid properties");
2483 pa_card_new_data_done(&data);
2487 data.profiles = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
2489 /* we base hsp/a2dp availability on UUIDs.
2490 Ideally, it would be based on "Connected" state, but
2491 we can't afford to wait for this information when
2492 we are loaded with profile="hsp", for instance */
2493 if (pa_bluetooth_uuid_has(device->uuids, A2DP_SINK_UUID)) {
2494 p = pa_card_profile_new("a2dp", _("High Fidelity Playback (A2DP)"), sizeof(enum profile));
2498 p->max_sink_channels = 2;
2499 p->max_source_channels = 0;
2501 d = PA_CARD_PROFILE_DATA(p);
2504 pa_hashmap_put(data.profiles, p->name, p);
2507 if (pa_bluetooth_uuid_has(device->uuids, A2DP_SOURCE_UUID)) {
2508 p = pa_card_profile_new("a2dp_source", _("High Fidelity Capture (A2DP)"), sizeof(enum profile));
2512 p->max_sink_channels = 0;
2513 p->max_source_channels = 2;
2515 d = PA_CARD_PROFILE_DATA(p);
2516 *d = PROFILE_A2DP_SOURCE;
2518 pa_hashmap_put(data.profiles, p->name, p);
2521 if (pa_bluetooth_uuid_has(device->uuids, HSP_HS_UUID) ||
2522 pa_bluetooth_uuid_has(device->uuids, HFP_HS_UUID)) {
2523 p = pa_card_profile_new("hsp", _("Telephony Duplex (HSP/HFP)"), sizeof(enum profile));
2527 p->max_sink_channels = 1;
2528 p->max_source_channels = 1;
2530 d = PA_CARD_PROFILE_DATA(p);
2533 pa_hashmap_put(data.profiles, p->name, p);
2536 if (pa_bluetooth_uuid_has(device->uuids, HFP_AG_UUID)) {
2537 p = pa_card_profile_new("hfgw", _("Handsfree Gateway"), sizeof(enum profile));
2541 p->max_sink_channels = 1;
2542 p->max_source_channels = 1;
2544 d = PA_CARD_PROFILE_DATA(p);
2547 pa_hashmap_put(data.profiles, p->name, p);
2550 pa_assert(!pa_hashmap_isempty(data.profiles));
2552 p = pa_card_profile_new("off", _("Off"), sizeof(enum profile));
2553 d = PA_CARD_PROFILE_DATA(p);
2555 pa_hashmap_put(data.profiles, p->name, p);
2557 if ((default_profile = pa_modargs_get_value(u->modargs, "profile", NULL))) {
2558 if (pa_hashmap_get(data.profiles, default_profile))
2559 pa_card_new_data_set_profile(&data, default_profile);
2561 pa_log_warn("Profile '%s' not valid or not supported by device.", default_profile);
2564 u->card = pa_card_new(u->core, &data);
2565 pa_card_new_data_done(&data);
2568 pa_log("Failed to allocate card.");
2572 u->card->userdata = u;
2573 u->card->set_profile = card_set_profile;
2575 d = PA_CARD_PROFILE_DATA(u->card->active_profile);
2577 if ((device->headset_state < PA_BT_AUDIO_STATE_CONNECTED && *d == PROFILE_HSP) ||
2578 (device->audio_sink_state < PA_BT_AUDIO_STATE_CONNECTED && *d == PROFILE_A2DP) ||
2579 (device->hfgw_state < PA_BT_AUDIO_STATE_CONNECTED && *d == PROFILE_HFGW)) {
2580 pa_log_warn("Default profile not connected, selecting off profile");
2581 u->card->active_profile = pa_hashmap_get(u->card->profiles, "off");
2582 u->card->save_profile = FALSE;
2585 d = PA_CARD_PROFILE_DATA(u->card->active_profile);
2591 /* Run from main thread */
2592 static const pa_bluetooth_device* find_device(struct userdata *u, const char *address, const char *path) {
2593 const pa_bluetooth_device *d = NULL;
2597 if (!address && !path) {
2598 pa_log_error("Failed to get device address/path from module arguments.");
2603 if (!(d = pa_bluetooth_discovery_get_by_path(u->discovery, path))) {
2604 pa_log_error("%s is not a valid BlueZ audio device.", path);
2608 if (address && !(pa_streq(d->address, address))) {
2609 pa_log_error("Passed path %s address %s != %s don't match.", path, d->address, address);
2614 if (!(d = pa_bluetooth_discovery_get_by_address(u->discovery, address))) {
2615 pa_log_error("%s is not known.", address);
2621 u->address = pa_xstrdup(d->address);
2622 u->path = pa_xstrdup(d->path);
2628 /* Run from main thread */
2629 static int setup_dbus(struct userdata *u) {
2632 dbus_error_init(&err);
2634 u->connection = pa_dbus_bus_get(u->core, DBUS_BUS_SYSTEM, &err);
2636 if (dbus_error_is_set(&err) || !u->connection) {
2637 pa_log("Failed to get D-Bus connection: %s", err.message);
2638 dbus_error_free(&err);
2645 int pa__init(pa_module* m) {
2649 const char *address, *path;
2651 char *mike, *speaker;
2652 const pa_bluetooth_device *device;
2656 dbus_error_init(&err);
2658 if (!(ma = pa_modargs_new(m->argument, valid_modargs))) {
2659 pa_log_error("Failed to parse module arguments");
2663 m->userdata = u = pa_xnew0(struct userdata, 1);
2668 u->sample_spec = m->core->default_sample_spec;
2672 if (pa_modargs_get_value(ma, "sco_sink", NULL) &&
2673 !(u->hsp.sco_sink = pa_namereg_get(m->core, pa_modargs_get_value(ma, "sco_sink", NULL), PA_NAMEREG_SINK))) {
2674 pa_log("SCO sink not found");
2678 if (pa_modargs_get_value(ma, "sco_source", NULL) &&
2679 !(u->hsp.sco_source = pa_namereg_get(m->core, pa_modargs_get_value(ma, "sco_source", NULL), PA_NAMEREG_SOURCE))) {
2680 pa_log("SCO source not found");
2685 if (pa_modargs_get_value_u32(ma, "rate", &u->sample_spec.rate) < 0 ||
2686 u->sample_spec.rate <= 0 || u->sample_spec.rate > PA_RATE_MAX) {
2687 pa_log_error("Failed to get rate from module arguments");
2691 u->auto_connect = TRUE;
2692 if (pa_modargs_get_value_boolean(ma, "auto_connect", &u->auto_connect)) {
2693 pa_log("Failed to parse auto_connect= argument");
2697 channels = u->sample_spec.channels;
2698 if (pa_modargs_get_value_u32(ma, "channels", &channels) < 0 ||
2699 channels <= 0 || channels > PA_CHANNELS_MAX) {
2700 pa_log_error("Failed to get channels from module arguments");
2703 u->sample_spec.channels = (uint8_t) channels;
2704 u->requested_sample_spec = u->sample_spec;
2706 address = pa_modargs_get_value(ma, "address", NULL);
2707 path = pa_modargs_get_value(ma, "path", NULL);
2709 if (setup_dbus(u) < 0)
2712 if (!(u->discovery = pa_bluetooth_discovery_get(m->core)))
2715 if (!(device = find_device(u, address, path)))
2718 /* Add the card structure. This will also initialize the default profile */
2719 if (add_card(u, device) < 0)
2722 if (!dbus_connection_add_filter(pa_dbus_connection_get(u->connection), filter_cb, u, NULL)) {
2723 pa_log_error("Failed to add filter function");
2726 u->filter_added = TRUE;
2728 speaker = pa_sprintf_malloc("type='signal',sender='org.bluez',interface='org.bluez.Headset',member='SpeakerGainChanged',path='%s'", u->path);
2729 mike = pa_sprintf_malloc("type='signal',sender='org.bluez',interface='org.bluez.Headset',member='MicrophoneGainChanged',path='%s'", u->path);
2731 if (pa_dbus_add_matches(
2732 pa_dbus_connection_get(u->connection), &err,
2740 pa_log("Failed to add D-Bus matches: %s", err.message);
2747 /* Connect to the BT service */
2750 if (u->profile != PROFILE_OFF)
2751 if (init_profile(u) < 0)
2754 if (u->sink || u->source)
2755 if (start_thread(u) < 0)
2764 dbus_error_free(&err);
2769 int pa__get_n_used(pa_module *m) {
2773 pa_assert_se(u = m->userdata);
2776 (u->sink ? pa_sink_linked_by(u->sink) : 0) +
2777 (u->source ? pa_source_linked_by(u->source) : 0);
2780 void pa__done(pa_module *m) {
2784 if (!(u = m->userdata))
2789 && !USE_SCO_OVER_PCM(u)
2792 pa_sink_unlink(u->sink);
2796 && !USE_SCO_OVER_PCM(u)
2799 pa_source_unlink(u->source);
2803 if (u->connection) {
2806 char *speaker, *mike;
2807 speaker = pa_sprintf_malloc("type='signal',sender='org.bluez',interface='org.bluez.Headset',member='SpeakerGainChanged',path='%s'", u->path);
2808 mike = pa_sprintf_malloc("type='signal',sender='org.bluez',interface='org.bluez.Headset',member='MicrophoneGainChanged',path='%s'", u->path);
2810 pa_dbus_remove_matches(pa_dbus_connection_get(u->connection), speaker, mike, NULL);
2816 if (u->filter_added)
2817 dbus_connection_remove_filter(pa_dbus_connection_get(u->connection), filter_cb, u);
2819 pa_dbus_connection_unref(u->connection);
2823 pa_card_free(u->card);
2825 if (u->read_smoother)
2826 pa_smoother_free(u->read_smoother);
2831 pa_xfree(u->a2dp.buffer);
2833 sbc_finish(&u->a2dp.sbc);
2836 pa_modargs_free(u->modargs);
2838 pa_xfree(u->address);
2842 bt_transport_release(u);
2843 pa_xfree(u->transport);
2847 pa_bluetooth_discovery_unref(u->discovery);