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, pa_bool_t changed) {
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);
1942 } else if (changed) {
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, TRUE);
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, TRUE);
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 u->sample_spec.format = PA_SAMPLE_S16LE;
2161 if (a2dp->sbc_initialized)
2162 sbc_reinit(&a2dp->sbc, 0);
2164 sbc_init(&a2dp->sbc, 0);
2165 a2dp->sbc_initialized = TRUE;
2167 switch (config->frequency) {
2168 case BT_SBC_SAMPLING_FREQ_16000:
2169 a2dp->sbc.frequency = SBC_FREQ_16000;
2170 u->sample_spec.rate = 16000U;
2172 case BT_SBC_SAMPLING_FREQ_32000:
2173 a2dp->sbc.frequency = SBC_FREQ_32000;
2174 u->sample_spec.rate = 32000U;
2176 case BT_SBC_SAMPLING_FREQ_44100:
2177 a2dp->sbc.frequency = SBC_FREQ_44100;
2178 u->sample_spec.rate = 44100U;
2180 case BT_SBC_SAMPLING_FREQ_48000:
2181 a2dp->sbc.frequency = SBC_FREQ_48000;
2182 u->sample_spec.rate = 48000U;
2185 pa_assert_not_reached();
2188 switch (config->channel_mode) {
2189 case BT_A2DP_CHANNEL_MODE_MONO:
2190 a2dp->sbc.mode = SBC_MODE_MONO;
2191 u->sample_spec.channels = 1;
2193 case BT_A2DP_CHANNEL_MODE_DUAL_CHANNEL:
2194 a2dp->sbc.mode = SBC_MODE_DUAL_CHANNEL;
2195 u->sample_spec.channels = 2;
2197 case BT_A2DP_CHANNEL_MODE_STEREO:
2198 a2dp->sbc.mode = SBC_MODE_STEREO;
2199 u->sample_spec.channels = 2;
2201 case BT_A2DP_CHANNEL_MODE_JOINT_STEREO:
2202 a2dp->sbc.mode = SBC_MODE_JOINT_STEREO;
2203 u->sample_spec.channels = 2;
2206 pa_assert_not_reached();
2209 switch (config->allocation_method) {
2210 case BT_A2DP_ALLOCATION_SNR:
2211 a2dp->sbc.allocation = SBC_AM_SNR;
2213 case BT_A2DP_ALLOCATION_LOUDNESS:
2214 a2dp->sbc.allocation = SBC_AM_LOUDNESS;
2217 pa_assert_not_reached();
2220 switch (config->subbands) {
2221 case BT_A2DP_SUBBANDS_4:
2222 a2dp->sbc.subbands = SBC_SB_4;
2224 case BT_A2DP_SUBBANDS_8:
2225 a2dp->sbc.subbands = SBC_SB_8;
2228 pa_assert_not_reached();
2231 switch (config->block_length) {
2232 case BT_A2DP_BLOCK_LENGTH_4:
2233 a2dp->sbc.blocks = SBC_BLK_4;
2235 case BT_A2DP_BLOCK_LENGTH_8:
2236 a2dp->sbc.blocks = SBC_BLK_8;
2238 case BT_A2DP_BLOCK_LENGTH_12:
2239 a2dp->sbc.blocks = SBC_BLK_12;
2241 case BT_A2DP_BLOCK_LENGTH_16:
2242 a2dp->sbc.blocks = SBC_BLK_16;
2245 pa_assert_not_reached();
2248 a2dp->min_bitpool = config->min_bitpool;
2249 a2dp->max_bitpool = config->max_bitpool;
2251 /* Set minimum bitpool for source to get the maximum possible block_size */
2252 a2dp->sbc.bitpool = u->profile == PROFILE_A2DP ? a2dp->max_bitpool : a2dp->min_bitpool;
2253 a2dp->codesize = sbc_get_codesize(&a2dp->sbc);
2254 a2dp->frame_length = sbc_get_frame_length(&a2dp->sbc);
2257 ((u->link_mtu - sizeof(struct rtp_header) - sizeof(struct rtp_payload))
2258 / a2dp->frame_length
2261 pa_log_info("SBC parameters:\n\tallocation=%u\n\tsubbands=%u\n\tblocks=%u\n\tbitpool=%u\n",
2262 a2dp->sbc.allocation, a2dp->sbc.subbands, a2dp->sbc.blocks, a2dp->sbc.bitpool);
2267 static int bt_transport_config(struct userdata *u) {
2268 if (u->profile == PROFILE_HSP || u->profile == PROFILE_HFGW) {
2269 u->block_size = u->link_mtu;
2270 u->sample_spec.format = PA_SAMPLE_S16LE;
2271 u->sample_spec.channels = 1;
2272 u->sample_spec.rate = 8000;
2276 return bt_transport_config_a2dp(u);
2279 /* Run from main thread */
2280 static int bt_transport_open(struct userdata *u) {
2281 if (bt_transport_acquire(u, FALSE) < 0)
2284 return bt_transport_config(u);
2287 /* Run from main thread */
2288 static int init_bt(struct userdata *u) {
2293 u->stream_write_type = 0;
2294 u->service_write_type = 0;
2295 u->service_read_type = 0;
2297 if ((u->service_fd = bt_audio_service_open()) < 0) {
2298 pa_log_warn("Bluetooth audio service not available");
2302 pa_log_debug("Connected to the bluetooth audio service");
2307 /* Run from main thread */
2308 static int setup_bt(struct userdata *u) {
2309 const pa_bluetooth_device *d;
2310 const pa_bluetooth_transport *t;
2314 if (!(d = pa_bluetooth_discovery_get_by_path(u->discovery, u->path))) {
2315 pa_log_error("Failed to get device object.");
2319 /* release transport if exist */
2321 bt_transport_release(u);
2322 pa_xfree(u->transport);
2323 u->transport = NULL;
2326 /* check if profile has a transport */
2327 t = pa_bluetooth_device_get_transport(d, u->profile);
2329 u->transport = pa_xstrdup(t->path);
2330 return bt_transport_open(u);
2333 if (get_caps(u, 0) < 0)
2336 pa_log_debug("Got device capabilities");
2338 if (set_conf(u) < 0)
2341 pa_log_debug("Connection to the device configured");
2343 if (USE_SCO_OVER_PCM(u)) {
2344 pa_log_debug("Configured to use SCO over PCM");
2348 pa_log_debug("Got the stream socket");
2353 /* Run from main thread */
2354 static int init_profile(struct userdata *u) {
2357 pa_assert(u->profile != PROFILE_OFF);
2359 if (setup_bt(u) < 0)
2362 if (u->profile == PROFILE_A2DP ||
2363 u->profile == PROFILE_HSP ||
2364 u->profile == PROFILE_HFGW)
2365 if (add_sink(u) < 0)
2368 if (u->profile == PROFILE_HSP ||
2369 u->profile == PROFILE_A2DP_SOURCE ||
2370 u->profile == PROFILE_HFGW)
2371 if (add_source(u) < 0)
2377 /* Run from main thread */
2378 static void stop_thread(struct userdata *u) {
2384 pa_asyncmsgq_send(u->thread_mq.inq, NULL, PA_MESSAGE_SHUTDOWN, NULL, 0, NULL);
2385 pa_thread_free(u->thread);
2389 if (u->rtpoll_item) {
2390 pa_rtpoll_item_free(u->rtpoll_item);
2391 u->rtpoll_item = NULL;
2394 if (u->hsp.sink_state_changed_slot) {
2395 pa_hook_slot_free(u->hsp.sink_state_changed_slot);
2396 u->hsp.sink_state_changed_slot = NULL;
2399 if (u->hsp.source_state_changed_slot) {
2400 pa_hook_slot_free(u->hsp.source_state_changed_slot);
2401 u->hsp.source_state_changed_slot = NULL;
2405 if (u->profile == PROFILE_HSP) {
2406 k = pa_sprintf_malloc("bluetooth-device@%p", (void*) u->sink);
2407 pa_shared_remove(u->core, k);
2411 pa_sink_unref(u->sink);
2416 if (u->profile == PROFILE_HSP) {
2417 k = pa_sprintf_malloc("bluetooth-device@%p", (void*) u->source);
2418 pa_shared_remove(u->core, k);
2422 pa_source_unref(u->source);
2427 pa_thread_mq_done(&u->thread_mq);
2429 pa_rtpoll_free(u->rtpoll);
2433 if (u->read_smoother) {
2434 pa_smoother_free(u->read_smoother);
2435 u->read_smoother = NULL;
2439 /* Run from main thread */
2440 static int start_thread(struct userdata *u) {
2442 pa_assert(!u->thread);
2443 pa_assert(!u->rtpoll);
2444 pa_assert(!u->rtpoll_item);
2446 u->rtpoll = pa_rtpoll_new();
2447 pa_thread_mq_init(&u->thread_mq, u->core->mainloop, u->rtpoll);
2449 if (USE_SCO_OVER_PCM(u)) {
2450 if (sco_over_pcm_state_update(u, FALSE) < 0) {
2454 k = pa_sprintf_malloc("bluetooth-device@%p", (void*) u->sink);
2455 pa_shared_remove(u->core, k);
2460 k = pa_sprintf_malloc("bluetooth-device@%p", (void*) u->source);
2461 pa_shared_remove(u->core, k);
2468 pa_sink_ref(u->sink);
2469 pa_source_ref(u->source);
2470 /* FIXME: monitor stream_fd error */
2474 if (!(u->thread = pa_thread_new("bluetooth", thread_func, u))) {
2475 pa_log_error("Failed to create IO thread");
2481 pa_sink_set_asyncmsgq(u->sink, u->thread_mq.inq);
2482 pa_sink_set_rtpoll(u->sink, u->rtpoll);
2483 pa_sink_put(u->sink);
2485 if (u->sink->set_volume)
2486 u->sink->set_volume(u->sink);
2490 pa_source_set_asyncmsgq(u->source, u->thread_mq.inq);
2491 pa_source_set_rtpoll(u->source, u->rtpoll);
2492 pa_source_put(u->source);
2494 if (u->source->set_volume)
2495 u->source->set_volume(u->source);
2501 static void save_sco_volume_callbacks(struct userdata *u) {
2503 pa_assert(USE_SCO_OVER_PCM(u));
2505 u->hsp.sco_sink_set_volume = u->hsp.sco_sink->set_volume;
2506 u->hsp.sco_source_set_volume = u->hsp.sco_source->set_volume;
2509 static void restore_sco_volume_callbacks(struct userdata *u) {
2511 pa_assert(USE_SCO_OVER_PCM(u));
2513 u->hsp.sco_sink->set_volume = u->hsp.sco_sink_set_volume;
2514 u->hsp.sco_source->set_volume = u->hsp.sco_source_set_volume;
2517 /* Run from main thread */
2518 static int card_set_profile(pa_card *c, pa_card_profile *new_profile) {
2521 pa_queue *inputs = NULL, *outputs = NULL;
2522 const pa_bluetooth_device *device;
2525 pa_assert(new_profile);
2526 pa_assert_se(u = c->userdata);
2528 d = PA_CARD_PROFILE_DATA(new_profile);
2530 if (!(device = pa_bluetooth_discovery_get_by_path(u->discovery, u->path))) {
2531 pa_log_error("Failed to get device object.");
2535 /* The state signal is sent by bluez, so it is racy to check
2536 strictly for CONNECTED, we should also accept STREAMING state
2537 as being good enough. However, if the profile is used
2538 concurrently (which is unlikely), ipc will fail later on, and
2539 module will be unloaded. */
2540 if (device->headset_state < PA_BT_AUDIO_STATE_CONNECTED && *d == PROFILE_HSP) {
2541 pa_log_warn("HSP is not connected, refused to switch profile");
2544 else if (device->audio_sink_state < PA_BT_AUDIO_STATE_CONNECTED && *d == PROFILE_A2DP) {
2545 pa_log_warn("A2DP is not connected, refused to switch profile");
2548 else if (device->hfgw_state <= PA_BT_AUDIO_STATE_CONNECTED && *d == PROFILE_HFGW) {
2549 pa_log_warn("HandsfreeGateway is not connected, refused to switch profile");
2554 inputs = pa_sink_move_all_start(u->sink, NULL);
2556 if (!USE_SCO_OVER_PCM(u))
2557 pa_sink_unlink(u->sink);
2561 outputs = pa_source_move_all_start(u->source, NULL);
2563 if (!USE_SCO_OVER_PCM(u))
2564 pa_source_unlink(u->source);
2570 if (USE_SCO_OVER_PCM(u))
2571 restore_sco_volume_callbacks(u);
2574 u->sample_spec = u->requested_sample_spec;
2576 if (USE_SCO_OVER_PCM(u))
2577 save_sco_volume_callbacks(u);
2581 if (u->profile != PROFILE_OFF)
2584 if (u->sink || u->source)
2589 pa_sink_move_all_finish(u->sink, inputs, FALSE);
2591 pa_sink_move_all_fail(inputs);
2596 pa_source_move_all_finish(u->source, outputs, FALSE);
2598 pa_source_move_all_fail(outputs);
2604 /* Run from main thread */
2605 static int add_card(struct userdata *u, const pa_bluetooth_device *device) {
2606 pa_card_new_data data;
2612 const char *default_profile;
2617 pa_card_new_data_init(&data);
2618 data.driver = __FILE__;
2619 data.module = u->module;
2621 n = pa_bluetooth_cleanup_name(device->name);
2622 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_DESCRIPTION, n);
2624 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_STRING, device->address);
2625 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_API, "bluez");
2626 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_CLASS, "sound");
2627 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_BUS, "bluetooth");
2628 if ((ff = pa_bluetooth_get_form_factor(device->class)))
2629 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_FORM_FACTOR, ff);
2630 pa_proplist_sets(data.proplist, "bluez.path", device->path);
2631 pa_proplist_setf(data.proplist, "bluez.class", "0x%06x", (unsigned) device->class);
2632 pa_proplist_sets(data.proplist, "bluez.name", device->name);
2633 data.name = get_name("card", u->modargs, device->address, &b);
2634 data.namereg_fail = b;
2636 if (pa_modargs_get_proplist(u->modargs, "card_properties", data.proplist, PA_UPDATE_REPLACE) < 0) {
2637 pa_log("Invalid properties");
2638 pa_card_new_data_done(&data);
2642 data.profiles = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
2644 /* we base hsp/a2dp availability on UUIDs.
2645 Ideally, it would be based on "Connected" state, but
2646 we can't afford to wait for this information when
2647 we are loaded with profile="hsp", for instance */
2648 if (pa_bluetooth_uuid_has(device->uuids, A2DP_SINK_UUID)) {
2649 p = pa_card_profile_new("a2dp", _("High Fidelity Playback (A2DP)"), sizeof(enum profile));
2653 p->max_sink_channels = 2;
2654 p->max_source_channels = 0;
2656 d = PA_CARD_PROFILE_DATA(p);
2659 pa_hashmap_put(data.profiles, p->name, p);
2662 if (pa_bluetooth_uuid_has(device->uuids, A2DP_SOURCE_UUID)) {
2663 p = pa_card_profile_new("a2dp_source", _("High Fidelity Capture (A2DP)"), sizeof(enum profile));
2667 p->max_sink_channels = 0;
2668 p->max_source_channels = 2;
2670 d = PA_CARD_PROFILE_DATA(p);
2671 *d = PROFILE_A2DP_SOURCE;
2673 pa_hashmap_put(data.profiles, p->name, p);
2676 if (pa_bluetooth_uuid_has(device->uuids, HSP_HS_UUID) ||
2677 pa_bluetooth_uuid_has(device->uuids, HFP_HS_UUID)) {
2678 p = pa_card_profile_new("hsp", _("Telephony Duplex (HSP/HFP)"), sizeof(enum profile));
2682 p->max_sink_channels = 1;
2683 p->max_source_channels = 1;
2685 d = PA_CARD_PROFILE_DATA(p);
2688 pa_hashmap_put(data.profiles, p->name, p);
2691 if (pa_bluetooth_uuid_has(device->uuids, HFP_AG_UUID)) {
2692 p = pa_card_profile_new("hfgw", _("Handsfree Gateway"), sizeof(enum profile));
2696 p->max_sink_channels = 1;
2697 p->max_source_channels = 1;
2699 d = PA_CARD_PROFILE_DATA(p);
2702 pa_hashmap_put(data.profiles, p->name, p);
2705 pa_assert(!pa_hashmap_isempty(data.profiles));
2707 p = pa_card_profile_new("off", _("Off"), sizeof(enum profile));
2708 d = PA_CARD_PROFILE_DATA(p);
2710 pa_hashmap_put(data.profiles, p->name, p);
2712 if ((default_profile = pa_modargs_get_value(u->modargs, "profile", NULL))) {
2713 if (pa_hashmap_get(data.profiles, default_profile))
2714 pa_card_new_data_set_profile(&data, default_profile);
2716 pa_log_warn("Profile '%s' not valid or not supported by device.", default_profile);
2719 u->card = pa_card_new(u->core, &data);
2720 pa_card_new_data_done(&data);
2723 pa_log("Failed to allocate card.");
2727 u->card->userdata = u;
2728 u->card->set_profile = card_set_profile;
2730 d = PA_CARD_PROFILE_DATA(u->card->active_profile);
2732 if ((device->headset_state < PA_BT_AUDIO_STATE_CONNECTED && *d == PROFILE_HSP) ||
2733 (device->audio_sink_state < PA_BT_AUDIO_STATE_CONNECTED && *d == PROFILE_A2DP) ||
2734 (device->hfgw_state < PA_BT_AUDIO_STATE_CONNECTED && *d == PROFILE_HFGW)) {
2735 pa_log_warn("Default profile not connected, selecting off profile");
2736 u->card->active_profile = pa_hashmap_get(u->card->profiles, "off");
2737 u->card->save_profile = FALSE;
2740 d = PA_CARD_PROFILE_DATA(u->card->active_profile);
2743 if (USE_SCO_OVER_PCM(u))
2744 save_sco_volume_callbacks(u);
2749 /* Run from main thread */
2750 static const pa_bluetooth_device* find_device(struct userdata *u, const char *address, const char *path) {
2751 const pa_bluetooth_device *d = NULL;
2755 if (!address && !path) {
2756 pa_log_error("Failed to get device address/path from module arguments.");
2761 if (!(d = pa_bluetooth_discovery_get_by_path(u->discovery, path))) {
2762 pa_log_error("%s is not a valid BlueZ audio device.", path);
2766 if (address && !(pa_streq(d->address, address))) {
2767 pa_log_error("Passed path %s address %s != %s don't match.", path, d->address, address);
2772 if (!(d = pa_bluetooth_discovery_get_by_address(u->discovery, address))) {
2773 pa_log_error("%s is not known.", address);
2779 u->address = pa_xstrdup(d->address);
2780 u->path = pa_xstrdup(d->path);
2786 /* Run from main thread */
2787 static int setup_dbus(struct userdata *u) {
2790 dbus_error_init(&err);
2792 u->connection = pa_dbus_bus_get(u->core, DBUS_BUS_SYSTEM, &err);
2794 if (dbus_error_is_set(&err) || !u->connection) {
2795 pa_log("Failed to get D-Bus connection: %s", err.message);
2796 dbus_error_free(&err);
2803 int pa__init(pa_module* m) {
2807 const char *address, *path;
2809 char *mike, *speaker, *transport;
2810 const pa_bluetooth_device *device;
2814 dbus_error_init(&err);
2816 if (!(ma = pa_modargs_new(m->argument, valid_modargs))) {
2817 pa_log_error("Failed to parse module arguments");
2821 m->userdata = u = pa_xnew0(struct userdata, 1);
2826 u->sample_spec = m->core->default_sample_spec;
2829 if (pa_modargs_get_value(ma, "sco_sink", NULL) &&
2830 !(u->hsp.sco_sink = pa_namereg_get(m->core, pa_modargs_get_value(ma, "sco_sink", NULL), PA_NAMEREG_SINK))) {
2831 pa_log("SCO sink not found");
2835 if (pa_modargs_get_value(ma, "sco_source", NULL) &&
2836 !(u->hsp.sco_source = pa_namereg_get(m->core, pa_modargs_get_value(ma, "sco_source", NULL), PA_NAMEREG_SOURCE))) {
2837 pa_log("SCO source not found");
2841 if (pa_modargs_get_value_u32(ma, "rate", &u->sample_spec.rate) < 0 ||
2842 u->sample_spec.rate <= 0 || u->sample_spec.rate > PA_RATE_MAX) {
2843 pa_log_error("Failed to get rate from module arguments");
2847 u->auto_connect = TRUE;
2848 if (pa_modargs_get_value_boolean(ma, "auto_connect", &u->auto_connect)) {
2849 pa_log("Failed to parse auto_connect= argument");
2853 channels = u->sample_spec.channels;
2854 if (pa_modargs_get_value_u32(ma, "channels", &channels) < 0 ||
2855 channels <= 0 || channels > PA_CHANNELS_MAX) {
2856 pa_log_error("Failed to get channels from module arguments");
2859 u->sample_spec.channels = (uint8_t) channels;
2860 u->requested_sample_spec = u->sample_spec;
2862 address = pa_modargs_get_value(ma, "address", NULL);
2863 path = pa_modargs_get_value(ma, "path", NULL);
2865 if (setup_dbus(u) < 0)
2868 if (!(u->discovery = pa_bluetooth_discovery_get(m->core)))
2871 if (!(device = find_device(u, address, path)))
2874 /* Add the card structure. This will also initialize the default profile */
2875 if (add_card(u, device) < 0)
2878 if (!dbus_connection_add_filter(pa_dbus_connection_get(u->connection), filter_cb, u, NULL)) {
2879 pa_log_error("Failed to add filter function");
2882 u->filter_added = TRUE;
2884 speaker = pa_sprintf_malloc("type='signal',sender='org.bluez',interface='org.bluez.Headset',member='SpeakerGainChanged',path='%s'", u->path);
2885 mike = pa_sprintf_malloc("type='signal',sender='org.bluez',interface='org.bluez.Headset',member='MicrophoneGainChanged',path='%s'", u->path);
2886 transport = pa_sprintf_malloc("type='signal',sender='org.bluez',interface='org.bluez.MediaTransport',member='PropertyChanged'");
2888 if (pa_dbus_add_matches(
2889 pa_dbus_connection_get(u->connection), &err,
2897 pa_xfree(transport);
2899 pa_log("Failed to add D-Bus matches: %s", err.message);
2905 pa_xfree(transport);
2907 /* Connect to the BT service */
2910 if (u->profile != PROFILE_OFF)
2911 if (init_profile(u) < 0)
2914 if (u->sink || u->source)
2915 if (start_thread(u) < 0)
2924 dbus_error_free(&err);
2929 int pa__get_n_used(pa_module *m) {
2933 pa_assert_se(u = m->userdata);
2936 (u->sink ? pa_sink_linked_by(u->sink) : 0) +
2937 (u->source ? pa_source_linked_by(u->source) : 0);
2940 void pa__done(pa_module *m) {
2945 if (!(u = m->userdata))
2948 if (u->sink && !USE_SCO_OVER_PCM(u))
2949 pa_sink_unlink(u->sink);
2951 if (u->source && !USE_SCO_OVER_PCM(u))
2952 pa_source_unlink(u->source);
2956 if (USE_SCO_OVER_PCM(u))
2957 restore_sco_volume_callbacks(u);
2959 if (u->connection) {
2962 char *speaker, *mike;
2963 speaker = pa_sprintf_malloc("type='signal',sender='org.bluez',interface='org.bluez.Headset',member='SpeakerGainChanged',path='%s'", u->path);
2964 mike = pa_sprintf_malloc("type='signal',sender='org.bluez',interface='org.bluez.Headset',member='MicrophoneGainChanged',path='%s'", u->path);
2966 pa_dbus_remove_matches(pa_dbus_connection_get(u->connection), speaker, mike, NULL);
2972 if (u->filter_added)
2973 dbus_connection_remove_filter(pa_dbus_connection_get(u->connection), filter_cb, u);
2975 pa_dbus_connection_unref(u->connection);
2979 pa_card_free(u->card);
2981 if (u->read_smoother)
2982 pa_smoother_free(u->read_smoother);
2987 pa_xfree(u->a2dp.buffer);
2989 sbc_finish(&u->a2dp.sbc);
2992 pa_modargs_free(u->modargs);
2994 pa_xfree(u->address);
2998 bt_transport_release(u);
2999 pa_xfree(u->transport);
3003 pa_bluetooth_discovery_unref(u->discovery);