2 This file is part of PulseAudio.
4 Copyright 2008-2013 João Paulo Rechi Vita
5 Copyright 2011-2013 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 <arpa/inet.h>
32 #include <pulse/rtclock.h>
33 #include <pulse/timeval.h>
35 #include <pulsecore/core-error.h>
36 #include <pulsecore/core-util.h>
37 #include <pulsecore/i18n.h>
38 #include <pulsecore/module.h>
39 #include <pulsecore/modargs.h>
40 #include <pulsecore/poll.h>
41 #include <pulsecore/rtpoll.h>
42 #include <pulsecore/shared.h>
43 #include <pulsecore/socket-util.h>
44 #include <pulsecore/thread.h>
45 #include <pulsecore/thread-mq.h>
46 #include <pulsecore/time-smoother.h>
48 #include "a2dp-codecs.h"
49 #include "bluez5-util.h"
52 #include "module-bluez5-device-symdef.h"
54 PA_MODULE_AUTHOR("João Paulo Rechi Vita");
55 PA_MODULE_DESCRIPTION("BlueZ 5 Bluetooth audio sink and source");
56 PA_MODULE_VERSION(PACKAGE_VERSION
);
57 PA_MODULE_LOAD_ONCE(false);
58 PA_MODULE_USAGE("path=<device object path>");
60 #define MAX_PLAYBACK_CATCH_UP_USEC (100 * PA_USEC_PER_MSEC)
61 #define FIXED_LATENCY_PLAYBACK_A2DP (25 * PA_USEC_PER_MSEC)
62 #define FIXED_LATENCY_RECORD_A2DP (25 * PA_USEC_PER_MSEC)
64 #define BITPOOL_DEC_LIMIT 32
65 #define BITPOOL_DEC_STEP 5
67 static const char* const valid_modargs
[] = {
73 BLUETOOTH_MESSAGE_IO_THREAD_FAILED
,
77 typedef struct bluetooth_msg
{
81 PA_DEFINE_PRIVATE_CLASS(bluetooth_msg
, pa_msgobject
);
82 #define BLUETOOTH_MSG(o) (bluetooth_msg_cast(o))
84 typedef struct sbc_info
{
85 sbc_t sbc
; /* Codec data */
86 bool sbc_initialized
; /* Keep track if the encoder is initialized */
87 size_t codesize
, frame_length
; /* SBC Codesize, frame_length. We simply cache those values here */
88 uint16_t seq_num
; /* Cumulative packet sequence */
92 void* buffer
; /* Codec transfer buffer */
93 size_t buffer_size
; /* Size of the buffer */
100 pa_hook_slot
*device_connection_changed_slot
;
101 pa_hook_slot
*transport_state_changed_slot
;
103 pa_bluetooth_discovery
*discovery
;
104 pa_bluetooth_device
*device
;
105 pa_bluetooth_transport
*transport
;
106 bool transport_acquired
;
111 pa_bluetooth_profile_t profile
;
112 char *output_port_name
;
113 char *input_port_name
;
116 pa_thread_mq thread_mq
;
118 pa_rtpoll_item
*rtpoll_item
;
122 int stream_write_type
;
123 size_t read_link_mtu
;
124 size_t write_link_mtu
;
125 size_t read_block_size
;
126 size_t write_block_size
;
128 uint64_t write_index
;
129 pa_usec_t started_at
;
130 pa_smoother
*read_smoother
;
131 pa_memchunk write_memchunk
;
132 pa_sample_spec sample_spec
;
133 struct sbc_info sbc_info
;
136 typedef enum pa_bluetooth_form_factor
{
137 PA_BLUETOOTH_FORM_FACTOR_UNKNOWN
,
138 PA_BLUETOOTH_FORM_FACTOR_HEADSET
,
139 PA_BLUETOOTH_FORM_FACTOR_HANDSFREE
,
140 PA_BLUETOOTH_FORM_FACTOR_MICROPHONE
,
141 PA_BLUETOOTH_FORM_FACTOR_SPEAKER
,
142 PA_BLUETOOTH_FORM_FACTOR_HEADPHONE
,
143 PA_BLUETOOTH_FORM_FACTOR_PORTABLE
,
144 PA_BLUETOOTH_FORM_FACTOR_CAR
,
145 PA_BLUETOOTH_FORM_FACTOR_HIFI
,
146 PA_BLUETOOTH_FORM_FACTOR_PHONE
,
147 } pa_bluetooth_form_factor_t
;
149 /* Run from main thread */
150 static pa_bluetooth_form_factor_t
form_factor_from_class(uint32_t class_of_device
) {
151 unsigned major
, minor
;
152 pa_bluetooth_form_factor_t r
;
154 static const pa_bluetooth_form_factor_t table
[] = {
155 [1] = PA_BLUETOOTH_FORM_FACTOR_HEADSET
,
156 [2] = PA_BLUETOOTH_FORM_FACTOR_HANDSFREE
,
157 [4] = PA_BLUETOOTH_FORM_FACTOR_MICROPHONE
,
158 [5] = PA_BLUETOOTH_FORM_FACTOR_SPEAKER
,
159 [6] = PA_BLUETOOTH_FORM_FACTOR_HEADPHONE
,
160 [7] = PA_BLUETOOTH_FORM_FACTOR_PORTABLE
,
161 [8] = PA_BLUETOOTH_FORM_FACTOR_CAR
,
162 [10] = PA_BLUETOOTH_FORM_FACTOR_HIFI
166 * See Bluetooth Assigned Numbers:
167 * https://www.bluetooth.org/Technical/AssignedNumbers/baseband.htm
169 major
= (class_of_device
>> 8) & 0x1F;
170 minor
= (class_of_device
>> 2) & 0x3F;
174 return PA_BLUETOOTH_FORM_FACTOR_PHONE
;
178 pa_log_debug("Unknown Bluetooth major device class %u", major
);
179 return PA_BLUETOOTH_FORM_FACTOR_UNKNOWN
;
182 r
= minor
< PA_ELEMENTSOF(table
) ? table
[minor
] : PA_BLUETOOTH_FORM_FACTOR_UNKNOWN
;
185 pa_log_debug("Unknown Bluetooth minor device class %u", minor
);
190 /* Run from main thread */
191 static const char *form_factor_to_string(pa_bluetooth_form_factor_t ff
) {
193 case PA_BLUETOOTH_FORM_FACTOR_UNKNOWN
:
195 case PA_BLUETOOTH_FORM_FACTOR_HEADSET
:
197 case PA_BLUETOOTH_FORM_FACTOR_HANDSFREE
:
199 case PA_BLUETOOTH_FORM_FACTOR_MICROPHONE
:
201 case PA_BLUETOOTH_FORM_FACTOR_SPEAKER
:
203 case PA_BLUETOOTH_FORM_FACTOR_HEADPHONE
:
205 case PA_BLUETOOTH_FORM_FACTOR_PORTABLE
:
207 case PA_BLUETOOTH_FORM_FACTOR_CAR
:
209 case PA_BLUETOOTH_FORM_FACTOR_HIFI
:
211 case PA_BLUETOOTH_FORM_FACTOR_PHONE
:
215 pa_assert_not_reached();
218 /* Run from main thread */
219 static void connect_ports(struct userdata
*u
, void *new_data
, pa_direction_t direction
) {
220 pa_device_port
*port
;
222 if (direction
== PA_DIRECTION_OUTPUT
) {
223 pa_sink_new_data
*sink_new_data
= new_data
;
225 pa_assert_se(port
= pa_hashmap_get(u
->card
->ports
, u
->output_port_name
));
226 pa_assert_se(pa_hashmap_put(sink_new_data
->ports
, port
->name
, port
) >= 0);
227 pa_device_port_ref(port
);
229 pa_source_new_data
*source_new_data
= new_data
;
231 pa_assert_se(port
= pa_hashmap_get(u
->card
->ports
, u
->input_port_name
));
232 pa_assert_se(pa_hashmap_put(source_new_data
->ports
, port
->name
, port
) >= 0);
233 pa_device_port_ref(port
);
237 /* Run from IO thread */
238 static void a2dp_prepare_buffer(struct userdata
*u
) {
239 size_t min_buffer_size
= PA_MAX(u
->read_link_mtu
, u
->write_link_mtu
);
243 if (u
->sbc_info
.buffer_size
>= min_buffer_size
)
246 u
->sbc_info
.buffer_size
= 2 * min_buffer_size
;
247 pa_xfree(u
->sbc_info
.buffer
);
248 u
->sbc_info
.buffer
= pa_xmalloc(u
->sbc_info
.buffer_size
);
251 /* Run from IO thread */
252 static int a2dp_process_render(struct userdata
*u
) {
253 struct sbc_info
*sbc_info
;
254 struct rtp_header
*header
;
255 struct rtp_payload
*payload
;
259 size_t to_write
, to_encode
;
260 unsigned frame_count
;
264 pa_assert(u
->profile
== PA_BLUETOOTH_PROFILE_A2DP_SINK
);
267 /* First, render some data */
268 if (!u
->write_memchunk
.memblock
)
269 pa_sink_render_full(u
->sink
, u
->write_block_size
, &u
->write_memchunk
);
271 pa_assert(u
->write_memchunk
.length
== u
->write_block_size
);
273 a2dp_prepare_buffer(u
);
275 sbc_info
= &u
->sbc_info
;
276 header
= sbc_info
->buffer
;
277 payload
= (struct rtp_payload
*) ((uint8_t*) sbc_info
->buffer
+ sizeof(*header
));
281 /* Try to create a packet of the full MTU */
283 p
= (const uint8_t *) pa_memblock_acquire_chunk(&u
->write_memchunk
);
284 to_encode
= u
->write_memchunk
.length
;
286 d
= (uint8_t*) sbc_info
->buffer
+ sizeof(*header
) + sizeof(*payload
);
287 to_write
= sbc_info
->buffer_size
- sizeof(*header
) - sizeof(*payload
);
289 while (PA_LIKELY(to_encode
> 0 && to_write
> 0)) {
293 encoded
= sbc_encode(&sbc_info
->sbc
,
298 if (PA_UNLIKELY(encoded
<= 0)) {
299 pa_log_error("SBC encoding error (%li)", (long) encoded
);
300 pa_memblock_release(u
->write_memchunk
.memblock
);
304 pa_assert_fp((size_t) encoded
<= to_encode
);
305 pa_assert_fp((size_t) encoded
== sbc_info
->codesize
);
307 pa_assert_fp((size_t) written
<= to_write
);
308 pa_assert_fp((size_t) written
== sbc_info
->frame_length
);
310 p
= (const uint8_t*) p
+ encoded
;
311 to_encode
-= encoded
;
313 d
= (uint8_t*) d
+ written
;
319 pa_memblock_release(u
->write_memchunk
.memblock
);
321 pa_assert(to_encode
== 0);
324 pa_log_debug("Using SBC encoder implementation: %s", pa_strnull(sbc_get_implementation_info(&sbc_info
->sbc
)));
327 /* write it to the fifo */
328 memset(sbc_info
->buffer
, 0, sizeof(*header
) + sizeof(*payload
));
331 header
->sequence_number
= htons(sbc_info
->seq_num
++);
332 header
->timestamp
= htonl(u
->write_index
/ pa_frame_size(&u
->sample_spec
));
333 header
->ssrc
= htonl(1);
334 payload
->frame_count
= frame_count
;
336 nbytes
= (uint8_t*) d
- (uint8_t*) sbc_info
->buffer
;
341 l
= pa_write(u
->stream_fd
, sbc_info
->buffer
, nbytes
, &u
->stream_write_type
);
348 /* Retry right away if we got interrupted */
351 else if (errno
== EAGAIN
)
352 /* Hmm, apparently the socket was not writable, give up for now */
355 pa_log_error("Failed to write data to socket: %s", pa_cstrerror(errno
));
360 pa_assert((size_t) l
<= nbytes
);
362 if ((size_t) l
!= nbytes
) {
363 pa_log_warn("Wrote memory block to socket only partially! %llu written, wanted to write %llu.",
364 (unsigned long long) l
,
365 (unsigned long long) nbytes
);
370 u
->write_index
+= (uint64_t) u
->write_memchunk
.length
;
371 pa_memblock_unref(u
->write_memchunk
.memblock
);
372 pa_memchunk_reset(&u
->write_memchunk
);
382 /* Run from IO thread */
383 static int a2dp_process_push(struct userdata
*u
) {
385 pa_memchunk memchunk
;
388 pa_assert(u
->profile
== PA_BLUETOOTH_PROFILE_A2DP_SOURCE
);
389 pa_assert(u
->source
);
390 pa_assert(u
->read_smoother
);
392 memchunk
.memblock
= pa_memblock_new(u
->core
->mempool
, u
->read_block_size
);
393 memchunk
.index
= memchunk
.length
= 0;
396 bool found_tstamp
= false;
398 struct sbc_info
*sbc_info
;
399 struct rtp_header
*header
;
400 struct rtp_payload
*payload
;
404 size_t to_write
, to_decode
;
406 a2dp_prepare_buffer(u
);
408 sbc_info
= &u
->sbc_info
;
409 header
= sbc_info
->buffer
;
410 payload
= (struct rtp_payload
*) ((uint8_t*) sbc_info
->buffer
+ sizeof(*header
));
412 l
= pa_read(u
->stream_fd
, sbc_info
->buffer
, sbc_info
->buffer_size
, &u
->stream_write_type
);
416 if (l
< 0 && errno
== EINTR
)
417 /* Retry right away if we got interrupted */
420 else if (l
< 0 && errno
== EAGAIN
)
421 /* Hmm, apparently the socket was not readable, give up for now. */
424 pa_log_error("Failed to read data from socket: %s", l
< 0 ? pa_cstrerror(errno
) : "EOF");
429 pa_assert((size_t) l
<= sbc_info
->buffer_size
);
431 u
->read_index
+= (uint64_t) l
;
433 /* TODO: get timestamp from rtp */
435 /* pa_log_warn("Couldn't find SO_TIMESTAMP data in auxiliary recvmsg() data!"); */
436 tstamp
= pa_rtclock_now();
439 pa_smoother_put(u
->read_smoother
, tstamp
, pa_bytes_to_usec(u
->read_index
, &u
->sample_spec
));
440 pa_smoother_resume(u
->read_smoother
, tstamp
, true);
442 p
= (uint8_t*) sbc_info
->buffer
+ sizeof(*header
) + sizeof(*payload
);
443 to_decode
= l
- sizeof(*header
) - sizeof(*payload
);
445 d
= pa_memblock_acquire(memchunk
.memblock
);
446 to_write
= memchunk
.length
= pa_memblock_get_length(memchunk
.memblock
);
448 while (PA_LIKELY(to_decode
> 0)) {
452 decoded
= sbc_decode(&sbc_info
->sbc
,
457 if (PA_UNLIKELY(decoded
<= 0)) {
458 pa_log_error("SBC decoding error (%li)", (long) decoded
);
459 pa_memblock_release(memchunk
.memblock
);
460 pa_memblock_unref(memchunk
.memblock
);
464 /* Reset frame length, it can be changed due to bitpool change */
465 sbc_info
->frame_length
= sbc_get_frame_length(&sbc_info
->sbc
);
467 pa_assert_fp((size_t) decoded
<= to_decode
);
468 pa_assert_fp((size_t) decoded
== sbc_info
->frame_length
);
470 pa_assert_fp((size_t) written
== sbc_info
->codesize
);
472 p
= (const uint8_t*) p
+ decoded
;
473 to_decode
-= decoded
;
475 d
= (uint8_t*) d
+ written
;
479 memchunk
.length
-= to_write
;
481 pa_memblock_release(memchunk
.memblock
);
483 pa_source_post(u
->source
, &memchunk
);
489 pa_memblock_unref(memchunk
.memblock
);
494 /* Run from I/O thread */
495 static void a2dp_set_bitpool(struct userdata
*u
, uint8_t bitpool
) {
496 struct sbc_info
*sbc_info
;
500 sbc_info
= &u
->sbc_info
;
502 if (sbc_info
->sbc
.bitpool
== bitpool
)
505 if (bitpool
> sbc_info
->max_bitpool
)
506 bitpool
= sbc_info
->max_bitpool
;
507 else if (bitpool
< sbc_info
->min_bitpool
)
508 bitpool
= sbc_info
->min_bitpool
;
510 sbc_info
->sbc
.bitpool
= bitpool
;
512 sbc_info
->codesize
= sbc_get_codesize(&sbc_info
->sbc
);
513 sbc_info
->frame_length
= sbc_get_frame_length(&sbc_info
->sbc
);
515 pa_log_debug("Bitpool has changed to %u", sbc_info
->sbc
.bitpool
);
518 (u
->read_link_mtu
- sizeof(struct rtp_header
) - sizeof(struct rtp_payload
))
519 / sbc_info
->frame_length
* sbc_info
->codesize
;
521 u
->write_block_size
=
522 (u
->write_link_mtu
- sizeof(struct rtp_header
) - sizeof(struct rtp_payload
))
523 / sbc_info
->frame_length
* sbc_info
->codesize
;
525 pa_sink_set_max_request_within_thread(u
->sink
, u
->write_block_size
);
526 pa_sink_set_fixed_latency_within_thread(u
->sink
,
527 FIXED_LATENCY_PLAYBACK_A2DP
+ pa_bytes_to_usec(u
->write_block_size
, &u
->sample_spec
));
530 /* Run from I/O thread */
531 static void a2dp_reduce_bitpool(struct userdata
*u
) {
532 struct sbc_info
*sbc_info
;
537 sbc_info
= &u
->sbc_info
;
539 /* Check if bitpool is already at its limit */
540 if (sbc_info
->sbc
.bitpool
<= BITPOOL_DEC_LIMIT
)
543 bitpool
= sbc_info
->sbc
.bitpool
- BITPOOL_DEC_STEP
;
545 if (bitpool
< BITPOOL_DEC_LIMIT
)
546 bitpool
= BITPOOL_DEC_LIMIT
;
548 a2dp_set_bitpool(u
, bitpool
);
551 static void teardown_stream(struct userdata
*u
) {
552 if (u
->rtpoll_item
) {
553 pa_rtpoll_item_free(u
->rtpoll_item
);
554 u
->rtpoll_item
= NULL
;
557 if (u
->stream_fd
>= 0) {
558 pa_close(u
->stream_fd
);
562 if (u
->read_smoother
) {
563 pa_smoother_free(u
->read_smoother
);
564 u
->read_smoother
= NULL
;
567 if (u
->write_memchunk
.memblock
) {
568 pa_memblock_unref(u
->write_memchunk
.memblock
);
569 pa_memchunk_reset(&u
->write_memchunk
);
572 pa_log_debug("Audio stream torn down");
575 static int transport_acquire(struct userdata
*u
, bool optional
) {
576 pa_assert(u
->transport
);
578 if (u
->transport_acquired
)
581 pa_log_debug("Acquiring transport %s", u
->transport
->path
);
583 u
->stream_fd
= u
->transport
->acquire(u
->transport
, optional
, &u
->read_link_mtu
, &u
->write_link_mtu
);
584 if (u
->stream_fd
< 0)
587 u
->transport_acquired
= true;
588 pa_log_info("Transport %s acquired: fd %d", u
->transport
->path
, u
->stream_fd
);
593 static void transport_release(struct userdata
*u
) {
594 pa_assert(u
->transport
);
596 /* Ignore if already released */
597 if (!u
->transport_acquired
)
600 pa_log_debug("Releasing transport %s", u
->transport
->path
);
602 u
->transport
->release(u
->transport
);
604 u
->transport_acquired
= false;
609 /* Run from I/O thread */
610 static void transport_config_mtu(struct userdata
*u
) {
612 (u
->read_link_mtu
- sizeof(struct rtp_header
) - sizeof(struct rtp_payload
))
613 / u
->sbc_info
.frame_length
* u
->sbc_info
.codesize
;
615 u
->write_block_size
=
616 (u
->write_link_mtu
- sizeof(struct rtp_header
) - sizeof(struct rtp_payload
))
617 / u
->sbc_info
.frame_length
* u
->sbc_info
.codesize
;
620 pa_sink_set_max_request_within_thread(u
->sink
, u
->write_block_size
);
621 pa_sink_set_fixed_latency_within_thread(u
->sink
,
622 FIXED_LATENCY_PLAYBACK_A2DP
+
623 pa_bytes_to_usec(u
->write_block_size
, &u
->sample_spec
));
627 pa_source_set_fixed_latency_within_thread(u
->source
,
628 FIXED_LATENCY_RECORD_A2DP
+
629 pa_bytes_to_usec(u
->read_block_size
, &u
->sample_spec
));
632 /* Run from I/O thread */
633 static void setup_stream(struct userdata
*u
) {
634 struct pollfd
*pollfd
;
637 pa_log_info("Transport %s resuming", u
->transport
->path
);
639 transport_config_mtu(u
);
641 pa_make_fd_nonblock(u
->stream_fd
);
642 pa_make_socket_low_delay(u
->stream_fd
);
645 if (setsockopt(u
->stream_fd
, SOL_SOCKET
, SO_TIMESTAMP
, &one
, sizeof(one
)) < 0)
646 pa_log_warn("Failed to enable SO_TIMESTAMP: %s", pa_cstrerror(errno
));
648 pa_log_debug("Stream properly set up, we're ready to roll!");
650 if (u
->profile
== PA_BLUETOOTH_PROFILE_A2DP_SINK
)
651 a2dp_set_bitpool(u
, u
->sbc_info
.max_bitpool
);
653 u
->rtpoll_item
= pa_rtpoll_item_new(u
->rtpoll
, PA_RTPOLL_NEVER
, 1);
654 pollfd
= pa_rtpoll_item_get_pollfd(u
->rtpoll_item
, NULL
);
655 pollfd
->fd
= u
->stream_fd
;
656 pollfd
->events
= pollfd
->revents
= 0;
658 u
->read_index
= u
->write_index
= 0;
662 u
->read_smoother
= pa_smoother_new(PA_USEC_PER_SEC
, 2*PA_USEC_PER_SEC
, true, true, 10, pa_rtclock_now(), true);
665 /* Run from IO thread */
666 static int source_process_msg(pa_msgobject
*o
, int code
, void *data
, int64_t offset
, pa_memchunk
*chunk
) {
667 struct userdata
*u
= PA_SOURCE(o
)->userdata
;
671 pa_assert(u
->source
== PA_SOURCE(o
));
672 pa_assert(u
->transport
);
676 case PA_SOURCE_MESSAGE_SET_STATE
:
678 switch ((pa_source_state_t
) PA_PTR_TO_UINT(data
)) {
680 case PA_SOURCE_SUSPENDED
:
681 /* Ignore if transition is PA_SOURCE_INIT->PA_SOURCE_SUSPENDED */
682 if (!PA_SOURCE_IS_OPENED(u
->source
->thread_info
.state
))
685 /* Stop the device if the sink is suspended as well */
686 if (!u
->sink
|| u
->sink
->state
== PA_SINK_SUSPENDED
)
687 transport_release(u
);
689 if (u
->read_smoother
)
690 pa_smoother_pause(u
->read_smoother
, pa_rtclock_now());
695 case PA_SOURCE_RUNNING
:
696 if (u
->source
->thread_info
.state
!= PA_SOURCE_SUSPENDED
)
699 /* Resume the device if the sink was suspended as well */
700 if (!u
->sink
|| !PA_SINK_IS_OPENED(u
->sink
->thread_info
.state
)) {
701 if (transport_acquire(u
, false) < 0)
707 /* We don't resume the smoother here. Instead we
708 * wait until the first packet arrives */
712 case PA_SOURCE_UNLINKED
:
714 case PA_SOURCE_INVALID_STATE
:
720 case PA_SOURCE_MESSAGE_GET_LATENCY
: {
723 if (u
->read_smoother
) {
724 wi
= pa_smoother_get(u
->read_smoother
, pa_rtclock_now());
725 ri
= pa_bytes_to_usec(u
->read_index
, &u
->sample_spec
);
727 *((pa_usec_t
*) data
) = FIXED_LATENCY_RECORD_A2DP
+ wi
> ri
? FIXED_LATENCY_RECORD_A2DP
+ wi
- ri
: 0;
729 *((pa_usec_t
*) data
) = 0;
736 r
= pa_source_process_msg(o
, code
, data
, offset
, chunk
);
738 return (r
< 0 || !failed
) ? r
: -1;
741 /* Run from main thread */
742 static int add_source(struct userdata
*u
) {
743 pa_source_new_data data
;
745 pa_assert(u
->transport
);
747 pa_source_new_data_init(&data
);
748 data
.module
= u
->module
;
750 data
.driver
= __FILE__
;
751 data
.name
= pa_sprintf_malloc("bluez_source.%s", u
->device
->address
);
752 data
.namereg_fail
= false;
753 pa_proplist_sets(data
.proplist
, "bluetooth.protocol", pa_bluetooth_profile_to_string(u
->profile
));
754 pa_source_new_data_set_sample_spec(&data
, &u
->sample_spec
);
756 connect_ports(u
, &data
, PA_DIRECTION_INPUT
);
758 if (!u
->transport_acquired
)
759 switch (u
->profile
) {
760 case PA_BLUETOOTH_PROFILE_A2DP_SOURCE
:
761 data
.suspend_cause
= PA_SUSPEND_USER
;
763 case PA_BLUETOOTH_PROFILE_A2DP_SINK
:
764 case PA_BLUETOOTH_PROFILE_OFF
:
765 pa_assert_not_reached();
769 u
->source
= pa_source_new(u
->core
, &data
, PA_SOURCE_HARDWARE
|PA_SOURCE_LATENCY
);
770 pa_source_new_data_done(&data
);
772 pa_log_error("Failed to create source");
776 u
->source
->userdata
= u
;
777 u
->source
->parent
.process_msg
= source_process_msg
;
782 /* Run from IO thread */
783 static int sink_process_msg(pa_msgobject
*o
, int code
, void *data
, int64_t offset
, pa_memchunk
*chunk
) {
784 struct userdata
*u
= PA_SINK(o
)->userdata
;
788 pa_assert(u
->sink
== PA_SINK(o
));
789 pa_assert(u
->transport
);
793 case PA_SINK_MESSAGE_SET_STATE
:
795 switch ((pa_sink_state_t
) PA_PTR_TO_UINT(data
)) {
797 case PA_SINK_SUSPENDED
:
798 /* Ignore if transition is PA_SINK_INIT->PA_SINK_SUSPENDED */
799 if (!PA_SINK_IS_OPENED(u
->sink
->thread_info
.state
))
802 /* Stop the device if the source is suspended as well */
803 if (!u
->source
|| u
->source
->state
== PA_SOURCE_SUSPENDED
)
804 /* We deliberately ignore whether stopping
805 * actually worked. Since the stream_fd is
806 * closed it doesn't really matter */
807 transport_release(u
);
812 case PA_SINK_RUNNING
:
813 if (u
->sink
->thread_info
.state
!= PA_SINK_SUSPENDED
)
816 /* Resume the device if the source was suspended as well */
817 if (!u
->source
|| !PA_SOURCE_IS_OPENED(u
->source
->thread_info
.state
)) {
818 if (transport_acquire(u
, false) < 0)
826 case PA_SINK_UNLINKED
:
828 case PA_SINK_INVALID_STATE
:
834 case PA_SINK_MESSAGE_GET_LATENCY
: {
837 if (u
->read_smoother
) {
838 ri
= pa_smoother_get(u
->read_smoother
, pa_rtclock_now());
839 wi
= pa_bytes_to_usec(u
->write_index
+ u
->write_block_size
, &u
->sample_spec
);
841 ri
= pa_rtclock_now() - u
->started_at
;
842 wi
= pa_bytes_to_usec(u
->write_index
, &u
->sample_spec
);
845 *((pa_usec_t
*) data
) = FIXED_LATENCY_PLAYBACK_A2DP
+ wi
> ri
? FIXED_LATENCY_PLAYBACK_A2DP
+ wi
- ri
: 0;
851 r
= pa_sink_process_msg(o
, code
, data
, offset
, chunk
);
853 return (r
< 0 || !failed
) ? r
: -1;
856 /* Run from main thread */
857 static int add_sink(struct userdata
*u
) {
858 pa_sink_new_data data
;
860 pa_assert(u
->transport
);
862 pa_sink_new_data_init(&data
);
863 data
.module
= u
->module
;
865 data
.driver
= __FILE__
;
866 data
.name
= pa_sprintf_malloc("bluez_sink.%s", u
->device
->address
);
867 data
.namereg_fail
= false;
868 pa_proplist_sets(data
.proplist
, "bluetooth.protocol", pa_bluetooth_profile_to_string(u
->profile
));
869 pa_sink_new_data_set_sample_spec(&data
, &u
->sample_spec
);
871 connect_ports(u
, &data
, PA_DIRECTION_OUTPUT
);
873 if (!u
->transport_acquired
)
874 switch (u
->profile
) {
875 case PA_BLUETOOTH_PROFILE_A2DP_SINK
:
876 /* Profile switch should have failed */
877 case PA_BLUETOOTH_PROFILE_A2DP_SOURCE
:
878 case PA_BLUETOOTH_PROFILE_OFF
:
879 pa_assert_not_reached();
883 u
->sink
= pa_sink_new(u
->core
, &data
, PA_SINK_HARDWARE
|PA_SINK_LATENCY
);
884 pa_sink_new_data_done(&data
);
886 pa_log_error("Failed to create sink");
890 u
->sink
->userdata
= u
;
891 u
->sink
->parent
.process_msg
= sink_process_msg
;
896 /* Run from main thread */
897 static void transport_config(struct userdata
*u
) {
898 sbc_info_t
*sbc_info
= &u
->sbc_info
;
901 pa_assert(u
->transport
);
903 u
->sample_spec
.format
= PA_SAMPLE_S16LE
;
904 config
= (a2dp_sbc_t
*) u
->transport
->config
;
906 if (sbc_info
->sbc_initialized
)
907 sbc_reinit(&sbc_info
->sbc
, 0);
909 sbc_init(&sbc_info
->sbc
, 0);
910 sbc_info
->sbc_initialized
= true;
912 switch (config
->frequency
) {
913 case SBC_SAMPLING_FREQ_16000
:
914 sbc_info
->sbc
.frequency
= SBC_FREQ_16000
;
915 u
->sample_spec
.rate
= 16000U;
917 case SBC_SAMPLING_FREQ_32000
:
918 sbc_info
->sbc
.frequency
= SBC_FREQ_32000
;
919 u
->sample_spec
.rate
= 32000U;
921 case SBC_SAMPLING_FREQ_44100
:
922 sbc_info
->sbc
.frequency
= SBC_FREQ_44100
;
923 u
->sample_spec
.rate
= 44100U;
925 case SBC_SAMPLING_FREQ_48000
:
926 sbc_info
->sbc
.frequency
= SBC_FREQ_48000
;
927 u
->sample_spec
.rate
= 48000U;
930 pa_assert_not_reached();
933 switch (config
->channel_mode
) {
934 case SBC_CHANNEL_MODE_MONO
:
935 sbc_info
->sbc
.mode
= SBC_MODE_MONO
;
936 u
->sample_spec
.channels
= 1;
938 case SBC_CHANNEL_MODE_DUAL_CHANNEL
:
939 sbc_info
->sbc
.mode
= SBC_MODE_DUAL_CHANNEL
;
940 u
->sample_spec
.channels
= 2;
942 case SBC_CHANNEL_MODE_STEREO
:
943 sbc_info
->sbc
.mode
= SBC_MODE_STEREO
;
944 u
->sample_spec
.channels
= 2;
946 case SBC_CHANNEL_MODE_JOINT_STEREO
:
947 sbc_info
->sbc
.mode
= SBC_MODE_JOINT_STEREO
;
948 u
->sample_spec
.channels
= 2;
951 pa_assert_not_reached();
954 switch (config
->allocation_method
) {
955 case SBC_ALLOCATION_SNR
:
956 sbc_info
->sbc
.allocation
= SBC_AM_SNR
;
958 case SBC_ALLOCATION_LOUDNESS
:
959 sbc_info
->sbc
.allocation
= SBC_AM_LOUDNESS
;
962 pa_assert_not_reached();
965 switch (config
->subbands
) {
967 sbc_info
->sbc
.subbands
= SBC_SB_4
;
970 sbc_info
->sbc
.subbands
= SBC_SB_8
;
973 pa_assert_not_reached();
976 switch (config
->block_length
) {
977 case SBC_BLOCK_LENGTH_4
:
978 sbc_info
->sbc
.blocks
= SBC_BLK_4
;
980 case SBC_BLOCK_LENGTH_8
:
981 sbc_info
->sbc
.blocks
= SBC_BLK_8
;
983 case SBC_BLOCK_LENGTH_12
:
984 sbc_info
->sbc
.blocks
= SBC_BLK_12
;
986 case SBC_BLOCK_LENGTH_16
:
987 sbc_info
->sbc
.blocks
= SBC_BLK_16
;
990 pa_assert_not_reached();
993 sbc_info
->min_bitpool
= config
->min_bitpool
;
994 sbc_info
->max_bitpool
= config
->max_bitpool
;
996 /* Set minimum bitpool for source to get the maximum possible block_size */
997 sbc_info
->sbc
.bitpool
= u
->profile
== PA_BLUETOOTH_PROFILE_A2DP_SINK
? sbc_info
->max_bitpool
: sbc_info
->min_bitpool
;
998 sbc_info
->codesize
= sbc_get_codesize(&sbc_info
->sbc
);
999 sbc_info
->frame_length
= sbc_get_frame_length(&sbc_info
->sbc
);
1001 pa_log_info("SBC parameters: allocation=%u, subbands=%u, blocks=%u, bitpool=%u",
1002 sbc_info
->sbc
.allocation
, sbc_info
->sbc
.subbands
, sbc_info
->sbc
.blocks
, sbc_info
->sbc
.bitpool
);
1005 /* Run from main thread */
1006 static int setup_transport(struct userdata
*u
) {
1007 pa_bluetooth_transport
*t
;
1010 pa_assert(!u
->transport
);
1011 pa_assert(u
->profile
!= PA_BLUETOOTH_PROFILE_OFF
);
1013 /* check if profile has a transport */
1014 t
= u
->device
->transports
[u
->profile
];
1015 if (!t
|| t
->state
<= PA_BLUETOOTH_TRANSPORT_STATE_DISCONNECTED
) {
1016 pa_log_warn("Profile has no transport");
1022 if (u
->profile
== PA_BLUETOOTH_PROFILE_A2DP_SOURCE
)
1023 transport_acquire(u
, true); /* In case of error, the sink/sources will be created suspended */
1024 else if (transport_acquire(u
, false) < 0)
1025 return -1; /* We need to fail here until the interactions with module-suspend-on-idle and alike get improved */
1027 transport_config(u
);
1032 /* Run from main thread */
1033 static int init_profile(struct userdata
*u
) {
1036 pa_assert(u
->profile
!= PA_BLUETOOTH_PROFILE_OFF
);
1038 if (setup_transport(u
) < 0)
1041 pa_assert(u
->transport
);
1043 if (u
->profile
== PA_BLUETOOTH_PROFILE_A2DP_SINK
)
1044 if (add_sink(u
) < 0)
1047 if (u
->profile
== PA_BLUETOOTH_PROFILE_A2DP_SOURCE
)
1048 if (add_source(u
) < 0)
1054 /* I/O thread function */
1055 static void thread_func(void *userdata
) {
1056 struct userdata
*u
= userdata
;
1057 unsigned do_write
= 0;
1058 unsigned pending_read_bytes
= 0;
1059 bool writable
= false;
1062 pa_assert(u
->transport
);
1064 pa_log_debug("IO Thread starting up");
1066 if (u
->core
->realtime_scheduling
)
1067 pa_make_realtime(u
->core
->realtime_priority
);
1069 pa_thread_mq_install(&u
->thread_mq
);
1071 /* Setup the stream only if the transport was already acquired */
1072 if (u
->transport_acquired
)
1076 struct pollfd
*pollfd
;
1078 bool disable_timer
= true;
1080 pollfd
= u
->rtpoll_item
? pa_rtpoll_item_get_pollfd(u
->rtpoll_item
, NULL
) : NULL
;
1082 if (u
->source
&& PA_SOURCE_IS_LINKED(u
->source
->thread_info
.state
)) {
1084 /* We should send two blocks to the device before we expect
1087 if (u
->write_index
== 0 && u
->read_index
<= 0)
1090 if (pollfd
&& (pollfd
->revents
& POLLIN
)) {
1093 n_read
= a2dp_process_push(u
);
1099 /* We just read something, so we are supposed to write something, too */
1100 pending_read_bytes
+= n_read
;
1101 do_write
+= pending_read_bytes
/ u
->write_block_size
;
1102 pending_read_bytes
= pending_read_bytes
% u
->write_block_size
;
1107 if (u
->sink
&& PA_SINK_IS_LINKED(u
->sink
->thread_info
.state
)) {
1109 if (PA_UNLIKELY(u
->sink
->thread_info
.rewind_requested
))
1110 pa_sink_process_rewind(u
->sink
, 0);
1113 if (pollfd
->revents
& POLLOUT
)
1116 if ((!u
->source
|| !PA_SOURCE_IS_LINKED(u
->source
->thread_info
.state
)) && do_write
<= 0 && writable
) {
1117 pa_usec_t time_passed
;
1118 pa_usec_t audio_sent
;
1120 /* Hmm, there is no input stream we could synchronize
1121 * to. So let's do things by time */
1123 time_passed
= pa_rtclock_now() - u
->started_at
;
1124 audio_sent
= pa_bytes_to_usec(u
->write_index
, &u
->sample_spec
);
1126 if (audio_sent
<= time_passed
) {
1127 pa_usec_t audio_to_send
= time_passed
- audio_sent
;
1129 /* Never try to catch up for more than 100ms */
1130 if (u
->write_index
> 0 && audio_to_send
> MAX_PLAYBACK_CATCH_UP_USEC
) {
1131 pa_usec_t skip_usec
;
1132 uint64_t skip_bytes
;
1134 skip_usec
= audio_to_send
- MAX_PLAYBACK_CATCH_UP_USEC
;
1135 skip_bytes
= pa_usec_to_bytes(skip_usec
, &u
->sample_spec
);
1137 if (skip_bytes
> 0) {
1140 pa_log_warn("Skipping %llu us (= %llu bytes) in audio stream",
1141 (unsigned long long) skip_usec
,
1142 (unsigned long long) skip_bytes
);
1144 pa_sink_render_full(u
->sink
, skip_bytes
, &tmp
);
1145 pa_memblock_unref(tmp
.memblock
);
1146 u
->write_index
+= skip_bytes
;
1148 if (u
->profile
== PA_BLUETOOTH_PROFILE_A2DP_SINK
)
1149 a2dp_reduce_bitpool(u
);
1154 pending_read_bytes
= 0;
1158 if (writable
&& do_write
> 0) {
1161 if (u
->write_index
<= 0)
1162 u
->started_at
= pa_rtclock_now();
1164 if ((n_written
= a2dp_process_render(u
)) < 0)
1168 pa_log("Broken kernel: we got EAGAIN on write() after POLLOUT!");
1170 do_write
-= n_written
;
1174 if ((!u
->source
|| !PA_SOURCE_IS_LINKED(u
->source
->thread_info
.state
)) && do_write
<= 0) {
1175 pa_usec_t sleep_for
;
1176 pa_usec_t time_passed
, next_write_at
;
1179 /* Hmm, there is no input stream we could synchronize
1180 * to. So let's estimate when we need to wake up the latest */
1181 time_passed
= pa_rtclock_now() - u
->started_at
;
1182 next_write_at
= pa_bytes_to_usec(u
->write_index
, &u
->sample_spec
);
1183 sleep_for
= time_passed
< next_write_at
? next_write_at
- time_passed
: 0;
1184 /* 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); */
1186 /* drop stream every 500 ms */
1187 sleep_for
= PA_USEC_PER_MSEC
* 500;
1189 pa_rtpoll_set_timer_relative(u
->rtpoll
, sleep_for
);
1190 disable_timer
= false;
1196 pa_rtpoll_set_timer_disabled(u
->rtpoll
);
1198 /* Hmm, nothing to do. Let's sleep */
1200 pollfd
->events
= (short) (((u
->sink
&& PA_SINK_IS_LINKED(u
->sink
->thread_info
.state
) && !writable
) ? POLLOUT
: 0) |
1201 (u
->source
&& PA_SOURCE_IS_LINKED(u
->source
->thread_info
.state
) ? POLLIN
: 0));
1203 if ((ret
= pa_rtpoll_run(u
->rtpoll
, true)) < 0) {
1204 pa_log_debug("pa_rtpoll_run failed with: %d", ret
);
1208 pa_log_debug("IO thread shutdown requested, stopping cleanly");
1209 transport_release(u
);
1213 pollfd
= u
->rtpoll_item
? pa_rtpoll_item_get_pollfd(u
->rtpoll_item
, NULL
) : NULL
;
1215 if (pollfd
&& (pollfd
->revents
& ~(POLLOUT
|POLLIN
))) {
1216 pa_log_info("FD error: %s%s%s%s",
1217 pollfd
->revents
& POLLERR
? "POLLERR " :"",
1218 pollfd
->revents
& POLLHUP
? "POLLHUP " :"",
1219 pollfd
->revents
& POLLPRI
? "POLLPRI " :"",
1220 pollfd
->revents
& POLLNVAL
? "POLLNVAL " :"");
1227 /* In case of HUP, just tear down the streams */
1228 if (!pollfd
|| (pollfd
->revents
& POLLHUP
) == 0)
1232 pending_read_bytes
= 0;
1239 /* If this was no regular exit from the loop we have to continue processing messages until we receive PA_MESSAGE_SHUTDOWN */
1240 pa_log_debug("IO thread failed");
1241 pa_asyncmsgq_post(pa_thread_mq_get()->outq
, PA_MSGOBJECT(u
->msg
), BLUETOOTH_MESSAGE_IO_THREAD_FAILED
, NULL
, 0, NULL
, NULL
);
1242 pa_asyncmsgq_wait_for(u
->thread_mq
.inq
, PA_MESSAGE_SHUTDOWN
);
1245 pa_log_debug("IO thread shutting down");
1248 /* Run from main thread */
1249 static int start_thread(struct userdata
*u
) {
1251 pa_assert(!u
->thread
);
1252 pa_assert(!u
->rtpoll
);
1253 pa_assert(!u
->rtpoll_item
);
1255 u
->rtpoll
= pa_rtpoll_new();
1256 pa_thread_mq_init(&u
->thread_mq
, u
->core
->mainloop
, u
->rtpoll
);
1258 if (!(u
->thread
= pa_thread_new("bluetooth", thread_func
, u
))) {
1259 pa_log_error("Failed to create IO thread");
1264 pa_sink_set_asyncmsgq(u
->sink
, u
->thread_mq
.inq
);
1265 pa_sink_set_rtpoll(u
->sink
, u
->rtpoll
);
1266 pa_sink_put(u
->sink
);
1268 if (u
->sink
->set_volume
)
1269 u
->sink
->set_volume(u
->sink
);
1273 pa_source_set_asyncmsgq(u
->source
, u
->thread_mq
.inq
);
1274 pa_source_set_rtpoll(u
->source
, u
->rtpoll
);
1275 pa_source_put(u
->source
);
1277 if (u
->source
->set_volume
)
1278 u
->source
->set_volume(u
->source
);
1284 /* Run from main thread */
1285 static void stop_thread(struct userdata
*u
) {
1289 pa_sink_unlink(u
->sink
);
1292 pa_source_unlink(u
->source
);
1295 pa_asyncmsgq_send(u
->thread_mq
.inq
, NULL
, PA_MESSAGE_SHUTDOWN
, NULL
, 0, NULL
);
1296 pa_thread_free(u
->thread
);
1300 if (u
->rtpoll_item
) {
1301 pa_rtpoll_item_free(u
->rtpoll_item
);
1302 u
->rtpoll_item
= NULL
;
1306 pa_thread_mq_done(&u
->thread_mq
);
1307 pa_rtpoll_free(u
->rtpoll
);
1312 transport_release(u
);
1313 u
->transport
= NULL
;
1317 pa_sink_unref(u
->sink
);
1322 pa_source_unref(u
->source
);
1326 if (u
->read_smoother
) {
1327 pa_smoother_free(u
->read_smoother
);
1328 u
->read_smoother
= NULL
;
1332 /* Run from main thread */
1333 static char *cleanup_name(const char *name
) {
1339 while ((*name
>= 1 && *name
<= 32) || *name
>= 127)
1342 t
= pa_xstrdup(name
);
1344 for (s
= d
= t
; *s
; s
++) {
1346 if (*s
<= 32 || *s
>= 127 || *s
== '_') {
1364 /* Run from main thread */
1365 static pa_direction_t
get_profile_direction(pa_bluetooth_profile_t p
) {
1366 static const pa_direction_t profile_direction
[] = {
1367 [PA_BLUETOOTH_PROFILE_A2DP_SINK
] = PA_DIRECTION_OUTPUT
,
1368 [PA_BLUETOOTH_PROFILE_A2DP_SOURCE
] = PA_DIRECTION_INPUT
,
1369 [PA_BLUETOOTH_PROFILE_OFF
] = 0
1372 return profile_direction
[p
];
1375 /* Run from main thread */
1376 static pa_available_t
get_port_availability(struct userdata
*u
, pa_direction_t direction
) {
1377 pa_available_t result
= PA_AVAILABLE_NO
;
1381 pa_assert(u
->device
);
1383 for (i
= 0; i
< PA_BLUETOOTH_PROFILE_COUNT
; i
++) {
1384 pa_bluetooth_transport
*transport
;
1386 if (!(get_profile_direction(i
) & direction
))
1389 if (!(transport
= u
->device
->transports
[i
]))
1392 switch(transport
->state
) {
1393 case PA_BLUETOOTH_TRANSPORT_STATE_DISCONNECTED
:
1396 case PA_BLUETOOTH_TRANSPORT_STATE_IDLE
:
1397 if (result
== PA_AVAILABLE_NO
)
1398 result
= PA_AVAILABLE_UNKNOWN
;
1402 case PA_BLUETOOTH_TRANSPORT_STATE_PLAYING
:
1403 return PA_AVAILABLE_YES
;
1410 /* Run from main thread */
1411 static pa_available_t
transport_state_to_availability(pa_bluetooth_transport_state_t state
) {
1413 case PA_BLUETOOTH_TRANSPORT_STATE_DISCONNECTED
:
1414 return PA_AVAILABLE_NO
;
1415 case PA_BLUETOOTH_TRANSPORT_STATE_PLAYING
:
1416 return PA_AVAILABLE_YES
;
1418 return PA_AVAILABLE_UNKNOWN
;
1422 /* Run from main thread */
1423 static void create_card_ports(struct userdata
*u
, pa_hashmap
*ports
) {
1424 pa_device_port
*port
;
1425 pa_device_port_new_data port_data
;
1426 const char *name_prefix
, *input_description
, *output_description
;
1430 pa_assert(u
->device
);
1432 name_prefix
= "unknown";
1433 input_description
= _("Bluetooth Input");
1434 output_description
= _("Bluetooth Output");
1436 switch (form_factor_from_class(u
->device
->class_of_device
)) {
1437 case PA_BLUETOOTH_FORM_FACTOR_HEADSET
:
1438 name_prefix
= "headset";
1439 input_description
= output_description
= _("Headset");
1442 case PA_BLUETOOTH_FORM_FACTOR_HANDSFREE
:
1443 name_prefix
= "handsfree";
1444 input_description
= output_description
= _("Handsfree");
1447 case PA_BLUETOOTH_FORM_FACTOR_MICROPHONE
:
1448 name_prefix
= "microphone";
1449 input_description
= _("Microphone");
1450 output_description
= _("Bluetooth Output");
1453 case PA_BLUETOOTH_FORM_FACTOR_SPEAKER
:
1454 name_prefix
= "speaker";
1455 input_description
= _("Bluetooth Input");
1456 output_description
= _("Speaker");
1459 case PA_BLUETOOTH_FORM_FACTOR_HEADPHONE
:
1460 name_prefix
= "headphone";
1461 input_description
= _("Bluetooth Input");
1462 output_description
= _("Headphone");
1465 case PA_BLUETOOTH_FORM_FACTOR_PORTABLE
:
1466 name_prefix
= "portable";
1467 input_description
= output_description
= _("Portable");
1470 case PA_BLUETOOTH_FORM_FACTOR_CAR
:
1471 name_prefix
= "car";
1472 input_description
= output_description
= _("Car");
1475 case PA_BLUETOOTH_FORM_FACTOR_HIFI
:
1476 name_prefix
= "hifi";
1477 input_description
= output_description
= _("HiFi");
1480 case PA_BLUETOOTH_FORM_FACTOR_PHONE
:
1481 name_prefix
= "phone";
1482 input_description
= output_description
= _("Phone");
1485 case PA_BLUETOOTH_FORM_FACTOR_UNKNOWN
:
1486 name_prefix
= "unknown";
1487 input_description
= _("Bluetooth Input");
1488 output_description
= _("Bluetooth Output");
1492 u
->output_port_name
= pa_sprintf_malloc("%s-output", name_prefix
);
1493 pa_device_port_new_data_init(&port_data
);
1494 pa_device_port_new_data_set_name(&port_data
, u
->output_port_name
);
1495 pa_device_port_new_data_set_description(&port_data
, output_description
);
1496 pa_device_port_new_data_set_direction(&port_data
, PA_DIRECTION_OUTPUT
);
1497 pa_device_port_new_data_set_available(&port_data
, get_port_availability(u
, PA_DIRECTION_OUTPUT
));
1498 pa_assert_se(port
= pa_device_port_new(u
->core
, &port_data
, 0));
1499 pa_assert_se(pa_hashmap_put(ports
, port
->name
, port
) >= 0);
1500 pa_device_port_new_data_done(&port_data
);
1502 u
->input_port_name
= pa_sprintf_malloc("%s-input", name_prefix
);
1503 pa_device_port_new_data_init(&port_data
);
1504 pa_device_port_new_data_set_name(&port_data
, u
->input_port_name
);
1505 pa_device_port_new_data_set_description(&port_data
, input_description
);
1506 pa_device_port_new_data_set_direction(&port_data
, PA_DIRECTION_INPUT
);
1507 pa_device_port_new_data_set_available(&port_data
, get_port_availability(u
, PA_DIRECTION_INPUT
));
1508 pa_assert_se(port
= pa_device_port_new(u
->core
, &port_data
, 0));
1509 pa_assert_se(pa_hashmap_put(ports
, port
->name
, port
) >= 0);
1510 pa_device_port_new_data_done(&port_data
);
1513 /* Run from main thread */
1514 static pa_card_profile
*create_card_profile(struct userdata
*u
, const char *uuid
, pa_hashmap
*ports
) {
1515 pa_device_port
*input_port
, *output_port
;
1516 pa_card_profile
*cp
= NULL
;
1517 pa_bluetooth_profile_t
*p
;
1519 pa_assert(u
->input_port_name
);
1520 pa_assert(u
->output_port_name
);
1521 pa_assert_se(input_port
= pa_hashmap_get(ports
, u
->input_port_name
));
1522 pa_assert_se(output_port
= pa_hashmap_get(ports
, u
->output_port_name
));
1524 if (pa_streq(uuid
, PA_BLUETOOTH_UUID_A2DP_SINK
)) {
1525 /* TODO: Change this profile's name to a2dp_sink, to reflect the remote
1526 * device's role and be consistent with the a2dp source profile */
1527 cp
= pa_card_profile_new("a2dp", _("High Fidelity Playback (A2DP Sink)"), sizeof(pa_bluetooth_profile_t
));
1531 cp
->max_sink_channels
= 2;
1532 cp
->max_source_channels
= 0;
1533 pa_hashmap_put(output_port
->profiles
, cp
->name
, cp
);
1535 p
= PA_CARD_PROFILE_DATA(cp
);
1536 *p
= PA_BLUETOOTH_PROFILE_A2DP_SINK
;
1537 } else if (pa_streq(uuid
, PA_BLUETOOTH_UUID_A2DP_SOURCE
)) {
1538 cp
= pa_card_profile_new("a2dp_source", _("High Fidelity Capture (A2DP Source)"), sizeof(pa_bluetooth_profile_t
));
1542 cp
->max_sink_channels
= 0;
1543 cp
->max_source_channels
= 2;
1544 pa_hashmap_put(input_port
->profiles
, cp
->name
, cp
);
1546 p
= PA_CARD_PROFILE_DATA(cp
);
1547 *p
= PA_BLUETOOTH_PROFILE_A2DP_SOURCE
;
1550 if (cp
&& u
->device
->transports
[*p
])
1551 cp
->available
= transport_state_to_availability(u
->device
->transports
[*p
]->state
);
1556 /* Run from main thread */
1557 static int set_profile_cb(pa_card
*c
, pa_card_profile
*new_profile
) {
1559 pa_bluetooth_profile_t
*p
;
1562 pa_assert(new_profile
);
1563 pa_assert_se(u
= c
->userdata
);
1565 p
= PA_CARD_PROFILE_DATA(new_profile
);
1567 if (*p
!= PA_BLUETOOTH_PROFILE_OFF
) {
1568 const pa_bluetooth_device
*d
= u
->device
;
1570 if (!d
->transports
[*p
] || d
->transports
[*p
]->state
<= PA_BLUETOOTH_TRANSPORT_STATE_DISCONNECTED
) {
1571 pa_log_warn("Refused to switch profile to %s: Not connected", new_profile
->name
);
1580 if (u
->profile
!= PA_BLUETOOTH_PROFILE_OFF
)
1581 if (init_profile(u
) < 0)
1584 if (u
->sink
|| u
->source
)
1585 if (start_thread(u
) < 0)
1593 pa_assert_se(pa_card_set_profile(u
->card
, pa_hashmap_get(u
->card
->profiles
, "off"), false) >= 0);
1598 /* Run from main thread */
1599 static int add_card(struct userdata
*u
) {
1600 const pa_bluetooth_device
*d
;
1601 pa_card_new_data data
;
1603 pa_bluetooth_form_factor_t ff
;
1604 pa_card_profile
*cp
;
1605 pa_bluetooth_profile_t
*p
;
1610 pa_assert(u
->device
);
1614 pa_card_new_data_init(&data
);
1615 data
.driver
= __FILE__
;
1616 data
.module
= u
->module
;
1618 alias
= cleanup_name(d
->alias
);
1619 pa_proplist_sets(data
.proplist
, PA_PROP_DEVICE_DESCRIPTION
, alias
);
1622 pa_proplist_sets(data
.proplist
, PA_PROP_DEVICE_STRING
, d
->address
);
1623 pa_proplist_sets(data
.proplist
, PA_PROP_DEVICE_API
, "bluez");
1624 pa_proplist_sets(data
.proplist
, PA_PROP_DEVICE_CLASS
, "sound");
1625 pa_proplist_sets(data
.proplist
, PA_PROP_DEVICE_BUS
, "bluetooth");
1627 if ((ff
= form_factor_from_class(d
->class_of_device
)) != PA_BLUETOOTH_FORM_FACTOR_UNKNOWN
)
1628 pa_proplist_sets(data
.proplist
, PA_PROP_DEVICE_FORM_FACTOR
, form_factor_to_string(ff
));
1630 pa_proplist_sets(data
.proplist
, "bluez.path", d
->path
);
1631 pa_proplist_setf(data
.proplist
, "bluez.class", "0x%06x", d
->class_of_device
);
1632 pa_proplist_sets(data
.proplist
, "bluez.alias", d
->alias
);
1633 data
.name
= pa_sprintf_malloc("bluez_card.%s", d
->address
);
1634 data
.namereg_fail
= false;
1636 create_card_ports(u
, data
.ports
);
1638 PA_HASHMAP_FOREACH(uuid
, d
->uuids
, state
) {
1639 cp
= create_card_profile(u
, uuid
, data
.ports
);
1644 if (pa_hashmap_get(data
.profiles
, cp
->name
)) {
1645 pa_card_profile_free(cp
);
1649 pa_hashmap_put(data
.profiles
, cp
->name
, cp
);
1652 pa_assert(!pa_hashmap_isempty(data
.profiles
));
1654 cp
= pa_card_profile_new("off", _("Off"), sizeof(pa_bluetooth_profile_t
));
1655 cp
->available
= PA_AVAILABLE_YES
;
1656 p
= PA_CARD_PROFILE_DATA(cp
);
1657 *p
= PA_BLUETOOTH_PROFILE_OFF
;
1658 pa_hashmap_put(data
.profiles
, cp
->name
, cp
);
1660 u
->card
= pa_card_new(u
->core
, &data
);
1661 pa_card_new_data_done(&data
);
1663 pa_log("Failed to allocate card.");
1667 u
->card
->userdata
= u
;
1668 u
->card
->set_profile
= set_profile_cb
;
1670 p
= PA_CARD_PROFILE_DATA(u
->card
->active_profile
);
1676 /* Run from main thread */
1677 static void handle_transport_state_change(struct userdata
*u
, struct pa_bluetooth_transport
*t
) {
1678 bool acquire
= false;
1679 bool release
= false;
1680 pa_card_profile
*cp
;
1681 pa_device_port
*port
;
1686 /* Update profile availability */
1687 if (!(cp
= pa_hashmap_get(u
->card
->profiles
, pa_bluetooth_profile_to_string(t
->profile
))))
1689 pa_card_profile_set_available(cp
, transport_state_to_availability(t
->state
));
1691 /* Update port availability */
1692 pa_assert_se(port
= pa_hashmap_get(u
->card
->ports
, u
->output_port_name
));
1693 pa_device_port_set_available(port
, get_port_availability(u
, PA_DIRECTION_OUTPUT
));
1694 pa_assert_se(port
= pa_hashmap_get(u
->card
->ports
, u
->input_port_name
));
1695 pa_device_port_set_available(port
, get_port_availability(u
, PA_DIRECTION_INPUT
));
1697 /* Acquire or release transport as needed */
1698 acquire
= (t
->state
== PA_BLUETOOTH_TRANSPORT_STATE_PLAYING
&& u
->profile
== t
->profile
);
1699 release
= (t
->state
!= PA_BLUETOOTH_TRANSPORT_STATE_PLAYING
&& u
->profile
== t
->profile
);
1701 if (acquire
&& transport_acquire(u
, true) >= 0) {
1703 pa_log_debug("Resuming source %s because its transport state changed to playing", u
->source
->name
);
1705 /* We remove the IDLE suspend cause, because otherwise
1706 * module-loopback doesn't uncork its streams. FIXME: Messing with
1707 * the IDLE suspend cause here is wrong, the correct way to handle
1708 * this would probably be to uncork the loopback streams not only
1709 * when the other end is unsuspended, but also when the other end's
1710 * suspend cause changes to IDLE only (currently there's no
1711 * notification mechanism for suspend cause changes, though). */
1712 pa_source_suspend(u
->source
, false, PA_SUSPEND_IDLE
|PA_SUSPEND_USER
);
1716 pa_log_debug("Resuming sink %s because its transport state changed to playing", u
->sink
->name
);
1718 /* FIXME: See the previous comment. */
1719 pa_sink_suspend(u
->sink
, false, PA_SUSPEND_IDLE
|PA_SUSPEND_USER
);
1723 if (release
&& u
->transport_acquired
) {
1724 /* FIXME: this release is racy, since the audio stream might have
1725 * been set up again in the meantime (but not processed yet by PA).
1726 * BlueZ should probably release the transport automatically, and in
1727 * that case we would just mark the transport as released */
1729 /* Remote side closed the stream so we consider it PA_SUSPEND_USER */
1731 pa_log_debug("Suspending source %s because the remote end closed the stream", u
->source
->name
);
1732 pa_source_suspend(u
->source
, true, PA_SUSPEND_USER
);
1736 pa_log_debug("Suspending sink %s because the remote end closed the stream", u
->sink
->name
);
1737 pa_sink_suspend(u
->sink
, true, PA_SUSPEND_USER
);
1742 /* Run from main thread */
1743 static pa_hook_result_t
device_connection_changed_cb(pa_bluetooth_discovery
*y
, const pa_bluetooth_device
*d
, struct userdata
*u
) {
1747 if (d
!= u
->device
|| pa_bluetooth_device_any_transport_connected(d
))
1750 pa_log_debug("Unloading module for device %s", d
->path
);
1751 pa_module_unload(u
->core
, u
->module
, true);
1756 /* Run from main thread */
1757 static pa_hook_result_t
transport_state_changed_cb(pa_bluetooth_discovery
*y
, pa_bluetooth_transport
*t
, struct userdata
*u
) {
1761 if (t
== u
->transport
&& t
->state
<= PA_BLUETOOTH_TRANSPORT_STATE_DISCONNECTED
)
1762 pa_assert_se(pa_card_set_profile(u
->card
, pa_hashmap_get(u
->card
->profiles
, "off"), false) >= 0);
1764 if (t
->device
== u
->device
)
1765 handle_transport_state_change(u
, t
);
1770 /* Run from main thread context */
1771 static int device_process_msg(pa_msgobject
*obj
, int code
, void *data
, int64_t offset
, pa_memchunk
*chunk
) {
1772 struct bluetooth_msg
*u
= BLUETOOTH_MSG(obj
);
1775 case BLUETOOTH_MESSAGE_IO_THREAD_FAILED
:
1776 if (u
->card
->module
->unload_requested
)
1779 pa_log_debug("Switching the profile to off due to IO thread failure.");
1780 pa_assert_se(pa_card_set_profile(u
->card
, pa_hashmap_get(u
->card
->profiles
, "off"), false) >= 0);
1787 int pa__init(pa_module
* m
) {
1794 m
->userdata
= u
= pa_xnew0(struct userdata
, 1);
1798 if (!(ma
= pa_modargs_new(m
->argument
, valid_modargs
))) {
1799 pa_log_error("Failed to parse module arguments");
1803 if (!(path
= pa_modargs_get_value(ma
, "path", NULL
))) {
1804 pa_log_error("Failed to get device path from module arguments");
1808 if ((u
->discovery
= pa_shared_get(u
->core
, "bluetooth-discovery")))
1809 pa_bluetooth_discovery_ref(u
->discovery
);
1811 pa_log_error("module-bluez5-discover doesn't seem to be loaded, refusing to load module-bluez5-device");
1815 if (!(u
->device
= pa_bluetooth_discovery_get_device_by_path(u
->discovery
, path
))) {
1816 pa_log_error("%s is unknown", path
);
1820 pa_modargs_free(ma
);
1822 u
->device_connection_changed_slot
=
1823 pa_hook_connect(pa_bluetooth_discovery_hook(u
->discovery
, PA_BLUETOOTH_HOOK_DEVICE_CONNECTION_CHANGED
),
1824 PA_HOOK_NORMAL
, (pa_hook_cb_t
) device_connection_changed_cb
, u
);
1826 u
->transport_state_changed_slot
=
1827 pa_hook_connect(pa_bluetooth_discovery_hook(u
->discovery
, PA_BLUETOOTH_HOOK_TRANSPORT_STATE_CHANGED
),
1828 PA_HOOK_NORMAL
, (pa_hook_cb_t
) transport_state_changed_cb
, u
);
1830 if (add_card(u
) < 0)
1833 if (!(u
->msg
= pa_msgobject_new(bluetooth_msg
)))
1836 u
->msg
->parent
.process_msg
= device_process_msg
;
1837 u
->msg
->card
= u
->card
;
1839 if (u
->profile
!= PA_BLUETOOTH_PROFILE_OFF
)
1840 if (init_profile(u
) < 0)
1843 if (u
->sink
|| u
->source
)
1844 if (start_thread(u
) < 0)
1852 pa_assert_se(pa_card_set_profile(u
->card
, pa_hashmap_get(u
->card
->profiles
, "off"), false) >= 0);
1859 pa_modargs_free(ma
);
1866 void pa__done(pa_module
*m
) {
1871 if (!(u
= m
->userdata
))
1876 if (u
->device_connection_changed_slot
)
1877 pa_hook_slot_free(u
->device_connection_changed_slot
);
1879 if (u
->transport_state_changed_slot
)
1880 pa_hook_slot_free(u
->transport_state_changed_slot
);
1882 if (u
->sbc_info
.buffer
)
1883 pa_xfree(u
->sbc_info
.buffer
);
1885 if (u
->sbc_info
.sbc_initialized
)
1886 sbc_finish(&u
->sbc_info
.sbc
);
1892 pa_card_free(u
->card
);
1895 pa_bluetooth_discovery_unref(u
->discovery
);
1897 pa_xfree(u
->output_port_name
);
1898 pa_xfree(u
->input_port_name
);
1903 int pa__get_n_used(pa_module
*m
) {
1907 pa_assert_se(u
= m
->userdata
);
1909 return (u
->sink
? pa_sink_linked_by(u
->sink
) : 0) + (u
->source
? pa_source_linked_by(u
->source
) : 0);