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
);
1098 /* We just read something, so we are supposed to write something, too */
1099 pending_read_bytes
+= n_read
;
1100 do_write
+= pending_read_bytes
/ u
->write_block_size
;
1101 pending_read_bytes
= pending_read_bytes
% u
->write_block_size
;
1105 if (u
->sink
&& PA_SINK_IS_LINKED(u
->sink
->thread_info
.state
)) {
1107 if (PA_UNLIKELY(u
->sink
->thread_info
.rewind_requested
))
1108 pa_sink_process_rewind(u
->sink
, 0);
1111 if (pollfd
->revents
& POLLOUT
)
1114 if ((!u
->source
|| !PA_SOURCE_IS_LINKED(u
->source
->thread_info
.state
)) && do_write
<= 0 && writable
) {
1115 pa_usec_t time_passed
;
1116 pa_usec_t audio_sent
;
1118 /* Hmm, there is no input stream we could synchronize
1119 * to. So let's do things by time */
1121 time_passed
= pa_rtclock_now() - u
->started_at
;
1122 audio_sent
= pa_bytes_to_usec(u
->write_index
, &u
->sample_spec
);
1124 if (audio_sent
<= time_passed
) {
1125 pa_usec_t audio_to_send
= time_passed
- audio_sent
;
1127 /* Never try to catch up for more than 100ms */
1128 if (u
->write_index
> 0 && audio_to_send
> MAX_PLAYBACK_CATCH_UP_USEC
) {
1129 pa_usec_t skip_usec
;
1130 uint64_t skip_bytes
;
1132 skip_usec
= audio_to_send
- MAX_PLAYBACK_CATCH_UP_USEC
;
1133 skip_bytes
= pa_usec_to_bytes(skip_usec
, &u
->sample_spec
);
1135 if (skip_bytes
> 0) {
1138 pa_log_warn("Skipping %llu us (= %llu bytes) in audio stream",
1139 (unsigned long long) skip_usec
,
1140 (unsigned long long) skip_bytes
);
1142 pa_sink_render_full(u
->sink
, skip_bytes
, &tmp
);
1143 pa_memblock_unref(tmp
.memblock
);
1144 u
->write_index
+= skip_bytes
;
1146 if (u
->profile
== PA_BLUETOOTH_PROFILE_A2DP_SINK
)
1147 a2dp_reduce_bitpool(u
);
1152 pending_read_bytes
= 0;
1156 if (writable
&& do_write
> 0) {
1159 if (u
->write_index
<= 0)
1160 u
->started_at
= pa_rtclock_now();
1162 if ((n_written
= a2dp_process_render(u
)) < 0)
1166 pa_log("Broken kernel: we got EAGAIN on write() after POLLOUT!");
1168 do_write
-= n_written
;
1172 if ((!u
->source
|| !PA_SOURCE_IS_LINKED(u
->source
->thread_info
.state
)) && do_write
<= 0) {
1173 pa_usec_t sleep_for
;
1174 pa_usec_t time_passed
, next_write_at
;
1177 /* Hmm, there is no input stream we could synchronize
1178 * to. So let's estimate when we need to wake up the latest */
1179 time_passed
= pa_rtclock_now() - u
->started_at
;
1180 next_write_at
= pa_bytes_to_usec(u
->write_index
, &u
->sample_spec
);
1181 sleep_for
= time_passed
< next_write_at
? next_write_at
- time_passed
: 0;
1182 /* 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); */
1184 /* drop stream every 500 ms */
1185 sleep_for
= PA_USEC_PER_MSEC
* 500;
1187 pa_rtpoll_set_timer_relative(u
->rtpoll
, sleep_for
);
1188 disable_timer
= false;
1194 pa_rtpoll_set_timer_disabled(u
->rtpoll
);
1196 /* Hmm, nothing to do. Let's sleep */
1198 pollfd
->events
= (short) (((u
->sink
&& PA_SINK_IS_LINKED(u
->sink
->thread_info
.state
) && !writable
) ? POLLOUT
: 0) |
1199 (u
->source
&& PA_SOURCE_IS_LINKED(u
->source
->thread_info
.state
) ? POLLIN
: 0));
1201 if ((ret
= pa_rtpoll_run(u
->rtpoll
, true)) < 0) {
1202 pa_log_debug("pa_rtpoll_run failed with: %d", ret
);
1206 pa_log_debug("IO thread shutdown requested, stopping cleanly");
1207 transport_release(u
);
1211 pollfd
= u
->rtpoll_item
? pa_rtpoll_item_get_pollfd(u
->rtpoll_item
, NULL
) : NULL
;
1213 if (pollfd
&& (pollfd
->revents
& ~(POLLOUT
|POLLIN
))) {
1214 pa_log_info("FD error: %s%s%s%s",
1215 pollfd
->revents
& POLLERR
? "POLLERR " :"",
1216 pollfd
->revents
& POLLHUP
? "POLLHUP " :"",
1217 pollfd
->revents
& POLLPRI
? "POLLPRI " :"",
1218 pollfd
->revents
& POLLNVAL
? "POLLNVAL " :"");
1225 /* In case of HUP, just tear down the streams */
1226 if (!pollfd
|| (pollfd
->revents
& POLLHUP
) == 0)
1230 pending_read_bytes
= 0;
1237 /* If this was no regular exit from the loop we have to continue processing messages until we receive PA_MESSAGE_SHUTDOWN */
1238 pa_log_debug("IO thread failed");
1239 pa_asyncmsgq_post(pa_thread_mq_get()->outq
, PA_MSGOBJECT(u
->msg
), BLUETOOTH_MESSAGE_IO_THREAD_FAILED
, NULL
, 0, NULL
, NULL
);
1240 pa_asyncmsgq_wait_for(u
->thread_mq
.inq
, PA_MESSAGE_SHUTDOWN
);
1243 pa_log_debug("IO thread shutting down");
1246 /* Run from main thread */
1247 static int start_thread(struct userdata
*u
) {
1249 pa_assert(!u
->thread
);
1250 pa_assert(!u
->rtpoll
);
1251 pa_assert(!u
->rtpoll_item
);
1253 u
->rtpoll
= pa_rtpoll_new();
1254 pa_thread_mq_init(&u
->thread_mq
, u
->core
->mainloop
, u
->rtpoll
);
1256 if (!(u
->thread
= pa_thread_new("bluetooth", thread_func
, u
))) {
1257 pa_log_error("Failed to create IO thread");
1262 pa_sink_set_asyncmsgq(u
->sink
, u
->thread_mq
.inq
);
1263 pa_sink_set_rtpoll(u
->sink
, u
->rtpoll
);
1264 pa_sink_put(u
->sink
);
1266 if (u
->sink
->set_volume
)
1267 u
->sink
->set_volume(u
->sink
);
1271 pa_source_set_asyncmsgq(u
->source
, u
->thread_mq
.inq
);
1272 pa_source_set_rtpoll(u
->source
, u
->rtpoll
);
1273 pa_source_put(u
->source
);
1275 if (u
->source
->set_volume
)
1276 u
->source
->set_volume(u
->source
);
1282 /* Run from main thread */
1283 static void stop_thread(struct userdata
*u
) {
1287 pa_sink_unlink(u
->sink
);
1290 pa_source_unlink(u
->source
);
1293 pa_asyncmsgq_send(u
->thread_mq
.inq
, NULL
, PA_MESSAGE_SHUTDOWN
, NULL
, 0, NULL
);
1294 pa_thread_free(u
->thread
);
1298 if (u
->rtpoll_item
) {
1299 pa_rtpoll_item_free(u
->rtpoll_item
);
1300 u
->rtpoll_item
= NULL
;
1304 pa_thread_mq_done(&u
->thread_mq
);
1305 pa_rtpoll_free(u
->rtpoll
);
1310 transport_release(u
);
1311 u
->transport
= NULL
;
1315 pa_sink_unref(u
->sink
);
1320 pa_source_unref(u
->source
);
1324 if (u
->read_smoother
) {
1325 pa_smoother_free(u
->read_smoother
);
1326 u
->read_smoother
= NULL
;
1330 /* Run from main thread */
1331 static char *cleanup_name(const char *name
) {
1337 while ((*name
>= 1 && *name
<= 32) || *name
>= 127)
1340 t
= pa_xstrdup(name
);
1342 for (s
= d
= t
; *s
; s
++) {
1344 if (*s
<= 32 || *s
>= 127 || *s
== '_') {
1362 /* Run from main thread */
1363 static pa_direction_t
get_profile_direction(pa_bluetooth_profile_t p
) {
1364 static const pa_direction_t profile_direction
[] = {
1365 [PA_BLUETOOTH_PROFILE_A2DP_SINK
] = PA_DIRECTION_OUTPUT
,
1366 [PA_BLUETOOTH_PROFILE_A2DP_SOURCE
] = PA_DIRECTION_INPUT
,
1367 [PA_BLUETOOTH_PROFILE_OFF
] = 0
1370 return profile_direction
[p
];
1373 /* Run from main thread */
1374 static pa_available_t
get_port_availability(struct userdata
*u
, pa_direction_t direction
) {
1375 pa_available_t result
= PA_AVAILABLE_NO
;
1379 pa_assert(u
->device
);
1381 for (i
= 0; i
< PA_BLUETOOTH_PROFILE_COUNT
; i
++) {
1382 pa_bluetooth_transport
*transport
;
1384 if (!(get_profile_direction(i
) & direction
))
1387 if (!(transport
= u
->device
->transports
[i
]))
1390 switch(transport
->state
) {
1391 case PA_BLUETOOTH_TRANSPORT_STATE_DISCONNECTED
:
1394 case PA_BLUETOOTH_TRANSPORT_STATE_IDLE
:
1395 if (result
== PA_AVAILABLE_NO
)
1396 result
= PA_AVAILABLE_UNKNOWN
;
1400 case PA_BLUETOOTH_TRANSPORT_STATE_PLAYING
:
1401 return PA_AVAILABLE_YES
;
1408 /* Run from main thread */
1409 static pa_available_t
transport_state_to_availability(pa_bluetooth_transport_state_t state
) {
1411 case PA_BLUETOOTH_TRANSPORT_STATE_DISCONNECTED
:
1412 return PA_AVAILABLE_NO
;
1413 case PA_BLUETOOTH_TRANSPORT_STATE_PLAYING
:
1414 return PA_AVAILABLE_YES
;
1416 return PA_AVAILABLE_UNKNOWN
;
1420 /* Run from main thread */
1421 static void create_card_ports(struct userdata
*u
, pa_hashmap
*ports
) {
1422 pa_device_port
*port
;
1423 pa_device_port_new_data port_data
;
1424 const char *name_prefix
, *input_description
, *output_description
;
1428 pa_assert(u
->device
);
1430 name_prefix
= "unknown";
1431 input_description
= _("Bluetooth Input");
1432 output_description
= _("Bluetooth Output");
1434 switch (form_factor_from_class(u
->device
->class_of_device
)) {
1435 case PA_BLUETOOTH_FORM_FACTOR_HEADSET
:
1436 name_prefix
= "headset";
1437 input_description
= output_description
= _("Headset");
1440 case PA_BLUETOOTH_FORM_FACTOR_HANDSFREE
:
1441 name_prefix
= "handsfree";
1442 input_description
= output_description
= _("Handsfree");
1445 case PA_BLUETOOTH_FORM_FACTOR_MICROPHONE
:
1446 name_prefix
= "microphone";
1447 input_description
= _("Microphone");
1448 output_description
= _("Bluetooth Output");
1451 case PA_BLUETOOTH_FORM_FACTOR_SPEAKER
:
1452 name_prefix
= "speaker";
1453 input_description
= _("Bluetooth Input");
1454 output_description
= _("Speaker");
1457 case PA_BLUETOOTH_FORM_FACTOR_HEADPHONE
:
1458 name_prefix
= "headphone";
1459 input_description
= _("Bluetooth Input");
1460 output_description
= _("Headphone");
1463 case PA_BLUETOOTH_FORM_FACTOR_PORTABLE
:
1464 name_prefix
= "portable";
1465 input_description
= output_description
= _("Portable");
1468 case PA_BLUETOOTH_FORM_FACTOR_CAR
:
1469 name_prefix
= "car";
1470 input_description
= output_description
= _("Car");
1473 case PA_BLUETOOTH_FORM_FACTOR_HIFI
:
1474 name_prefix
= "hifi";
1475 input_description
= output_description
= _("HiFi");
1478 case PA_BLUETOOTH_FORM_FACTOR_PHONE
:
1479 name_prefix
= "phone";
1480 input_description
= output_description
= _("Phone");
1483 case PA_BLUETOOTH_FORM_FACTOR_UNKNOWN
:
1484 name_prefix
= "unknown";
1485 input_description
= _("Bluetooth Input");
1486 output_description
= _("Bluetooth Output");
1490 u
->output_port_name
= pa_sprintf_malloc("%s-output", name_prefix
);
1491 pa_device_port_new_data_init(&port_data
);
1492 pa_device_port_new_data_set_name(&port_data
, u
->output_port_name
);
1493 pa_device_port_new_data_set_description(&port_data
, output_description
);
1494 pa_device_port_new_data_set_direction(&port_data
, PA_DIRECTION_OUTPUT
);
1495 pa_device_port_new_data_set_available(&port_data
, get_port_availability(u
, PA_DIRECTION_OUTPUT
));
1496 pa_assert_se(port
= pa_device_port_new(u
->core
, &port_data
, 0));
1497 pa_assert_se(pa_hashmap_put(ports
, port
->name
, port
) >= 0);
1498 pa_device_port_new_data_done(&port_data
);
1500 u
->input_port_name
= pa_sprintf_malloc("%s-input", name_prefix
);
1501 pa_device_port_new_data_init(&port_data
);
1502 pa_device_port_new_data_set_name(&port_data
, u
->input_port_name
);
1503 pa_device_port_new_data_set_description(&port_data
, input_description
);
1504 pa_device_port_new_data_set_direction(&port_data
, PA_DIRECTION_INPUT
);
1505 pa_device_port_new_data_set_available(&port_data
, get_port_availability(u
, PA_DIRECTION_INPUT
));
1506 pa_assert_se(port
= pa_device_port_new(u
->core
, &port_data
, 0));
1507 pa_assert_se(pa_hashmap_put(ports
, port
->name
, port
) >= 0);
1508 pa_device_port_new_data_done(&port_data
);
1511 /* Run from main thread */
1512 static pa_card_profile
*create_card_profile(struct userdata
*u
, const char *uuid
, pa_hashmap
*ports
) {
1513 pa_device_port
*input_port
, *output_port
;
1514 pa_card_profile
*cp
= NULL
;
1515 pa_bluetooth_profile_t
*p
;
1517 pa_assert(u
->input_port_name
);
1518 pa_assert(u
->output_port_name
);
1519 pa_assert_se(input_port
= pa_hashmap_get(ports
, u
->input_port_name
));
1520 pa_assert_se(output_port
= pa_hashmap_get(ports
, u
->output_port_name
));
1522 if (pa_streq(uuid
, PA_BLUETOOTH_UUID_A2DP_SINK
)) {
1523 /* TODO: Change this profile's name to a2dp_sink, to reflect the remote
1524 * device's role and be consistent with the a2dp source profile */
1525 cp
= pa_card_profile_new("a2dp", _("High Fidelity Playback (A2DP Sink)"), sizeof(pa_bluetooth_profile_t
));
1529 cp
->max_sink_channels
= 2;
1530 cp
->max_source_channels
= 0;
1531 pa_hashmap_put(output_port
->profiles
, cp
->name
, cp
);
1533 p
= PA_CARD_PROFILE_DATA(cp
);
1534 *p
= PA_BLUETOOTH_PROFILE_A2DP_SINK
;
1535 } else if (pa_streq(uuid
, PA_BLUETOOTH_UUID_A2DP_SOURCE
)) {
1536 cp
= pa_card_profile_new("a2dp_source", _("High Fidelity Capture (A2DP Source)"), sizeof(pa_bluetooth_profile_t
));
1540 cp
->max_sink_channels
= 0;
1541 cp
->max_source_channels
= 2;
1542 pa_hashmap_put(input_port
->profiles
, cp
->name
, cp
);
1544 p
= PA_CARD_PROFILE_DATA(cp
);
1545 *p
= PA_BLUETOOTH_PROFILE_A2DP_SOURCE
;
1548 if (cp
&& u
->device
->transports
[*p
])
1549 cp
->available
= transport_state_to_availability(u
->device
->transports
[*p
]->state
);
1554 /* Run from main thread */
1555 static int set_profile_cb(pa_card
*c
, pa_card_profile
*new_profile
) {
1557 pa_bluetooth_profile_t
*p
;
1560 pa_assert(new_profile
);
1561 pa_assert_se(u
= c
->userdata
);
1563 p
= PA_CARD_PROFILE_DATA(new_profile
);
1565 if (*p
!= PA_BLUETOOTH_PROFILE_OFF
) {
1566 const pa_bluetooth_device
*d
= u
->device
;
1568 if (!d
->transports
[*p
] || d
->transports
[*p
]->state
<= PA_BLUETOOTH_TRANSPORT_STATE_DISCONNECTED
) {
1569 pa_log_warn("Refused to switch profile to %s: Not connected", new_profile
->name
);
1578 if (u
->profile
!= PA_BLUETOOTH_PROFILE_OFF
)
1579 if (init_profile(u
) < 0)
1582 if (u
->sink
|| u
->source
)
1583 if (start_thread(u
) < 0)
1591 pa_assert_se(pa_card_set_profile(u
->card
, "off", false) >= 0);
1596 /* Run from main thread */
1597 static int add_card(struct userdata
*u
) {
1598 const pa_bluetooth_device
*d
;
1599 pa_card_new_data data
;
1601 pa_bluetooth_form_factor_t ff
;
1602 pa_card_profile
*cp
;
1603 pa_bluetooth_profile_t
*p
;
1608 pa_assert(u
->device
);
1612 pa_card_new_data_init(&data
);
1613 data
.driver
= __FILE__
;
1614 data
.module
= u
->module
;
1616 alias
= cleanup_name(d
->alias
);
1617 pa_proplist_sets(data
.proplist
, PA_PROP_DEVICE_DESCRIPTION
, alias
);
1620 pa_proplist_sets(data
.proplist
, PA_PROP_DEVICE_STRING
, d
->address
);
1621 pa_proplist_sets(data
.proplist
, PA_PROP_DEVICE_API
, "bluez");
1622 pa_proplist_sets(data
.proplist
, PA_PROP_DEVICE_CLASS
, "sound");
1623 pa_proplist_sets(data
.proplist
, PA_PROP_DEVICE_BUS
, "bluetooth");
1625 if ((ff
= form_factor_from_class(d
->class_of_device
)) != PA_BLUETOOTH_FORM_FACTOR_UNKNOWN
)
1626 pa_proplist_sets(data
.proplist
, PA_PROP_DEVICE_FORM_FACTOR
, form_factor_to_string(ff
));
1628 pa_proplist_sets(data
.proplist
, "bluez.path", d
->path
);
1629 pa_proplist_setf(data
.proplist
, "bluez.class", "0x%06x", d
->class_of_device
);
1630 pa_proplist_sets(data
.proplist
, "bluez.alias", d
->alias
);
1631 data
.name
= pa_sprintf_malloc("bluez_card.%s", d
->address
);
1632 data
.namereg_fail
= false;
1634 create_card_ports(u
, data
.ports
);
1636 PA_HASHMAP_FOREACH(uuid
, d
->uuids
, state
) {
1637 cp
= create_card_profile(u
, uuid
, data
.ports
);
1642 if (pa_hashmap_get(data
.profiles
, cp
->name
)) {
1643 pa_card_profile_free(cp
);
1647 pa_hashmap_put(data
.profiles
, cp
->name
, cp
);
1650 pa_assert(!pa_hashmap_isempty(data
.profiles
));
1652 cp
= pa_card_profile_new("off", _("Off"), sizeof(pa_bluetooth_profile_t
));
1653 cp
->available
= PA_AVAILABLE_YES
;
1654 p
= PA_CARD_PROFILE_DATA(cp
);
1655 *p
= PA_BLUETOOTH_PROFILE_OFF
;
1656 pa_hashmap_put(data
.profiles
, cp
->name
, cp
);
1658 u
->card
= pa_card_new(u
->core
, &data
);
1659 pa_card_new_data_done(&data
);
1661 pa_log("Failed to allocate card.");
1665 u
->card
->userdata
= u
;
1666 u
->card
->set_profile
= set_profile_cb
;
1668 p
= PA_CARD_PROFILE_DATA(u
->card
->active_profile
);
1674 /* Run from main thread */
1675 static void handle_transport_state_change(struct userdata
*u
, struct pa_bluetooth_transport
*t
) {
1676 bool acquire
= false;
1677 bool release
= false;
1678 pa_card_profile
*cp
;
1679 pa_device_port
*port
;
1684 /* Update profile availability */
1685 if (!(cp
= pa_hashmap_get(u
->card
->profiles
, pa_bluetooth_profile_to_string(t
->profile
))))
1687 pa_card_profile_set_available(cp
, transport_state_to_availability(t
->state
));
1689 /* Update port availability */
1690 pa_assert_se(port
= pa_hashmap_get(u
->card
->ports
, u
->output_port_name
));
1691 pa_device_port_set_available(port
, get_port_availability(u
, PA_DIRECTION_OUTPUT
));
1692 pa_assert_se(port
= pa_hashmap_get(u
->card
->ports
, u
->input_port_name
));
1693 pa_device_port_set_available(port
, get_port_availability(u
, PA_DIRECTION_INPUT
));
1695 /* Acquire or release transport as needed */
1696 acquire
= (t
->state
== PA_BLUETOOTH_TRANSPORT_STATE_PLAYING
&& u
->profile
== t
->profile
);
1697 release
= (t
->state
!= PA_BLUETOOTH_TRANSPORT_STATE_PLAYING
&& u
->profile
== t
->profile
);
1699 if (acquire
&& transport_acquire(u
, true) >= 0) {
1701 pa_log_debug("Resuming source %s because its transport state changed to playing", u
->source
->name
);
1703 /* We remove the IDLE suspend cause, because otherwise
1704 * module-loopback doesn't uncork its streams. FIXME: Messing with
1705 * the IDLE suspend cause here is wrong, the correct way to handle
1706 * this would probably be to uncork the loopback streams not only
1707 * when the other end is unsuspended, but also when the other end's
1708 * suspend cause changes to IDLE only (currently there's no
1709 * notification mechanism for suspend cause changes, though). */
1710 pa_source_suspend(u
->source
, false, PA_SUSPEND_IDLE
|PA_SUSPEND_USER
);
1714 pa_log_debug("Resuming sink %s because its transport state changed to playing", u
->sink
->name
);
1716 /* FIXME: See the previous comment. */
1717 pa_sink_suspend(u
->sink
, false, PA_SUSPEND_IDLE
|PA_SUSPEND_USER
);
1721 if (release
&& u
->transport_acquired
) {
1722 /* FIXME: this release is racy, since the audio stream might have
1723 * been set up again in the meantime (but not processed yet by PA).
1724 * BlueZ should probably release the transport automatically, and in
1725 * that case we would just mark the transport as released */
1727 /* Remote side closed the stream so we consider it PA_SUSPEND_USER */
1729 pa_log_debug("Suspending source %s because the remote end closed the stream", u
->source
->name
);
1730 pa_source_suspend(u
->source
, true, PA_SUSPEND_USER
);
1734 pa_log_debug("Suspending sink %s because the remote end closed the stream", u
->sink
->name
);
1735 pa_sink_suspend(u
->sink
, true, PA_SUSPEND_USER
);
1740 /* Run from main thread */
1741 static pa_hook_result_t
device_connection_changed_cb(pa_bluetooth_discovery
*y
, const pa_bluetooth_device
*d
, struct userdata
*u
) {
1745 if (d
!= u
->device
|| pa_bluetooth_device_any_transport_connected(d
))
1748 pa_log_debug("Unloading module for device %s", d
->path
);
1749 pa_module_unload(u
->core
, u
->module
, true);
1754 /* Run from main thread */
1755 static pa_hook_result_t
transport_state_changed_cb(pa_bluetooth_discovery
*y
, pa_bluetooth_transport
*t
, struct userdata
*u
) {
1759 if (t
== u
->transport
&& t
->state
<= PA_BLUETOOTH_TRANSPORT_STATE_DISCONNECTED
)
1760 pa_assert_se(pa_card_set_profile(u
->card
, "off", false) >= 0);
1762 if (t
->device
== u
->device
)
1763 handle_transport_state_change(u
, t
);
1768 /* Run from main thread context */
1769 static int device_process_msg(pa_msgobject
*obj
, int code
, void *data
, int64_t offset
, pa_memchunk
*chunk
) {
1770 struct bluetooth_msg
*u
= BLUETOOTH_MSG(obj
);
1773 case BLUETOOTH_MESSAGE_IO_THREAD_FAILED
:
1774 if (u
->card
->module
->unload_requested
)
1777 pa_log_debug("Switching the profile to off due to IO thread failure.");
1778 pa_assert_se(pa_card_set_profile(u
->card
, "off", false) >= 0);
1785 int pa__init(pa_module
* m
) {
1792 m
->userdata
= u
= pa_xnew0(struct userdata
, 1);
1796 if (!(ma
= pa_modargs_new(m
->argument
, valid_modargs
))) {
1797 pa_log_error("Failed to parse module arguments");
1801 if (!(path
= pa_modargs_get_value(ma
, "path", NULL
))) {
1802 pa_log_error("Failed to get device path from module arguments");
1806 if ((u
->discovery
= pa_shared_get(u
->core
, "bluetooth-discovery")))
1807 pa_bluetooth_discovery_ref(u
->discovery
);
1809 pa_log_error("module-bluez5-discover doesn't seem to be loaded, refusing to load module-bluez5-device");
1813 if (!(u
->device
= pa_bluetooth_discovery_get_device_by_path(u
->discovery
, path
))) {
1814 pa_log_error("%s is unknown", path
);
1818 pa_modargs_free(ma
);
1820 u
->device_connection_changed_slot
=
1821 pa_hook_connect(pa_bluetooth_discovery_hook(u
->discovery
, PA_BLUETOOTH_HOOK_DEVICE_CONNECTION_CHANGED
),
1822 PA_HOOK_NORMAL
, (pa_hook_cb_t
) device_connection_changed_cb
, u
);
1824 u
->transport_state_changed_slot
=
1825 pa_hook_connect(pa_bluetooth_discovery_hook(u
->discovery
, PA_BLUETOOTH_HOOK_TRANSPORT_STATE_CHANGED
),
1826 PA_HOOK_NORMAL
, (pa_hook_cb_t
) transport_state_changed_cb
, u
);
1828 if (add_card(u
) < 0)
1831 if (!(u
->msg
= pa_msgobject_new(bluetooth_msg
)))
1834 u
->msg
->parent
.process_msg
= device_process_msg
;
1835 u
->msg
->card
= u
->card
;
1837 if (u
->profile
!= PA_BLUETOOTH_PROFILE_OFF
)
1838 if (init_profile(u
) < 0)
1841 if (u
->sink
|| u
->source
)
1842 if (start_thread(u
) < 0)
1850 pa_assert_se(pa_card_set_profile(u
->card
, "off", false) >= 0);
1857 pa_modargs_free(ma
);
1864 void pa__done(pa_module
*m
) {
1869 if (!(u
= m
->userdata
))
1874 if (u
->device_connection_changed_slot
)
1875 pa_hook_slot_free(u
->device_connection_changed_slot
);
1877 if (u
->transport_state_changed_slot
)
1878 pa_hook_slot_free(u
->transport_state_changed_slot
);
1880 if (u
->sbc_info
.buffer
)
1881 pa_xfree(u
->sbc_info
.buffer
);
1883 if (u
->sbc_info
.sbc_initialized
)
1884 sbc_finish(&u
->sbc_info
.sbc
);
1890 pa_card_free(u
->card
);
1893 pa_bluetooth_discovery_unref(u
->discovery
);
1895 pa_xfree(u
->output_port_name
);
1896 pa_xfree(u
->input_port_name
);
1901 int pa__get_n_used(pa_module
*m
) {
1905 pa_assert_se(u
= m
->userdata
);
1907 return (u
->sink
? pa_sink_linked_by(u
->sink
) : 0) + (u
->source
? pa_source_linked_by(u
->source
) : 0);