2 This file is part of PulseAudio.
4 Copyright 2008-2009 Joao Paulo Rechi Vita
5 Copyright 2011-2012 BMW Car IT GmbH.
7 PulseAudio is free software; you can redistribute it and/or modify
8 it under the terms of the GNU Lesser General Public License as
9 published by the Free Software Foundation; either version 2.1 of the
10 License, or (at your option) any later version.
12 PulseAudio is distributed in the hope that it will be useful, but
13 WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 General Public License for more details.
17 You should have received a copy of the GNU Lesser General Public
18 License along with PulseAudio; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
29 #include <linux/sockios.h>
30 #include <arpa/inet.h>
32 #include <pulse/rtclock.h>
33 #include <pulse/sample.h>
34 #include <pulse/timeval.h>
35 #include <pulse/xmalloc.h>
37 #include <pulsecore/i18n.h>
38 #include <pulsecore/module.h>
39 #include <pulsecore/modargs.h>
40 #include <pulsecore/core-rtclock.h>
41 #include <pulsecore/core-util.h>
42 #include <pulsecore/core-error.h>
43 #include <pulsecore/shared.h>
44 #include <pulsecore/socket-util.h>
45 #include <pulsecore/thread.h>
46 #include <pulsecore/thread-mq.h>
47 #include <pulsecore/poll.h>
48 #include <pulsecore/rtpoll.h>
49 #include <pulsecore/time-smoother.h>
50 #include <pulsecore/namereg.h>
51 #include <pulsecore/dbus-shared.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;
128 pa_hook_slot *nrec_changed_slot;
131 struct bluetooth_msg {
136 typedef struct bluetooth_msg bluetooth_msg;
137 PA_DEFINE_PRIVATE_CLASS(bluetooth_msg, pa_msgobject);
138 #define BLUETOOTH_MSG(o) (bluetooth_msg_cast(o))
149 pa_bluetooth_discovery *discovery;
150 pa_bool_t auto_connect;
152 pa_dbus_connection *connection;
158 pa_thread_mq thread_mq;
160 pa_rtpoll_item *rtpoll_item;
164 uint64_t read_index, write_index;
165 pa_usec_t started_at;
166 pa_smoother *read_smoother;
168 pa_memchunk write_memchunk;
170 pa_sample_spec sample_spec, requested_sample_spec;
174 size_t read_link_mtu;
175 size_t read_block_size;
177 size_t write_link_mtu;
178 size_t write_block_size;
180 struct a2dp_info a2dp;
183 enum profile profile;
187 int stream_write_type;
189 pa_bool_t filter_added;
193 BLUETOOTH_MESSAGE_IO_THREAD_FAILED,
194 BLUETOOTH_MESSAGE_MAX
197 #define FIXED_LATENCY_PLAYBACK_A2DP (25*PA_USEC_PER_MSEC)
198 #define FIXED_LATENCY_RECORD_A2DP (25*PA_USEC_PER_MSEC)
199 #define FIXED_LATENCY_PLAYBACK_HSP (125*PA_USEC_PER_MSEC)
200 #define FIXED_LATENCY_RECORD_HSP (25*PA_USEC_PER_MSEC)
202 #define MAX_PLAYBACK_CATCH_UP_USEC (100*PA_USEC_PER_MSEC)
204 #define USE_SCO_OVER_PCM(u) (u->profile == PROFILE_HSP && (u->hsp.sco_sink && u->hsp.sco_source))
206 static int init_profile(struct userdata *u);
209 static void a2dp_set_bitpool(struct userdata *u, uint8_t bitpool)
211 struct a2dp_info *a2dp;
217 if (a2dp->sbc.bitpool == bitpool)
220 if (bitpool > a2dp->max_bitpool)
221 bitpool = a2dp->max_bitpool;
222 else if (bitpool < a2dp->min_bitpool)
223 bitpool = a2dp->min_bitpool;
225 a2dp->sbc.bitpool = bitpool;
227 a2dp->codesize = sbc_get_codesize(&a2dp->sbc);
228 a2dp->frame_length = sbc_get_frame_length(&a2dp->sbc);
230 pa_log_debug("Bitpool has changed to %u", a2dp->sbc.bitpool);
233 (u->read_link_mtu - sizeof(struct rtp_header) - sizeof(struct rtp_payload))
234 / a2dp->frame_length * a2dp->codesize;
236 u->write_block_size =
237 (u->write_link_mtu - sizeof(struct rtp_header) - sizeof(struct rtp_payload))
238 / a2dp->frame_length * a2dp->codesize;
240 pa_sink_set_max_request_within_thread(u->sink, u->write_block_size);
241 pa_sink_set_fixed_latency_within_thread(u->sink,
242 FIXED_LATENCY_PLAYBACK_A2DP + pa_bytes_to_usec(u->write_block_size, &u->sample_spec));
245 /* from IO thread, except in SCO over PCM */
246 static void bt_transport_config_mtu(struct userdata *u) {
247 /* Calculate block sizes */
248 if (u->profile == PROFILE_HSP || u->profile == PROFILE_HFGW) {
249 u->read_block_size = u->read_link_mtu;
250 u->write_block_size = u->write_link_mtu;
253 (u->read_link_mtu - sizeof(struct rtp_header) - sizeof(struct rtp_payload))
254 / u->a2dp.frame_length * u->a2dp.codesize;
256 u->write_block_size =
257 (u->write_link_mtu - sizeof(struct rtp_header) - sizeof(struct rtp_payload))
258 / u->a2dp.frame_length * u->a2dp.codesize;
261 if (USE_SCO_OVER_PCM(u))
265 pa_sink_set_max_request_within_thread(u->sink, u->write_block_size);
266 pa_sink_set_fixed_latency_within_thread(u->sink,
267 (u->profile == PROFILE_A2DP ?
268 FIXED_LATENCY_PLAYBACK_A2DP : FIXED_LATENCY_PLAYBACK_HSP) +
269 pa_bytes_to_usec(u->write_block_size, &u->sample_spec));
273 pa_source_set_fixed_latency_within_thread(u->source,
274 (u->profile == PROFILE_A2DP_SOURCE ?
275 FIXED_LATENCY_RECORD_A2DP : FIXED_LATENCY_RECORD_HSP) +
276 pa_bytes_to_usec(u->read_block_size, &u->sample_spec));
279 /* from IO thread, except in SCO over PCM */
281 static void setup_stream(struct userdata *u) {
282 struct pollfd *pollfd;
285 bt_transport_config_mtu(u);
287 pa_make_fd_nonblock(u->stream_fd);
288 pa_make_socket_low_delay(u->stream_fd);
291 if (setsockopt(u->stream_fd, SOL_SOCKET, SO_TIMESTAMP, &one, sizeof(one)) < 0)
292 pa_log_warn("Failed to enable SO_TIMESTAMP: %s", pa_cstrerror(errno));
294 pa_log_debug("Stream properly set up, we're ready to roll!");
296 if (u->profile == PROFILE_A2DP)
297 a2dp_set_bitpool(u, u->a2dp.max_bitpool);
299 u->rtpoll_item = pa_rtpoll_item_new(u->rtpoll, PA_RTPOLL_NEVER, 1);
300 pollfd = pa_rtpoll_item_get_pollfd(u->rtpoll_item, NULL);
301 pollfd->fd = u->stream_fd;
302 pollfd->events = pollfd->revents = 0;
304 u->read_index = u->write_index = 0;
308 u->read_smoother = pa_smoother_new(
318 static bool bt_transport_is_acquired(struct userdata *u) {
319 if (u->accesstype == NULL) {
320 pa_assert(u->stream_fd < 0);
323 pa_assert(u->stream_fd >= 0);
328 static void bt_transport_release(struct userdata *u) {
329 const char *accesstype = "rw";
330 const pa_bluetooth_transport *t;
332 /* Ignore if already released */
333 if (!bt_transport_is_acquired(u))
336 pa_log_debug("Releasing transport %s", u->transport);
338 t = pa_bluetooth_discovery_get_transport(u->discovery, u->transport);
340 pa_bluetooth_transport_release(t, accesstype);
342 pa_xfree(u->accesstype);
343 u->accesstype = NULL;
345 if (u->rtpoll_item) {
346 pa_rtpoll_item_free(u->rtpoll_item);
347 u->rtpoll_item = NULL;
350 if (u->stream_fd >= 0) {
351 pa_close(u->stream_fd);
355 if (u->read_smoother) {
356 pa_smoother_free(u->read_smoother);
357 u->read_smoother = NULL;
361 static int bt_transport_acquire(struct userdata *u, pa_bool_t start) {
362 const char *accesstype = "rw";
363 const pa_bluetooth_transport *t;
365 if (u->transport == NULL) {
366 pa_log("Transport no longer available.");
370 if (bt_transport_is_acquired(u)) {
376 pa_log_debug("Acquiring transport %s", u->transport);
378 t = pa_bluetooth_discovery_get_transport(u->discovery, u->transport);
380 pa_log("Transport %s no longer available", u->transport);
381 pa_xfree(u->transport);
386 u->stream_fd = pa_bluetooth_transport_acquire(t, accesstype, &u->read_link_mtu, &u->write_link_mtu);
387 if (u->stream_fd < 0)
390 u->accesstype = pa_xstrdup(accesstype);
391 pa_log_info("Transport %s acquired: fd %d", u->transport, u->stream_fd);
397 pa_log_info("Transport %s resuming", u->transport);
403 /* Run from IO thread */
404 static int sink_process_msg(pa_msgobject *o, int code, void *data, int64_t offset, pa_memchunk *chunk) {
405 struct userdata *u = PA_SINK(o)->userdata;
406 pa_bool_t failed = FALSE;
409 pa_assert(u->sink == PA_SINK(o));
410 pa_assert(u->transport);
414 case PA_SINK_MESSAGE_SET_STATE:
416 switch ((pa_sink_state_t) PA_PTR_TO_UINT(data)) {
418 case PA_SINK_SUSPENDED:
419 /* Ignore if transition is PA_SINK_INIT->PA_SINK_SUSPENDED */
420 if (!PA_SINK_IS_OPENED(u->sink->thread_info.state))
423 /* Stop the device if the source is suspended as well */
424 if (!u->source || u->source->state == PA_SOURCE_SUSPENDED)
425 /* We deliberately ignore whether stopping
426 * actually worked. Since the stream_fd is
427 * closed it doesn't really matter */
428 bt_transport_release(u);
433 case PA_SINK_RUNNING:
434 if (u->sink->thread_info.state != PA_SINK_SUSPENDED)
437 /* Resume the device if the source was suspended as well */
438 if (!u->source || u->source->state == PA_SOURCE_SUSPENDED) {
439 if (bt_transport_acquire(u, TRUE) < 0)
444 case PA_SINK_UNLINKED:
446 case PA_SINK_INVALID_STATE:
451 case PA_SINK_MESSAGE_GET_LATENCY: {
453 if (u->read_smoother) {
456 ri = pa_smoother_get(u->read_smoother, pa_rtclock_now());
457 wi = pa_bytes_to_usec(u->write_index + u->write_block_size, &u->sample_spec);
459 *((pa_usec_t*) data) = wi > ri ? wi - ri : 0;
463 ri = pa_rtclock_now() - u->started_at;
464 wi = pa_bytes_to_usec(u->write_index, &u->sample_spec);
466 *((pa_usec_t*) data) = wi > ri ? wi - ri : 0;
469 *((pa_usec_t*) data) += u->sink->thread_info.fixed_latency;
474 r = pa_sink_process_msg(o, code, data, offset, chunk);
476 return (r < 0 || !failed) ? r : -1;
479 /* Run from IO thread */
480 static int source_process_msg(pa_msgobject *o, int code, void *data, int64_t offset, pa_memchunk *chunk) {
481 struct userdata *u = PA_SOURCE(o)->userdata;
482 pa_bool_t failed = FALSE;
485 pa_assert(u->source == PA_SOURCE(o));
486 pa_assert(u->transport);
490 case PA_SOURCE_MESSAGE_SET_STATE:
492 switch ((pa_source_state_t) PA_PTR_TO_UINT(data)) {
494 case PA_SOURCE_SUSPENDED:
495 /* Ignore if transition is PA_SOURCE_INIT->PA_SOURCE_SUSPENDED */
496 if (!PA_SOURCE_IS_OPENED(u->source->thread_info.state))
499 /* Stop the device if the sink is suspended as well */
500 if (!u->sink || u->sink->state == PA_SINK_SUSPENDED)
501 bt_transport_release(u);
503 if (u->read_smoother)
504 pa_smoother_pause(u->read_smoother, pa_rtclock_now());
508 case PA_SOURCE_RUNNING:
509 if (u->source->thread_info.state != PA_SOURCE_SUSPENDED)
512 /* Resume the device if the sink was suspended as well */
513 if (!u->sink || u->sink->thread_info.state == PA_SINK_SUSPENDED) {
514 if (bt_transport_acquire(u, TRUE) < 0)
517 /* We don't resume the smoother here. Instead we
518 * wait until the first packet arrives */
521 case PA_SOURCE_UNLINKED:
523 case PA_SOURCE_INVALID_STATE:
528 case PA_SOURCE_MESSAGE_GET_LATENCY: {
531 if (u->read_smoother) {
532 wi = pa_smoother_get(u->read_smoother, pa_rtclock_now());
533 ri = pa_bytes_to_usec(u->read_index, &u->sample_spec);
535 *((pa_usec_t*) data) = (wi > ri ? wi - ri : 0) + u->source->thread_info.fixed_latency;
537 *((pa_usec_t*) data) = 0;
544 r = pa_source_process_msg(o, code, data, offset, chunk);
546 return (r < 0 || !failed) ? r : -1;
549 /* Called from main thread context */
550 static int device_process_msg(pa_msgobject *obj, int code, void *data, int64_t offset, pa_memchunk *chunk) {
551 struct bluetooth_msg *u = BLUETOOTH_MSG(obj);
554 case BLUETOOTH_MESSAGE_IO_THREAD_FAILED: {
555 if (u->card->module->unload_requested)
558 pa_log_debug("Switching the profile to off due to IO thread failure.");
560 if (pa_card_set_profile(u->card, "off", FALSE) < 0)
561 pa_log_debug("Failed to switch profile to off");
568 /* Run from IO thread */
569 static int hsp_process_render(struct userdata *u) {
573 pa_assert(u->profile == PROFILE_HSP || u->profile == PROFILE_HFGW);
576 /* First, render some data */
577 if (!u->write_memchunk.memblock)
578 pa_sink_render_full(u->sink, u->write_block_size, &u->write_memchunk);
580 pa_assert(u->write_memchunk.length == u->write_block_size);
586 /* Now write that data to the socket. The socket is of type
587 * SEQPACKET, and we generated the data of the MTU size, so this
588 * should just work. */
590 p = (const uint8_t*) pa_memblock_acquire(u->write_memchunk.memblock) + u->write_memchunk.index;
591 l = pa_write(u->stream_fd, p, u->write_memchunk.length, &u->stream_write_type);
592 pa_memblock_release(u->write_memchunk.memblock);
599 /* Retry right away if we got interrupted */
602 else if (errno == EAGAIN)
603 /* Hmm, apparently the socket was not writable, give up for now */
606 pa_log_error("Failed to write data to SCO socket: %s", pa_cstrerror(errno));
611 pa_assert((size_t) l <= u->write_memchunk.length);
613 if ((size_t) l != u->write_memchunk.length) {
614 pa_log_error("Wrote memory block to socket only partially! %llu written, wanted to write %llu.",
615 (unsigned long long) l,
616 (unsigned long long) u->write_memchunk.length);
621 u->write_index += (uint64_t) u->write_memchunk.length;
622 pa_memblock_unref(u->write_memchunk.memblock);
623 pa_memchunk_reset(&u->write_memchunk);
632 /* Run from IO thread */
633 static int hsp_process_push(struct userdata *u) {
635 pa_memchunk memchunk;
638 pa_assert(u->profile == PROFILE_HSP || u->profile == PROFILE_HFGW);
639 pa_assert(u->source);
640 pa_assert(u->read_smoother);
642 memchunk.memblock = pa_memblock_new(u->core->mempool, u->read_block_size);
643 memchunk.index = memchunk.length = 0;
652 pa_bool_t found_tstamp = FALSE;
655 memset(&m, 0, sizeof(m));
656 memset(&aux, 0, sizeof(aux));
657 memset(&iov, 0, sizeof(iov));
662 m.msg_controllen = sizeof(aux);
664 p = pa_memblock_acquire(memchunk.memblock);
666 iov.iov_len = pa_memblock_get_length(memchunk.memblock);
667 l = recvmsg(u->stream_fd, &m, 0);
668 pa_memblock_release(memchunk.memblock);
672 if (l < 0 && errno == EINTR)
673 /* Retry right away if we got interrupted */
676 else if (l < 0 && errno == EAGAIN)
677 /* Hmm, apparently the socket was not readable, give up for now. */
680 pa_log_error("Failed to read data from SCO socket: %s", l < 0 ? pa_cstrerror(errno) : "EOF");
685 pa_assert((size_t) l <= pa_memblock_get_length(memchunk.memblock));
687 memchunk.length = (size_t) l;
688 u->read_index += (uint64_t) l;
690 for (cm = CMSG_FIRSTHDR(&m); cm; cm = CMSG_NXTHDR(&m, cm))
691 if (cm->cmsg_level == SOL_SOCKET && cm->cmsg_type == SO_TIMESTAMP) {
692 struct timeval *tv = (struct timeval*) CMSG_DATA(cm);
693 pa_rtclock_from_wallclock(tv);
694 tstamp = pa_timeval_load(tv);
700 pa_log_warn("Couldn't find SO_TIMESTAMP data in auxiliary recvmsg() data!");
701 tstamp = pa_rtclock_now();
704 pa_smoother_put(u->read_smoother, tstamp, pa_bytes_to_usec(u->read_index, &u->sample_spec));
705 pa_smoother_resume(u->read_smoother, tstamp, TRUE);
707 pa_source_post(u->source, &memchunk);
713 pa_memblock_unref(memchunk.memblock);
718 /* Run from IO thread */
719 static void a2dp_prepare_buffer(struct userdata *u) {
720 size_t min_buffer_size = PA_MAX(u->read_link_mtu, u->write_link_mtu);
724 if (u->a2dp.buffer_size >= min_buffer_size)
727 u->a2dp.buffer_size = 2 * min_buffer_size;
728 pa_xfree(u->a2dp.buffer);
729 u->a2dp.buffer = pa_xmalloc(u->a2dp.buffer_size);
732 /* Run from IO thread */
733 static int a2dp_process_render(struct userdata *u) {
734 struct a2dp_info *a2dp;
735 struct rtp_header *header;
736 struct rtp_payload *payload;
740 size_t to_write, to_encode;
741 unsigned frame_count;
745 pa_assert(u->profile == PROFILE_A2DP);
748 /* First, render some data */
749 if (!u->write_memchunk.memblock)
750 pa_sink_render_full(u->sink, u->write_block_size, &u->write_memchunk);
752 pa_assert(u->write_memchunk.length == u->write_block_size);
754 a2dp_prepare_buffer(u);
757 header = a2dp->buffer;
758 payload = (struct rtp_payload*) ((uint8_t*) a2dp->buffer + sizeof(*header));
762 /* Try to create a packet of the full MTU */
764 p = (const uint8_t*) pa_memblock_acquire(u->write_memchunk.memblock) + u->write_memchunk.index;
765 to_encode = u->write_memchunk.length;
767 d = (uint8_t*) a2dp->buffer + sizeof(*header) + sizeof(*payload);
768 to_write = a2dp->buffer_size - sizeof(*header) - sizeof(*payload);
770 while (PA_LIKELY(to_encode > 0 && to_write > 0)) {
774 encoded = sbc_encode(&a2dp->sbc,
779 if (PA_UNLIKELY(encoded <= 0)) {
780 pa_log_error("SBC encoding error (%li)", (long) encoded);
781 pa_memblock_release(u->write_memchunk.memblock);
785 /* pa_log_debug("SBC: encoded: %lu; written: %lu", (unsigned long) encoded, (unsigned long) written); */
786 /* pa_log_debug("SBC: codesize: %lu; frame_length: %lu", (unsigned long) a2dp->codesize, (unsigned long) a2dp->frame_length); */
788 pa_assert_fp((size_t) encoded <= to_encode);
789 pa_assert_fp((size_t) encoded == a2dp->codesize);
791 pa_assert_fp((size_t) written <= to_write);
792 pa_assert_fp((size_t) written == a2dp->frame_length);
794 p = (const uint8_t*) p + encoded;
795 to_encode -= encoded;
797 d = (uint8_t*) d + written;
803 pa_memblock_release(u->write_memchunk.memblock);
805 pa_assert(to_encode == 0);
808 pa_log_debug("Using SBC encoder implementation: %s", pa_strnull(sbc_get_implementation_info(&a2dp->sbc)));
811 /* write it to the fifo */
812 memset(a2dp->buffer, 0, sizeof(*header) + sizeof(*payload));
815 header->sequence_number = htons(a2dp->seq_num++);
816 header->timestamp = htonl(u->write_index / pa_frame_size(&u->sample_spec));
817 header->ssrc = htonl(1);
818 payload->frame_count = frame_count;
820 nbytes = (uint8_t*) d - (uint8_t*) a2dp->buffer;
825 l = pa_write(u->stream_fd, a2dp->buffer, nbytes, &u->stream_write_type);
832 /* Retry right away if we got interrupted */
835 else if (errno == EAGAIN)
836 /* Hmm, apparently the socket was not writable, give up for now */
839 pa_log_error("Failed to write data to socket: %s", pa_cstrerror(errno));
844 pa_assert((size_t) l <= nbytes);
846 if ((size_t) l != nbytes) {
847 pa_log_warn("Wrote memory block to socket only partially! %llu written, wanted to write %llu.",
848 (unsigned long long) l,
849 (unsigned long long) nbytes);
854 u->write_index += (uint64_t) u->write_memchunk.length;
855 pa_memblock_unref(u->write_memchunk.memblock);
856 pa_memchunk_reset(&u->write_memchunk);
866 static int a2dp_process_push(struct userdata *u) {
868 pa_memchunk memchunk;
871 pa_assert(u->profile == PROFILE_A2DP_SOURCE);
872 pa_assert(u->source);
873 pa_assert(u->read_smoother);
875 memchunk.memblock = pa_memblock_new(u->core->mempool, u->read_block_size);
876 memchunk.index = memchunk.length = 0;
879 pa_bool_t found_tstamp = FALSE;
881 struct a2dp_info *a2dp;
882 struct rtp_header *header;
883 struct rtp_payload *payload;
887 size_t to_write, to_decode;
889 a2dp_prepare_buffer(u);
892 header = a2dp->buffer;
893 payload = (struct rtp_payload*) ((uint8_t*) a2dp->buffer + sizeof(*header));
895 l = pa_read(u->stream_fd, a2dp->buffer, a2dp->buffer_size, &u->stream_write_type);
899 if (l < 0 && errno == EINTR)
900 /* Retry right away if we got interrupted */
903 else if (l < 0 && errno == EAGAIN)
904 /* Hmm, apparently the socket was not readable, give up for now. */
907 pa_log_error("Failed to read data from socket: %s", l < 0 ? pa_cstrerror(errno) : "EOF");
912 pa_assert((size_t) l <= a2dp->buffer_size);
914 u->read_index += (uint64_t) l;
916 /* TODO: get timestamp from rtp */
918 /* pa_log_warn("Couldn't find SO_TIMESTAMP data in auxiliary recvmsg() data!"); */
919 tstamp = pa_rtclock_now();
922 pa_smoother_put(u->read_smoother, tstamp, pa_bytes_to_usec(u->read_index, &u->sample_spec));
923 pa_smoother_resume(u->read_smoother, tstamp, TRUE);
925 p = (uint8_t*) a2dp->buffer + sizeof(*header) + sizeof(*payload);
926 to_decode = l - sizeof(*header) - sizeof(*payload);
928 d = pa_memblock_acquire(memchunk.memblock);
929 to_write = memchunk.length = pa_memblock_get_length(memchunk.memblock);
931 while (PA_LIKELY(to_decode > 0)) {
935 decoded = sbc_decode(&a2dp->sbc,
940 if (PA_UNLIKELY(decoded <= 0)) {
941 pa_log_error("SBC decoding error (%li)", (long) decoded);
942 pa_memblock_release(memchunk.memblock);
943 pa_memblock_unref(memchunk.memblock);
947 /* pa_log_debug("SBC: decoded: %lu; written: %lu", (unsigned long) decoded, (unsigned long) written); */
948 /* pa_log_debug("SBC: frame_length: %lu; codesize: %lu", (unsigned long) a2dp->frame_length, (unsigned long) a2dp->codesize); */
950 /* Reset frame length, it can be changed due to bitpool change */
951 a2dp->frame_length = sbc_get_frame_length(&a2dp->sbc);
953 pa_assert_fp((size_t) decoded <= to_decode);
954 pa_assert_fp((size_t) decoded == a2dp->frame_length);
956 pa_assert_fp((size_t) written == a2dp->codesize);
958 p = (const uint8_t*) p + decoded;
959 to_decode -= decoded;
961 d = (uint8_t*) d + written;
965 memchunk.length -= to_write;
967 pa_memblock_release(memchunk.memblock);
969 pa_source_post(u->source, &memchunk);
975 pa_memblock_unref(memchunk.memblock);
980 static void a2dp_reduce_bitpool(struct userdata *u)
982 struct a2dp_info *a2dp;
989 /* Check if bitpool is already at its limit */
990 if (a2dp->sbc.bitpool <= BITPOOL_DEC_LIMIT)
993 bitpool = a2dp->sbc.bitpool - BITPOOL_DEC_STEP;
995 if (bitpool < BITPOOL_DEC_LIMIT)
996 bitpool = BITPOOL_DEC_LIMIT;
998 a2dp_set_bitpool(u, bitpool);
1001 static void thread_func(void *userdata) {
1002 struct userdata *u = userdata;
1003 unsigned do_write = 0;
1004 unsigned pending_read_bytes = 0;
1005 pa_bool_t writable = FALSE;
1008 pa_assert(u->transport);
1010 pa_log_debug("IO Thread starting up");
1012 if (u->core->realtime_scheduling)
1013 pa_make_realtime(u->core->realtime_priority);
1015 pa_thread_mq_install(&u->thread_mq);
1017 if (bt_transport_acquire(u, TRUE) < 0)
1021 struct pollfd *pollfd;
1023 pa_bool_t disable_timer = TRUE;
1025 pollfd = u->rtpoll_item ? pa_rtpoll_item_get_pollfd(u->rtpoll_item, NULL) : NULL;
1027 if (u->source && PA_SOURCE_IS_LINKED(u->source->thread_info.state)) {
1029 /* We should send two blocks to the device before we expect
1032 if (u->write_index == 0 && u->read_index <= 0)
1035 if (pollfd && (pollfd->revents & POLLIN)) {
1038 if (u->profile == PROFILE_HSP || u->profile == PROFILE_HFGW)
1039 n_read = hsp_process_push(u);
1041 n_read = a2dp_process_push(u);
1046 /* We just read something, so we are supposed to write something, too */
1047 pending_read_bytes += n_read;
1048 do_write += pending_read_bytes / u->write_block_size;
1049 pending_read_bytes = pending_read_bytes % u->write_block_size;
1053 if (u->sink && PA_SINK_IS_LINKED(u->sink->thread_info.state)) {
1055 if (u->sink->thread_info.rewind_requested)
1056 pa_sink_process_rewind(u->sink, 0);
1059 if (pollfd->revents & POLLOUT)
1062 if ((!u->source || !PA_SOURCE_IS_LINKED(u->source->thread_info.state)) && do_write <= 0 && writable) {
1063 pa_usec_t time_passed;
1064 pa_usec_t audio_sent;
1066 /* Hmm, there is no input stream we could synchronize
1067 * to. So let's do things by time */
1069 time_passed = pa_rtclock_now() - u->started_at;
1070 audio_sent = pa_bytes_to_usec(u->write_index, &u->sample_spec);
1072 if (audio_sent <= time_passed) {
1073 pa_usec_t audio_to_send = time_passed - audio_sent;
1075 /* Never try to catch up for more than 100ms */
1076 if (u->write_index > 0 && audio_to_send > MAX_PLAYBACK_CATCH_UP_USEC) {
1077 pa_usec_t skip_usec;
1078 uint64_t skip_bytes;
1080 skip_usec = audio_to_send - MAX_PLAYBACK_CATCH_UP_USEC;
1081 skip_bytes = pa_usec_to_bytes(skip_usec, &u->sample_spec);
1083 if (skip_bytes > 0) {
1086 pa_log_warn("Skipping %llu us (= %llu bytes) in audio stream",
1087 (unsigned long long) skip_usec,
1088 (unsigned long long) skip_bytes);
1090 pa_sink_render_full(u->sink, skip_bytes, &tmp);
1091 pa_memblock_unref(tmp.memblock);
1092 u->write_index += skip_bytes;
1094 if (u->profile == PROFILE_A2DP)
1095 a2dp_reduce_bitpool(u);
1100 pending_read_bytes = 0;
1104 if (writable && do_write > 0) {
1107 if (u->write_index <= 0)
1108 u->started_at = pa_rtclock_now();
1110 if (u->profile == PROFILE_A2DP) {
1111 if ((n_written = a2dp_process_render(u)) < 0)
1114 if ((n_written = hsp_process_render(u)) < 0)
1119 pa_log("Broken kernel: we got EAGAIN on write() after POLLOUT!");
1121 do_write -= n_written;
1125 if ((!u->source || !PA_SOURCE_IS_LINKED(u->source->thread_info.state)) && do_write <= 0) {
1126 pa_usec_t sleep_for;
1127 pa_usec_t time_passed, next_write_at;
1130 /* Hmm, there is no input stream we could synchronize
1131 * to. So let's estimate when we need to wake up the latest */
1132 time_passed = pa_rtclock_now() - u->started_at;
1133 next_write_at = pa_bytes_to_usec(u->write_index, &u->sample_spec);
1134 sleep_for = time_passed < next_write_at ? next_write_at - time_passed : 0;
1135 /* 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); */
1137 /* drop stream every 500 ms */
1138 sleep_for = PA_USEC_PER_MSEC * 500;
1140 pa_rtpoll_set_timer_relative(u->rtpoll, sleep_for);
1141 disable_timer = FALSE;
1147 pa_rtpoll_set_timer_disabled(u->rtpoll);
1149 /* Hmm, nothing to do. Let's sleep */
1151 pollfd->events = (short) (((u->sink && PA_SINK_IS_LINKED(u->sink->thread_info.state) && !writable) ? POLLOUT : 0) |
1152 (u->source && PA_SOURCE_IS_LINKED(u->source->thread_info.state) ? POLLIN : 0));
1154 if ((ret = pa_rtpoll_run(u->rtpoll, TRUE)) < 0) {
1155 pa_log_debug("pa_rtpoll_run failed with: %d", ret);
1159 pa_log_debug("IO thread shutdown requested, stopping cleanly");
1160 bt_transport_release(u);
1164 pollfd = u->rtpoll_item ? pa_rtpoll_item_get_pollfd(u->rtpoll_item, NULL) : NULL;
1166 if (pollfd && (pollfd->revents & ~(POLLOUT|POLLIN))) {
1167 pa_log_info("FD error: %s%s%s%s",
1168 pollfd->revents & POLLERR ? "POLLERR " :"",
1169 pollfd->revents & POLLHUP ? "POLLHUP " :"",
1170 pollfd->revents & POLLPRI ? "POLLPRI " :"",
1171 pollfd->revents & POLLNVAL ? "POLLNVAL " :"");
1177 /* If this was no regular exit from the loop we have to continue processing messages until we receive PA_MESSAGE_SHUTDOWN */
1178 pa_log_debug("IO thread failed");
1179 pa_asyncmsgq_post(pa_thread_mq_get()->outq, PA_MSGOBJECT(u->msg), BLUETOOTH_MESSAGE_IO_THREAD_FAILED, NULL, 0, NULL, NULL);
1180 pa_asyncmsgq_wait_for(u->thread_mq.inq, PA_MESSAGE_SHUTDOWN);
1183 pa_log_debug("IO thread shutting down");
1186 static pa_bt_audio_state_t parse_state_property_change(DBusMessage *m) {
1187 DBusMessageIter iter;
1188 DBusMessageIter variant;
1191 pa_bt_audio_state_t state;
1193 if (!dbus_message_iter_init(m, &iter)) {
1194 pa_log("Failed to parse PropertyChanged");
1195 return PA_BT_AUDIO_STATE_INVALID;
1198 if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING) {
1199 pa_log("Property name not a string");
1200 return PA_BT_AUDIO_STATE_INVALID;
1203 dbus_message_iter_get_basic(&iter, &key);
1205 if (!pa_streq(key, "State"))
1206 return PA_BT_AUDIO_STATE_INVALID;
1208 if (!dbus_message_iter_next(&iter)) {
1209 pa_log("Property value missing");
1210 return PA_BT_AUDIO_STATE_INVALID;
1213 dbus_message_iter_recurse(&iter, &variant);
1215 if (dbus_message_iter_get_arg_type(&variant) != DBUS_TYPE_STRING) {
1216 pa_log("Property value not a string");
1217 return PA_BT_AUDIO_STATE_INVALID;
1220 dbus_message_iter_get_basic(&variant, &value);
1222 pa_log_debug("dbus: %s property 'State' changed to value '%s'", dbus_message_get_interface(m), value);
1224 state = pa_bt_audio_state_from_string(value);
1226 if (state == PA_BT_AUDIO_STATE_INVALID)
1227 pa_log("Unexpected value for property 'State': '%s'", value);
1232 static pa_port_available_t audio_state_to_availability(pa_bt_audio_state_t state) {
1233 if (state < PA_BT_AUDIO_STATE_CONNECTED)
1234 return PA_PORT_AVAILABLE_NO;
1235 else if (state >= PA_BT_AUDIO_STATE_PLAYING)
1236 return PA_PORT_AVAILABLE_YES;
1238 return PA_PORT_AVAILABLE_UNKNOWN;
1241 /* Run from main thread */
1242 static DBusHandlerResult filter_cb(DBusConnection *bus, DBusMessage *m, void *userdata) {
1245 bool acquire = FALSE;
1246 bool release = FALSE;
1250 pa_assert_se(u = userdata);
1252 dbus_error_init(&err);
1254 pa_log_debug("dbus: interface=%s, path=%s, member=%s\n",
1255 dbus_message_get_interface(m),
1256 dbus_message_get_path(m),
1257 dbus_message_get_member(m));
1259 if (!dbus_message_has_path(m, u->path) && !dbus_message_has_path(m, u->transport))
1262 if (dbus_message_is_signal(m, "org.bluez.Headset", "SpeakerGainChanged") ||
1263 dbus_message_is_signal(m, "org.bluez.Headset", "MicrophoneGainChanged")) {
1268 if (!dbus_message_get_args(m, &err, DBUS_TYPE_UINT16, &gain, DBUS_TYPE_INVALID) || gain > HSP_MAX_GAIN) {
1269 pa_log("Failed to parse org.bluez.Headset.{Speaker|Microphone}GainChanged: %s", err.message);
1273 if (u->profile == PROFILE_HSP) {
1274 if (u->sink && dbus_message_is_signal(m, "org.bluez.Headset", "SpeakerGainChanged")) {
1275 pa_volume_t volume = (pa_volume_t) (gain * PA_VOLUME_NORM / HSP_MAX_GAIN);
1277 /* increment volume by one to correct rounding errors */
1278 if (volume < PA_VOLUME_NORM)
1281 pa_cvolume_set(&v, u->sample_spec.channels, volume);
1282 pa_sink_volume_changed(u->sink, &v);
1284 } else if (u->source && dbus_message_is_signal(m, "org.bluez.Headset", "MicrophoneGainChanged")) {
1285 pa_volume_t volume = (pa_volume_t) (gain * PA_VOLUME_NORM / HSP_MAX_GAIN);
1287 /* increment volume by one to correct rounding errors */
1288 if (volume < PA_VOLUME_NORM)
1291 pa_cvolume_set(&v, u->sample_spec.channels, volume);
1292 pa_source_volume_changed(u->source, &v);
1295 } else if (dbus_message_is_signal(m, "org.bluez.HandsfreeGateway", "PropertyChanged")) {
1296 pa_bt_audio_state_t state = parse_state_property_change(m);
1299 case PA_BT_AUDIO_STATE_INVALID:
1300 case PA_BT_AUDIO_STATE_DISCONNECTED:
1301 case PA_BT_AUDIO_STATE_CONNECTED:
1302 case PA_BT_AUDIO_STATE_CONNECTING:
1305 case PA_BT_AUDIO_STATE_PLAYING:
1307 pa_log_debug("Changing profile to hfgw");
1308 if (pa_card_set_profile(u->card, "hfgw", FALSE) < 0)
1309 pa_log("Failed to change profile to hfgw");
1314 if (state != PA_BT_AUDIO_STATE_INVALID) {
1315 pa_device_port *port;
1316 pa_port_available_t available = audio_state_to_availability(state);
1318 pa_assert_se(port = pa_hashmap_get(u->card->ports, "hfgw-output"));
1319 pa_device_port_set_available(port, available);
1321 pa_assert_se(port = pa_hashmap_get(u->card->ports, "hfgw-input"));
1322 pa_device_port_set_available(port, available);
1324 acquire = (available == PA_PORT_AVAILABLE_YES && u->profile == PROFILE_HFGW);
1325 release = (available != PA_PORT_AVAILABLE_YES && u->profile == PROFILE_HFGW);
1327 } else if (dbus_message_is_signal(m, "org.bluez.Headset", "PropertyChanged")) {
1328 pa_bt_audio_state_t state = parse_state_property_change(m);
1330 if (state != PA_BT_AUDIO_STATE_INVALID) {
1331 pa_device_port *port;
1332 pa_port_available_t available = audio_state_to_availability(state);
1334 pa_assert_se(port = pa_hashmap_get(u->card->ports, "hsp-output"));
1335 pa_device_port_set_available(port, available);
1337 pa_assert_se(port = pa_hashmap_get(u->card->ports, "hsp-input"));
1338 pa_device_port_set_available(port, available);
1340 acquire = (available == PA_PORT_AVAILABLE_YES && u->profile == PROFILE_HSP);
1341 release = (available != PA_PORT_AVAILABLE_YES && u->profile == PROFILE_HSP);
1343 } else if (dbus_message_is_signal(m, "org.bluez.AudioSource", "PropertyChanged")) {
1344 pa_bt_audio_state_t state = parse_state_property_change(m);
1346 if (state != PA_BT_AUDIO_STATE_INVALID) {
1347 pa_device_port *port;
1348 pa_port_available_t available = audio_state_to_availability(state);
1350 pa_assert_se(port = pa_hashmap_get(u->card->ports, "a2dp-input"));
1351 pa_device_port_set_available(port, available);
1353 acquire = (available == PA_PORT_AVAILABLE_YES && u->profile == PROFILE_A2DP_SOURCE);
1354 release = (available != PA_PORT_AVAILABLE_YES && u->profile == PROFILE_A2DP_SOURCE);
1356 } else if (dbus_message_is_signal(m, "org.bluez.AudioSink", "PropertyChanged")) {
1357 pa_bt_audio_state_t state = parse_state_property_change(m);
1359 if (state != PA_BT_AUDIO_STATE_INVALID) {
1360 pa_device_port *port;
1361 pa_port_available_t available = audio_state_to_availability(state);
1363 pa_assert_se(port = pa_hashmap_get(u->card->ports, "a2dp-output"));
1364 pa_device_port_set_available(port, available);
1366 acquire = (available == PA_PORT_AVAILABLE_YES && u->profile == PROFILE_A2DP);
1367 release = (available != PA_PORT_AVAILABLE_YES && u->profile == PROFILE_A2DP);
1372 if (bt_transport_acquire(u, FALSE) >= 0) {
1374 pa_source_suspend(u->source, FALSE, PA_SUSPEND_IDLE|PA_SUSPEND_USER);
1377 pa_sink_suspend(u->sink, FALSE, PA_SUSPEND_IDLE|PA_SUSPEND_USER);
1380 if (release && bt_transport_is_acquired(u)) {
1381 /* FIXME: this release is racy, since the audio stream might have
1382 been set up again in the meantime (but not processed yet by PA).
1383 BlueZ should probably release the transport automatically, and
1384 in that case we would just mark the transport as released */
1386 /* Remote side closed the stream so we consider it PA_SUSPEND_USER */
1388 pa_source_suspend(u->source, TRUE, PA_SUSPEND_USER);
1391 pa_sink_suspend(u->sink, TRUE, PA_SUSPEND_USER);
1395 dbus_error_free(&err);
1397 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1400 /* Run from main thread */
1401 static void sink_set_volume_cb(pa_sink *s) {
1411 k = pa_sprintf_malloc("bluetooth-device@%p", (void*) s);
1412 u = pa_shared_get(s->core, k);
1416 pa_assert(u->sink == s);
1417 pa_assert(u->profile == PROFILE_HSP);
1419 gain = (pa_cvolume_max(&s->real_volume) * HSP_MAX_GAIN) / PA_VOLUME_NORM;
1421 if (gain > HSP_MAX_GAIN)
1422 gain = HSP_MAX_GAIN;
1424 volume = (pa_volume_t) (gain * PA_VOLUME_NORM / HSP_MAX_GAIN);
1426 /* increment volume by one to correct rounding errors */
1427 if (volume < PA_VOLUME_NORM)
1430 pa_cvolume_set(&s->real_volume, u->sample_spec.channels, volume);
1432 pa_assert_se(m = dbus_message_new_method_call("org.bluez", u->path, "org.bluez.Headset", "SetSpeakerGain"));
1433 pa_assert_se(dbus_message_append_args(m, DBUS_TYPE_UINT16, &gain, DBUS_TYPE_INVALID));
1434 pa_assert_se(dbus_connection_send(pa_dbus_connection_get(u->connection), m, NULL));
1435 dbus_message_unref(m);
1438 /* Run from main thread */
1439 static void source_set_volume_cb(pa_source *s) {
1449 k = pa_sprintf_malloc("bluetooth-device@%p", (void*) s);
1450 u = pa_shared_get(s->core, k);
1454 pa_assert(u->source == s);
1455 pa_assert(u->profile == PROFILE_HSP);
1457 gain = (pa_cvolume_max(&s->real_volume) * HSP_MAX_GAIN) / PA_VOLUME_NORM;
1459 if (gain > HSP_MAX_GAIN)
1460 gain = HSP_MAX_GAIN;
1462 volume = (pa_volume_t) (gain * PA_VOLUME_NORM / HSP_MAX_GAIN);
1464 /* increment volume by one to correct rounding errors */
1465 if (volume < PA_VOLUME_NORM)
1468 pa_cvolume_set(&s->real_volume, u->sample_spec.channels, volume);
1470 pa_assert_se(m = dbus_message_new_method_call("org.bluez", u->path, "org.bluez.Headset", "SetMicrophoneGain"));
1471 pa_assert_se(dbus_message_append_args(m, DBUS_TYPE_UINT16, &gain, DBUS_TYPE_INVALID));
1472 pa_assert_se(dbus_connection_send(pa_dbus_connection_get(u->connection), m, NULL));
1473 dbus_message_unref(m);
1476 /* Run from main thread */
1477 static char *get_name(const char *type, pa_modargs *ma, const char *device_id, pa_bool_t *namereg_fail) {
1483 pa_assert(device_id);
1484 pa_assert(namereg_fail);
1486 t = pa_sprintf_malloc("%s_name", type);
1487 n = pa_modargs_get_value(ma, t, NULL);
1491 *namereg_fail = TRUE;
1492 return pa_xstrdup(n);
1495 if ((n = pa_modargs_get_value(ma, "name", NULL)))
1496 *namereg_fail = TRUE;
1499 *namereg_fail = FALSE;
1502 return pa_sprintf_malloc("bluez_%s.%s", type, n);
1505 static int sco_over_pcm_state_update(struct userdata *u, pa_bool_t changed) {
1507 pa_assert(USE_SCO_OVER_PCM(u));
1509 if (PA_SINK_IS_OPENED(pa_sink_get_state(u->hsp.sco_sink)) ||
1510 PA_SOURCE_IS_OPENED(pa_source_get_state(u->hsp.sco_source))) {
1512 if (u->stream_fd >= 0)
1515 pa_log_debug("Resuming SCO over PCM");
1516 if (init_profile(u) < 0) {
1517 pa_log("Can't resume SCO over PCM");
1521 return bt_transport_acquire(u, TRUE);
1525 if (u->stream_fd < 0)
1528 pa_log_debug("Closing SCO over PCM");
1530 bt_transport_release(u);
1536 static pa_hook_result_t sink_state_changed_cb(pa_core *c, pa_sink *s, struct userdata *u) {
1538 pa_sink_assert_ref(s);
1541 if (s != u->hsp.sco_sink)
1544 sco_over_pcm_state_update(u, TRUE);
1549 static pa_hook_result_t source_state_changed_cb(pa_core *c, pa_source *s, struct userdata *u) {
1551 pa_source_assert_ref(s);
1554 if (s != u->hsp.sco_source)
1557 sco_over_pcm_state_update(u, TRUE);
1562 static pa_hook_result_t nrec_changed_cb(pa_bluetooth_transport *t, void *call_data, struct userdata *u) {
1568 p = pa_proplist_new();
1569 pa_proplist_sets(p, "bluetooth.nrec", t->nrec ? "1" : "0");
1570 pa_source_update_proplist(u->source, PA_UPDATE_REPLACE, p);
1571 pa_proplist_free(p);
1576 static void connect_ports(struct userdata *u, void *sink_or_source_new_data, pa_direction_t direction) {
1578 pa_sink_new_data *sink_new_data;
1579 pa_source_new_data *source_new_data;
1581 pa_device_port *port;
1583 if (direction == PA_DIRECTION_OUTPUT) {
1584 data.sink_new_data = sink_or_source_new_data;
1585 data.sink_new_data->ports = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
1587 data.source_new_data = sink_or_source_new_data;
1588 data.source_new_data->ports = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
1591 switch (u->profile) {
1593 pa_assert_se(port = pa_hashmap_get(u->card->ports, "a2dp-output"));
1594 pa_assert_se(pa_hashmap_put(data.sink_new_data->ports, port->name, port) >= 0);
1595 pa_device_port_ref(port);
1598 case PROFILE_A2DP_SOURCE:
1599 pa_assert_se(port = pa_hashmap_get(u->card->ports, "a2dp-input"));
1600 pa_assert_se(pa_hashmap_put(data.source_new_data->ports, port->name, port) >= 0);
1601 pa_device_port_ref(port);
1605 if (direction == PA_DIRECTION_OUTPUT) {
1606 pa_assert_se(port = pa_hashmap_get(u->card->ports, "hsp-output"));
1607 pa_assert_se(pa_hashmap_put(data.sink_new_data->ports, port->name, port) >= 0);
1609 pa_assert_se(port = pa_hashmap_get(u->card->ports, "hsp-input"));
1610 pa_assert_se(pa_hashmap_put(data.source_new_data->ports, port->name, port) >= 0);
1612 pa_device_port_ref(port);
1616 if (direction == PA_DIRECTION_OUTPUT) {
1617 pa_assert_se(port = pa_hashmap_get(u->card->ports, "hfgw-output"));
1618 pa_assert_se(pa_hashmap_put(data.sink_new_data->ports, port->name, port) >= 0);
1620 pa_assert_se(port = pa_hashmap_get(u->card->ports, "hfgw-input"));
1621 pa_assert_se(pa_hashmap_put(data.source_new_data->ports, port->name, port) >= 0);
1623 pa_device_port_ref(port);
1627 pa_assert_not_reached();
1631 static const char *profile_to_string(enum profile profile) {
1635 case PROFILE_A2DP_SOURCE:
1636 return "a2dp_source";
1642 pa_assert_not_reached();
1646 static int sink_set_port_cb(pa_sink *s, pa_device_port *p) {
1650 static int source_set_port_cb(pa_source *s, pa_device_port *p) {
1654 /* Run from main thread */
1655 static int add_sink(struct userdata *u) {
1658 if (USE_SCO_OVER_PCM(u)) {
1661 u->sink = u->hsp.sco_sink;
1662 p = pa_proplist_new();
1663 pa_proplist_sets(p, "bluetooth.protocol", profile_to_string(u->profile));
1664 pa_proplist_update(u->sink->proplist, PA_UPDATE_MERGE, p);
1665 pa_proplist_free(p);
1667 if (!u->hsp.sink_state_changed_slot)
1668 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);
1671 pa_sink_new_data data;
1674 pa_sink_new_data_init(&data);
1675 data.driver = __FILE__;
1676 data.module = u->module;
1677 pa_sink_new_data_set_sample_spec(&data, &u->sample_spec);
1678 pa_proplist_sets(data.proplist, "bluetooth.protocol", profile_to_string(u->profile));
1679 if (u->profile == PROFILE_HSP)
1680 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_INTENDED_ROLES, "phone");
1681 data.card = u->card;
1682 data.name = get_name("sink", u->modargs, u->address, &b);
1683 data.namereg_fail = b;
1685 if (pa_modargs_get_proplist(u->modargs, "sink_properties", data.proplist, PA_UPDATE_REPLACE) < 0) {
1686 pa_log("Invalid properties");
1687 pa_sink_new_data_done(&data);
1690 connect_ports(u, &data, PA_DIRECTION_OUTPUT);
1692 u->sink = pa_sink_new(u->core, &data, PA_SINK_HARDWARE|PA_SINK_LATENCY);
1693 pa_sink_new_data_done(&data);
1696 pa_log_error("Failed to create sink");
1700 u->sink->userdata = u;
1701 u->sink->parent.process_msg = sink_process_msg;
1702 u->sink->set_port = sink_set_port_cb;
1705 if (u->profile == PROFILE_HSP) {
1706 pa_sink_set_set_volume_callback(u->sink, sink_set_volume_cb);
1707 u->sink->n_volume_steps = 16;
1709 k = pa_sprintf_malloc("bluetooth-device@%p", (void*) u->sink);
1710 pa_shared_set(u->core, k, u);
1717 /* Run from main thread */
1718 static int add_source(struct userdata *u) {
1721 if (USE_SCO_OVER_PCM(u)) {
1722 u->source = u->hsp.sco_source;
1723 pa_proplist_sets(u->source->proplist, "bluetooth.protocol", profile_to_string(u->profile));
1725 if (!u->hsp.source_state_changed_slot)
1726 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);
1729 pa_source_new_data data;
1732 pa_source_new_data_init(&data);
1733 data.driver = __FILE__;
1734 data.module = u->module;
1735 pa_source_new_data_set_sample_spec(&data, &u->sample_spec);
1736 pa_proplist_sets(data.proplist, "bluetooth.protocol", profile_to_string(u->profile));
1737 if (u->profile == PROFILE_HSP)
1738 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_INTENDED_ROLES, "phone");
1740 data.card = u->card;
1741 data.name = get_name("source", u->modargs, u->address, &b);
1742 data.namereg_fail = b;
1744 if (pa_modargs_get_proplist(u->modargs, "source_properties", data.proplist, PA_UPDATE_REPLACE) < 0) {
1745 pa_log("Invalid properties");
1746 pa_source_new_data_done(&data);
1750 connect_ports(u, &data, PA_DIRECTION_INPUT);
1751 u->source = pa_source_new(u->core, &data, PA_SOURCE_HARDWARE|PA_SOURCE_LATENCY);
1752 pa_source_new_data_done(&data);
1755 pa_log_error("Failed to create source");
1759 u->source->userdata = u;
1760 u->source->parent.process_msg = source_process_msg;
1761 u->source->set_port = source_set_port_cb;
1764 if ((u->profile == PROFILE_HSP) || (u->profile == PROFILE_HFGW)) {
1765 pa_bluetooth_transport *t;
1766 t = pa_bluetooth_discovery_get_transport(u->discovery, u->transport);
1768 pa_proplist_sets(u->source->proplist, "bluetooth.nrec", t->nrec ? "1" : "0");
1770 if (!u->hsp.nrec_changed_slot)
1771 u->hsp.nrec_changed_slot = pa_hook_connect(&t->hooks[PA_BLUETOOTH_TRANSPORT_HOOK_NREC_CHANGED], PA_HOOK_NORMAL, (pa_hook_cb_t) nrec_changed_cb, u);
1774 if (u->profile == PROFILE_HSP) {
1775 pa_source_set_set_volume_callback(u->source, source_set_volume_cb);
1776 u->source->n_volume_steps = 16;
1778 k = pa_sprintf_malloc("bluetooth-device@%p", (void*) u->source);
1779 pa_shared_set(u->core, k, u);
1786 static void bt_transport_config_a2dp(struct userdata *u) {
1787 const pa_bluetooth_transport *t;
1788 struct a2dp_info *a2dp = &u->a2dp;
1791 t = pa_bluetooth_discovery_get_transport(u->discovery, u->transport);
1794 config = (a2dp_sbc_t *) t->config;
1796 u->sample_spec.format = PA_SAMPLE_S16LE;
1798 if (a2dp->sbc_initialized)
1799 sbc_reinit(&a2dp->sbc, 0);
1801 sbc_init(&a2dp->sbc, 0);
1802 a2dp->sbc_initialized = TRUE;
1804 switch (config->frequency) {
1805 case BT_SBC_SAMPLING_FREQ_16000:
1806 a2dp->sbc.frequency = SBC_FREQ_16000;
1807 u->sample_spec.rate = 16000U;
1809 case BT_SBC_SAMPLING_FREQ_32000:
1810 a2dp->sbc.frequency = SBC_FREQ_32000;
1811 u->sample_spec.rate = 32000U;
1813 case BT_SBC_SAMPLING_FREQ_44100:
1814 a2dp->sbc.frequency = SBC_FREQ_44100;
1815 u->sample_spec.rate = 44100U;
1817 case BT_SBC_SAMPLING_FREQ_48000:
1818 a2dp->sbc.frequency = SBC_FREQ_48000;
1819 u->sample_spec.rate = 48000U;
1822 pa_assert_not_reached();
1825 switch (config->channel_mode) {
1826 case BT_A2DP_CHANNEL_MODE_MONO:
1827 a2dp->sbc.mode = SBC_MODE_MONO;
1828 u->sample_spec.channels = 1;
1830 case BT_A2DP_CHANNEL_MODE_DUAL_CHANNEL:
1831 a2dp->sbc.mode = SBC_MODE_DUAL_CHANNEL;
1832 u->sample_spec.channels = 2;
1834 case BT_A2DP_CHANNEL_MODE_STEREO:
1835 a2dp->sbc.mode = SBC_MODE_STEREO;
1836 u->sample_spec.channels = 2;
1838 case BT_A2DP_CHANNEL_MODE_JOINT_STEREO:
1839 a2dp->sbc.mode = SBC_MODE_JOINT_STEREO;
1840 u->sample_spec.channels = 2;
1843 pa_assert_not_reached();
1846 switch (config->allocation_method) {
1847 case BT_A2DP_ALLOCATION_SNR:
1848 a2dp->sbc.allocation = SBC_AM_SNR;
1850 case BT_A2DP_ALLOCATION_LOUDNESS:
1851 a2dp->sbc.allocation = SBC_AM_LOUDNESS;
1854 pa_assert_not_reached();
1857 switch (config->subbands) {
1858 case BT_A2DP_SUBBANDS_4:
1859 a2dp->sbc.subbands = SBC_SB_4;
1861 case BT_A2DP_SUBBANDS_8:
1862 a2dp->sbc.subbands = SBC_SB_8;
1865 pa_assert_not_reached();
1868 switch (config->block_length) {
1869 case BT_A2DP_BLOCK_LENGTH_4:
1870 a2dp->sbc.blocks = SBC_BLK_4;
1872 case BT_A2DP_BLOCK_LENGTH_8:
1873 a2dp->sbc.blocks = SBC_BLK_8;
1875 case BT_A2DP_BLOCK_LENGTH_12:
1876 a2dp->sbc.blocks = SBC_BLK_12;
1878 case BT_A2DP_BLOCK_LENGTH_16:
1879 a2dp->sbc.blocks = SBC_BLK_16;
1882 pa_assert_not_reached();
1885 a2dp->min_bitpool = config->min_bitpool;
1886 a2dp->max_bitpool = config->max_bitpool;
1888 /* Set minimum bitpool for source to get the maximum possible block_size */
1889 a2dp->sbc.bitpool = u->profile == PROFILE_A2DP ? a2dp->max_bitpool : a2dp->min_bitpool;
1890 a2dp->codesize = sbc_get_codesize(&a2dp->sbc);
1891 a2dp->frame_length = sbc_get_frame_length(&a2dp->sbc);
1893 pa_log_info("SBC parameters:\n\tallocation=%u\n\tsubbands=%u\n\tblocks=%u\n\tbitpool=%u\n",
1894 a2dp->sbc.allocation, a2dp->sbc.subbands, a2dp->sbc.blocks, a2dp->sbc.bitpool);
1897 static void bt_transport_config(struct userdata *u) {
1898 if (u->profile == PROFILE_HSP || u->profile == PROFILE_HFGW) {
1899 u->sample_spec.format = PA_SAMPLE_S16LE;
1900 u->sample_spec.channels = 1;
1901 u->sample_spec.rate = 8000;
1903 bt_transport_config_a2dp(u);
1906 /* Run from main thread */
1907 static int setup_bt(struct userdata *u) {
1908 const pa_bluetooth_device *d;
1909 const pa_bluetooth_transport *t;
1913 if (!(d = pa_bluetooth_discovery_get_by_path(u->discovery, u->path))) {
1914 pa_log_error("Failed to get device object.");
1918 /* release transport if exist */
1920 bt_transport_release(u);
1921 pa_xfree(u->transport);
1922 u->transport = NULL;
1925 /* check if profile has a transport */
1926 t = pa_bluetooth_device_get_transport(d, u->profile);
1928 pa_log_warn("Profile has no transport");
1932 u->transport = pa_xstrdup(t->path);
1934 if (bt_transport_acquire(u, FALSE) < 0)
1937 bt_transport_config(u);
1942 /* Run from main thread */
1943 static int init_profile(struct userdata *u) {
1946 pa_assert(u->profile != PROFILE_OFF);
1948 if (setup_bt(u) < 0)
1951 if (u->profile == PROFILE_A2DP ||
1952 u->profile == PROFILE_HSP ||
1953 u->profile == PROFILE_HFGW)
1954 if (add_sink(u) < 0)
1957 if (u->profile == PROFILE_HSP ||
1958 u->profile == PROFILE_A2DP_SOURCE ||
1959 u->profile == PROFILE_HFGW)
1960 if (add_source(u) < 0)
1966 /* Run from main thread */
1967 static void stop_thread(struct userdata *u) {
1973 pa_asyncmsgq_send(u->thread_mq.inq, NULL, PA_MESSAGE_SHUTDOWN, NULL, 0, NULL);
1974 pa_thread_free(u->thread);
1978 if (u->rtpoll_item) {
1979 pa_rtpoll_item_free(u->rtpoll_item);
1980 u->rtpoll_item = NULL;
1983 if (u->hsp.sink_state_changed_slot) {
1984 pa_hook_slot_free(u->hsp.sink_state_changed_slot);
1985 u->hsp.sink_state_changed_slot = NULL;
1988 if (u->hsp.source_state_changed_slot) {
1989 pa_hook_slot_free(u->hsp.source_state_changed_slot);
1990 u->hsp.source_state_changed_slot = NULL;
1993 if (u->hsp.nrec_changed_slot) {
1994 pa_hook_slot_free(u->hsp.nrec_changed_slot);
1995 u->hsp.nrec_changed_slot = NULL;
1999 if (u->profile == PROFILE_HSP) {
2000 k = pa_sprintf_malloc("bluetooth-device@%p", (void*) u->sink);
2001 pa_shared_remove(u->core, k);
2005 pa_sink_unref(u->sink);
2010 if (u->profile == PROFILE_HSP) {
2011 k = pa_sprintf_malloc("bluetooth-device@%p", (void*) u->source);
2012 pa_shared_remove(u->core, k);
2016 pa_source_unref(u->source);
2021 pa_thread_mq_done(&u->thread_mq);
2023 pa_rtpoll_free(u->rtpoll);
2027 if (u->read_smoother) {
2028 pa_smoother_free(u->read_smoother);
2029 u->read_smoother = NULL;
2033 /* Run from main thread */
2034 static int start_thread(struct userdata *u) {
2036 pa_assert(!u->thread);
2037 pa_assert(!u->rtpoll);
2038 pa_assert(!u->rtpoll_item);
2040 u->rtpoll = pa_rtpoll_new();
2041 pa_thread_mq_init(&u->thread_mq, u->core->mainloop, u->rtpoll);
2043 if (USE_SCO_OVER_PCM(u)) {
2044 if (sco_over_pcm_state_update(u, FALSE) < 0) {
2048 k = pa_sprintf_malloc("bluetooth-device@%p", (void*) u->sink);
2049 pa_shared_remove(u->core, k);
2054 k = pa_sprintf_malloc("bluetooth-device@%p", (void*) u->source);
2055 pa_shared_remove(u->core, k);
2062 pa_sink_ref(u->sink);
2063 pa_source_ref(u->source);
2064 /* FIXME: monitor stream_fd error */
2068 if (!(u->thread = pa_thread_new("bluetooth", thread_func, u))) {
2069 pa_log_error("Failed to create IO thread");
2075 pa_sink_set_asyncmsgq(u->sink, u->thread_mq.inq);
2076 pa_sink_set_rtpoll(u->sink, u->rtpoll);
2077 pa_sink_put(u->sink);
2079 if (u->sink->set_volume)
2080 u->sink->set_volume(u->sink);
2084 pa_source_set_asyncmsgq(u->source, u->thread_mq.inq);
2085 pa_source_set_rtpoll(u->source, u->rtpoll);
2086 pa_source_put(u->source);
2088 if (u->source->set_volume)
2089 u->source->set_volume(u->source);
2095 static void save_sco_volume_callbacks(struct userdata *u) {
2097 pa_assert(USE_SCO_OVER_PCM(u));
2099 u->hsp.sco_sink_set_volume = u->hsp.sco_sink->set_volume;
2100 u->hsp.sco_source_set_volume = u->hsp.sco_source->set_volume;
2103 static void restore_sco_volume_callbacks(struct userdata *u) {
2105 pa_assert(USE_SCO_OVER_PCM(u));
2107 pa_sink_set_set_volume_callback(u->hsp.sco_sink, u->hsp.sco_sink_set_volume);
2108 pa_source_set_set_volume_callback(u->hsp.sco_source, u->hsp.sco_source_set_volume);
2111 /* Run from main thread */
2112 static int card_set_profile(pa_card *c, pa_card_profile *new_profile) {
2115 pa_queue *inputs = NULL, *outputs = NULL;
2116 const pa_bluetooth_device *device;
2119 pa_assert(new_profile);
2120 pa_assert_se(u = c->userdata);
2122 d = PA_CARD_PROFILE_DATA(new_profile);
2124 if (!(device = pa_bluetooth_discovery_get_by_path(u->discovery, u->path))) {
2125 pa_log_error("Failed to get device object.");
2129 /* The state signal is sent by bluez, so it is racy to check
2130 strictly for CONNECTED, we should also accept STREAMING state
2131 as being good enough. However, if the profile is used
2132 concurrently (which is unlikely), ipc will fail later on, and
2133 module will be unloaded. */
2134 if (device->headset_state < PA_BT_AUDIO_STATE_CONNECTED && *d == PROFILE_HSP) {
2135 pa_log_warn("HSP is not connected, refused to switch profile");
2137 } else if (device->audio_sink_state < PA_BT_AUDIO_STATE_CONNECTED && *d == PROFILE_A2DP) {
2138 pa_log_warn("A2DP Sink is not connected, refused to switch profile");
2140 } else if (device->audio_source_state < PA_BT_AUDIO_STATE_CONNECTED && *d == PROFILE_A2DP_SOURCE) {
2141 pa_log_warn("A2DP Source is not connected, refused to switch profile");
2143 } else if (device->hfgw_state < PA_BT_AUDIO_STATE_CONNECTED && *d == PROFILE_HFGW) {
2144 pa_log_warn("HandsfreeGateway is not connected, refused to switch profile");
2149 inputs = pa_sink_move_all_start(u->sink, NULL);
2151 if (!USE_SCO_OVER_PCM(u))
2152 pa_sink_unlink(u->sink);
2156 outputs = pa_source_move_all_start(u->source, NULL);
2158 if (!USE_SCO_OVER_PCM(u))
2159 pa_source_unlink(u->source);
2164 if (u->profile != PROFILE_OFF && u->transport) {
2165 bt_transport_release(u);
2166 pa_xfree(u->transport);
2167 u->transport = NULL;
2170 if (USE_SCO_OVER_PCM(u))
2171 restore_sco_volume_callbacks(u);
2174 u->sample_spec = u->requested_sample_spec;
2176 if (USE_SCO_OVER_PCM(u))
2177 save_sco_volume_callbacks(u);
2179 if (u->profile != PROFILE_OFF)
2182 if (u->sink || u->source)
2187 pa_sink_move_all_finish(u->sink, inputs, FALSE);
2189 pa_sink_move_all_fail(inputs);
2194 pa_source_move_all_finish(u->source, outputs, FALSE);
2196 pa_source_move_all_fail(outputs);
2202 static void create_ports_for_profile(struct userdata *u, const pa_bluetooth_device *device, pa_card_new_data *card_new_data, pa_card_profile *profile) {
2203 pa_device_port *port;
2206 d = PA_CARD_PROFILE_DATA(profile);
2210 pa_assert_se(port = pa_device_port_new(u->core, "a2dp-output", _("Bluetooth High Quality (A2DP)"), 0));
2211 pa_assert_se(pa_hashmap_put(card_new_data->ports, port->name, port) >= 0);
2212 port->is_output = 1;
2214 port->priority = profile->priority * 100;
2215 port->available = audio_state_to_availability(device->audio_sink_state);
2216 pa_hashmap_put(port->profiles, profile->name, profile);
2219 case PROFILE_A2DP_SOURCE:
2220 pa_assert_se(port = pa_device_port_new(u->core, "a2dp-input", _("Bluetooth High Quality (A2DP)"), 0));
2221 pa_assert_se(pa_hashmap_put(card_new_data->ports, port->name, port) >= 0);
2222 port->is_output = 0;
2224 port->priority = profile->priority * 100;
2225 port->available = audio_state_to_availability(device->audio_source_state);
2226 pa_hashmap_put(port->profiles, profile->name, profile);
2230 pa_assert_se(port = pa_device_port_new(u->core, "hsp-output", _("Bluetooth Telephony (HSP/HFP)"), 0));
2231 pa_assert_se(pa_hashmap_put(card_new_data->ports, port->name, port) >= 0);
2232 port->is_output = 1;
2234 port->priority = profile->priority * 100;
2235 port->available = audio_state_to_availability(device->headset_state);
2236 pa_hashmap_put(port->profiles, profile->name, profile);
2238 pa_assert_se(port = pa_device_port_new(u->core, "hsp-input", _("Bluetooth Telephony (HSP/HFP)"), 0));
2239 pa_assert_se(pa_hashmap_put(card_new_data->ports, port->name, port) >= 0);
2240 port->is_output = 0;
2242 port->priority = profile->priority * 100;
2243 port->available = audio_state_to_availability(device->headset_state);
2244 pa_hashmap_put(port->profiles, profile->name, profile);
2248 pa_assert_se(port = pa_device_port_new(u->core, "hfgw-output", _("Bluetooth Handsfree Gateway"), 0));
2249 pa_assert_se(pa_hashmap_put(card_new_data->ports, port->name, port) >= 0);
2250 port->is_output = 1;
2252 port->priority = profile->priority * 100;
2253 port->available = audio_state_to_availability(device->hfgw_state);
2254 pa_hashmap_put(port->profiles, profile->name, profile);
2256 pa_assert_se(port = pa_device_port_new(u->core, "hfgw-input", _("Bluetooth Handsfree Gateway"), 0));
2257 pa_assert_se(pa_hashmap_put(card_new_data->ports, port->name, port) >= 0);
2258 port->is_output = 0;
2260 port->priority = profile->priority * 100;
2261 port->available = audio_state_to_availability(device->hfgw_state);
2262 pa_hashmap_put(port->profiles, profile->name, profile);
2266 pa_assert_not_reached();
2271 /* Run from main thread */
2272 static int add_card(struct userdata *u, const pa_bluetooth_device *device) {
2273 pa_card_new_data data;
2279 const char *default_profile;
2284 pa_card_new_data_init(&data);
2285 data.driver = __FILE__;
2286 data.module = u->module;
2288 n = pa_bluetooth_cleanup_name(device->name);
2289 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_DESCRIPTION, n);
2291 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_STRING, device->address);
2292 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_API, "bluez");
2293 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_CLASS, "sound");
2294 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_BUS, "bluetooth");
2295 if ((ff = pa_bluetooth_get_form_factor(device->class)))
2296 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_FORM_FACTOR, ff);
2297 pa_proplist_sets(data.proplist, "bluez.path", device->path);
2298 pa_proplist_setf(data.proplist, "bluez.class", "0x%06x", (unsigned) device->class);
2299 pa_proplist_sets(data.proplist, "bluez.name", device->name);
2300 data.name = get_name("card", u->modargs, device->address, &b);
2301 data.namereg_fail = b;
2303 if (pa_modargs_get_proplist(u->modargs, "card_properties", data.proplist, PA_UPDATE_REPLACE) < 0) {
2304 pa_log("Invalid properties");
2305 pa_card_new_data_done(&data);
2309 data.profiles = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
2311 /* we base hsp/a2dp availability on UUIDs.
2312 Ideally, it would be based on "Connected" state, but
2313 we can't afford to wait for this information when
2314 we are loaded with profile="hsp", for instance */
2315 if (pa_bluetooth_uuid_has(device->uuids, A2DP_SINK_UUID)) {
2316 p = pa_card_profile_new("a2dp", _("High Fidelity Playback (A2DP)"), sizeof(enum profile));
2320 p->max_sink_channels = 2;
2321 p->max_source_channels = 0;
2323 d = PA_CARD_PROFILE_DATA(p);
2325 create_ports_for_profile(u, device, &data, p);
2327 pa_hashmap_put(data.profiles, p->name, p);
2330 if (pa_bluetooth_uuid_has(device->uuids, A2DP_SOURCE_UUID)) {
2331 p = pa_card_profile_new("a2dp_source", _("High Fidelity Capture (A2DP)"), sizeof(enum profile));
2335 p->max_sink_channels = 0;
2336 p->max_source_channels = 2;
2338 d = PA_CARD_PROFILE_DATA(p);
2339 *d = PROFILE_A2DP_SOURCE;
2340 create_ports_for_profile(u, device, &data, p);
2342 pa_hashmap_put(data.profiles, p->name, p);
2345 if (pa_bluetooth_uuid_has(device->uuids, HSP_HS_UUID) ||
2346 pa_bluetooth_uuid_has(device->uuids, HFP_HS_UUID)) {
2347 p = pa_card_profile_new("hsp", _("Telephony Duplex (HSP/HFP)"), sizeof(enum profile));
2351 p->max_sink_channels = 1;
2352 p->max_source_channels = 1;
2354 d = PA_CARD_PROFILE_DATA(p);
2356 create_ports_for_profile(u, device, &data, p);
2358 pa_hashmap_put(data.profiles, p->name, p);
2361 if (pa_bluetooth_uuid_has(device->uuids, HFP_AG_UUID)) {
2362 p = pa_card_profile_new("hfgw", _("Handsfree Gateway"), sizeof(enum profile));
2366 p->max_sink_channels = 1;
2367 p->max_source_channels = 1;
2369 d = PA_CARD_PROFILE_DATA(p);
2371 create_ports_for_profile(u, device, &data, p);
2373 pa_hashmap_put(data.profiles, p->name, p);
2376 pa_assert(!pa_hashmap_isempty(data.profiles));
2378 p = pa_card_profile_new("off", _("Off"), sizeof(enum profile));
2379 d = PA_CARD_PROFILE_DATA(p);
2381 pa_hashmap_put(data.profiles, p->name, p);
2383 if ((default_profile = pa_modargs_get_value(u->modargs, "profile", NULL))) {
2384 if (pa_hashmap_get(data.profiles, default_profile))
2385 pa_card_new_data_set_profile(&data, default_profile);
2387 pa_log_warn("Profile '%s' not valid or not supported by device.", default_profile);
2390 u->card = pa_card_new(u->core, &data);
2391 pa_card_new_data_done(&data);
2394 pa_log("Failed to allocate card.");
2398 u->card->userdata = u;
2399 u->card->set_profile = card_set_profile;
2401 d = PA_CARD_PROFILE_DATA(u->card->active_profile);
2403 if ((device->headset_state < PA_BT_AUDIO_STATE_CONNECTED && *d == PROFILE_HSP) ||
2404 (device->audio_sink_state < PA_BT_AUDIO_STATE_CONNECTED && *d == PROFILE_A2DP) ||
2405 (device->audio_source_state < PA_BT_AUDIO_STATE_CONNECTED && *d == PROFILE_A2DP_SOURCE) ||
2406 (device->hfgw_state < PA_BT_AUDIO_STATE_CONNECTED && *d == PROFILE_HFGW)) {
2407 pa_log_warn("Default profile not connected, selecting off profile");
2408 u->card->active_profile = pa_hashmap_get(u->card->profiles, "off");
2409 u->card->save_profile = FALSE;
2412 d = PA_CARD_PROFILE_DATA(u->card->active_profile);
2415 if (USE_SCO_OVER_PCM(u))
2416 save_sco_volume_callbacks(u);
2421 /* Run from main thread */
2422 static const pa_bluetooth_device* find_device(struct userdata *u, const char *address, const char *path) {
2423 const pa_bluetooth_device *d = NULL;
2427 if (!address && !path) {
2428 pa_log_error("Failed to get device address/path from module arguments.");
2433 if (!(d = pa_bluetooth_discovery_get_by_path(u->discovery, path))) {
2434 pa_log_error("%s is not a valid BlueZ audio device.", path);
2438 if (address && !(pa_streq(d->address, address))) {
2439 pa_log_error("Passed path %s address %s != %s don't match.", path, d->address, address);
2444 if (!(d = pa_bluetooth_discovery_get_by_address(u->discovery, address))) {
2445 pa_log_error("%s is not known.", address);
2451 u->address = pa_xstrdup(d->address);
2452 u->path = pa_xstrdup(d->path);
2458 /* Run from main thread */
2459 static int setup_dbus(struct userdata *u) {
2462 dbus_error_init(&err);
2464 u->connection = pa_dbus_bus_get(u->core, DBUS_BUS_SYSTEM, &err);
2466 if (dbus_error_is_set(&err) || !u->connection) {
2467 pa_log("Failed to get D-Bus connection: %s", err.message);
2468 dbus_error_free(&err);
2475 int pa__init(pa_module* m) {
2479 const char *address, *path;
2481 char *mike, *speaker;
2482 const pa_bluetooth_device *device;
2486 dbus_error_init(&err);
2488 if (!(ma = pa_modargs_new(m->argument, valid_modargs))) {
2489 pa_log_error("Failed to parse module arguments");
2493 m->userdata = u = pa_xnew0(struct userdata, 1);
2497 u->sample_spec = m->core->default_sample_spec;
2500 if (pa_modargs_get_value(ma, "sco_sink", NULL) &&
2501 !(u->hsp.sco_sink = pa_namereg_get(m->core, pa_modargs_get_value(ma, "sco_sink", NULL), PA_NAMEREG_SINK))) {
2502 pa_log("SCO sink not found");
2506 if (pa_modargs_get_value(ma, "sco_source", NULL) &&
2507 !(u->hsp.sco_source = pa_namereg_get(m->core, pa_modargs_get_value(ma, "sco_source", NULL), PA_NAMEREG_SOURCE))) {
2508 pa_log("SCO source not found");
2512 if (pa_modargs_get_value_u32(ma, "rate", &u->sample_spec.rate) < 0 ||
2513 u->sample_spec.rate <= 0 || u->sample_spec.rate > PA_RATE_MAX) {
2514 pa_log_error("Failed to get rate from module arguments");
2518 u->auto_connect = TRUE;
2519 if (pa_modargs_get_value_boolean(ma, "auto_connect", &u->auto_connect)) {
2520 pa_log("Failed to parse auto_connect= argument");
2524 channels = u->sample_spec.channels;
2525 if (pa_modargs_get_value_u32(ma, "channels", &channels) < 0 ||
2526 channels <= 0 || channels > PA_CHANNELS_MAX) {
2527 pa_log_error("Failed to get channels from module arguments");
2530 u->sample_spec.channels = (uint8_t) channels;
2531 u->requested_sample_spec = u->sample_spec;
2533 address = pa_modargs_get_value(ma, "address", NULL);
2534 path = pa_modargs_get_value(ma, "path", NULL);
2536 if (setup_dbus(u) < 0)
2539 if (!(u->discovery = pa_bluetooth_discovery_get(m->core)))
2542 if (!(device = find_device(u, address, path)))
2545 /* Add the card structure. This will also initialize the default profile */
2546 if (add_card(u, device) < 0)
2549 if (!(u->msg = pa_msgobject_new(bluetooth_msg)))
2552 u->msg->parent.process_msg = device_process_msg;
2553 u->msg->card = u->card;
2555 if (!dbus_connection_add_filter(pa_dbus_connection_get(u->connection), filter_cb, u, NULL)) {
2556 pa_log_error("Failed to add filter function");
2559 u->filter_added = TRUE;
2561 speaker = pa_sprintf_malloc("type='signal',sender='org.bluez',interface='org.bluez.Headset',member='SpeakerGainChanged',path='%s'", u->path);
2562 mike = pa_sprintf_malloc("type='signal',sender='org.bluez',interface='org.bluez.Headset',member='MicrophoneGainChanged',path='%s'", u->path);
2564 if (pa_dbus_add_matches(
2565 pa_dbus_connection_get(u->connection), &err,
2568 "type='signal',sender='org.bluez',interface='org.bluez.MediaTransport',member='PropertyChanged'",
2569 "type='signal',sender='org.bluez',interface='org.bluez.HandsfreeGateway',member='PropertyChanged'",
2570 "type='signal',sender='org.bluez',interface='org.bluez.Headset',member='PropertyChanged'",
2571 "type='signal',sender='org.bluez',interface='org.bluez.AudioSource',member='PropertyChanged'",
2572 "type='signal',sender='org.bluez',interface='org.bluez.AudioSink',member='PropertyChanged'",
2578 pa_log("Failed to add D-Bus matches: %s", err.message);
2585 if (u->profile != PROFILE_OFF)
2586 if (init_profile(u) < 0)
2589 if (u->sink || u->source)
2590 if (start_thread(u) < 0)
2599 dbus_error_free(&err);
2604 int pa__get_n_used(pa_module *m) {
2608 pa_assert_se(u = m->userdata);
2611 (u->sink ? pa_sink_linked_by(u->sink) : 0) +
2612 (u->source ? pa_source_linked_by(u->source) : 0);
2615 void pa__done(pa_module *m) {
2620 if (!(u = m->userdata))
2623 if (u->sink && !USE_SCO_OVER_PCM(u))
2624 pa_sink_unlink(u->sink);
2626 if (u->source && !USE_SCO_OVER_PCM(u))
2627 pa_source_unlink(u->source);
2631 if (USE_SCO_OVER_PCM(u))
2632 restore_sco_volume_callbacks(u);
2634 if (u->connection) {
2637 char *speaker, *mike;
2638 speaker = pa_sprintf_malloc("type='signal',sender='org.bluez',interface='org.bluez.Headset',member='SpeakerGainChanged',path='%s'", u->path);
2639 mike = pa_sprintf_malloc("type='signal',sender='org.bluez',interface='org.bluez.Headset',member='MicrophoneGainChanged',path='%s'", u->path);
2641 pa_dbus_remove_matches(pa_dbus_connection_get(u->connection), speaker, mike,
2642 "type='signal',sender='org.bluez',interface='org.bluez.MediaTransport',member='PropertyChanged'",
2643 "type='signal',sender='org.bluez',interface='org.bluez.HandsfreeGateway',member='PropertyChanged'",
2650 if (u->filter_added)
2651 dbus_connection_remove_filter(pa_dbus_connection_get(u->connection), filter_cb, u);
2653 pa_dbus_connection_unref(u->connection);
2660 pa_card_free(u->card);
2662 if (u->read_smoother)
2663 pa_smoother_free(u->read_smoother);
2666 pa_xfree(u->a2dp.buffer);
2668 sbc_finish(&u->a2dp.sbc);
2671 pa_modargs_free(u->modargs);
2673 pa_xfree(u->address);
2677 bt_transport_release(u);
2678 pa_xfree(u->transport);
2682 pa_bluetooth_discovery_unref(u->discovery);