2 This file is part of PulseAudio.
4 Copyright 2008 Joao Paulo Rechi Vita
6 PulseAudio is free software; you can redistribute it and/or modify
7 it under the terms of the GNU Lesser General Public License as
8 published by the Free Software Foundation; either version 2.1 of the
9 License, or (at your option) any later version.
11 PulseAudio is distributed in the hope that it will be useful, but
12 WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 General Public License for more details.
16 You should have received a copy of the GNU Lesser General Public
17 License along with PulseAudio; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
29 #include <sys/ioctl.h>
30 #include <linux/sockios.h>
31 #include <arpa/inet.h>
33 #include <pulse/i18n.h>
34 #include <pulse/rtclock.h>
35 #include <pulse/sample.h>
36 #include <pulse/timeval.h>
37 #include <pulse/xmalloc.h>
39 #include <pulsecore/module.h>
40 #include <pulsecore/modargs.h>
41 #include <pulsecore/core-rtclock.h>
42 #include <pulsecore/core-util.h>
43 #include <pulsecore/core-error.h>
44 #include <pulsecore/socket-util.h>
45 #include <pulsecore/thread.h>
46 #include <pulsecore/thread-mq.h>
47 #include <pulsecore/rtpoll.h>
48 #include <pulsecore/time-smoother.h>
49 #include <pulsecore/namereg.h>
50 #include <pulsecore/dbus-shared.h>
52 #include "module-bluetooth-device-symdef.h"
56 #include "bluetooth-util.h"
58 #define MAX_BITPOOL 64
59 #define MIN_BITPOOL 2U
61 PA_MODULE_AUTHOR("Joao Paulo Rechi Vita");
62 PA_MODULE_DESCRIPTION("Bluetooth audio sink and source");
63 PA_MODULE_VERSION(PACKAGE_VERSION);
64 PA_MODULE_LOAD_ONCE(FALSE);
66 "name=<name for the card/sink/source, to be prefixed> "
67 "card_name=<name for the card> "
68 "card_properties=<properties for the card> "
69 "sink_name=<name for the sink> "
70 "sink_properties=<properties for the sink> "
71 "source_name=<name for the source> "
72 "source_properties=<properties for the source> "
73 "address=<address of the device> "
76 "channels=<number of channels> "
77 "path=<device object path>");
81 "sco_sink=<SCO over PCM sink name> "
82 "sco_source=<SCO over PCM source name>"
86 /* TODO: not close fd when entering suspend mode in a2dp */
88 static const char* const valid_modargs[] = {
109 sbc_capabilities_t sbc_capabilities;
110 sbc_t sbc; /* Codec data */
111 pa_bool_t sbc_initialized; /* Keep track if the encoder is initialized */
112 size_t codesize, frame_length; /* SBC Codesize, frame_length. We simply cache those values here */
114 void* buffer; /* Codec transfer buffer */
115 size_t buffer_size; /* Size of the buffer */
117 uint16_t seq_num; /* Cumulative packet sequence */
121 pcm_capabilities_t pcm_capabilities;
124 pa_source *sco_source;
126 pa_hook_slot *sink_state_changed_slot;
127 pa_hook_slot *source_state_changed_slot;
142 pa_bluetooth_discovery *discovery;
144 pa_dbus_connection *connection;
150 pa_thread_mq thread_mq;
152 pa_rtpoll_item *rtpoll_item;
155 uint64_t read_index, write_index;
156 pa_usec_t started_at;
157 pa_smoother *read_smoother;
159 pa_memchunk write_memchunk;
161 pa_sample_spec sample_spec, requested_sample_spec;
169 struct a2dp_info a2dp;
172 enum profile profile;
176 int stream_write_type;
177 int service_write_type, service_read_type;
180 #define FIXED_LATENCY_PLAYBACK_A2DP (25*PA_USEC_PER_MSEC)
181 #define FIXED_LATENCY_PLAYBACK_HSP (125*PA_USEC_PER_MSEC)
182 #define FIXED_LATENCY_RECORD_HSP (25*PA_USEC_PER_MSEC)
184 #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))
190 static int init_bt(struct userdata *u);
191 static int init_profile(struct userdata *u);
193 static int service_send(struct userdata *u, const bt_audio_msg_header_t *msg) {
197 pa_assert(u->service_fd >= 0);
199 pa_assert(msg->length > 0);
201 pa_log_debug("Sending %s -> %s",
202 pa_strnull(bt_audio_strtype(msg->type)),
203 pa_strnull(bt_audio_strname(msg->name)));
205 if ((r = pa_loop_write(u->service_fd, msg, msg->length, &u->service_write_type)) == (ssize_t) msg->length)
209 pa_log_error("Error sending data to audio service: %s", pa_cstrerror(errno));
211 pa_log_error("Short write()");
216 static int service_recv(struct userdata *u, bt_audio_msg_header_t *msg, size_t room) {
220 pa_assert(u->service_fd >= 0);
224 room = BT_SUGGESTED_BUFFER_SIZE;
226 pa_log_debug("Trying to receive message from audio service...");
228 /* First, read the header */
229 if ((r = pa_loop_read(u->service_fd, msg, sizeof(*msg), &u->service_read_type)) != sizeof(*msg))
232 if (msg->length < sizeof(*msg)) {
233 pa_log_error("Invalid message size.");
237 /* Secondly, read the payload */
238 if (msg->length > sizeof(*msg)) {
240 size_t remains = msg->length - sizeof(*msg);
242 if ((r = pa_loop_read(u->service_fd,
243 (uint8_t*) msg + sizeof(*msg),
245 &u->service_read_type)) != (ssize_t) remains)
249 pa_log_debug("Received %s <- %s",
250 pa_strnull(bt_audio_strtype(msg->type)),
251 pa_strnull(bt_audio_strname(msg->name)));
258 pa_log_error("Error receiving data from audio service: %s", pa_cstrerror(errno));
260 pa_log_error("Short read()");
265 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) {
269 pa_assert(u->service_fd >= 0);
272 if ((r = service_recv(u, rsp, room)) < 0)
275 if ((rsp->type != BT_INDICATION && rsp->type != BT_RESPONSE) ||
276 rsp->name != expected_name ||
277 (expected_size > 0 && rsp->length != expected_size)) {
279 if (rsp->type == BT_ERROR && rsp->length == sizeof(bt_audio_error_t))
280 pa_log_error("Received error condition: %s", pa_cstrerror(((bt_audio_error_t*) rsp)->posix_errno));
282 pa_log_error("Bogus message %s received while %s was expected",
283 pa_strnull(bt_audio_strname(rsp->name)),
284 pa_strnull(bt_audio_strname(expected_name)));
291 /* Run from main thread */
292 static int parse_caps(struct userdata *u, uint8_t seid, const struct bt_get_capabilities_rsp *rsp) {
294 const codec_capabilities_t *codec;
299 bytes_left = rsp->h.length - sizeof(*rsp);
301 if (bytes_left < sizeof(codec_capabilities_t)) {
302 pa_log_error("Packet too small to store codec information.");
306 codec = (codec_capabilities_t *) rsp->data; /** ALIGNMENT? **/
308 pa_log_debug("Payload size is %lu %lu", (unsigned long) bytes_left, (unsigned long) sizeof(*codec));
310 if ((u->profile == PROFILE_A2DP && codec->transport != BT_CAPABILITIES_TRANSPORT_A2DP) ||
311 (u->profile == PROFILE_HSP && codec->transport != BT_CAPABILITIES_TRANSPORT_SCO)) {
312 pa_log_error("Got capabilities for wrong codec.");
316 if (u->profile == PROFILE_HSP) {
318 if (bytes_left <= 0 || codec->length != sizeof(u->hsp.pcm_capabilities))
321 pa_assert(codec->type == BT_HFP_CODEC_PCM);
323 if (codec->configured && seid == 0)
326 memcpy(&u->hsp.pcm_capabilities, codec, sizeof(u->hsp.pcm_capabilities));
328 } else if (u->profile == PROFILE_A2DP) {
330 while (bytes_left > 0) {
331 if ((codec->type == BT_A2DP_SBC_SINK) && !codec->lock)
334 bytes_left -= codec->length;
335 codec = (const codec_capabilities_t*) ((const uint8_t*) codec + codec->length);
338 if (bytes_left <= 0 || codec->length != sizeof(u->a2dp.sbc_capabilities))
341 pa_assert(codec->type == BT_A2DP_SBC_SINK);
343 if (codec->configured && seid == 0)
346 memcpy(&u->a2dp.sbc_capabilities, codec, sizeof(u->a2dp.sbc_capabilities));
352 /* Run from main thread */
353 static int get_caps(struct userdata *u, uint8_t seid) {
355 struct bt_get_capabilities_req getcaps_req;
356 struct bt_get_capabilities_rsp getcaps_rsp;
357 bt_audio_error_t error;
358 uint8_t buf[BT_SUGGESTED_BUFFER_SIZE];
364 memset(&msg, 0, sizeof(msg));
365 msg.getcaps_req.h.type = BT_REQUEST;
366 msg.getcaps_req.h.name = BT_GET_CAPABILITIES;
367 msg.getcaps_req.h.length = sizeof(msg.getcaps_req);
368 msg.getcaps_req.seid = seid;
370 pa_strlcpy(msg.getcaps_req.object, u->path, sizeof(msg.getcaps_req.object));
371 if (u->profile == PROFILE_A2DP)
372 msg.getcaps_req.transport = BT_CAPABILITIES_TRANSPORT_A2DP;
374 pa_assert(u->profile == PROFILE_HSP);
375 msg.getcaps_req.transport = BT_CAPABILITIES_TRANSPORT_SCO;
377 msg.getcaps_req.flags = BT_FLAG_AUTOCONNECT;
379 if (service_send(u, &msg.getcaps_req.h) < 0)
382 if (service_expect(u, &msg.getcaps_rsp.h, sizeof(msg), BT_GET_CAPABILITIES, 0) < 0)
385 ret = parse_caps(u, seid, &msg.getcaps_rsp);
389 return get_caps(u, ret);
392 /* Run from main thread */
393 static uint8_t a2dp_default_bitpool(uint8_t freq, uint8_t mode) {
396 case BT_SBC_SAMPLING_FREQ_16000:
397 case BT_SBC_SAMPLING_FREQ_32000:
400 case BT_SBC_SAMPLING_FREQ_44100:
403 case BT_A2DP_CHANNEL_MODE_MONO:
404 case BT_A2DP_CHANNEL_MODE_DUAL_CHANNEL:
407 case BT_A2DP_CHANNEL_MODE_STEREO:
408 case BT_A2DP_CHANNEL_MODE_JOINT_STEREO:
412 pa_log_warn("Invalid channel mode %u", mode);
416 case BT_SBC_SAMPLING_FREQ_48000:
419 case BT_A2DP_CHANNEL_MODE_MONO:
420 case BT_A2DP_CHANNEL_MODE_DUAL_CHANNEL:
423 case BT_A2DP_CHANNEL_MODE_STEREO:
424 case BT_A2DP_CHANNEL_MODE_JOINT_STEREO:
428 pa_log_warn("Invalid channel mode %u", mode);
433 pa_log_warn("Invalid sampling freq %u", freq);
438 /* Run from main thread */
439 static int setup_a2dp(struct userdata *u) {
440 sbc_capabilities_t *cap;
443 static const struct {
447 { 16000U, BT_SBC_SAMPLING_FREQ_16000 },
448 { 32000U, BT_SBC_SAMPLING_FREQ_32000 },
449 { 44100U, BT_SBC_SAMPLING_FREQ_44100 },
450 { 48000U, BT_SBC_SAMPLING_FREQ_48000 }
454 pa_assert(u->profile == PROFILE_A2DP);
456 cap = &u->a2dp.sbc_capabilities;
458 /* Find the lowest freq that is at least as high as the requested
460 for (i = 0; (unsigned) i < PA_ELEMENTSOF(freq_table); i++)
461 if (freq_table[i].rate >= u->sample_spec.rate && (cap->frequency & freq_table[i].cap)) {
462 u->sample_spec.rate = freq_table[i].rate;
463 cap->frequency = freq_table[i].cap;
467 if ((unsigned) i == PA_ELEMENTSOF(freq_table)) {
468 for (--i; i >= 0; i--) {
469 if (cap->frequency & freq_table[i].cap) {
470 u->sample_spec.rate = freq_table[i].rate;
471 cap->frequency = freq_table[i].cap;
477 pa_log("Not suitable sample rate");
482 pa_assert((unsigned) i < PA_ELEMENTSOF(freq_table));
484 if (cap->capability.configured)
487 if (u->sample_spec.channels <= 1) {
488 if (cap->channel_mode & BT_A2DP_CHANNEL_MODE_MONO) {
489 cap->channel_mode = BT_A2DP_CHANNEL_MODE_MONO;
490 u->sample_spec.channels = 1;
492 u->sample_spec.channels = 2;
495 if (u->sample_spec.channels >= 2) {
496 u->sample_spec.channels = 2;
498 if (cap->channel_mode & BT_A2DP_CHANNEL_MODE_JOINT_STEREO)
499 cap->channel_mode = BT_A2DP_CHANNEL_MODE_JOINT_STEREO;
500 else if (cap->channel_mode & BT_A2DP_CHANNEL_MODE_STEREO)
501 cap->channel_mode = BT_A2DP_CHANNEL_MODE_STEREO;
502 else if (cap->channel_mode & BT_A2DP_CHANNEL_MODE_DUAL_CHANNEL)
503 cap->channel_mode = BT_A2DP_CHANNEL_MODE_DUAL_CHANNEL;
504 else if (cap->channel_mode & BT_A2DP_CHANNEL_MODE_MONO) {
505 cap->channel_mode = BT_A2DP_CHANNEL_MODE_MONO;
506 u->sample_spec.channels = 1;
508 pa_log("No supported channel modes");
513 if (cap->block_length & BT_A2DP_BLOCK_LENGTH_16)
514 cap->block_length = BT_A2DP_BLOCK_LENGTH_16;
515 else if (cap->block_length & BT_A2DP_BLOCK_LENGTH_12)
516 cap->block_length = BT_A2DP_BLOCK_LENGTH_12;
517 else if (cap->block_length & BT_A2DP_BLOCK_LENGTH_8)
518 cap->block_length = BT_A2DP_BLOCK_LENGTH_8;
519 else if (cap->block_length & BT_A2DP_BLOCK_LENGTH_4)
520 cap->block_length = BT_A2DP_BLOCK_LENGTH_4;
522 pa_log_error("No supported block lengths");
526 if (cap->subbands & BT_A2DP_SUBBANDS_8)
527 cap->subbands = BT_A2DP_SUBBANDS_8;
528 else if (cap->subbands & BT_A2DP_SUBBANDS_4)
529 cap->subbands = BT_A2DP_SUBBANDS_4;
531 pa_log_error("No supported subbands");
535 if (cap->allocation_method & BT_A2DP_ALLOCATION_LOUDNESS)
536 cap->allocation_method = BT_A2DP_ALLOCATION_LOUDNESS;
537 else if (cap->allocation_method & BT_A2DP_ALLOCATION_SNR)
538 cap->allocation_method = BT_A2DP_ALLOCATION_SNR;
540 cap->min_bitpool = (uint8_t) PA_MAX(MIN_BITPOOL, cap->min_bitpool);
541 cap->max_bitpool = (uint8_t) PA_MIN(a2dp_default_bitpool(cap->frequency, cap->channel_mode), cap->max_bitpool);
546 /* Run from main thread */
547 static void setup_sbc(struct a2dp_info *a2dp) {
548 sbc_capabilities_t *active_capabilities;
552 active_capabilities = &a2dp->sbc_capabilities;
554 if (a2dp->sbc_initialized)
555 sbc_reinit(&a2dp->sbc, 0);
557 sbc_init(&a2dp->sbc, 0);
558 a2dp->sbc_initialized = TRUE;
560 switch (active_capabilities->frequency) {
561 case BT_SBC_SAMPLING_FREQ_16000:
562 a2dp->sbc.frequency = SBC_FREQ_16000;
564 case BT_SBC_SAMPLING_FREQ_32000:
565 a2dp->sbc.frequency = SBC_FREQ_32000;
567 case BT_SBC_SAMPLING_FREQ_44100:
568 a2dp->sbc.frequency = SBC_FREQ_44100;
570 case BT_SBC_SAMPLING_FREQ_48000:
571 a2dp->sbc.frequency = SBC_FREQ_48000;
574 pa_assert_not_reached();
577 switch (active_capabilities->channel_mode) {
578 case BT_A2DP_CHANNEL_MODE_MONO:
579 a2dp->sbc.mode = SBC_MODE_MONO;
581 case BT_A2DP_CHANNEL_MODE_DUAL_CHANNEL:
582 a2dp->sbc.mode = SBC_MODE_DUAL_CHANNEL;
584 case BT_A2DP_CHANNEL_MODE_STEREO:
585 a2dp->sbc.mode = SBC_MODE_STEREO;
587 case BT_A2DP_CHANNEL_MODE_JOINT_STEREO:
588 a2dp->sbc.mode = SBC_MODE_JOINT_STEREO;
591 pa_assert_not_reached();
594 switch (active_capabilities->allocation_method) {
595 case BT_A2DP_ALLOCATION_SNR:
596 a2dp->sbc.allocation = SBC_AM_SNR;
598 case BT_A2DP_ALLOCATION_LOUDNESS:
599 a2dp->sbc.allocation = SBC_AM_LOUDNESS;
602 pa_assert_not_reached();
605 switch (active_capabilities->subbands) {
606 case BT_A2DP_SUBBANDS_4:
607 a2dp->sbc.subbands = SBC_SB_4;
609 case BT_A2DP_SUBBANDS_8:
610 a2dp->sbc.subbands = SBC_SB_8;
613 pa_assert_not_reached();
616 switch (active_capabilities->block_length) {
617 case BT_A2DP_BLOCK_LENGTH_4:
618 a2dp->sbc.blocks = SBC_BLK_4;
620 case BT_A2DP_BLOCK_LENGTH_8:
621 a2dp->sbc.blocks = SBC_BLK_8;
623 case BT_A2DP_BLOCK_LENGTH_12:
624 a2dp->sbc.blocks = SBC_BLK_12;
626 case BT_A2DP_BLOCK_LENGTH_16:
627 a2dp->sbc.blocks = SBC_BLK_16;
630 pa_assert_not_reached();
633 a2dp->sbc.bitpool = active_capabilities->max_bitpool;
634 a2dp->codesize = sbc_get_codesize(&a2dp->sbc);
635 a2dp->frame_length = sbc_get_frame_length(&a2dp->sbc);
638 /* Run from main thread */
639 static int set_conf(struct userdata *u) {
641 struct bt_open_req open_req;
642 struct bt_open_rsp open_rsp;
643 struct bt_set_configuration_req setconf_req;
644 struct bt_set_configuration_rsp setconf_rsp;
645 bt_audio_error_t error;
646 uint8_t buf[BT_SUGGESTED_BUFFER_SIZE];
649 memset(&msg, 0, sizeof(msg));
650 msg.open_req.h.type = BT_REQUEST;
651 msg.open_req.h.name = BT_OPEN;
652 msg.open_req.h.length = sizeof(msg.open_req);
654 pa_strlcpy(msg.open_req.object, u->path, sizeof(msg.open_req.object));
655 msg.open_req.seid = u->profile == PROFILE_A2DP ? u->a2dp.sbc_capabilities.capability.seid : BT_A2DP_SEID_RANGE + 1;
656 msg.open_req.lock = u->profile == PROFILE_A2DP ? BT_WRITE_LOCK : BT_READ_LOCK | BT_WRITE_LOCK;
658 if (service_send(u, &msg.open_req.h) < 0)
661 if (service_expect(u, &msg.open_rsp.h, sizeof(msg), BT_OPEN, sizeof(msg.open_rsp)) < 0)
664 if (u->profile == PROFILE_A2DP ) {
665 u->sample_spec.format = PA_SAMPLE_S16LE;
667 if (setup_a2dp(u) < 0)
670 pa_assert(u->profile == PROFILE_HSP);
672 u->sample_spec.format = PA_SAMPLE_S16LE;
673 u->sample_spec.channels = 1;
674 u->sample_spec.rate = 8000;
677 memset(&msg, 0, sizeof(msg));
678 msg.setconf_req.h.type = BT_REQUEST;
679 msg.setconf_req.h.name = BT_SET_CONFIGURATION;
680 msg.setconf_req.h.length = sizeof(msg.setconf_req);
682 if (u->profile == PROFILE_A2DP) {
683 memcpy(&msg.setconf_req.codec, &u->a2dp.sbc_capabilities, sizeof(u->a2dp.sbc_capabilities));
685 msg.setconf_req.codec.transport = BT_CAPABILITIES_TRANSPORT_SCO;
686 msg.setconf_req.codec.seid = BT_A2DP_SEID_RANGE + 1;
687 msg.setconf_req.codec.length = sizeof(pcm_capabilities_t);
689 msg.setconf_req.h.length += msg.setconf_req.codec.length - sizeof(msg.setconf_req.codec);
691 if (service_send(u, &msg.setconf_req.h) < 0)
694 if (service_expect(u, &msg.setconf_rsp.h, sizeof(msg), BT_SET_CONFIGURATION, sizeof(msg.setconf_rsp)) < 0)
697 u->link_mtu = msg.setconf_rsp.link_mtu;
699 /* setup SBC encoder now we agree on parameters */
700 if (u->profile == PROFILE_A2DP) {
704 ((u->link_mtu - sizeof(struct rtp_header) - sizeof(struct rtp_payload))
705 / u->a2dp.frame_length
708 pa_log_info("SBC parameters:\n\tallocation=%u\n\tsubbands=%u\n\tblocks=%u\n\tbitpool=%u\n",
709 u->a2dp.sbc.allocation, u->a2dp.sbc.subbands, u->a2dp.sbc.blocks, u->a2dp.sbc.bitpool);
711 u->block_size = u->link_mtu;
716 /* from IO thread, except in SCO over PCM */
717 static int start_stream_fd(struct userdata *u) {
719 bt_audio_msg_header_t rsp;
720 struct bt_start_stream_req start_req;
721 struct bt_start_stream_rsp start_rsp;
722 struct bt_new_stream_ind streamfd_ind;
723 bt_audio_error_t error;
724 uint8_t buf[BT_SUGGESTED_BUFFER_SIZE];
726 struct pollfd *pollfd;
730 pa_assert(u->rtpoll);
731 pa_assert(!u->rtpoll_item);
732 pa_assert(u->stream_fd < 0);
734 memset(msg.buf, 0, BT_SUGGESTED_BUFFER_SIZE);
735 msg.start_req.h.type = BT_REQUEST;
736 msg.start_req.h.name = BT_START_STREAM;
737 msg.start_req.h.length = sizeof(msg.start_req);
739 if (service_send(u, &msg.start_req.h) < 0)
742 if (service_expect(u, &msg.rsp, sizeof(msg), BT_START_STREAM, sizeof(msg.start_rsp)) < 0)
745 if (service_expect(u, &msg.rsp, sizeof(msg), BT_NEW_STREAM, sizeof(msg.streamfd_ind)) < 0)
748 if ((u->stream_fd = bt_audio_service_get_data_fd(u->service_fd)) < 0) {
749 pa_log("Failed to get stream fd from audio service.");
753 pa_make_fd_nonblock(u->stream_fd);
754 pa_make_socket_low_delay(u->stream_fd);
757 if (setsockopt(u->stream_fd, SOL_SOCKET, SO_TIMESTAMP, &one, sizeof(one)) < 0)
758 pa_log_warn("Failed to enable SO_TIMESTAMP: %s", pa_cstrerror(errno));
760 pa_log_debug("Stream properly set up, we're ready to roll!");
762 u->rtpoll_item = pa_rtpoll_item_new(u->rtpoll, PA_RTPOLL_NEVER, 1);
763 pollfd = pa_rtpoll_item_get_pollfd(u->rtpoll_item, NULL);
764 pollfd->fd = u->stream_fd;
765 pollfd->events = pollfd->revents = 0;
767 u->read_index = u->write_index = 0;
771 u->read_smoother = pa_smoother_new(
784 static int stop_stream_fd(struct userdata *u) {
786 bt_audio_msg_header_t rsp;
787 struct bt_stop_stream_req start_req;
788 struct bt_stop_stream_rsp start_rsp;
789 bt_audio_error_t error;
790 uint8_t buf[BT_SUGGESTED_BUFFER_SIZE];
795 pa_assert(u->rtpoll);
796 pa_assert(u->rtpoll_item);
797 pa_assert(u->stream_fd >= 0);
799 pa_rtpoll_item_free(u->rtpoll_item);
800 u->rtpoll_item = NULL;
802 memset(msg.buf, 0, BT_SUGGESTED_BUFFER_SIZE);
803 msg.start_req.h.type = BT_REQUEST;
804 msg.start_req.h.name = BT_STOP_STREAM;
805 msg.start_req.h.length = sizeof(msg.start_req);
807 if (service_send(u, &msg.start_req.h) < 0 ||
808 service_expect(u, &msg.rsp, sizeof(msg), BT_STOP_STREAM, sizeof(msg.start_rsp)) < 0)
811 pa_close(u->stream_fd);
814 if (u->read_smoother) {
815 pa_smoother_free(u->read_smoother);
816 u->read_smoother = NULL;
822 /* Run from IO thread */
823 static int sink_process_msg(pa_msgobject *o, int code, void *data, int64_t offset, pa_memchunk *chunk) {
824 struct userdata *u = PA_SINK(o)->userdata;
825 pa_bool_t failed = FALSE;
828 pa_assert(u->sink == PA_SINK(o));
832 case PA_SINK_MESSAGE_SET_STATE:
834 switch ((pa_sink_state_t) PA_PTR_TO_UINT(data)) {
836 case PA_SINK_SUSPENDED:
837 pa_assert(PA_SINK_IS_OPENED(u->sink->thread_info.state));
839 /* Stop the device if the source is suspended as well */
840 if (!u->source || u->source->state == PA_SOURCE_SUSPENDED)
841 /* We deliberately ignore whether stopping
842 * actually worked. Since the stream_fd is
843 * closed it doesn't really matter */
849 case PA_SINK_RUNNING:
850 if (u->sink->thread_info.state != PA_SINK_SUSPENDED)
853 /* Resume the device if the source was suspended as well */
854 if (!u->source || u->source->state == PA_SOURCE_SUSPENDED)
855 if (start_stream_fd(u) < 0)
859 case PA_SINK_UNLINKED:
861 case PA_SINK_INVALID_STATE:
866 case PA_SINK_MESSAGE_GET_LATENCY: {
868 if (u->read_smoother) {
871 ri = pa_smoother_get(u->read_smoother, pa_rtclock_now());
872 wi = pa_bytes_to_usec(u->write_index + u->block_size, &u->sample_spec);
874 *((pa_usec_t*) data) = wi > ri ? wi - ri : 0;
878 ri = pa_rtclock_now() - u->started_at;
879 wi = pa_bytes_to_usec(u->write_index, &u->sample_spec);
881 *((pa_usec_t*) data) = wi > ri ? wi - ri : 0;
884 *((pa_usec_t*) data) += u->sink->thread_info.fixed_latency;
889 r = pa_sink_process_msg(o, code, data, offset, chunk);
891 return (r < 0 || !failed) ? r : -1;
894 /* Run from IO thread */
895 static int source_process_msg(pa_msgobject *o, int code, void *data, int64_t offset, pa_memchunk *chunk) {
896 struct userdata *u = PA_SOURCE(o)->userdata;
897 pa_bool_t failed = FALSE;
900 pa_assert(u->source == PA_SOURCE(o));
904 case PA_SOURCE_MESSAGE_SET_STATE:
906 switch ((pa_source_state_t) PA_PTR_TO_UINT(data)) {
908 case PA_SOURCE_SUSPENDED:
909 pa_assert(PA_SOURCE_IS_OPENED(u->source->thread_info.state));
911 /* Stop the device if the sink is suspended as well */
912 if (!u->sink || u->sink->state == PA_SINK_SUSPENDED)
915 if (u->read_smoother)
916 pa_smoother_pause(u->read_smoother, pa_rtclock_now());
920 case PA_SOURCE_RUNNING:
921 if (u->source->thread_info.state != PA_SOURCE_SUSPENDED)
924 /* Resume the device if the sink was suspended as well */
925 if (!u->sink || u->sink->thread_info.state == PA_SINK_SUSPENDED)
926 if (start_stream_fd(u) < 0)
929 /* We don't resume the smoother here. Instead we
930 * wait until the first packet arrives */
933 case PA_SOURCE_UNLINKED:
935 case PA_SOURCE_INVALID_STATE:
940 case PA_SOURCE_MESSAGE_GET_LATENCY: {
943 wi = pa_smoother_get(u->read_smoother, pa_rtclock_now());
944 ri = pa_bytes_to_usec(u->read_index, &u->sample_spec);
946 *((pa_usec_t*) data) = (wi > ri ? wi - ri : 0) + u->source->thread_info.fixed_latency;
952 r = pa_source_process_msg(o, code, data, offset, chunk);
954 return (r < 0 || !failed) ? r : -1;
957 /* Run from IO thread */
958 static int hsp_process_render(struct userdata *u) {
962 pa_assert(u->profile == PROFILE_HSP);
965 /* First, render some data */
966 if (!u->write_memchunk.memblock)
967 pa_sink_render_full(u->sink, u->block_size, &u->write_memchunk);
969 pa_assert(u->write_memchunk.length == u->block_size);
975 /* Now write that data to the socket. The socket is of type
976 * SEQPACKET, and we generated the data of the MTU size, so this
977 * should just work. */
979 p = (const uint8_t*) pa_memblock_acquire(u->write_memchunk.memblock) + u->write_memchunk.index;
980 l = pa_write(u->stream_fd, p, u->write_memchunk.length, &u->stream_write_type);
981 pa_memblock_release(u->write_memchunk.memblock);
988 /* Retry right away if we got interrupted */
991 else if (errno == EAGAIN)
992 /* Hmm, apparently the socket was not writable, give up for now */
995 pa_log_error("Failed to write data to SCO socket: %s", pa_cstrerror(errno));
1000 pa_assert((size_t) l <= u->write_memchunk.length);
1002 if ((size_t) l != u->write_memchunk.length) {
1003 pa_log_error("Wrote memory block to socket only partially! %llu written, wanted to write %llu.",
1004 (unsigned long long) l,
1005 (unsigned long long) u->write_memchunk.length);
1010 u->write_index += (uint64_t) u->write_memchunk.length;
1011 pa_memblock_unref(u->write_memchunk.memblock);
1012 pa_memchunk_reset(&u->write_memchunk);
1021 /* Run from IO thread */
1022 static int hsp_process_push(struct userdata *u) {
1024 pa_memchunk memchunk;
1027 pa_assert(u->profile == PROFILE_HSP);
1028 pa_assert(u->source);
1029 pa_assert(u->read_smoother);
1031 memchunk.memblock = pa_memblock_new(u->core->mempool, u->block_size);
1032 memchunk.index = memchunk.length = 0;
1041 pa_bool_t found_tstamp = FALSE;
1044 memset(&m, 0, sizeof(m));
1045 memset(&aux, 0, sizeof(aux));
1046 memset(&iov, 0, sizeof(iov));
1050 m.msg_control = aux;
1051 m.msg_controllen = sizeof(aux);
1053 p = pa_memblock_acquire(memchunk.memblock);
1055 iov.iov_len = pa_memblock_get_length(memchunk.memblock);
1056 l = recvmsg(u->stream_fd, &m, 0);
1057 pa_memblock_release(memchunk.memblock);
1061 if (l < 0 && errno == EINTR)
1062 /* Retry right away if we got interrupted */
1065 else if (l < 0 && errno == EAGAIN)
1066 /* Hmm, apparently the socket was not readable, give up for now. */
1069 pa_log_error("Failed to read data from SCO socket: %s", l < 0 ? pa_cstrerror(errno) : "EOF");
1074 pa_assert((size_t) l <= pa_memblock_get_length(memchunk.memblock));
1076 memchunk.length = (size_t) l;
1077 u->read_index += (uint64_t) l;
1079 for (cm = CMSG_FIRSTHDR(&m); cm; cm = CMSG_NXTHDR(&m, cm))
1080 if (cm->cmsg_level == SOL_SOCKET && cm->cmsg_type == SO_TIMESTAMP) {
1081 struct timeval *tv = (struct timeval*) CMSG_DATA(cm);
1082 pa_rtclock_from_wallclock(tv);
1083 tstamp = pa_timeval_load(tv);
1084 found_tstamp = TRUE;
1088 if (!found_tstamp) {
1089 pa_log_warn("Couldn't find SO_TIMESTAMP data in auxiliary recvmsg() data!");
1090 tstamp = pa_rtclock_now();
1093 pa_smoother_put(u->read_smoother, tstamp, pa_bytes_to_usec(u->read_index, &u->sample_spec));
1094 pa_smoother_resume(u->read_smoother, tstamp, TRUE);
1096 pa_source_post(u->source, &memchunk);
1102 pa_memblock_unref(memchunk.memblock);
1107 /* Run from IO thread */
1108 static void a2dp_prepare_buffer(struct userdata *u) {
1111 if (u->a2dp.buffer_size >= u->link_mtu)
1114 u->a2dp.buffer_size = 2 * u->link_mtu;
1115 pa_xfree(u->a2dp.buffer);
1116 u->a2dp.buffer = pa_xmalloc(u->a2dp.buffer_size);
1119 /* Run from IO thread */
1120 static int a2dp_process_render(struct userdata *u) {
1121 struct a2dp_info *a2dp;
1122 struct rtp_header *header;
1123 struct rtp_payload *payload;
1127 size_t to_write, to_encode;
1128 unsigned frame_count;
1132 pa_assert(u->profile == PROFILE_A2DP);
1135 /* First, render some data */
1136 if (!u->write_memchunk.memblock)
1137 pa_sink_render_full(u->sink, u->block_size, &u->write_memchunk);
1139 pa_assert(u->write_memchunk.length == u->block_size);
1141 a2dp_prepare_buffer(u);
1144 header = a2dp->buffer;
1145 payload = (struct rtp_payload*) ((uint8_t*) a2dp->buffer + sizeof(*header));
1149 /* Try to create a packet of the full MTU */
1151 p = (const uint8_t*) pa_memblock_acquire(u->write_memchunk.memblock) + u->write_memchunk.index;
1152 to_encode = u->write_memchunk.length;
1154 d = (uint8_t*) a2dp->buffer + sizeof(*header) + sizeof(*payload);
1155 to_write = a2dp->buffer_size - sizeof(*header) - sizeof(*payload);
1157 while (PA_LIKELY(to_encode > 0 && to_write > 0)) {
1161 encoded = sbc_encode(&a2dp->sbc,
1166 if (PA_UNLIKELY(encoded <= 0)) {
1167 pa_log_error("SBC encoding error (%li)", (long) encoded);
1168 pa_memblock_release(u->write_memchunk.memblock);
1172 /* pa_log_debug("SBC: encoded: %lu; written: %lu", (unsigned long) encoded, (unsigned long) written); */
1173 /* pa_log_debug("SBC: codesize: %lu; frame_length: %lu", (unsigned long) a2dp->codesize, (unsigned long) a2dp->frame_length); */
1175 pa_assert_fp((size_t) encoded <= to_encode);
1176 pa_assert_fp((size_t) encoded == a2dp->codesize);
1178 pa_assert_fp((size_t) written <= to_write);
1179 pa_assert_fp((size_t) written == a2dp->frame_length);
1181 p = (const uint8_t*) p + encoded;
1182 to_encode -= encoded;
1184 d = (uint8_t*) d + written;
1185 to_write -= written;
1190 pa_memblock_release(u->write_memchunk.memblock);
1192 pa_assert(to_encode == 0);
1195 pa_log_debug("Using SBC encoder implementation: %s", pa_strnull(sbc_get_implementation_info(&a2dp->sbc)));
1198 /* write it to the fifo */
1199 memset(a2dp->buffer, 0, sizeof(*header) + sizeof(*payload));
1202 header->sequence_number = htons(a2dp->seq_num++);
1203 header->timestamp = htonl(u->write_index / pa_frame_size(&u->sample_spec));
1204 header->ssrc = htonl(1);
1205 payload->frame_count = frame_count;
1207 nbytes = (uint8_t*) d - (uint8_t*) a2dp->buffer;
1212 l = pa_write(u->stream_fd, a2dp->buffer, nbytes, &u->stream_write_type);
1219 /* Retry right away if we got interrupted */
1222 else if (errno == EAGAIN)
1223 /* Hmm, apparently the socket was not writable, give up for now */
1226 pa_log_error("Failed to write data to socket: %s", pa_cstrerror(errno));
1231 pa_assert((size_t) l <= nbytes);
1233 if ((size_t) l != nbytes) {
1234 pa_log_warn("Wrote memory block to socket only partially! %llu written, wanted to write %llu.",
1235 (unsigned long long) l,
1236 (unsigned long long) nbytes);
1241 u->write_index += (uint64_t) u->write_memchunk.length;
1242 pa_memblock_unref(u->write_memchunk.memblock);
1243 pa_memchunk_reset(&u->write_memchunk);
1253 static void thread_func(void *userdata) {
1254 struct userdata *u = userdata;
1255 unsigned do_write = 0;
1256 pa_bool_t writable = FALSE;
1260 pa_log_debug("IO Thread starting up");
1262 if (u->core->realtime_scheduling)
1263 pa_make_realtime(u->core->realtime_priority);
1265 pa_thread_mq_install(&u->thread_mq);
1267 if (start_stream_fd(u) < 0)
1271 struct pollfd *pollfd;
1273 pa_bool_t disable_timer = TRUE;
1275 pollfd = u->rtpoll_item ? pa_rtpoll_item_get_pollfd(u->rtpoll_item, NULL) : NULL;
1277 if (u->source && PA_SOURCE_IS_LINKED(u->source->thread_info.state)) {
1279 /* We should send two blocks to the device before we expect
1282 if (u->write_index == 0 && u->read_index <= 0)
1285 if (pollfd && (pollfd->revents & POLLIN)) {
1288 if ((n_read = hsp_process_push(u)) < 0)
1291 /* We just read something, so we are supposed to write something, too */
1296 if (u->sink && PA_SINK_IS_LINKED(u->sink->thread_info.state)) {
1298 if (u->sink->thread_info.rewind_requested)
1299 pa_sink_process_rewind(u->sink, 0);
1302 if (pollfd->revents & POLLOUT)
1305 if ((!u->source || !PA_SOURCE_IS_LINKED(u->source->thread_info.state)) && do_write <= 0 && writable) {
1306 pa_usec_t time_passed;
1307 pa_usec_t audio_sent;
1309 /* Hmm, there is no input stream we could synchronize
1310 * to. So let's do things by time */
1312 time_passed = pa_rtclock_now() - u->started_at;
1313 audio_sent = pa_bytes_to_usec(u->write_index, &u->sample_spec);
1315 if (audio_sent <= time_passed) {
1316 pa_usec_t audio_to_send = time_passed - audio_sent;
1318 /* Never try to catch up for more than 100ms */
1319 if (u->write_index > 0 && audio_to_send > MAX_PLAYBACK_CATCH_UP_USEC) {
1320 pa_usec_t skip_usec;
1321 uint64_t skip_bytes;
1323 skip_usec = audio_to_send - MAX_PLAYBACK_CATCH_UP_USEC;
1324 skip_bytes = pa_usec_to_bytes(skip_usec, &u->sample_spec);
1326 if (skip_bytes > 0) {
1329 pa_log_warn("Skipping %llu us (= %llu bytes) in audio stream",
1330 (unsigned long long) skip_usec,
1331 (unsigned long long) skip_bytes);
1333 pa_sink_render_full(u->sink, skip_bytes, &tmp);
1334 pa_memblock_unref(tmp.memblock);
1335 u->write_index += skip_bytes;
1343 if (writable && do_write > 0) {
1346 if (u->write_index <= 0)
1347 u->started_at = pa_rtclock_now();
1349 if (u->profile == PROFILE_A2DP) {
1350 if ((n_written = a2dp_process_render(u)) < 0)
1353 if ((n_written = hsp_process_render(u)) < 0)
1358 pa_log("Broken kernel: we got EAGAIN on write() after POLLOUT!");
1360 do_write -= n_written;
1364 if ((!u->source || !PA_SOURCE_IS_LINKED(u->source->thread_info.state)) && do_write <= 0 && writable) {
1365 pa_usec_t time_passed, next_write_at, sleep_for;
1367 /* Hmm, there is no input stream we could synchronize
1368 * to. So let's estimate when we need to wake up the latest */
1370 time_passed = pa_rtclock_now() - u->started_at;
1371 next_write_at = pa_bytes_to_usec(u->write_index, &u->sample_spec);
1372 sleep_for = time_passed < next_write_at ? next_write_at - time_passed : 0;
1374 /* 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); */
1376 pa_rtpoll_set_timer_relative(u->rtpoll, sleep_for);
1377 disable_timer = FALSE;
1383 pa_rtpoll_set_timer_disabled(u->rtpoll);
1385 /* Hmm, nothing to do. Let's sleep */
1387 pollfd->events = (short) (((u->sink && PA_SINK_IS_LINKED(u->sink->thread_info.state) && !writable) ? POLLOUT : 0) |
1388 (u->source && PA_SOURCE_IS_LINKED(u->source->thread_info.state) ? POLLIN : 0));
1390 if ((ret = pa_rtpoll_run(u->rtpoll, TRUE)) < 0)
1396 pollfd = u->rtpoll_item ? pa_rtpoll_item_get_pollfd(u->rtpoll_item, NULL) : NULL;
1398 if (pollfd && (pollfd->revents & ~(POLLOUT|POLLIN))) {
1399 pa_log_info("FD error: %s%s%s%s",
1400 pollfd->revents & POLLERR ? "POLLERR " :"",
1401 pollfd->revents & POLLHUP ? "POLLHUP " :"",
1402 pollfd->revents & POLLPRI ? "POLLPRI " :"",
1403 pollfd->revents & POLLNVAL ? "POLLNVAL " :"");
1409 /* If this was no regular exit from the loop we have to continue processing messages until we receive PA_MESSAGE_SHUTDOWN */
1410 pa_log_debug("IO thread failed");
1411 pa_asyncmsgq_post(u->thread_mq.outq, PA_MSGOBJECT(u->core), PA_CORE_MESSAGE_UNLOAD_MODULE, u->module, 0, NULL, NULL);
1412 pa_asyncmsgq_wait_for(u->thread_mq.inq, PA_MESSAGE_SHUTDOWN);
1415 pa_log_debug("IO thread shutting down");
1418 /* Run from main thread */
1419 static DBusHandlerResult filter_cb(DBusConnection *bus, DBusMessage *m, void *userdata) {
1425 pa_assert_se(u = userdata);
1427 dbus_error_init(&err);
1429 pa_log_debug("dbus: interface=%s, path=%s, member=%s\n",
1430 dbus_message_get_interface(m),
1431 dbus_message_get_path(m),
1432 dbus_message_get_member(m));
1434 if (!dbus_message_has_path(m, u->path))
1437 if (dbus_message_is_signal(m, "org.bluez.Headset", "SpeakerGainChanged") ||
1438 dbus_message_is_signal(m, "org.bluez.Headset", "MicrophoneGainChanged")) {
1443 if (!dbus_message_get_args(m, &err, DBUS_TYPE_UINT16, &gain, DBUS_TYPE_INVALID) || gain > 15) {
1444 pa_log("Failed to parse org.bluez.Headset.{Speaker|Microphone}GainChanged: %s", err.message);
1448 if (u->profile == PROFILE_HSP) {
1449 if (u->sink && dbus_message_is_signal(m, "org.bluez.Headset", "SpeakerGainChanged")) {
1451 pa_cvolume_set(&v, u->sample_spec.channels, (pa_volume_t) (gain * PA_VOLUME_NORM / 15));
1452 pa_sink_volume_changed(u->sink, &v);
1454 } else if (u->source && dbus_message_is_signal(m, "org.bluez.Headset", "MicrophoneGainChanged")) {
1456 pa_cvolume_set(&v, u->sample_spec.channels, (pa_volume_t) (gain * PA_VOLUME_NORM / 15));
1457 pa_source_volume_changed(u->source, &v);
1463 dbus_error_free(&err);
1465 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1468 /* Run from main thread */
1469 static void sink_set_volume_cb(pa_sink *s) {
1470 struct userdata *u = s->userdata;
1476 if (u->profile != PROFILE_HSP)
1479 gain = (pa_cvolume_max(&s->virtual_volume) * 15) / PA_VOLUME_NORM;
1484 pa_cvolume_set(&s->virtual_volume, u->sample_spec.channels, (pa_volume_t) (gain * PA_VOLUME_NORM / 15));
1486 pa_assert_se(m = dbus_message_new_method_call("org.bluez", u->path, "org.bluez.Headset", "SetSpeakerGain"));
1487 pa_assert_se(dbus_message_append_args(m, DBUS_TYPE_UINT16, &gain, DBUS_TYPE_INVALID));
1488 pa_assert_se(dbus_connection_send(pa_dbus_connection_get(u->connection), m, NULL));
1489 dbus_message_unref(m);
1492 /* Run from main thread */
1493 static void source_set_volume_cb(pa_source *s) {
1494 struct userdata *u = s->userdata;
1500 if (u->profile != PROFILE_HSP)
1503 gain = (pa_cvolume_max(&s->volume) * 15) / PA_VOLUME_NORM;
1508 pa_cvolume_set(&s->volume, u->sample_spec.channels, (pa_volume_t) (gain * PA_VOLUME_NORM / 15));
1510 pa_assert_se(m = dbus_message_new_method_call("org.bluez", u->path, "org.bluez.Headset", "SetMicrophoneGain"));
1511 pa_assert_se(dbus_message_append_args(m, DBUS_TYPE_UINT16, &gain, DBUS_TYPE_INVALID));
1512 pa_assert_se(dbus_connection_send(pa_dbus_connection_get(u->connection), m, NULL));
1513 dbus_message_unref(m);
1516 /* Run from main thread */
1517 static char *get_name(const char *type, pa_modargs *ma, const char *device_id, pa_bool_t *namereg_fail) {
1523 pa_assert(device_id);
1524 pa_assert(namereg_fail);
1526 t = pa_sprintf_malloc("%s_name", type);
1527 n = pa_modargs_get_value(ma, t, NULL);
1531 *namereg_fail = TRUE;
1532 return pa_xstrdup(n);
1535 if ((n = pa_modargs_get_value(ma, "name", NULL)))
1536 *namereg_fail = TRUE;
1539 *namereg_fail = FALSE;
1542 return pa_sprintf_malloc("bluez_%s.%s", type, n);
1547 static void sco_over_pcm_state_update(struct userdata *u) {
1549 pa_assert(USE_SCO_OVER_PCM(u));
1551 if (PA_SINK_IS_OPENED(pa_sink_get_state(u->hsp.sco_sink)) ||
1552 PA_SOURCE_IS_OPENED(pa_source_get_state(u->hsp.sco_source))) {
1554 if (u->service_fd >= 0)
1557 pa_log_debug("Resuming SCO over PCM");
1558 if ((init_bt(u) < 0) || (init_profile(u) < 0))
1559 pa_log("Can't resume SCO over PCM");
1564 if (u->service_fd < 0)
1569 pa_log_debug("Closing SCO over PCM");
1570 pa_close(u->service_fd);
1575 static pa_hook_result_t sink_state_changed_cb(pa_core *c, pa_sink *s, struct userdata *u) {
1577 pa_sink_assert_ref(s);
1580 if (s != u->hsp.sco_sink)
1583 sco_over_pcm_state_update(u);
1588 static pa_hook_result_t source_state_changed_cb(pa_core *c, pa_source *s, struct userdata *u) {
1590 pa_source_assert_ref(s);
1593 if (s != u->hsp.sco_source)
1596 sco_over_pcm_state_update(u);
1603 /* Run from main thread */
1604 static int add_sink(struct userdata *u) {
1607 if (USE_SCO_OVER_PCM(u)) {
1610 u->sink = u->hsp.sco_sink;
1611 p = pa_proplist_new();
1612 pa_proplist_sets(p, "bluetooth.protocol", "sco");
1613 pa_proplist_update(u->sink->proplist, PA_UPDATE_MERGE, p);
1614 pa_proplist_free(p);
1616 if (!u->hsp.sink_state_changed_slot)
1617 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);
1623 pa_sink_new_data data;
1626 pa_sink_new_data_init(&data);
1627 data.driver = __FILE__;
1628 data.module = u->module;
1629 pa_sink_new_data_set_sample_spec(&data, &u->sample_spec);
1630 pa_proplist_sets(data.proplist, "bluetooth.protocol", u->profile == PROFILE_A2DP ? "a2dp" : "sco");
1631 if (u->profile == PROFILE_HSP)
1632 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_INTENDED_ROLES, "phone");
1633 data.card = u->card;
1634 data.name = get_name("sink", u->modargs, u->address, &b);
1635 data.namereg_fail = b;
1637 if (pa_modargs_get_proplist(u->modargs, "sink_properties", data.proplist, PA_UPDATE_REPLACE) < 0) {
1638 pa_log("Invalid properties");
1639 pa_sink_new_data_done(&data);
1643 u->sink = pa_sink_new(u->core, &data, PA_SINK_HARDWARE|PA_SINK_LATENCY | (u->profile == PROFILE_HSP ? PA_SINK_HW_VOLUME_CTRL : 0));
1644 pa_sink_new_data_done(&data);
1647 pa_log_error("Failed to create sink");
1651 u->sink->userdata = u;
1652 u->sink->parent.process_msg = sink_process_msg;
1654 pa_sink_set_max_request(u->sink, u->block_size);
1655 pa_sink_set_fixed_latency(u->sink,
1656 (u->profile == PROFILE_A2DP ? FIXED_LATENCY_PLAYBACK_A2DP : FIXED_LATENCY_PLAYBACK_HSP) +
1657 pa_bytes_to_usec(u->block_size, &u->sample_spec));
1660 if (u->profile == PROFILE_HSP) {
1661 u->sink->set_volume = sink_set_volume_cb;
1662 u->sink->n_volume_steps = 16;
1668 /* Run from main thread */
1669 static int add_source(struct userdata *u) {
1672 if (USE_SCO_OVER_PCM(u)) {
1673 u->source = u->hsp.sco_source;
1674 pa_proplist_sets(u->source->proplist, "bluetooth.protocol", "hsp");
1676 if (!u->hsp.source_state_changed_slot)
1677 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);
1683 pa_source_new_data data;
1686 pa_source_new_data_init(&data);
1687 data.driver = __FILE__;
1688 data.module = u->module;
1689 pa_source_new_data_set_sample_spec(&data, &u->sample_spec);
1690 pa_proplist_sets(data.proplist, "bluetooth.protocol", u->profile == PROFILE_A2DP ? "a2dp" : "hsp");
1691 if (u->profile == PROFILE_HSP)
1692 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_INTENDED_ROLES, "phone");
1693 data.card = u->card;
1694 data.name = get_name("source", u->modargs, u->address, &b);
1695 data.namereg_fail = b;
1697 if (pa_modargs_get_proplist(u->modargs, "source_properties", data.proplist, PA_UPDATE_REPLACE) < 0) {
1698 pa_log("Invalid properties");
1699 pa_source_new_data_done(&data);
1703 u->source = pa_source_new(u->core, &data, PA_SOURCE_HARDWARE|PA_SOURCE_LATENCY | (u->profile == PROFILE_HSP ? PA_SOURCE_HW_VOLUME_CTRL : 0));
1704 pa_source_new_data_done(&data);
1707 pa_log_error("Failed to create source");
1711 u->source->userdata = u;
1712 u->source->parent.process_msg = source_process_msg;
1714 pa_source_set_fixed_latency(u->source,
1715 (/* u->profile == PROFILE_A2DP ? FIXED_LATENCY_RECORD_A2DP : */ FIXED_LATENCY_RECORD_HSP) +
1716 pa_bytes_to_usec(u->block_size, &u->sample_spec));
1719 if (u->profile == PROFILE_HSP) {
1720 pa_proplist_sets(u->source->proplist, "bluetooth.nrec", (u->hsp.pcm_capabilities.flags & BT_PCM_FLAG_NREC) ? "1" : "0");
1721 u->source->set_volume = source_set_volume_cb;
1722 u->source->n_volume_steps = 16;
1728 /* Run from main thread */
1729 static void shutdown_bt(struct userdata *u) {
1732 if (u->stream_fd >= 0) {
1733 pa_close(u->stream_fd);
1736 u->stream_write_type = 0;
1739 if (u->service_fd >= 0) {
1740 pa_close(u->service_fd);
1742 u->service_write_type = 0;
1743 u->service_read_type = 0;
1746 if (u->write_memchunk.memblock) {
1747 pa_memblock_unref(u->write_memchunk.memblock);
1748 pa_memchunk_reset(&u->write_memchunk);
1752 /* Run from main thread */
1753 static int init_bt(struct userdata *u) {
1758 u->stream_write_type = 0;
1759 u->service_write_type = 0;
1760 u->service_read_type = 0;
1762 if ((u->service_fd = bt_audio_service_open()) < 0) {
1763 pa_log_error("Couldn't connect to bluetooth audio service");
1767 pa_log_debug("Connected to the bluetooth audio service");
1772 /* Run from main thread */
1773 static int setup_bt(struct userdata *u) {
1776 if (get_caps(u, 0) < 0)
1779 pa_log_debug("Got device capabilities");
1781 if (set_conf(u) < 0)
1784 pa_log_debug("Connection to the device configured");
1787 if (USE_SCO_OVER_PCM(u)) {
1788 pa_log_debug("Configured to use SCO over PCM");
1793 pa_log_debug("Got the stream socket");
1798 /* Run from main thread */
1799 static int init_profile(struct userdata *u) {
1802 pa_assert(u->profile != PROFILE_OFF);
1804 if (setup_bt(u) < 0)
1807 if (u->profile == PROFILE_A2DP ||
1808 u->profile == PROFILE_HSP)
1809 if (add_sink(u) < 0)
1812 if (u->profile == PROFILE_HSP)
1813 if (add_source(u) < 0)
1819 /* Run from main thread */
1820 static void stop_thread(struct userdata *u) {
1824 pa_asyncmsgq_send(u->thread_mq.inq, NULL, PA_MESSAGE_SHUTDOWN, NULL, 0, NULL);
1825 pa_thread_free(u->thread);
1829 if (u->rtpoll_item) {
1830 pa_rtpoll_item_free(u->rtpoll_item);
1831 u->rtpoll_item = NULL;
1834 if (u->hsp.sink_state_changed_slot) {
1835 pa_hook_slot_free(u->hsp.sink_state_changed_slot);
1836 u->hsp.sink_state_changed_slot = NULL;
1839 if (u->hsp.source_state_changed_slot) {
1840 pa_hook_slot_free(u->hsp.source_state_changed_slot);
1841 u->hsp.source_state_changed_slot = NULL;
1845 pa_sink_unref(u->sink);
1850 pa_source_unref(u->source);
1855 pa_thread_mq_done(&u->thread_mq);
1857 pa_rtpoll_free(u->rtpoll);
1861 if (u->read_smoother) {
1862 pa_smoother_free(u->read_smoother);
1863 u->read_smoother = NULL;
1867 /* Run from main thread */
1868 static int start_thread(struct userdata *u) {
1870 pa_assert(!u->thread);
1871 pa_assert(!u->rtpoll);
1872 pa_assert(!u->rtpoll_item);
1874 u->rtpoll = pa_rtpoll_new();
1875 pa_thread_mq_init(&u->thread_mq, u->core->mainloop, u->rtpoll);
1878 if (USE_SCO_OVER_PCM(u)) {
1879 if (start_stream_fd(u) < 0)
1882 pa_sink_ref(u->sink);
1883 pa_source_ref(u->source);
1884 /* FIXME: monitor stream_fd error */
1889 if (!(u->thread = pa_thread_new(thread_func, u))) {
1890 pa_log_error("Failed to create IO thread");
1896 pa_sink_set_asyncmsgq(u->sink, u->thread_mq.inq);
1897 pa_sink_set_rtpoll(u->sink, u->rtpoll);
1898 pa_sink_put(u->sink);
1900 if (u->sink->set_volume)
1901 u->sink->set_volume(u->sink);
1905 pa_source_set_asyncmsgq(u->source, u->thread_mq.inq);
1906 pa_source_set_rtpoll(u->source, u->rtpoll);
1907 pa_source_put(u->source);
1909 if (u->source->set_volume)
1910 u->source->set_volume(u->source);
1916 /* Run from main thread */
1917 static int card_set_profile(pa_card *c, pa_card_profile *new_profile) {
1920 pa_queue *inputs = NULL, *outputs = NULL;
1921 const pa_bluetooth_device *device;
1924 pa_assert(new_profile);
1925 pa_assert_se(u = c->userdata);
1927 d = PA_CARD_PROFILE_DATA(new_profile);
1929 if (!(device = pa_bluetooth_discovery_get_by_path(u->discovery, u->path))) {
1930 pa_log_error("Failed to get device object.");
1934 /* The state signal is sent by bluez, so it is racy to check
1935 strictly for CONNECTED, we should also accept STREAMING state
1936 as being good enough. However, if the profile is used
1937 concurrently (which is unlikely), ipc will fail later on, and
1938 module will be unloaded. */
1939 if (device->headset_state < PA_BT_AUDIO_STATE_CONNECTED && *d == PROFILE_HSP) {
1940 pa_log_warn("HSP is not connected, refused to switch profile");
1943 else if (device->audio_sink_state < PA_BT_AUDIO_STATE_CONNECTED && *d == PROFILE_A2DP) {
1944 pa_log_warn("A2DP is not connected, refused to switch profile");
1949 inputs = pa_sink_move_all_start(u->sink, NULL);
1951 if (!USE_SCO_OVER_PCM(u))
1953 pa_sink_unlink(u->sink);
1957 outputs = pa_source_move_all_start(u->source, NULL);
1959 if (!USE_SCO_OVER_PCM(u))
1961 pa_source_unlink(u->source);
1968 u->sample_spec = u->requested_sample_spec;
1972 if (u->profile != PROFILE_OFF)
1975 if (u->sink || u->source)
1980 pa_sink_move_all_finish(u->sink, inputs, FALSE);
1982 pa_sink_move_all_fail(inputs);
1987 pa_source_move_all_finish(u->source, outputs, FALSE);
1989 pa_source_move_all_fail(outputs);
1995 /* Run from main thread */
1996 static int add_card(struct userdata *u, const pa_bluetooth_device *device) {
1997 pa_card_new_data data;
2003 const char *default_profile;
2008 pa_card_new_data_init(&data);
2009 data.driver = __FILE__;
2010 data.module = u->module;
2012 n = pa_bluetooth_cleanup_name(device->name);
2013 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_DESCRIPTION, n);
2015 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_STRING, device->address);
2016 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_API, "bluez");
2017 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_CLASS, "sound");
2018 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_BUS, "bluetooth");
2019 if ((ff = pa_bluetooth_get_form_factor(device->class)))
2020 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_FORM_FACTOR, ff);
2021 pa_proplist_sets(data.proplist, "bluez.path", device->path);
2022 pa_proplist_setf(data.proplist, "bluez.class", "0x%06x", (unsigned) device->class);
2023 pa_proplist_sets(data.proplist, "bluez.name", device->name);
2024 data.name = get_name("card", u->modargs, device->address, &b);
2025 data.namereg_fail = b;
2027 if (pa_modargs_get_proplist(u->modargs, "card_properties", data.proplist, PA_UPDATE_REPLACE) < 0) {
2028 pa_log("Invalid properties");
2029 pa_card_new_data_done(&data);
2033 data.profiles = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
2035 /* we base hsp/a2dp availability on UUIDs.
2036 Ideally, it would be based on "Connected" state, but
2037 we can't afford to wait for this information when
2038 we are loaded with profile="hsp", for instance */
2039 if (pa_bluetooth_uuid_has(device->uuids, A2DP_SINK_UUID)) {
2040 p = pa_card_profile_new("a2dp", _("High Fidelity Playback (A2DP)"), sizeof(enum profile));
2044 p->max_sink_channels = 2;
2045 p->max_source_channels = 0;
2047 d = PA_CARD_PROFILE_DATA(p);
2050 pa_hashmap_put(data.profiles, p->name, p);
2053 if (pa_bluetooth_uuid_has(device->uuids, HSP_HS_UUID) ||
2054 pa_bluetooth_uuid_has(device->uuids, HFP_HS_UUID)) {
2055 p = pa_card_profile_new("hsp", _("Telephony Duplex (HSP/HFP)"), sizeof(enum profile));
2059 p->max_sink_channels = 1;
2060 p->max_source_channels = 1;
2062 d = PA_CARD_PROFILE_DATA(p);
2065 pa_hashmap_put(data.profiles, p->name, p);
2068 pa_assert(!pa_hashmap_isempty(data.profiles));
2070 p = pa_card_profile_new("off", _("Off"), sizeof(enum profile));
2071 d = PA_CARD_PROFILE_DATA(p);
2073 pa_hashmap_put(data.profiles, p->name, p);
2075 if ((default_profile = pa_modargs_get_value(u->modargs, "profile", NULL))) {
2076 if (pa_hashmap_get(data.profiles, default_profile))
2077 pa_card_new_data_set_profile(&data, default_profile);
2079 pa_log_warn("Profile '%s' not valid or not supported by device.", default_profile);
2082 u->card = pa_card_new(u->core, &data);
2083 pa_card_new_data_done(&data);
2086 pa_log("Failed to allocate card.");
2090 u->card->userdata = u;
2091 u->card->set_profile = card_set_profile;
2093 d = PA_CARD_PROFILE_DATA(u->card->active_profile);
2095 if ((device->headset_state < PA_BT_AUDIO_STATE_CONNECTED && *d == PROFILE_HSP) ||
2096 (device->audio_sink_state < PA_BT_AUDIO_STATE_CONNECTED && *d == PROFILE_A2DP)) {
2097 pa_log_warn("Default profile not connected, selecting off profile");
2098 u->card->active_profile = pa_hashmap_get(u->card->profiles, "off");
2099 u->card->save_profile = FALSE;
2102 d = PA_CARD_PROFILE_DATA(u->card->active_profile);
2108 /* Run from main thread */
2109 static const pa_bluetooth_device* find_device(struct userdata *u, const char *address, const char *path) {
2110 const pa_bluetooth_device *d = NULL;
2114 if (!address && !path) {
2115 pa_log_error("Failed to get device address/path from module arguments.");
2120 if (!(d = pa_bluetooth_discovery_get_by_path(u->discovery, path))) {
2121 pa_log_error("%s is not a valid BlueZ audio device.", path);
2125 if (address && !(pa_streq(d->address, address))) {
2126 pa_log_error("Passed path %s and address %s don't match.", path, address);
2131 if (!(d = pa_bluetooth_discovery_get_by_address(u->discovery, address))) {
2132 pa_log_error("%s is not known.", address);
2138 u->address = pa_xstrdup(d->address);
2139 u->path = pa_xstrdup(d->path);
2145 /* Run from main thread */
2146 static int setup_dbus(struct userdata *u) {
2149 dbus_error_init(&err);
2151 u->connection = pa_dbus_bus_get(u->core, DBUS_BUS_SYSTEM, &err);
2153 if (dbus_error_is_set(&err) || !u->connection) {
2154 pa_log("Failed to get D-Bus connection: %s", err.message);
2155 dbus_error_free(&err);
2162 int pa__init(pa_module* m) {
2166 const char *address, *path;
2168 char *mike, *speaker;
2169 const pa_bluetooth_device *device;
2173 dbus_error_init(&err);
2175 if (!(ma = pa_modargs_new(m->argument, valid_modargs))) {
2176 pa_log_error("Failed to parse module arguments");
2180 m->userdata = u = pa_xnew0(struct userdata, 1);
2185 u->sample_spec = m->core->default_sample_spec;
2189 if (pa_modargs_get_value(ma, "sco_sink", NULL) &&
2190 !(u->hsp.sco_sink = pa_namereg_get(m->core, pa_modargs_get_value(ma, "sco_sink", NULL), PA_NAMEREG_SINK))) {
2191 pa_log("SCO sink not found");
2195 if (pa_modargs_get_value(ma, "sco_source", NULL) &&
2196 !(u->hsp.sco_source = pa_namereg_get(m->core, pa_modargs_get_value(ma, "sco_source", NULL), PA_NAMEREG_SOURCE))) {
2197 pa_log("SCO source not found");
2202 if (pa_modargs_get_value_u32(ma, "rate", &u->sample_spec.rate) < 0 ||
2203 u->sample_spec.rate <= 0 || u->sample_spec.rate > PA_RATE_MAX) {
2204 pa_log_error("Failed to get rate from module arguments");
2208 channels = u->sample_spec.channels;
2209 if (pa_modargs_get_value_u32(ma, "channels", &channels) < 0 ||
2210 channels <= 0 || channels > PA_CHANNELS_MAX) {
2211 pa_log_error("Failed to get channels from module arguments");
2214 u->sample_spec.channels = (uint8_t) channels;
2215 u->requested_sample_spec = u->sample_spec;
2217 address = pa_modargs_get_value(ma, "address", NULL);
2218 path = pa_modargs_get_value(ma, "path", NULL);
2220 if (setup_dbus(u) < 0)
2223 if (!(u->discovery = pa_bluetooth_discovery_get(m->core)))
2226 if (!(device = find_device(u, address, path)))
2229 /* Add the card structure. This will also initialize the default profile */
2230 if (add_card(u, device) < 0)
2233 /* Connect to the BT service and query capabilities */
2237 if (!dbus_connection_add_filter(pa_dbus_connection_get(u->connection), filter_cb, u, NULL)) {
2238 pa_log_error("Failed to add filter function");
2242 speaker = pa_sprintf_malloc("type='signal',sender='org.bluez',interface='org.bluez.Headset',member='SpeakerGainChanged',path='%s'", u->path);
2243 mike = pa_sprintf_malloc("type='signal',sender='org.bluez',interface='org.bluez.Headset',member='MicrophoneGainChanged',path='%s'", u->path);
2245 if (pa_dbus_add_matches(
2246 pa_dbus_connection_get(u->connection), &err,
2254 pa_log("Failed to add D-Bus matches: %s", err.message);
2261 if (u->profile != PROFILE_OFF)
2262 if (init_profile(u) < 0)
2265 if (u->sink || u->source)
2266 if (start_thread(u) < 0)
2275 dbus_error_free(&err);
2280 int pa__get_n_used(pa_module *m) {
2284 pa_assert_se(u = m->userdata);
2287 (u->sink ? pa_sink_linked_by(u->sink) : 0) +
2288 (u->source ? pa_source_linked_by(u->source) : 0);
2291 void pa__done(pa_module *m) {
2295 if (!(u = m->userdata))
2300 && !USE_SCO_OVER_PCM(u)
2303 pa_sink_unlink(u->sink);
2307 && !USE_SCO_OVER_PCM(u)
2310 pa_source_unlink(u->source);
2314 if (u->connection) {
2317 char *speaker, *mike;
2318 speaker = pa_sprintf_malloc("type='signal',sender='org.bluez',interface='org.bluez.Headset',member='SpeakerGainChanged',path='%s'", u->path);
2319 mike = pa_sprintf_malloc("type='signal',sender='org.bluez',interface='org.bluez.Headset',member='MicrophoneGainChanged',path='%s'", u->path);
2321 pa_dbus_remove_matches(pa_dbus_connection_get(u->connection),
2330 dbus_connection_remove_filter(pa_dbus_connection_get(u->connection), filter_cb, u);
2331 pa_dbus_connection_unref(u->connection);
2335 pa_card_free(u->card);
2337 if (u->read_smoother)
2338 pa_smoother_free(u->read_smoother);
2343 pa_xfree(u->a2dp.buffer);
2345 sbc_finish(&u->a2dp.sbc);
2348 pa_modargs_free(u->modargs);
2350 pa_xfree(u->address);
2354 pa_bluetooth_discovery_unref(u->discovery);