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/shared.h>
43 #include <pulsecore/socket-util.h>
44 #include <pulsecore/thread.h>
45 #include <pulsecore/thread-mq.h>
46 #include <pulsecore/poll.h>
47 #include <pulsecore/rtpoll.h>
48 #include <pulsecore/time-smoother.h>
49 #include <pulsecore/namereg.h>
50 #include <pulsecore/dbus-shared.h>
51 #include <pulsecore/llist.h>
53 #include "module-bluetooth-device-symdef.h"
56 #include "a2dp-codecs.h"
58 #include "bluetooth-util.h"
60 #define BITPOOL_DEC_LIMIT 32
61 #define BITPOOL_DEC_STEP 5
62 #define HSP_MAX_GAIN 15
64 PA_MODULE_AUTHOR("Joao Paulo Rechi Vita");
65 PA_MODULE_DESCRIPTION("Bluetooth audio sink and source");
66 PA_MODULE_VERSION(PACKAGE_VERSION);
67 PA_MODULE_LOAD_ONCE(FALSE);
69 "name=<name for the card/sink/source, to be prefixed> "
70 "card_name=<name for the card> "
71 "card_properties=<properties for the card> "
72 "sink_name=<name for the sink> "
73 "sink_properties=<properties for the sink> "
74 "source_name=<name for the source> "
75 "source_properties=<properties for the source> "
76 "address=<address of the device> "
77 "profile=<a2dp|hsp|hfgw> "
79 "channels=<number of channels> "
80 "path=<device object path> "
81 "auto_connect=<automatically connect?> "
82 "sco_sink=<SCO over PCM sink name> "
83 "sco_source=<SCO over PCM source name>");
85 /* TODO: not close fd when entering suspend mode in a2dp */
87 static const char* const valid_modargs[] = {
107 sbc_capabilities_t sbc_capabilities;
108 sbc_t sbc; /* Codec data */
109 pa_bool_t sbc_initialized; /* Keep track if the encoder is initialized */
110 size_t codesize, frame_length; /* SBC Codesize, frame_length. We simply cache those values here */
112 void* buffer; /* Codec transfer buffer */
113 size_t buffer_size; /* Size of the buffer */
115 uint16_t seq_num; /* Cumulative packet sequence */
121 pcm_capabilities_t pcm_capabilities;
123 void (*sco_sink_set_volume)(pa_sink *s);
124 pa_source *sco_source;
125 void (*sco_source_set_volume)(pa_source *s);
126 pa_hook_slot *sink_state_changed_slot;
127 pa_hook_slot *source_state_changed_slot;
139 pa_bluetooth_discovery *discovery;
140 pa_bool_t auto_connect;
142 pa_dbus_connection *connection;
148 pa_thread_mq thread_mq;
150 pa_rtpoll_item *rtpoll_item;
153 uint64_t read_index, write_index;
154 pa_usec_t started_at;
155 pa_smoother *read_smoother;
157 pa_memchunk write_memchunk;
159 pa_sample_spec sample_spec, requested_sample_spec;
167 struct a2dp_info a2dp;
170 enum profile profile;
174 int stream_write_type;
175 int service_write_type, service_read_type;
177 pa_bool_t filter_added;
180 #define FIXED_LATENCY_PLAYBACK_A2DP (25*PA_USEC_PER_MSEC)
181 #define FIXED_LATENCY_RECORD_A2DP (25*PA_USEC_PER_MSEC)
182 #define FIXED_LATENCY_PLAYBACK_HSP (125*PA_USEC_PER_MSEC)
183 #define FIXED_LATENCY_RECORD_HSP (25*PA_USEC_PER_MSEC)
185 #define MAX_PLAYBACK_CATCH_UP_USEC (100*PA_USEC_PER_MSEC)
187 #define USE_SCO_OVER_PCM(u) (u->profile == PROFILE_HSP && (u->hsp.sco_sink && u->hsp.sco_source))
189 static int init_bt(struct userdata *u);
190 static int init_profile(struct userdata *u);
192 static int service_send(struct userdata *u, const bt_audio_msg_header_t *msg) {
197 pa_assert(msg->length > 0);
199 if (u->service_fd < 0) {
200 pa_log_warn("Service not connected");
204 pa_log_debug("Sending %s -> %s",
205 pa_strnull(bt_audio_strtype(msg->type)),
206 pa_strnull(bt_audio_strname(msg->name)));
208 if ((r = pa_loop_write(u->service_fd, msg, msg->length, &u->service_write_type)) == (ssize_t) msg->length)
212 pa_log_error("Error sending data to audio service: %s", pa_cstrerror(errno));
214 pa_log_error("Short write()");
219 static int service_recv(struct userdata *u, bt_audio_msg_header_t *msg, size_t room) {
223 pa_assert(u->service_fd >= 0);
225 pa_assert(room >= sizeof(*msg));
227 pa_log_debug("Trying to receive message from audio service...");
229 /* First, read the header */
230 if ((r = pa_loop_read(u->service_fd, msg, sizeof(*msg), &u->service_read_type)) != sizeof(*msg))
233 if (msg->length < sizeof(*msg)) {
234 pa_log_error("Invalid message size.");
238 if (msg->length > room) {
239 pa_log_error("Not enough room.");
243 /* Secondly, read the payload */
244 if (msg->length > sizeof(*msg)) {
246 size_t remains = msg->length - sizeof(*msg);
248 if ((r = pa_loop_read(u->service_fd,
249 (uint8_t*) msg + sizeof(*msg),
251 &u->service_read_type)) != (ssize_t) remains)
255 pa_log_debug("Received %s <- %s",
256 pa_strnull(bt_audio_strtype(msg->type)),
257 pa_strnull(bt_audio_strname(msg->name)));
264 pa_log_error("Error receiving data from audio service: %s", pa_cstrerror(errno));
266 pa_log_error("Short read()");
271 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) {
275 pa_assert(u->service_fd >= 0);
278 if ((r = service_recv(u, rsp, room)) < 0)
281 if ((rsp->type != BT_INDICATION && rsp->type != BT_RESPONSE) ||
282 rsp->name != expected_name ||
283 (expected_size > 0 && rsp->length != expected_size)) {
285 if (rsp->type == BT_ERROR && rsp->length == sizeof(bt_audio_error_t))
286 pa_log_error("Received error condition: %s", pa_cstrerror(((bt_audio_error_t*) rsp)->posix_errno));
288 pa_log_error("Bogus message %s received while %s was expected",
289 pa_strnull(bt_audio_strname(rsp->name)),
290 pa_strnull(bt_audio_strname(expected_name)));
297 /* Run from main thread */
298 static int parse_caps(struct userdata *u, uint8_t seid, const struct bt_get_capabilities_rsp *rsp) {
300 const codec_capabilities_t *codec;
305 bytes_left = rsp->h.length - sizeof(*rsp);
307 if (bytes_left < sizeof(codec_capabilities_t)) {
308 pa_log_error("Packet too small to store codec information.");
312 codec = (codec_capabilities_t *) rsp->data; /** ALIGNMENT? **/
314 pa_log_debug("Payload size is %lu %lu", (unsigned long) bytes_left, (unsigned long) sizeof(*codec));
316 if (((u->profile == PROFILE_A2DP || u->profile == PROFILE_A2DP_SOURCE) && codec->transport != BT_CAPABILITIES_TRANSPORT_A2DP) ||
317 ((u->profile == PROFILE_HSP || u->profile == PROFILE_HFGW) && codec->transport != BT_CAPABILITIES_TRANSPORT_SCO)) {
318 pa_log_error("Got capabilities for wrong codec.");
322 if (u->profile == PROFILE_HSP || u->profile == PROFILE_HFGW) {
324 if (bytes_left <= 0 || codec->length != sizeof(u->hsp.pcm_capabilities))
327 pa_assert(codec->type == BT_HFP_CODEC_PCM);
329 if (codec->configured && seid == 0)
332 memcpy(&u->hsp.pcm_capabilities, codec, sizeof(u->hsp.pcm_capabilities));
334 } else if (u->profile == PROFILE_A2DP) {
336 while (bytes_left > 0) {
337 if ((codec->type == BT_A2DP_SBC_SINK) && !codec->lock)
340 bytes_left -= codec->length;
341 codec = (const codec_capabilities_t*) ((const uint8_t*) codec + codec->length);
344 if (bytes_left <= 0 || codec->length != sizeof(u->a2dp.sbc_capabilities))
347 pa_assert(codec->type == BT_A2DP_SBC_SINK);
349 if (codec->configured && seid == 0)
352 memcpy(&u->a2dp.sbc_capabilities, codec, sizeof(u->a2dp.sbc_capabilities));
354 } else if (u->profile == PROFILE_A2DP_SOURCE) {
356 while (bytes_left > 0) {
357 if ((codec->type == BT_A2DP_SBC_SOURCE) && !codec->lock)
360 bytes_left -= codec->length;
361 codec = (const codec_capabilities_t*) ((const uint8_t*) codec + codec->length);
364 if (bytes_left <= 0 || codec->length != sizeof(u->a2dp.sbc_capabilities))
367 pa_assert(codec->type == BT_A2DP_SBC_SOURCE);
369 if (codec->configured && seid == 0)
372 memcpy(&u->a2dp.sbc_capabilities, codec, sizeof(u->a2dp.sbc_capabilities));
378 /* Run from main thread */
379 static int get_caps(struct userdata *u, uint8_t seid) {
381 struct bt_get_capabilities_req getcaps_req;
382 struct bt_get_capabilities_rsp getcaps_rsp;
383 bt_audio_error_t error;
384 uint8_t buf[BT_SUGGESTED_BUFFER_SIZE];
390 memset(&msg, 0, sizeof(msg));
391 msg.getcaps_req.h.type = BT_REQUEST;
392 msg.getcaps_req.h.name = BT_GET_CAPABILITIES;
393 msg.getcaps_req.h.length = sizeof(msg.getcaps_req);
394 msg.getcaps_req.seid = seid;
396 pa_strlcpy(msg.getcaps_req.object, u->path, sizeof(msg.getcaps_req.object));
397 if (u->profile == PROFILE_A2DP || u->profile == PROFILE_A2DP_SOURCE)
398 msg.getcaps_req.transport = BT_CAPABILITIES_TRANSPORT_A2DP;
400 pa_assert(u->profile == PROFILE_HSP || u->profile == PROFILE_HFGW);
401 msg.getcaps_req.transport = BT_CAPABILITIES_TRANSPORT_SCO;
403 msg.getcaps_req.flags = u->auto_connect ? BT_FLAG_AUTOCONNECT : 0;
405 if (service_send(u, &msg.getcaps_req.h) < 0)
408 if (service_expect(u, &msg.getcaps_rsp.h, sizeof(msg), BT_GET_CAPABILITIES, 0) < 0)
411 ret = parse_caps(u, seid, &msg.getcaps_rsp);
415 return get_caps(u, ret);
418 /* Run from main thread */
419 static uint8_t a2dp_default_bitpool(uint8_t freq, uint8_t mode) {
422 case BT_SBC_SAMPLING_FREQ_16000:
423 case BT_SBC_SAMPLING_FREQ_32000:
426 case BT_SBC_SAMPLING_FREQ_44100:
429 case BT_A2DP_CHANNEL_MODE_MONO:
430 case BT_A2DP_CHANNEL_MODE_DUAL_CHANNEL:
433 case BT_A2DP_CHANNEL_MODE_STEREO:
434 case BT_A2DP_CHANNEL_MODE_JOINT_STEREO:
438 pa_log_warn("Invalid channel mode %u", mode);
442 case BT_SBC_SAMPLING_FREQ_48000:
445 case BT_A2DP_CHANNEL_MODE_MONO:
446 case BT_A2DP_CHANNEL_MODE_DUAL_CHANNEL:
449 case BT_A2DP_CHANNEL_MODE_STEREO:
450 case BT_A2DP_CHANNEL_MODE_JOINT_STEREO:
454 pa_log_warn("Invalid channel mode %u", mode);
459 pa_log_warn("Invalid sampling freq %u", freq);
464 /* Run from main thread */
465 static int setup_a2dp(struct userdata *u) {
466 sbc_capabilities_t *cap;
469 static const struct {
473 { 16000U, BT_SBC_SAMPLING_FREQ_16000 },
474 { 32000U, BT_SBC_SAMPLING_FREQ_32000 },
475 { 44100U, BT_SBC_SAMPLING_FREQ_44100 },
476 { 48000U, BT_SBC_SAMPLING_FREQ_48000 }
480 pa_assert(u->profile == PROFILE_A2DP || u->profile == PROFILE_A2DP_SOURCE);
482 cap = &u->a2dp.sbc_capabilities;
484 /* Find the lowest freq that is at least as high as the requested
486 for (i = 0; (unsigned) i < PA_ELEMENTSOF(freq_table); i++)
487 if (freq_table[i].rate >= u->sample_spec.rate && (cap->frequency & freq_table[i].cap)) {
488 u->sample_spec.rate = freq_table[i].rate;
489 cap->frequency = freq_table[i].cap;
493 if ((unsigned) i == PA_ELEMENTSOF(freq_table)) {
494 for (--i; i >= 0; i--) {
495 if (cap->frequency & freq_table[i].cap) {
496 u->sample_spec.rate = freq_table[i].rate;
497 cap->frequency = freq_table[i].cap;
503 pa_log("Not suitable sample rate");
508 pa_assert((unsigned) i < PA_ELEMENTSOF(freq_table));
510 if (cap->capability.configured)
513 if (u->sample_spec.channels <= 1) {
514 if (cap->channel_mode & BT_A2DP_CHANNEL_MODE_MONO) {
515 cap->channel_mode = BT_A2DP_CHANNEL_MODE_MONO;
516 u->sample_spec.channels = 1;
518 u->sample_spec.channels = 2;
521 if (u->sample_spec.channels >= 2) {
522 u->sample_spec.channels = 2;
524 if (cap->channel_mode & BT_A2DP_CHANNEL_MODE_JOINT_STEREO)
525 cap->channel_mode = BT_A2DP_CHANNEL_MODE_JOINT_STEREO;
526 else if (cap->channel_mode & BT_A2DP_CHANNEL_MODE_STEREO)
527 cap->channel_mode = BT_A2DP_CHANNEL_MODE_STEREO;
528 else if (cap->channel_mode & BT_A2DP_CHANNEL_MODE_DUAL_CHANNEL)
529 cap->channel_mode = BT_A2DP_CHANNEL_MODE_DUAL_CHANNEL;
530 else if (cap->channel_mode & BT_A2DP_CHANNEL_MODE_MONO) {
531 cap->channel_mode = BT_A2DP_CHANNEL_MODE_MONO;
532 u->sample_spec.channels = 1;
534 pa_log("No supported channel modes");
539 if (cap->block_length & BT_A2DP_BLOCK_LENGTH_16)
540 cap->block_length = BT_A2DP_BLOCK_LENGTH_16;
541 else if (cap->block_length & BT_A2DP_BLOCK_LENGTH_12)
542 cap->block_length = BT_A2DP_BLOCK_LENGTH_12;
543 else if (cap->block_length & BT_A2DP_BLOCK_LENGTH_8)
544 cap->block_length = BT_A2DP_BLOCK_LENGTH_8;
545 else if (cap->block_length & BT_A2DP_BLOCK_LENGTH_4)
546 cap->block_length = BT_A2DP_BLOCK_LENGTH_4;
548 pa_log_error("No supported block lengths");
552 if (cap->subbands & BT_A2DP_SUBBANDS_8)
553 cap->subbands = BT_A2DP_SUBBANDS_8;
554 else if (cap->subbands & BT_A2DP_SUBBANDS_4)
555 cap->subbands = BT_A2DP_SUBBANDS_4;
557 pa_log_error("No supported subbands");
561 if (cap->allocation_method & BT_A2DP_ALLOCATION_LOUDNESS)
562 cap->allocation_method = BT_A2DP_ALLOCATION_LOUDNESS;
563 else if (cap->allocation_method & BT_A2DP_ALLOCATION_SNR)
564 cap->allocation_method = BT_A2DP_ALLOCATION_SNR;
566 cap->min_bitpool = (uint8_t) PA_MAX(MIN_BITPOOL, cap->min_bitpool);
567 cap->max_bitpool = (uint8_t) PA_MIN(a2dp_default_bitpool(cap->frequency, cap->channel_mode), cap->max_bitpool);
572 /* Run from main thread */
573 static void setup_sbc(struct a2dp_info *a2dp, enum profile p) {
574 sbc_capabilities_t *active_capabilities;
578 active_capabilities = &a2dp->sbc_capabilities;
580 if (a2dp->sbc_initialized)
581 sbc_reinit(&a2dp->sbc, 0);
583 sbc_init(&a2dp->sbc, 0);
584 a2dp->sbc_initialized = TRUE;
586 switch (active_capabilities->frequency) {
587 case BT_SBC_SAMPLING_FREQ_16000:
588 a2dp->sbc.frequency = SBC_FREQ_16000;
590 case BT_SBC_SAMPLING_FREQ_32000:
591 a2dp->sbc.frequency = SBC_FREQ_32000;
593 case BT_SBC_SAMPLING_FREQ_44100:
594 a2dp->sbc.frequency = SBC_FREQ_44100;
596 case BT_SBC_SAMPLING_FREQ_48000:
597 a2dp->sbc.frequency = SBC_FREQ_48000;
600 pa_assert_not_reached();
603 switch (active_capabilities->channel_mode) {
604 case BT_A2DP_CHANNEL_MODE_MONO:
605 a2dp->sbc.mode = SBC_MODE_MONO;
607 case BT_A2DP_CHANNEL_MODE_DUAL_CHANNEL:
608 a2dp->sbc.mode = SBC_MODE_DUAL_CHANNEL;
610 case BT_A2DP_CHANNEL_MODE_STEREO:
611 a2dp->sbc.mode = SBC_MODE_STEREO;
613 case BT_A2DP_CHANNEL_MODE_JOINT_STEREO:
614 a2dp->sbc.mode = SBC_MODE_JOINT_STEREO;
617 pa_assert_not_reached();
620 switch (active_capabilities->allocation_method) {
621 case BT_A2DP_ALLOCATION_SNR:
622 a2dp->sbc.allocation = SBC_AM_SNR;
624 case BT_A2DP_ALLOCATION_LOUDNESS:
625 a2dp->sbc.allocation = SBC_AM_LOUDNESS;
628 pa_assert_not_reached();
631 switch (active_capabilities->subbands) {
632 case BT_A2DP_SUBBANDS_4:
633 a2dp->sbc.subbands = SBC_SB_4;
635 case BT_A2DP_SUBBANDS_8:
636 a2dp->sbc.subbands = SBC_SB_8;
639 pa_assert_not_reached();
642 switch (active_capabilities->block_length) {
643 case BT_A2DP_BLOCK_LENGTH_4:
644 a2dp->sbc.blocks = SBC_BLK_4;
646 case BT_A2DP_BLOCK_LENGTH_8:
647 a2dp->sbc.blocks = SBC_BLK_8;
649 case BT_A2DP_BLOCK_LENGTH_12:
650 a2dp->sbc.blocks = SBC_BLK_12;
652 case BT_A2DP_BLOCK_LENGTH_16:
653 a2dp->sbc.blocks = SBC_BLK_16;
656 pa_assert_not_reached();
659 a2dp->min_bitpool = active_capabilities->min_bitpool;
660 a2dp->max_bitpool = active_capabilities->max_bitpool;
662 /* Set minimum bitpool for source to get the maximum possible block_size */
663 a2dp->sbc.bitpool = p == PROFILE_A2DP ? a2dp->max_bitpool : a2dp->min_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) {
731 setup_sbc(&u->a2dp, u->profile);
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;
747 static void a2dp_set_bitpool(struct userdata *u, uint8_t bitpool)
749 struct a2dp_info *a2dp;
755 if (a2dp->sbc.bitpool == bitpool)
758 if (bitpool > a2dp->max_bitpool)
759 bitpool = a2dp->max_bitpool;
760 else if (bitpool < a2dp->min_bitpool)
761 bitpool = a2dp->min_bitpool;
763 a2dp->sbc.bitpool = bitpool;
765 a2dp->codesize = sbc_get_codesize(&a2dp->sbc);
766 a2dp->frame_length = sbc_get_frame_length(&a2dp->sbc);
768 pa_log_debug("Bitpool has changed to %u", a2dp->sbc.bitpool);
771 (u->link_mtu - sizeof(struct rtp_header) - sizeof(struct rtp_payload))
772 / a2dp->frame_length * a2dp->codesize;
774 pa_sink_set_max_request_within_thread(u->sink, u->block_size);
775 pa_sink_set_fixed_latency_within_thread(u->sink,
776 FIXED_LATENCY_PLAYBACK_A2DP + pa_bytes_to_usec(u->block_size, &u->sample_spec));
779 /* from IO thread, except in SCO over PCM */
781 static int setup_stream(struct userdata *u) {
782 struct pollfd *pollfd;
785 pa_make_fd_nonblock(u->stream_fd);
786 pa_make_socket_low_delay(u->stream_fd);
789 if (setsockopt(u->stream_fd, SOL_SOCKET, SO_TIMESTAMP, &one, sizeof(one)) < 0)
790 pa_log_warn("Failed to enable SO_TIMESTAMP: %s", pa_cstrerror(errno));
792 pa_log_debug("Stream properly set up, we're ready to roll!");
794 if (u->profile == PROFILE_A2DP)
795 a2dp_set_bitpool(u, u->a2dp.max_bitpool);
797 u->rtpoll_item = pa_rtpoll_item_new(u->rtpoll, PA_RTPOLL_NEVER, 1);
798 pollfd = pa_rtpoll_item_get_pollfd(u->rtpoll_item, NULL);
799 pollfd->fd = u->stream_fd;
800 pollfd->events = pollfd->revents = 0;
802 u->read_index = u->write_index = 0;
806 u->read_smoother = pa_smoother_new(
818 static int start_stream_fd(struct userdata *u) {
820 bt_audio_msg_header_t rsp;
821 struct bt_start_stream_req start_req;
822 struct bt_start_stream_rsp start_rsp;
823 struct bt_new_stream_ind streamfd_ind;
824 bt_audio_error_t error;
825 uint8_t buf[BT_SUGGESTED_BUFFER_SIZE];
829 pa_assert(u->rtpoll);
830 pa_assert(!u->rtpoll_item);
831 pa_assert(u->stream_fd < 0);
833 memset(msg.buf, 0, BT_SUGGESTED_BUFFER_SIZE);
834 msg.start_req.h.type = BT_REQUEST;
835 msg.start_req.h.name = BT_START_STREAM;
836 msg.start_req.h.length = sizeof(msg.start_req);
838 if (service_send(u, &msg.start_req.h) < 0)
841 if (service_expect(u, &msg.rsp, sizeof(msg), BT_START_STREAM, sizeof(msg.start_rsp)) < 0)
844 if (service_expect(u, &msg.rsp, sizeof(msg), BT_NEW_STREAM, sizeof(msg.streamfd_ind)) < 0)
847 if ((u->stream_fd = bt_audio_service_get_data_fd(u->service_fd)) < 0) {
848 pa_log("Failed to get stream fd from audio service.");
852 return setup_stream(u);
856 static int stop_stream_fd(struct userdata *u) {
858 bt_audio_msg_header_t rsp;
859 struct bt_stop_stream_req start_req;
860 struct bt_stop_stream_rsp start_rsp;
861 bt_audio_error_t error;
862 uint8_t buf[BT_SUGGESTED_BUFFER_SIZE];
867 pa_assert(u->rtpoll);
869 if (u->rtpoll_item) {
870 pa_rtpoll_item_free(u->rtpoll_item);
871 u->rtpoll_item = NULL;
874 if (u->stream_fd >= 0) {
875 memset(msg.buf, 0, BT_SUGGESTED_BUFFER_SIZE);
876 msg.start_req.h.type = BT_REQUEST;
877 msg.start_req.h.name = BT_STOP_STREAM;
878 msg.start_req.h.length = sizeof(msg.start_req);
880 if (service_send(u, &msg.start_req.h) < 0 ||
881 service_expect(u, &msg.rsp, sizeof(msg), BT_STOP_STREAM, sizeof(msg.start_rsp)) < 0)
884 pa_close(u->stream_fd);
888 if (u->read_smoother) {
889 pa_smoother_free(u->read_smoother);
890 u->read_smoother = NULL;
896 static void bt_transport_release(struct userdata *u) {
897 const char *accesstype = "rw";
898 const pa_bluetooth_transport *t;
900 /* Ignore if already released */
904 pa_log_debug("Releasing transport %s", u->transport);
906 t = pa_bluetooth_discovery_get_transport(u->discovery, u->transport);
908 pa_bluetooth_transport_release(t, accesstype);
910 pa_xfree(u->accesstype);
911 u->accesstype = NULL;
913 if (u->rtpoll_item) {
914 pa_rtpoll_item_free(u->rtpoll_item);
915 u->rtpoll_item = NULL;
918 if (u->stream_fd >= 0) {
919 pa_close(u->stream_fd);
923 if (u->read_smoother) {
924 pa_smoother_free(u->read_smoother);
925 u->read_smoother = NULL;
929 static int bt_transport_acquire(struct userdata *u, pa_bool_t start) {
930 const char *accesstype = "rw";
931 const pa_bluetooth_transport *t;
939 pa_log_debug("Acquiring transport %s", u->transport);
941 t = pa_bluetooth_discovery_get_transport(u->discovery, u->transport);
943 pa_log("Transport %s no longer available", u->transport);
944 pa_xfree(u->transport);
949 /* FIXME: Handle in/out MTU properly when unix socket is not longer supported */
950 u->stream_fd = pa_bluetooth_transport_acquire(t, accesstype, NULL, &u->link_mtu);
951 if (u->stream_fd < 0)
954 u->accesstype = pa_xstrdup(accesstype);
955 pa_log_info("Transport %s acquired: fd %d", u->transport, u->stream_fd);
961 pa_log_info("Transport %s resuming", u->transport);
962 return setup_stream(u);
965 /* Run from IO thread */
966 static int sink_process_msg(pa_msgobject *o, int code, void *data, int64_t offset, pa_memchunk *chunk) {
967 struct userdata *u = PA_SINK(o)->userdata;
968 pa_bool_t failed = FALSE;
971 pa_assert(u->sink == PA_SINK(o));
975 case PA_SINK_MESSAGE_SET_STATE:
977 switch ((pa_sink_state_t) PA_PTR_TO_UINT(data)) {
979 case PA_SINK_SUSPENDED:
980 pa_assert(PA_SINK_IS_OPENED(u->sink->thread_info.state));
982 /* Stop the device if the source is suspended as well */
983 if (!u->source || u->source->state == PA_SOURCE_SUSPENDED) {
984 /* We deliberately ignore whether stopping
985 * actually worked. Since the stream_fd is
986 * closed it doesn't really matter */
988 bt_transport_release(u);
996 case PA_SINK_RUNNING:
997 if (u->sink->thread_info.state != PA_SINK_SUSPENDED)
1000 /* Resume the device if the source was suspended as well */
1001 if (!u->source || u->source->state == PA_SOURCE_SUSPENDED) {
1003 if (bt_transport_acquire(u, TRUE) < 0)
1005 } else if (start_stream_fd(u) < 0)
1010 case PA_SINK_UNLINKED:
1012 case PA_SINK_INVALID_STATE:
1017 case PA_SINK_MESSAGE_GET_LATENCY: {
1019 if (u->read_smoother) {
1022 ri = pa_smoother_get(u->read_smoother, pa_rtclock_now());
1023 wi = pa_bytes_to_usec(u->write_index + u->block_size, &u->sample_spec);
1025 *((pa_usec_t*) data) = wi > ri ? wi - ri : 0;
1029 ri = pa_rtclock_now() - u->started_at;
1030 wi = pa_bytes_to_usec(u->write_index, &u->sample_spec);
1032 *((pa_usec_t*) data) = wi > ri ? wi - ri : 0;
1035 *((pa_usec_t*) data) += u->sink->thread_info.fixed_latency;
1040 r = pa_sink_process_msg(o, code, data, offset, chunk);
1042 return (r < 0 || !failed) ? r : -1;
1045 /* Run from IO thread */
1046 static int source_process_msg(pa_msgobject *o, int code, void *data, int64_t offset, pa_memchunk *chunk) {
1047 struct userdata *u = PA_SOURCE(o)->userdata;
1048 pa_bool_t failed = FALSE;
1051 pa_assert(u->source == PA_SOURCE(o));
1055 case PA_SOURCE_MESSAGE_SET_STATE:
1057 switch ((pa_source_state_t) PA_PTR_TO_UINT(data)) {
1059 case PA_SOURCE_SUSPENDED:
1060 pa_assert(PA_SOURCE_IS_OPENED(u->source->thread_info.state));
1062 /* Stop the device if the sink is suspended as well */
1063 if (!u->sink || u->sink->state == PA_SINK_SUSPENDED) {
1065 bt_transport_release(u);
1070 if (u->read_smoother)
1071 pa_smoother_pause(u->read_smoother, pa_rtclock_now());
1074 case PA_SOURCE_IDLE:
1075 case PA_SOURCE_RUNNING:
1076 if (u->source->thread_info.state != PA_SOURCE_SUSPENDED)
1079 /* Resume the device if the sink was suspended as well */
1080 if (!u->sink || u->sink->thread_info.state == PA_SINK_SUSPENDED) {
1082 if (bt_transport_acquire(u, TRUE) < 0)
1084 } else if (start_stream_fd(u) < 0)
1087 /* We don't resume the smoother here. Instead we
1088 * wait until the first packet arrives */
1091 case PA_SOURCE_UNLINKED:
1092 case PA_SOURCE_INIT:
1093 case PA_SOURCE_INVALID_STATE:
1098 case PA_SOURCE_MESSAGE_GET_LATENCY: {
1101 if (u->read_smoother) {
1102 wi = pa_smoother_get(u->read_smoother, pa_rtclock_now());
1103 ri = pa_bytes_to_usec(u->read_index, &u->sample_spec);
1105 *((pa_usec_t*) data) = (wi > ri ? wi - ri : 0) + u->source->thread_info.fixed_latency;
1107 *((pa_usec_t*) data) = 0;
1114 r = pa_source_process_msg(o, code, data, offset, chunk);
1116 return (r < 0 || !failed) ? r : -1;
1119 /* Run from IO thread */
1120 static int hsp_process_render(struct userdata *u) {
1124 pa_assert(u->profile == PROFILE_HSP || u->profile == PROFILE_HFGW);
1127 /* First, render some data */
1128 if (!u->write_memchunk.memblock)
1129 pa_sink_render_full(u->sink, u->block_size, &u->write_memchunk);
1131 pa_assert(u->write_memchunk.length == u->block_size);
1137 /* Now write that data to the socket. The socket is of type
1138 * SEQPACKET, and we generated the data of the MTU size, so this
1139 * should just work. */
1141 p = (const uint8_t*) pa_memblock_acquire(u->write_memchunk.memblock) + u->write_memchunk.index;
1142 l = pa_write(u->stream_fd, p, u->write_memchunk.length, &u->stream_write_type);
1143 pa_memblock_release(u->write_memchunk.memblock);
1150 /* Retry right away if we got interrupted */
1153 else if (errno == EAGAIN)
1154 /* Hmm, apparently the socket was not writable, give up for now */
1157 pa_log_error("Failed to write data to SCO socket: %s", pa_cstrerror(errno));
1162 pa_assert((size_t) l <= u->write_memchunk.length);
1164 if ((size_t) l != u->write_memchunk.length) {
1165 pa_log_error("Wrote memory block to socket only partially! %llu written, wanted to write %llu.",
1166 (unsigned long long) l,
1167 (unsigned long long) u->write_memchunk.length);
1172 u->write_index += (uint64_t) u->write_memchunk.length;
1173 pa_memblock_unref(u->write_memchunk.memblock);
1174 pa_memchunk_reset(&u->write_memchunk);
1183 /* Run from IO thread */
1184 static int hsp_process_push(struct userdata *u) {
1186 pa_memchunk memchunk;
1189 pa_assert(u->profile == PROFILE_HSP || u->profile == PROFILE_HFGW);
1190 pa_assert(u->source);
1191 pa_assert(u->read_smoother);
1193 memchunk.memblock = pa_memblock_new(u->core->mempool, u->block_size);
1194 memchunk.index = memchunk.length = 0;
1203 pa_bool_t found_tstamp = FALSE;
1206 memset(&m, 0, sizeof(m));
1207 memset(&aux, 0, sizeof(aux));
1208 memset(&iov, 0, sizeof(iov));
1212 m.msg_control = aux;
1213 m.msg_controllen = sizeof(aux);
1215 p = pa_memblock_acquire(memchunk.memblock);
1217 iov.iov_len = pa_memblock_get_length(memchunk.memblock);
1218 l = recvmsg(u->stream_fd, &m, 0);
1219 pa_memblock_release(memchunk.memblock);
1223 if (l < 0 && errno == EINTR)
1224 /* Retry right away if we got interrupted */
1227 else if (l < 0 && errno == EAGAIN)
1228 /* Hmm, apparently the socket was not readable, give up for now. */
1231 pa_log_error("Failed to read data from SCO socket: %s", l < 0 ? pa_cstrerror(errno) : "EOF");
1236 pa_assert((size_t) l <= pa_memblock_get_length(memchunk.memblock));
1238 memchunk.length = (size_t) l;
1239 u->read_index += (uint64_t) l;
1241 for (cm = CMSG_FIRSTHDR(&m); cm; cm = CMSG_NXTHDR(&m, cm))
1242 if (cm->cmsg_level == SOL_SOCKET && cm->cmsg_type == SO_TIMESTAMP) {
1243 struct timeval *tv = (struct timeval*) CMSG_DATA(cm);
1244 pa_rtclock_from_wallclock(tv);
1245 tstamp = pa_timeval_load(tv);
1246 found_tstamp = TRUE;
1250 if (!found_tstamp) {
1251 pa_log_warn("Couldn't find SO_TIMESTAMP data in auxiliary recvmsg() data!");
1252 tstamp = pa_rtclock_now();
1255 pa_smoother_put(u->read_smoother, tstamp, pa_bytes_to_usec(u->read_index, &u->sample_spec));
1256 pa_smoother_resume(u->read_smoother, tstamp, TRUE);
1258 pa_source_post(u->source, &memchunk);
1264 pa_memblock_unref(memchunk.memblock);
1269 /* Run from IO thread */
1270 static void a2dp_prepare_buffer(struct userdata *u) {
1273 if (u->a2dp.buffer_size >= u->link_mtu)
1276 u->a2dp.buffer_size = 2 * u->link_mtu;
1277 pa_xfree(u->a2dp.buffer);
1278 u->a2dp.buffer = pa_xmalloc(u->a2dp.buffer_size);
1281 /* Run from IO thread */
1282 static int a2dp_process_render(struct userdata *u) {
1283 struct a2dp_info *a2dp;
1284 struct rtp_header *header;
1285 struct rtp_payload *payload;
1289 size_t to_write, to_encode;
1290 unsigned frame_count;
1294 pa_assert(u->profile == PROFILE_A2DP);
1297 /* First, render some data */
1298 if (!u->write_memchunk.memblock)
1299 pa_sink_render_full(u->sink, u->block_size, &u->write_memchunk);
1301 pa_assert(u->write_memchunk.length == u->block_size);
1303 a2dp_prepare_buffer(u);
1306 header = a2dp->buffer;
1307 payload = (struct rtp_payload*) ((uint8_t*) a2dp->buffer + sizeof(*header));
1311 /* Try to create a packet of the full MTU */
1313 p = (const uint8_t*) pa_memblock_acquire(u->write_memchunk.memblock) + u->write_memchunk.index;
1314 to_encode = u->write_memchunk.length;
1316 d = (uint8_t*) a2dp->buffer + sizeof(*header) + sizeof(*payload);
1317 to_write = a2dp->buffer_size - sizeof(*header) - sizeof(*payload);
1319 while (PA_LIKELY(to_encode > 0 && to_write > 0)) {
1323 encoded = sbc_encode(&a2dp->sbc,
1328 if (PA_UNLIKELY(encoded <= 0)) {
1329 pa_log_error("SBC encoding error (%li)", (long) encoded);
1330 pa_memblock_release(u->write_memchunk.memblock);
1334 /* pa_log_debug("SBC: encoded: %lu; written: %lu", (unsigned long) encoded, (unsigned long) written); */
1335 /* pa_log_debug("SBC: codesize: %lu; frame_length: %lu", (unsigned long) a2dp->codesize, (unsigned long) a2dp->frame_length); */
1337 pa_assert_fp((size_t) encoded <= to_encode);
1338 pa_assert_fp((size_t) encoded == a2dp->codesize);
1340 pa_assert_fp((size_t) written <= to_write);
1341 pa_assert_fp((size_t) written == a2dp->frame_length);
1343 p = (const uint8_t*) p + encoded;
1344 to_encode -= encoded;
1346 d = (uint8_t*) d + written;
1347 to_write -= written;
1352 pa_memblock_release(u->write_memchunk.memblock);
1354 pa_assert(to_encode == 0);
1357 pa_log_debug("Using SBC encoder implementation: %s", pa_strnull(sbc_get_implementation_info(&a2dp->sbc)));
1360 /* write it to the fifo */
1361 memset(a2dp->buffer, 0, sizeof(*header) + sizeof(*payload));
1364 header->sequence_number = htons(a2dp->seq_num++);
1365 header->timestamp = htonl(u->write_index / pa_frame_size(&u->sample_spec));
1366 header->ssrc = htonl(1);
1367 payload->frame_count = frame_count;
1369 nbytes = (uint8_t*) d - (uint8_t*) a2dp->buffer;
1374 l = pa_write(u->stream_fd, a2dp->buffer, nbytes, &u->stream_write_type);
1381 /* Retry right away if we got interrupted */
1384 else if (errno == EAGAIN)
1385 /* Hmm, apparently the socket was not writable, give up for now */
1388 pa_log_error("Failed to write data to socket: %s", pa_cstrerror(errno));
1393 pa_assert((size_t) l <= nbytes);
1395 if ((size_t) l != nbytes) {
1396 pa_log_warn("Wrote memory block to socket only partially! %llu written, wanted to write %llu.",
1397 (unsigned long long) l,
1398 (unsigned long long) nbytes);
1403 u->write_index += (uint64_t) u->write_memchunk.length;
1404 pa_memblock_unref(u->write_memchunk.memblock);
1405 pa_memchunk_reset(&u->write_memchunk);
1415 static int a2dp_process_push(struct userdata *u) {
1417 pa_memchunk memchunk;
1420 pa_assert(u->profile == PROFILE_A2DP_SOURCE);
1421 pa_assert(u->source);
1422 pa_assert(u->read_smoother);
1424 memchunk.memblock = pa_memblock_new(u->core->mempool, u->block_size);
1425 memchunk.index = memchunk.length = 0;
1428 pa_bool_t found_tstamp = FALSE;
1430 struct a2dp_info *a2dp;
1431 struct rtp_header *header;
1432 struct rtp_payload *payload;
1436 size_t to_write, to_decode;
1437 unsigned frame_count;
1439 a2dp_prepare_buffer(u);
1442 header = a2dp->buffer;
1443 payload = (struct rtp_payload*) ((uint8_t*) a2dp->buffer + sizeof(*header));
1445 l = pa_read(u->stream_fd, a2dp->buffer, a2dp->buffer_size, &u->stream_write_type);
1449 if (l < 0 && errno == EINTR)
1450 /* Retry right away if we got interrupted */
1453 else if (l < 0 && errno == EAGAIN)
1454 /* Hmm, apparently the socket was not readable, give up for now. */
1457 pa_log_error("Failed to read data from socket: %s", l < 0 ? pa_cstrerror(errno) : "EOF");
1462 pa_assert((size_t) l <= a2dp->buffer_size);
1464 u->read_index += (uint64_t) l;
1466 /* TODO: get timestamp from rtp */
1467 if (!found_tstamp) {
1468 /* pa_log_warn("Couldn't find SO_TIMESTAMP data in auxiliary recvmsg() data!"); */
1469 tstamp = pa_rtclock_now();
1472 pa_smoother_put(u->read_smoother, tstamp, pa_bytes_to_usec(u->read_index, &u->sample_spec));
1473 pa_smoother_resume(u->read_smoother, tstamp, TRUE);
1475 p = (uint8_t*) a2dp->buffer + sizeof(*header) + sizeof(*payload);
1476 to_decode = l - sizeof(*header) - sizeof(*payload);
1478 d = pa_memblock_acquire(memchunk.memblock);
1479 to_write = memchunk.length = pa_memblock_get_length(memchunk.memblock);
1481 while (PA_LIKELY(to_decode > 0)) {
1485 decoded = sbc_decode(&a2dp->sbc,
1490 if (PA_UNLIKELY(decoded <= 0)) {
1491 pa_log_error("SBC decoding error (%li)", (long) decoded);
1492 pa_memblock_release(memchunk.memblock);
1493 pa_memblock_unref(memchunk.memblock);
1497 /* pa_log_debug("SBC: decoded: %lu; written: %lu", (unsigned long) decoded, (unsigned long) written); */
1498 /* pa_log_debug("SBC: frame_length: %lu; codesize: %lu", (unsigned long) a2dp->frame_length, (unsigned long) a2dp->codesize); */
1500 /* Reset frame length, it can be changed due to bitpool change */
1501 a2dp->frame_length = sbc_get_frame_length(&a2dp->sbc);
1503 pa_assert_fp((size_t) decoded <= to_decode);
1504 pa_assert_fp((size_t) decoded == a2dp->frame_length);
1506 pa_assert_fp((size_t) written == a2dp->codesize);
1508 p = (const uint8_t*) p + decoded;
1509 to_decode -= decoded;
1511 d = (uint8_t*) d + written;
1512 to_write -= written;
1517 memchunk.length -= to_write;
1519 pa_memblock_release(memchunk.memblock);
1521 pa_source_post(u->source, &memchunk);
1527 pa_memblock_unref(memchunk.memblock);
1532 static void a2dp_reduce_bitpool(struct userdata *u)
1534 struct a2dp_info *a2dp;
1541 /* Check if bitpool is already at its limit */
1542 if (a2dp->sbc.bitpool <= BITPOOL_DEC_LIMIT)
1545 bitpool = a2dp->sbc.bitpool - BITPOOL_DEC_STEP;
1547 if (bitpool < BITPOOL_DEC_LIMIT)
1548 bitpool = BITPOOL_DEC_LIMIT;
1550 a2dp_set_bitpool(u, bitpool);
1553 static void thread_func(void *userdata) {
1554 struct userdata *u = userdata;
1555 unsigned do_write = 0;
1556 pa_bool_t writable = FALSE;
1560 pa_log_debug("IO Thread starting up");
1562 if (u->core->realtime_scheduling)
1563 pa_make_realtime(u->core->realtime_priority);
1565 pa_thread_mq_install(&u->thread_mq);
1568 if (bt_transport_acquire(u, TRUE) < 0)
1570 } else if (start_stream_fd(u) < 0)
1574 struct pollfd *pollfd;
1576 pa_bool_t disable_timer = TRUE;
1578 pollfd = u->rtpoll_item ? pa_rtpoll_item_get_pollfd(u->rtpoll_item, NULL) : NULL;
1580 if (u->source && PA_SOURCE_IS_LINKED(u->source->thread_info.state)) {
1582 /* We should send two blocks to the device before we expect
1585 if (u->write_index == 0 && u->read_index <= 0)
1588 if (pollfd && (pollfd->revents & POLLIN)) {
1591 if (u->profile == PROFILE_HSP || u->profile == PROFILE_HFGW)
1592 n_read = hsp_process_push(u);
1594 n_read = a2dp_process_push(u);
1599 /* We just read something, so we are supposed to write something, too */
1604 if (u->sink && PA_SINK_IS_LINKED(u->sink->thread_info.state)) {
1606 if (u->sink->thread_info.rewind_requested)
1607 pa_sink_process_rewind(u->sink, 0);
1610 if (pollfd->revents & POLLOUT)
1613 if ((!u->source || !PA_SOURCE_IS_LINKED(u->source->thread_info.state)) && do_write <= 0 && writable) {
1614 pa_usec_t time_passed;
1615 pa_usec_t audio_sent;
1617 /* Hmm, there is no input stream we could synchronize
1618 * to. So let's do things by time */
1620 time_passed = pa_rtclock_now() - u->started_at;
1621 audio_sent = pa_bytes_to_usec(u->write_index, &u->sample_spec);
1623 if (audio_sent <= time_passed) {
1624 pa_usec_t audio_to_send = time_passed - audio_sent;
1626 /* Never try to catch up for more than 100ms */
1627 if (u->write_index > 0 && audio_to_send > MAX_PLAYBACK_CATCH_UP_USEC) {
1628 pa_usec_t skip_usec;
1629 uint64_t skip_bytes;
1631 skip_usec = audio_to_send - MAX_PLAYBACK_CATCH_UP_USEC;
1632 skip_bytes = pa_usec_to_bytes(skip_usec, &u->sample_spec);
1634 if (skip_bytes > 0) {
1637 pa_log_warn("Skipping %llu us (= %llu bytes) in audio stream",
1638 (unsigned long long) skip_usec,
1639 (unsigned long long) skip_bytes);
1641 pa_sink_render_full(u->sink, skip_bytes, &tmp);
1642 pa_memblock_unref(tmp.memblock);
1643 u->write_index += skip_bytes;
1645 if (u->profile == PROFILE_A2DP)
1646 a2dp_reduce_bitpool(u);
1654 if (writable && do_write > 0) {
1657 if (u->write_index <= 0)
1658 u->started_at = pa_rtclock_now();
1660 if (u->profile == PROFILE_A2DP) {
1661 if ((n_written = a2dp_process_render(u)) < 0)
1664 if ((n_written = hsp_process_render(u)) < 0)
1669 pa_log("Broken kernel: we got EAGAIN on write() after POLLOUT!");
1671 do_write -= n_written;
1675 if ((!u->source || !PA_SOURCE_IS_LINKED(u->source->thread_info.state)) && do_write <= 0) {
1676 pa_usec_t sleep_for;
1677 pa_usec_t time_passed, next_write_at;
1680 /* Hmm, there is no input stream we could synchronize
1681 * to. So let's estimate when we need to wake up the latest */
1682 time_passed = pa_rtclock_now() - u->started_at;
1683 next_write_at = pa_bytes_to_usec(u->write_index, &u->sample_spec);
1684 sleep_for = time_passed < next_write_at ? next_write_at - time_passed : 0;
1685 /* 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); */
1687 /* drop stream every 500 ms */
1688 sleep_for = PA_USEC_PER_MSEC * 500;
1690 pa_rtpoll_set_timer_relative(u->rtpoll, sleep_for);
1691 disable_timer = FALSE;
1697 pa_rtpoll_set_timer_disabled(u->rtpoll);
1699 /* Hmm, nothing to do. Let's sleep */
1701 pollfd->events = (short) (((u->sink && PA_SINK_IS_LINKED(u->sink->thread_info.state) && !writable) ? POLLOUT : 0) |
1702 (u->source && PA_SOURCE_IS_LINKED(u->source->thread_info.state) ? POLLIN : 0));
1704 if ((ret = pa_rtpoll_run(u->rtpoll, TRUE)) < 0)
1710 pollfd = u->rtpoll_item ? pa_rtpoll_item_get_pollfd(u->rtpoll_item, NULL) : NULL;
1712 if (pollfd && (pollfd->revents & ~(POLLOUT|POLLIN))) {
1713 pa_log_info("FD error: %s%s%s%s",
1714 pollfd->revents & POLLERR ? "POLLERR " :"",
1715 pollfd->revents & POLLHUP ? "POLLHUP " :"",
1716 pollfd->revents & POLLPRI ? "POLLPRI " :"",
1717 pollfd->revents & POLLNVAL ? "POLLNVAL " :"");
1723 /* If this was no regular exit from the loop we have to continue processing messages until we receive PA_MESSAGE_SHUTDOWN */
1724 pa_log_debug("IO thread failed");
1725 pa_asyncmsgq_post(u->thread_mq.outq, PA_MSGOBJECT(u->core), PA_CORE_MESSAGE_UNLOAD_MODULE, u->module, 0, NULL, NULL);
1726 pa_asyncmsgq_wait_for(u->thread_mq.inq, PA_MESSAGE_SHUTDOWN);
1729 pa_log_debug("IO thread shutting down");
1732 /* Run from main thread */
1733 static DBusHandlerResult filter_cb(DBusConnection *bus, DBusMessage *m, void *userdata) {
1739 pa_assert_se(u = userdata);
1741 dbus_error_init(&err);
1743 pa_log_debug("dbus: interface=%s, path=%s, member=%s\n",
1744 dbus_message_get_interface(m),
1745 dbus_message_get_path(m),
1746 dbus_message_get_member(m));
1748 if (!dbus_message_has_path(m, u->path) && !dbus_message_has_path(m, u->transport))
1751 if (dbus_message_is_signal(m, "org.bluez.Headset", "SpeakerGainChanged") ||
1752 dbus_message_is_signal(m, "org.bluez.Headset", "MicrophoneGainChanged")) {
1757 if (!dbus_message_get_args(m, &err, DBUS_TYPE_UINT16, &gain, DBUS_TYPE_INVALID) || gain > HSP_MAX_GAIN) {
1758 pa_log("Failed to parse org.bluez.Headset.{Speaker|Microphone}GainChanged: %s", err.message);
1762 if (u->profile == PROFILE_HSP) {
1763 if (u->sink && dbus_message_is_signal(m, "org.bluez.Headset", "SpeakerGainChanged")) {
1764 pa_volume_t volume = (pa_volume_t) (gain * PA_VOLUME_NORM / HSP_MAX_GAIN);
1766 /* increment volume by one to correct rounding errors */
1767 if (volume < PA_VOLUME_NORM)
1770 pa_cvolume_set(&v, u->sample_spec.channels, volume);
1771 pa_sink_volume_changed(u->sink, &v);
1773 } else if (u->source && dbus_message_is_signal(m, "org.bluez.Headset", "MicrophoneGainChanged")) {
1774 pa_volume_t volume = (pa_volume_t) (gain * PA_VOLUME_NORM / HSP_MAX_GAIN);
1776 /* increment volume by one to correct rounding errors */
1777 if (volume < PA_VOLUME_NORM)
1780 pa_cvolume_set(&v, u->sample_spec.channels, volume);
1781 pa_source_volume_changed(u->source, &v);
1784 } else if (dbus_message_is_signal(m, "org.bluez.MediaTransport", "PropertyChanged")) {
1785 DBusMessageIter arg_i;
1786 pa_bluetooth_transport *t;
1789 t = (pa_bluetooth_transport *) pa_bluetooth_discovery_get_transport(u->discovery, u->transport);
1792 if (!dbus_message_iter_init(m, &arg_i)) {
1793 pa_log("Failed to parse PropertyChanged: %s", err.message);
1799 if (pa_bluetooth_transport_parse_property(t, &arg_i) < 0)
1802 if (nrec != t->nrec) {
1803 pa_log_debug("dbus: property 'NREC' changed to value '%s'", t->nrec ? "True" : "False");
1804 pa_proplist_sets(u->source->proplist, "bluetooth.nrec", t->nrec ? "1" : "0");
1809 dbus_error_free(&err);
1811 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1814 /* Run from main thread */
1815 static void sink_set_volume_cb(pa_sink *s) {
1825 k = pa_sprintf_malloc("bluetooth-device@%p", (void*) s);
1826 u = pa_shared_get(s->core, k);
1830 pa_assert(u->sink == s);
1831 pa_assert(u->profile == PROFILE_HSP);
1833 gain = (pa_cvolume_max(&s->real_volume) * HSP_MAX_GAIN) / PA_VOLUME_NORM;
1835 if (gain > HSP_MAX_GAIN)
1836 gain = HSP_MAX_GAIN;
1838 volume = (pa_volume_t) (gain * PA_VOLUME_NORM / HSP_MAX_GAIN);
1840 /* increment volume by one to correct rounding errors */
1841 if (volume < PA_VOLUME_NORM)
1844 pa_cvolume_set(&s->real_volume, u->sample_spec.channels, volume);
1846 pa_assert_se(m = dbus_message_new_method_call("org.bluez", u->path, "org.bluez.Headset", "SetSpeakerGain"));
1847 pa_assert_se(dbus_message_append_args(m, DBUS_TYPE_UINT16, &gain, DBUS_TYPE_INVALID));
1848 pa_assert_se(dbus_connection_send(pa_dbus_connection_get(u->connection), m, NULL));
1849 dbus_message_unref(m);
1852 /* Run from main thread */
1853 static void source_set_volume_cb(pa_source *s) {
1863 k = pa_sprintf_malloc("bluetooth-device@%p", (void*) s);
1864 u = pa_shared_get(s->core, k);
1868 pa_assert(u->source == s);
1869 pa_assert(u->profile == PROFILE_HSP);
1871 gain = (pa_cvolume_max(&s->volume) * HSP_MAX_GAIN) / PA_VOLUME_NORM;
1873 if (gain > HSP_MAX_GAIN)
1874 gain = HSP_MAX_GAIN;
1876 volume = (pa_volume_t) (gain * PA_VOLUME_NORM / HSP_MAX_GAIN);
1878 /* increment volume by one to correct rounding errors */
1879 if (volume < PA_VOLUME_NORM)
1882 pa_cvolume_set(&s->volume, u->sample_spec.channels, volume);
1884 pa_assert_se(m = dbus_message_new_method_call("org.bluez", u->path, "org.bluez.Headset", "SetMicrophoneGain"));
1885 pa_assert_se(dbus_message_append_args(m, DBUS_TYPE_UINT16, &gain, DBUS_TYPE_INVALID));
1886 pa_assert_se(dbus_connection_send(pa_dbus_connection_get(u->connection), m, NULL));
1887 dbus_message_unref(m);
1890 /* Run from main thread */
1891 static char *get_name(const char *type, pa_modargs *ma, const char *device_id, pa_bool_t *namereg_fail) {
1897 pa_assert(device_id);
1898 pa_assert(namereg_fail);
1900 t = pa_sprintf_malloc("%s_name", type);
1901 n = pa_modargs_get_value(ma, t, NULL);
1905 *namereg_fail = TRUE;
1906 return pa_xstrdup(n);
1909 if ((n = pa_modargs_get_value(ma, "name", NULL)))
1910 *namereg_fail = TRUE;
1913 *namereg_fail = FALSE;
1916 return pa_sprintf_malloc("bluez_%s.%s", type, n);
1919 static int sco_over_pcm_state_update(struct userdata *u) {
1921 pa_assert(USE_SCO_OVER_PCM(u));
1923 if (PA_SINK_IS_OPENED(pa_sink_get_state(u->hsp.sco_sink)) ||
1924 PA_SOURCE_IS_OPENED(pa_source_get_state(u->hsp.sco_source))) {
1926 if (u->service_fd >= 0 && u->stream_fd >= 0)
1931 pa_log_debug("Resuming SCO over PCM");
1932 if (init_profile(u) < 0) {
1933 pa_log("Can't resume SCO over PCM");
1938 return bt_transport_acquire(u, TRUE);
1940 return start_stream_fd(u);
1943 if (u->service_fd < 0 && u->stream_fd < 0)
1946 pa_log_debug("Closing SCO over PCM");
1949 bt_transport_release(u);
1950 else if (u->stream_fd >= 0)
1953 if (u->service_fd >= 0) {
1954 pa_close(u->service_fd);
1962 static pa_hook_result_t sink_state_changed_cb(pa_core *c, pa_sink *s, struct userdata *u) {
1964 pa_sink_assert_ref(s);
1967 if (s != u->hsp.sco_sink)
1970 sco_over_pcm_state_update(u);
1975 static pa_hook_result_t source_state_changed_cb(pa_core *c, pa_source *s, struct userdata *u) {
1977 pa_source_assert_ref(s);
1980 if (s != u->hsp.sco_source)
1983 sco_over_pcm_state_update(u);
1988 /* Run from main thread */
1989 static int add_sink(struct userdata *u) {
1992 if (USE_SCO_OVER_PCM(u)) {
1995 u->sink = u->hsp.sco_sink;
1996 p = pa_proplist_new();
1997 pa_proplist_sets(p, "bluetooth.protocol", "sco");
1998 pa_proplist_update(u->sink->proplist, PA_UPDATE_MERGE, p);
1999 pa_proplist_free(p);
2001 if (!u->hsp.sink_state_changed_slot)
2002 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);
2005 pa_sink_new_data data;
2008 pa_sink_new_data_init(&data);
2009 data.driver = __FILE__;
2010 data.module = u->module;
2011 pa_sink_new_data_set_sample_spec(&data, &u->sample_spec);
2012 pa_proplist_sets(data.proplist, "bluetooth.protocol", u->profile == PROFILE_A2DP ? "a2dp" : "sco");
2013 if (u->profile == PROFILE_HSP)
2014 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_INTENDED_ROLES, "phone");
2015 data.card = u->card;
2016 data.name = get_name("sink", u->modargs, u->address, &b);
2017 data.namereg_fail = b;
2019 if (pa_modargs_get_proplist(u->modargs, "sink_properties", data.proplist, PA_UPDATE_REPLACE) < 0) {
2020 pa_log("Invalid properties");
2021 pa_sink_new_data_done(&data);
2025 u->sink = pa_sink_new(u->core, &data, PA_SINK_HARDWARE|PA_SINK_LATENCY | (u->profile == PROFILE_HSP ? PA_SINK_HW_VOLUME_CTRL : 0));
2026 pa_sink_new_data_done(&data);
2029 pa_log_error("Failed to create sink");
2033 u->sink->userdata = u;
2034 u->sink->parent.process_msg = sink_process_msg;
2036 pa_sink_set_max_request(u->sink, u->block_size);
2037 pa_sink_set_fixed_latency(u->sink,
2038 (u->profile == PROFILE_A2DP ? FIXED_LATENCY_PLAYBACK_A2DP : FIXED_LATENCY_PLAYBACK_HSP) +
2039 pa_bytes_to_usec(u->block_size, &u->sample_spec));
2042 if (u->profile == PROFILE_HSP) {
2043 u->sink->set_volume = sink_set_volume_cb;
2044 u->sink->n_volume_steps = 16;
2046 k = pa_sprintf_malloc("bluetooth-device@%p", (void*) u->sink);
2047 pa_shared_set(u->core, k, u);
2054 /* Run from main thread */
2055 static int add_source(struct userdata *u) {
2058 if (USE_SCO_OVER_PCM(u)) {
2059 u->source = u->hsp.sco_source;
2060 pa_proplist_sets(u->source->proplist, "bluetooth.protocol", "hsp");
2062 if (!u->hsp.source_state_changed_slot)
2063 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);
2066 pa_source_new_data data;
2069 pa_source_new_data_init(&data);
2070 data.driver = __FILE__;
2071 data.module = u->module;
2072 pa_source_new_data_set_sample_spec(&data, &u->sample_spec);
2073 pa_proplist_sets(data.proplist, "bluetooth.protocol", u->profile == PROFILE_A2DP_SOURCE ? "a2dp_source" : "hsp");
2074 if ((u->profile == PROFILE_HSP) || (u->profile == PROFILE_HFGW))
2075 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_INTENDED_ROLES, "phone");
2077 data.card = u->card;
2078 data.name = get_name("source", u->modargs, u->address, &b);
2079 data.namereg_fail = b;
2081 if (pa_modargs_get_proplist(u->modargs, "source_properties", data.proplist, PA_UPDATE_REPLACE) < 0) {
2082 pa_log("Invalid properties");
2083 pa_source_new_data_done(&data);
2087 u->source = pa_source_new(u->core, &data, PA_SOURCE_HARDWARE|PA_SOURCE_LATENCY | (u->profile == PROFILE_HSP ? PA_SOURCE_HW_VOLUME_CTRL : 0));
2088 pa_source_new_data_done(&data);
2091 pa_log_error("Failed to create source");
2095 u->source->userdata = u;
2096 u->source->parent.process_msg = source_process_msg;
2098 pa_source_set_fixed_latency(u->source,
2099 (u->profile == PROFILE_A2DP_SOURCE ? FIXED_LATENCY_RECORD_A2DP : FIXED_LATENCY_RECORD_HSP) +
2100 pa_bytes_to_usec(u->block_size, &u->sample_spec));
2103 if ((u->profile == PROFILE_HSP) || (u->profile == PROFILE_HFGW)) {
2105 const pa_bluetooth_transport *t;
2106 t = pa_bluetooth_discovery_get_transport(u->discovery, u->transport);
2108 pa_proplist_sets(u->source->proplist, "bluetooth.nrec", t->nrec ? "1" : "0");
2110 pa_proplist_sets(u->source->proplist, "bluetooth.nrec", (u->hsp.pcm_capabilities.flags & BT_PCM_FLAG_NREC) ? "1" : "0");
2113 if (u->profile == PROFILE_HSP) {
2114 u->source->set_volume = source_set_volume_cb;
2115 u->source->n_volume_steps = 16;
2117 k = pa_sprintf_malloc("bluetooth-device@%p", (void*) u->source);
2118 pa_shared_set(u->core, k, u);
2125 /* Run from main thread */
2126 static void shutdown_bt(struct userdata *u) {
2129 if (u->stream_fd >= 0) {
2130 pa_close(u->stream_fd);
2133 u->stream_write_type = 0;
2136 if (u->service_fd >= 0) {
2137 pa_close(u->service_fd);
2139 u->service_write_type = 0;
2140 u->service_read_type = 0;
2143 if (u->write_memchunk.memblock) {
2144 pa_memblock_unref(u->write_memchunk.memblock);
2145 pa_memchunk_reset(&u->write_memchunk);
2149 static int bt_transport_config_a2dp(struct userdata *u) {
2150 const pa_bluetooth_transport *t;
2151 struct a2dp_info *a2dp = &u->a2dp;
2154 t = pa_bluetooth_discovery_get_transport(u->discovery, u->transport);
2157 config = (a2dp_sbc_t *) t->config;
2159 if (a2dp->sbc_initialized)
2160 sbc_reinit(&a2dp->sbc, 0);
2162 sbc_init(&a2dp->sbc, 0);
2163 a2dp->sbc_initialized = TRUE;
2165 switch (config->frequency) {
2166 case BT_SBC_SAMPLING_FREQ_16000:
2167 a2dp->sbc.frequency = SBC_FREQ_16000;
2169 case BT_SBC_SAMPLING_FREQ_32000:
2170 a2dp->sbc.frequency = SBC_FREQ_32000;
2172 case BT_SBC_SAMPLING_FREQ_44100:
2173 a2dp->sbc.frequency = SBC_FREQ_44100;
2175 case BT_SBC_SAMPLING_FREQ_48000:
2176 a2dp->sbc.frequency = SBC_FREQ_48000;
2179 pa_assert_not_reached();
2182 switch (config->channel_mode) {
2183 case BT_A2DP_CHANNEL_MODE_MONO:
2184 a2dp->sbc.mode = SBC_MODE_MONO;
2186 case BT_A2DP_CHANNEL_MODE_DUAL_CHANNEL:
2187 a2dp->sbc.mode = SBC_MODE_DUAL_CHANNEL;
2189 case BT_A2DP_CHANNEL_MODE_STEREO:
2190 a2dp->sbc.mode = SBC_MODE_STEREO;
2192 case BT_A2DP_CHANNEL_MODE_JOINT_STEREO:
2193 a2dp->sbc.mode = SBC_MODE_JOINT_STEREO;
2196 pa_assert_not_reached();
2199 switch (config->allocation_method) {
2200 case BT_A2DP_ALLOCATION_SNR:
2201 a2dp->sbc.allocation = SBC_AM_SNR;
2203 case BT_A2DP_ALLOCATION_LOUDNESS:
2204 a2dp->sbc.allocation = SBC_AM_LOUDNESS;
2207 pa_assert_not_reached();
2210 switch (config->subbands) {
2211 case BT_A2DP_SUBBANDS_4:
2212 a2dp->sbc.subbands = SBC_SB_4;
2214 case BT_A2DP_SUBBANDS_8:
2215 a2dp->sbc.subbands = SBC_SB_8;
2218 pa_assert_not_reached();
2221 switch (config->block_length) {
2222 case BT_A2DP_BLOCK_LENGTH_4:
2223 a2dp->sbc.blocks = SBC_BLK_4;
2225 case BT_A2DP_BLOCK_LENGTH_8:
2226 a2dp->sbc.blocks = SBC_BLK_8;
2228 case BT_A2DP_BLOCK_LENGTH_12:
2229 a2dp->sbc.blocks = SBC_BLK_12;
2231 case BT_A2DP_BLOCK_LENGTH_16:
2232 a2dp->sbc.blocks = SBC_BLK_16;
2235 pa_assert_not_reached();
2238 a2dp->min_bitpool = config->min_bitpool;
2239 a2dp->max_bitpool = config->max_bitpool;
2241 /* Set minimum bitpool for source to get the maximum possible block_size */
2242 a2dp->sbc.bitpool = u->profile == PROFILE_A2DP ? a2dp->max_bitpool : a2dp->min_bitpool;
2243 a2dp->codesize = sbc_get_codesize(&a2dp->sbc);
2244 a2dp->frame_length = sbc_get_frame_length(&a2dp->sbc);
2247 ((u->link_mtu - sizeof(struct rtp_header) - sizeof(struct rtp_payload))
2248 / a2dp->frame_length
2251 pa_log_info("SBC parameters:\n\tallocation=%u\n\tsubbands=%u\n\tblocks=%u\n\tbitpool=%u\n",
2252 a2dp->sbc.allocation, a2dp->sbc.subbands, a2dp->sbc.blocks, a2dp->sbc.bitpool);
2257 static int bt_transport_config(struct userdata *u) {
2258 if (u->profile == PROFILE_HSP || u->profile == PROFILE_HFGW) {
2259 u->block_size = u->link_mtu;
2263 return bt_transport_config_a2dp(u);
2266 /* Run from main thread */
2267 static int bt_transport_open(struct userdata *u) {
2268 if (bt_transport_acquire(u, FALSE) < 0)
2271 return bt_transport_config(u);
2274 /* Run from main thread */
2275 static int init_bt(struct userdata *u) {
2280 u->stream_write_type = 0;
2281 u->service_write_type = 0;
2282 u->service_read_type = 0;
2284 if ((u->service_fd = bt_audio_service_open()) < 0) {
2285 pa_log_warn("Bluetooth audio service not available");
2289 pa_log_debug("Connected to the bluetooth audio service");
2294 /* Run from main thread */
2295 static int setup_bt(struct userdata *u) {
2296 const pa_bluetooth_device *d;
2297 const pa_bluetooth_transport *t;
2301 if (!(d = pa_bluetooth_discovery_get_by_path(u->discovery, u->path))) {
2302 pa_log_error("Failed to get device object.");
2306 /* release transport if exist */
2308 bt_transport_release(u);
2309 pa_xfree(u->transport);
2310 u->transport = NULL;
2313 /* check if profile has a transport */
2314 t = pa_bluetooth_device_get_transport(d, u->profile);
2316 u->transport = pa_xstrdup(t->path);
2317 return bt_transport_open(u);
2320 if (get_caps(u, 0) < 0)
2323 pa_log_debug("Got device capabilities");
2325 if (set_conf(u) < 0)
2328 pa_log_debug("Connection to the device configured");
2330 if (USE_SCO_OVER_PCM(u)) {
2331 pa_log_debug("Configured to use SCO over PCM");
2335 pa_log_debug("Got the stream socket");
2340 /* Run from main thread */
2341 static int init_profile(struct userdata *u) {
2344 pa_assert(u->profile != PROFILE_OFF);
2346 if (setup_bt(u) < 0)
2349 if (u->profile == PROFILE_A2DP ||
2350 u->profile == PROFILE_HSP ||
2351 u->profile == PROFILE_HFGW)
2352 if (add_sink(u) < 0)
2355 if (u->profile == PROFILE_HSP ||
2356 u->profile == PROFILE_A2DP_SOURCE ||
2357 u->profile == PROFILE_HFGW)
2358 if (add_source(u) < 0)
2364 /* Run from main thread */
2365 static void stop_thread(struct userdata *u) {
2371 pa_asyncmsgq_send(u->thread_mq.inq, NULL, PA_MESSAGE_SHUTDOWN, NULL, 0, NULL);
2372 pa_thread_free(u->thread);
2376 if (u->rtpoll_item) {
2377 pa_rtpoll_item_free(u->rtpoll_item);
2378 u->rtpoll_item = NULL;
2381 if (u->hsp.sink_state_changed_slot) {
2382 pa_hook_slot_free(u->hsp.sink_state_changed_slot);
2383 u->hsp.sink_state_changed_slot = NULL;
2386 if (u->hsp.source_state_changed_slot) {
2387 pa_hook_slot_free(u->hsp.source_state_changed_slot);
2388 u->hsp.source_state_changed_slot = NULL;
2392 if (u->profile == PROFILE_HSP) {
2393 k = pa_sprintf_malloc("bluetooth-device@%p", (void*) u->sink);
2394 pa_shared_remove(u->core, k);
2398 pa_sink_unref(u->sink);
2403 if (u->profile == PROFILE_HSP) {
2404 k = pa_sprintf_malloc("bluetooth-device@%p", (void*) u->source);
2405 pa_shared_remove(u->core, k);
2409 pa_source_unref(u->source);
2414 pa_thread_mq_done(&u->thread_mq);
2416 pa_rtpoll_free(u->rtpoll);
2420 if (u->read_smoother) {
2421 pa_smoother_free(u->read_smoother);
2422 u->read_smoother = NULL;
2426 /* Run from main thread */
2427 static int start_thread(struct userdata *u) {
2429 pa_assert(!u->thread);
2430 pa_assert(!u->rtpoll);
2431 pa_assert(!u->rtpoll_item);
2433 u->rtpoll = pa_rtpoll_new();
2434 pa_thread_mq_init(&u->thread_mq, u->core->mainloop, u->rtpoll);
2436 if (USE_SCO_OVER_PCM(u)) {
2437 if (sco_over_pcm_state_update(u) < 0) {
2441 k = pa_sprintf_malloc("bluetooth-device@%p", (void*) u->sink);
2442 pa_shared_remove(u->core, k);
2447 k = pa_sprintf_malloc("bluetooth-device@%p", (void*) u->source);
2448 pa_shared_remove(u->core, k);
2455 pa_sink_ref(u->sink);
2456 pa_source_ref(u->source);
2457 /* FIXME: monitor stream_fd error */
2461 if (!(u->thread = pa_thread_new("bluetooth", thread_func, u))) {
2462 pa_log_error("Failed to create IO thread");
2468 pa_sink_set_asyncmsgq(u->sink, u->thread_mq.inq);
2469 pa_sink_set_rtpoll(u->sink, u->rtpoll);
2470 pa_sink_put(u->sink);
2472 if (u->sink->set_volume)
2473 u->sink->set_volume(u->sink);
2477 pa_source_set_asyncmsgq(u->source, u->thread_mq.inq);
2478 pa_source_set_rtpoll(u->source, u->rtpoll);
2479 pa_source_put(u->source);
2481 if (u->source->set_volume)
2482 u->source->set_volume(u->source);
2488 static void save_sco_volume_callbacks(struct userdata *u) {
2490 pa_assert(USE_SCO_OVER_PCM(u));
2492 u->hsp.sco_sink_set_volume = u->hsp.sco_sink->set_volume;
2493 u->hsp.sco_source_set_volume = u->hsp.sco_source->set_volume;
2496 static void restore_sco_volume_callbacks(struct userdata *u) {
2498 pa_assert(USE_SCO_OVER_PCM(u));
2500 u->hsp.sco_sink->set_volume = u->hsp.sco_sink_set_volume;
2501 u->hsp.sco_source->set_volume = u->hsp.sco_source_set_volume;
2504 /* Run from main thread */
2505 static int card_set_profile(pa_card *c, pa_card_profile *new_profile) {
2508 pa_queue *inputs = NULL, *outputs = NULL;
2509 const pa_bluetooth_device *device;
2512 pa_assert(new_profile);
2513 pa_assert_se(u = c->userdata);
2515 d = PA_CARD_PROFILE_DATA(new_profile);
2517 if (!(device = pa_bluetooth_discovery_get_by_path(u->discovery, u->path))) {
2518 pa_log_error("Failed to get device object.");
2522 /* The state signal is sent by bluez, so it is racy to check
2523 strictly for CONNECTED, we should also accept STREAMING state
2524 as being good enough. However, if the profile is used
2525 concurrently (which is unlikely), ipc will fail later on, and
2526 module will be unloaded. */
2527 if (device->headset_state < PA_BT_AUDIO_STATE_CONNECTED && *d == PROFILE_HSP) {
2528 pa_log_warn("HSP is not connected, refused to switch profile");
2531 else if (device->audio_sink_state < PA_BT_AUDIO_STATE_CONNECTED && *d == PROFILE_A2DP) {
2532 pa_log_warn("A2DP is not connected, refused to switch profile");
2535 else if (device->hfgw_state <= PA_BT_AUDIO_STATE_CONNECTED && *d == PROFILE_HFGW) {
2536 pa_log_warn("HandsfreeGateway is not connected, refused to switch profile");
2541 inputs = pa_sink_move_all_start(u->sink, NULL);
2543 if (!USE_SCO_OVER_PCM(u))
2544 pa_sink_unlink(u->sink);
2548 outputs = pa_source_move_all_start(u->source, NULL);
2550 if (!USE_SCO_OVER_PCM(u))
2551 pa_source_unlink(u->source);
2557 if (USE_SCO_OVER_PCM(u))
2558 restore_sco_volume_callbacks(u);
2561 u->sample_spec = u->requested_sample_spec;
2563 if (USE_SCO_OVER_PCM(u))
2564 save_sco_volume_callbacks(u);
2568 if (u->profile != PROFILE_OFF)
2571 if (u->sink || u->source)
2576 pa_sink_move_all_finish(u->sink, inputs, FALSE);
2578 pa_sink_move_all_fail(inputs);
2583 pa_source_move_all_finish(u->source, outputs, FALSE);
2585 pa_source_move_all_fail(outputs);
2591 /* Run from main thread */
2592 static int add_card(struct userdata *u, const pa_bluetooth_device *device) {
2593 pa_card_new_data data;
2599 const char *default_profile;
2604 pa_card_new_data_init(&data);
2605 data.driver = __FILE__;
2606 data.module = u->module;
2608 n = pa_bluetooth_cleanup_name(device->name);
2609 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_DESCRIPTION, n);
2611 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_STRING, device->address);
2612 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_API, "bluez");
2613 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_CLASS, "sound");
2614 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_BUS, "bluetooth");
2615 if ((ff = pa_bluetooth_get_form_factor(device->class)))
2616 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_FORM_FACTOR, ff);
2617 pa_proplist_sets(data.proplist, "bluez.path", device->path);
2618 pa_proplist_setf(data.proplist, "bluez.class", "0x%06x", (unsigned) device->class);
2619 pa_proplist_sets(data.proplist, "bluez.name", device->name);
2620 data.name = get_name("card", u->modargs, device->address, &b);
2621 data.namereg_fail = b;
2623 if (pa_modargs_get_proplist(u->modargs, "card_properties", data.proplist, PA_UPDATE_REPLACE) < 0) {
2624 pa_log("Invalid properties");
2625 pa_card_new_data_done(&data);
2629 data.profiles = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
2631 /* we base hsp/a2dp availability on UUIDs.
2632 Ideally, it would be based on "Connected" state, but
2633 we can't afford to wait for this information when
2634 we are loaded with profile="hsp", for instance */
2635 if (pa_bluetooth_uuid_has(device->uuids, A2DP_SINK_UUID)) {
2636 p = pa_card_profile_new("a2dp", _("High Fidelity Playback (A2DP)"), sizeof(enum profile));
2640 p->max_sink_channels = 2;
2641 p->max_source_channels = 0;
2643 d = PA_CARD_PROFILE_DATA(p);
2646 pa_hashmap_put(data.profiles, p->name, p);
2649 if (pa_bluetooth_uuid_has(device->uuids, A2DP_SOURCE_UUID)) {
2650 p = pa_card_profile_new("a2dp_source", _("High Fidelity Capture (A2DP)"), sizeof(enum profile));
2654 p->max_sink_channels = 0;
2655 p->max_source_channels = 2;
2657 d = PA_CARD_PROFILE_DATA(p);
2658 *d = PROFILE_A2DP_SOURCE;
2660 pa_hashmap_put(data.profiles, p->name, p);
2663 if (pa_bluetooth_uuid_has(device->uuids, HSP_HS_UUID) ||
2664 pa_bluetooth_uuid_has(device->uuids, HFP_HS_UUID)) {
2665 p = pa_card_profile_new("hsp", _("Telephony Duplex (HSP/HFP)"), sizeof(enum profile));
2669 p->max_sink_channels = 1;
2670 p->max_source_channels = 1;
2672 d = PA_CARD_PROFILE_DATA(p);
2675 pa_hashmap_put(data.profiles, p->name, p);
2678 if (pa_bluetooth_uuid_has(device->uuids, HFP_AG_UUID)) {
2679 p = pa_card_profile_new("hfgw", _("Handsfree Gateway"), sizeof(enum profile));
2683 p->max_sink_channels = 1;
2684 p->max_source_channels = 1;
2686 d = PA_CARD_PROFILE_DATA(p);
2689 pa_hashmap_put(data.profiles, p->name, p);
2692 pa_assert(!pa_hashmap_isempty(data.profiles));
2694 p = pa_card_profile_new("off", _("Off"), sizeof(enum profile));
2695 d = PA_CARD_PROFILE_DATA(p);
2697 pa_hashmap_put(data.profiles, p->name, p);
2699 if ((default_profile = pa_modargs_get_value(u->modargs, "profile", NULL))) {
2700 if (pa_hashmap_get(data.profiles, default_profile))
2701 pa_card_new_data_set_profile(&data, default_profile);
2703 pa_log_warn("Profile '%s' not valid or not supported by device.", default_profile);
2706 u->card = pa_card_new(u->core, &data);
2707 pa_card_new_data_done(&data);
2710 pa_log("Failed to allocate card.");
2714 u->card->userdata = u;
2715 u->card->set_profile = card_set_profile;
2717 d = PA_CARD_PROFILE_DATA(u->card->active_profile);
2719 if ((device->headset_state < PA_BT_AUDIO_STATE_CONNECTED && *d == PROFILE_HSP) ||
2720 (device->audio_sink_state < PA_BT_AUDIO_STATE_CONNECTED && *d == PROFILE_A2DP) ||
2721 (device->hfgw_state < PA_BT_AUDIO_STATE_CONNECTED && *d == PROFILE_HFGW)) {
2722 pa_log_warn("Default profile not connected, selecting off profile");
2723 u->card->active_profile = pa_hashmap_get(u->card->profiles, "off");
2724 u->card->save_profile = FALSE;
2727 d = PA_CARD_PROFILE_DATA(u->card->active_profile);
2730 if (USE_SCO_OVER_PCM(u))
2731 save_sco_volume_callbacks(u);
2736 /* Run from main thread */
2737 static const pa_bluetooth_device* find_device(struct userdata *u, const char *address, const char *path) {
2738 const pa_bluetooth_device *d = NULL;
2742 if (!address && !path) {
2743 pa_log_error("Failed to get device address/path from module arguments.");
2748 if (!(d = pa_bluetooth_discovery_get_by_path(u->discovery, path))) {
2749 pa_log_error("%s is not a valid BlueZ audio device.", path);
2753 if (address && !(pa_streq(d->address, address))) {
2754 pa_log_error("Passed path %s address %s != %s don't match.", path, d->address, address);
2759 if (!(d = pa_bluetooth_discovery_get_by_address(u->discovery, address))) {
2760 pa_log_error("%s is not known.", address);
2766 u->address = pa_xstrdup(d->address);
2767 u->path = pa_xstrdup(d->path);
2773 /* Run from main thread */
2774 static int setup_dbus(struct userdata *u) {
2777 dbus_error_init(&err);
2779 u->connection = pa_dbus_bus_get(u->core, DBUS_BUS_SYSTEM, &err);
2781 if (dbus_error_is_set(&err) || !u->connection) {
2782 pa_log("Failed to get D-Bus connection: %s", err.message);
2783 dbus_error_free(&err);
2790 int pa__init(pa_module* m) {
2794 const char *address, *path;
2796 char *mike, *speaker, *transport;
2797 const pa_bluetooth_device *device;
2801 dbus_error_init(&err);
2803 if (!(ma = pa_modargs_new(m->argument, valid_modargs))) {
2804 pa_log_error("Failed to parse module arguments");
2808 m->userdata = u = pa_xnew0(struct userdata, 1);
2813 u->sample_spec = m->core->default_sample_spec;
2816 if (pa_modargs_get_value(ma, "sco_sink", NULL) &&
2817 !(u->hsp.sco_sink = pa_namereg_get(m->core, pa_modargs_get_value(ma, "sco_sink", NULL), PA_NAMEREG_SINK))) {
2818 pa_log("SCO sink not found");
2822 if (pa_modargs_get_value(ma, "sco_source", NULL) &&
2823 !(u->hsp.sco_source = pa_namereg_get(m->core, pa_modargs_get_value(ma, "sco_source", NULL), PA_NAMEREG_SOURCE))) {
2824 pa_log("SCO source not found");
2828 if (pa_modargs_get_value_u32(ma, "rate", &u->sample_spec.rate) < 0 ||
2829 u->sample_spec.rate <= 0 || u->sample_spec.rate > PA_RATE_MAX) {
2830 pa_log_error("Failed to get rate from module arguments");
2834 u->auto_connect = TRUE;
2835 if (pa_modargs_get_value_boolean(ma, "auto_connect", &u->auto_connect)) {
2836 pa_log("Failed to parse auto_connect= argument");
2840 channels = u->sample_spec.channels;
2841 if (pa_modargs_get_value_u32(ma, "channels", &channels) < 0 ||
2842 channels <= 0 || channels > PA_CHANNELS_MAX) {
2843 pa_log_error("Failed to get channels from module arguments");
2846 u->sample_spec.channels = (uint8_t) channels;
2847 u->requested_sample_spec = u->sample_spec;
2849 address = pa_modargs_get_value(ma, "address", NULL);
2850 path = pa_modargs_get_value(ma, "path", NULL);
2852 if (setup_dbus(u) < 0)
2855 if (!(u->discovery = pa_bluetooth_discovery_get(m->core)))
2858 if (!(device = find_device(u, address, path)))
2861 /* Add the card structure. This will also initialize the default profile */
2862 if (add_card(u, device) < 0)
2865 if (!dbus_connection_add_filter(pa_dbus_connection_get(u->connection), filter_cb, u, NULL)) {
2866 pa_log_error("Failed to add filter function");
2869 u->filter_added = TRUE;
2871 speaker = pa_sprintf_malloc("type='signal',sender='org.bluez',interface='org.bluez.Headset',member='SpeakerGainChanged',path='%s'", u->path);
2872 mike = pa_sprintf_malloc("type='signal',sender='org.bluez',interface='org.bluez.Headset',member='MicrophoneGainChanged',path='%s'", u->path);
2873 transport = pa_sprintf_malloc("type='signal',sender='org.bluez',interface='org.bluez.MediaTransport',member='PropertyChanged'");
2875 if (pa_dbus_add_matches(
2876 pa_dbus_connection_get(u->connection), &err,
2884 pa_xfree(transport);
2886 pa_log("Failed to add D-Bus matches: %s", err.message);
2892 pa_xfree(transport);
2894 /* Connect to the BT service */
2897 if (u->profile != PROFILE_OFF)
2898 if (init_profile(u) < 0)
2901 if (u->sink || u->source)
2902 if (start_thread(u) < 0)
2911 dbus_error_free(&err);
2916 int pa__get_n_used(pa_module *m) {
2920 pa_assert_se(u = m->userdata);
2923 (u->sink ? pa_sink_linked_by(u->sink) : 0) +
2924 (u->source ? pa_source_linked_by(u->source) : 0);
2927 void pa__done(pa_module *m) {
2932 if (!(u = m->userdata))
2935 if (u->sink && !USE_SCO_OVER_PCM(u))
2936 pa_sink_unlink(u->sink);
2938 if (u->source && !USE_SCO_OVER_PCM(u))
2939 pa_source_unlink(u->source);
2943 if (USE_SCO_OVER_PCM(u))
2944 restore_sco_volume_callbacks(u);
2946 if (u->connection) {
2949 char *speaker, *mike;
2950 speaker = pa_sprintf_malloc("type='signal',sender='org.bluez',interface='org.bluez.Headset',member='SpeakerGainChanged',path='%s'", u->path);
2951 mike = pa_sprintf_malloc("type='signal',sender='org.bluez',interface='org.bluez.Headset',member='MicrophoneGainChanged',path='%s'", u->path);
2953 pa_dbus_remove_matches(pa_dbus_connection_get(u->connection), speaker, mike, NULL);
2959 if (u->filter_added)
2960 dbus_connection_remove_filter(pa_dbus_connection_get(u->connection), filter_cb, u);
2962 pa_dbus_connection_unref(u->connection);
2966 pa_card_free(u->card);
2968 if (u->read_smoother)
2969 pa_smoother_free(u->read_smoother);
2974 pa_xfree(u->a2dp.buffer);
2976 sbc_finish(&u->a2dp.sbc);
2979 pa_modargs_free(u->modargs);
2981 pa_xfree(u->address);
2985 bt_transport_release(u);
2986 pa_xfree(u->transport);
2990 pa_bluetooth_discovery_unref(u->discovery);