2 This file is part of PulseAudio.
4 Copyright 2008 Joao Paulo Rechi Vita
6 PulseAudio is free software; you can redistribute it and/or modify
7 it under the terms of the GNU Lesser General Public License as
8 published by the Free Software Foundation; either version 2.1 of the
9 License, or (at your option) any later version.
11 PulseAudio is distributed in the hope that it will be useful, but
12 WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 General Public License for more details.
16 You should have received a copy of the GNU Lesser General Public
17 License along with PulseAudio; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
29 #include <sys/ioctl.h>
30 #include <linux/sockios.h>
31 #include <arpa/inet.h>
33 #include <pulse/xmalloc.h>
34 #include <pulse/timeval.h>
35 #include <pulse/sample.h>
36 #include <pulse/i18n.h>
38 #include <pulsecore/module.h>
39 #include <pulsecore/modargs.h>
40 #include <pulsecore/core-util.h>
41 #include <pulsecore/core-error.h>
42 #include <pulsecore/socket-util.h>
43 #include <pulsecore/thread.h>
44 #include <pulsecore/thread-mq.h>
45 #include <pulsecore/rtpoll.h>
46 #include <pulsecore/time-smoother.h>
47 #include <pulsecore/rtclock.h>
48 #include <pulsecore/namereg.h>
50 #include <modules/dbus-util.h>
52 #include "module-bluetooth-device-symdef.h"
56 #include "bluetooth-util.h"
58 #define MAX_BITPOOL 64
59 #define MIN_BITPOOL 2U
61 PA_MODULE_AUTHOR("Joao Paulo Rechi Vita");
62 PA_MODULE_DESCRIPTION("Bluetooth audio sink and source");
63 PA_MODULE_VERSION(PACKAGE_VERSION
);
64 PA_MODULE_LOAD_ONCE(FALSE
);
66 "name=<name for the card/sink/source, to be prefixed> "
67 "card_name=<name for the card> "
68 "sink_name=<name for the sink> "
69 "source_name=<name for the source> "
70 "address=<address of the device> "
73 "channels=<number of channels> "
74 "path=<device object path> "
75 "sco_sink=<SCO over PCM sink name> "
76 "sco_source=<SCO over PCM source name>");
78 /* TODO: not close fd when entering suspend mode in a2dp */
80 static const char* const valid_modargs
[] = {
96 sbc_capabilities_t sbc_capabilities
;
97 sbc_t sbc
; /* Codec data */
98 pa_bool_t sbc_initialized
; /* Keep track if the encoder is initialized */
99 size_t codesize
; /* SBC codesize */
101 void* buffer
; /* Codec transfer buffer */
102 size_t buffer_size
; /* Size of the buffer */
104 uint16_t seq_num
; /* Cumulative packet sequence */
108 pcm_capabilities_t pcm_capabilities
;
110 pa_source
*sco_source
;
111 pa_hook_slot
*sink_state_changed_slot
;
112 pa_hook_slot
*source_state_changed_slot
;
129 pa_thread_mq thread_mq
;
131 pa_rtpoll_item
*rtpoll_item
;
134 uint64_t read_index
, write_index
;
135 pa_usec_t started_at
;
136 pa_smoother
*read_smoother
;
138 pa_memchunk write_memchunk
;
140 pa_sample_spec sample_spec
, requested_sample_spec
;
148 struct a2dp_info a2dp
;
150 pa_dbus_connection
*connection
;
152 enum profile profile
;
156 pa_bluetooth_device
*device
;
158 int stream_write_type
, stream_read_type
;
159 int service_write_type
, service_read_type
;
162 #define USE_SCO_OVER_PCM(u) (u->profile == PROFILE_HSP && (u->hsp.sco_sink && u->hsp.sco_source))
164 static int init_bt(struct userdata
*u
);
165 static int init_profile(struct userdata
*u
);
167 static int service_send(struct userdata
*u
, const bt_audio_msg_header_t
*msg
) {
171 pa_assert(u
->service_fd
>= 0);
173 pa_assert(msg
->length
> 0);
175 pa_log_debug("Sending %s -> %s",
176 pa_strnull(bt_audio_strtype(msg
->type
)),
177 pa_strnull(bt_audio_strname(msg
->name
)));
179 if ((r
= pa_loop_write(u
->service_fd
, msg
, msg
->length
, &u
->service_write_type
)) == (ssize_t
) msg
->length
)
183 pa_log_error("Error sending data to audio service: %s", pa_cstrerror(errno
));
185 pa_log_error("Short write()");
190 static int service_recv(struct userdata
*u
, bt_audio_msg_header_t
*msg
, size_t room
) {
194 pa_assert(u
->service_fd
>= 0);
198 room
= BT_SUGGESTED_BUFFER_SIZE
;
200 pa_log_debug("Trying to receive message from audio service...");
202 /* First, read the header */
203 if ((r
= pa_loop_read(u
->service_fd
, msg
, sizeof(*msg
), &u
->service_read_type
)) != sizeof(*msg
))
206 if (msg
->length
< sizeof(*msg
)) {
207 pa_log_error("Invalid message size.");
211 /* Secondly, read the payload */
212 if (msg
->length
> sizeof(*msg
)) {
214 size_t remains
= msg
->length
- sizeof(*msg
);
216 if ((r
= pa_loop_read(u
->service_fd
,
217 (uint8_t*) msg
+ sizeof(*msg
),
219 &u
->service_read_type
)) != (ssize_t
) remains
)
223 pa_log_debug("Received %s <- %s",
224 pa_strnull(bt_audio_strtype(msg
->type
)),
225 pa_strnull(bt_audio_strname(msg
->name
)));
232 pa_log_error("Error receiving data from audio service: %s", pa_cstrerror(errno
));
234 pa_log_error("Short read()");
239 static ssize_t
service_expect(struct userdata
*u
, bt_audio_msg_header_t
*rsp
, size_t room
, uint8_t expected_name
, size_t expected_size
) {
243 pa_assert(u
->service_fd
>= 0);
246 if ((r
= service_recv(u
, rsp
, room
)) < 0)
249 if ((rsp
->type
!= BT_INDICATION
&& rsp
->type
!= BT_RESPONSE
) ||
250 rsp
->name
!= expected_name
||
251 (expected_size
> 0 && rsp
->length
!= expected_size
)) {
253 if (rsp
->type
== BT_ERROR
&& rsp
->length
== sizeof(bt_audio_error_t
))
254 pa_log_error("Received error condition: %s", pa_cstrerror(((bt_audio_error_t
*) rsp
)->posix_errno
));
256 pa_log_error("Bogus message %s received while %s was expected",
257 pa_strnull(bt_audio_strname(rsp
->name
)),
258 pa_strnull(bt_audio_strname(expected_name
)));
265 static int parse_caps(struct userdata
*u
, const struct bt_get_capabilities_rsp
*rsp
) {
267 const codec_capabilities_t
*codec
;
272 bytes_left
= rsp
->h
.length
- sizeof(*rsp
);
274 if (bytes_left
< sizeof(codec_capabilities_t
)) {
275 pa_log_error("Packet too small to store codec information.");
279 codec
= (codec_capabilities_t
*) rsp
->data
; /** ALIGNMENT? **/
281 pa_log_debug("Payload size is %lu %lu", (unsigned long) bytes_left
, (unsigned long) sizeof(*codec
));
283 if ((u
->profile
== PROFILE_A2DP
&& codec
->transport
!= BT_CAPABILITIES_TRANSPORT_A2DP
) ||
284 (u
->profile
== PROFILE_HSP
&& codec
->transport
!= BT_CAPABILITIES_TRANSPORT_SCO
)) {
285 pa_log_error("Got capabilities for wrong codec.");
289 if (u
->profile
== PROFILE_HSP
) {
291 if (bytes_left
<= 0 || codec
->length
!= sizeof(u
->hsp
.pcm_capabilities
))
294 pa_assert(codec
->type
== BT_HFP_CODEC_PCM
);
296 memcpy(&u
->hsp
.pcm_capabilities
, codec
, sizeof(u
->hsp
.pcm_capabilities
));
298 } else if (u
->profile
== PROFILE_A2DP
) {
300 while (bytes_left
> 0) {
301 if (codec
->type
== BT_A2DP_CODEC_SBC
)
304 bytes_left
-= codec
->length
;
305 codec
= (const codec_capabilities_t
*) ((const uint8_t*) codec
+ codec
->length
);
308 if (bytes_left
<= 0 || codec
->length
!= sizeof(u
->a2dp
.sbc_capabilities
))
311 pa_assert(codec
->type
== BT_A2DP_CODEC_SBC
);
313 memcpy(&u
->a2dp
.sbc_capabilities
, codec
, sizeof(u
->a2dp
.sbc_capabilities
));
319 static int get_caps(struct userdata
*u
) {
321 struct bt_get_capabilities_req getcaps_req
;
322 struct bt_get_capabilities_rsp getcaps_rsp
;
323 bt_audio_error_t error
;
324 uint8_t buf
[BT_SUGGESTED_BUFFER_SIZE
];
329 memset(&msg
, 0, sizeof(msg
));
330 msg
.getcaps_req
.h
.type
= BT_REQUEST
;
331 msg
.getcaps_req
.h
.name
= BT_GET_CAPABILITIES
;
332 msg
.getcaps_req
.h
.length
= sizeof(msg
.getcaps_req
);
334 pa_strlcpy(msg
.getcaps_req
.device
, u
->device
->address
, sizeof(msg
.getcaps_req
.device
));
335 if (u
->profile
== PROFILE_A2DP
)
336 msg
.getcaps_req
.transport
= BT_CAPABILITIES_TRANSPORT_A2DP
;
338 pa_assert(u
->profile
== PROFILE_HSP
);
339 msg
.getcaps_req
.transport
= BT_CAPABILITIES_TRANSPORT_SCO
;
341 msg
.getcaps_req
.flags
= BT_FLAG_AUTOCONNECT
;
343 if (service_send(u
, &msg
.getcaps_req
.h
) < 0)
346 if (service_expect(u
, &msg
.getcaps_rsp
.h
, sizeof(msg
), BT_GET_CAPABILITIES
, 0) < 0)
349 return parse_caps(u
, &msg
.getcaps_rsp
);
352 static uint8_t a2dp_default_bitpool(uint8_t freq
, uint8_t mode
) {
355 case BT_SBC_SAMPLING_FREQ_16000
:
356 case BT_SBC_SAMPLING_FREQ_32000
:
359 case BT_SBC_SAMPLING_FREQ_44100
:
362 case BT_A2DP_CHANNEL_MODE_MONO
:
363 case BT_A2DP_CHANNEL_MODE_DUAL_CHANNEL
:
366 case BT_A2DP_CHANNEL_MODE_STEREO
:
367 case BT_A2DP_CHANNEL_MODE_JOINT_STEREO
:
371 pa_log_warn("Invalid channel mode %u", mode
);
375 case BT_SBC_SAMPLING_FREQ_48000
:
378 case BT_A2DP_CHANNEL_MODE_MONO
:
379 case BT_A2DP_CHANNEL_MODE_DUAL_CHANNEL
:
382 case BT_A2DP_CHANNEL_MODE_STEREO
:
383 case BT_A2DP_CHANNEL_MODE_JOINT_STEREO
:
387 pa_log_warn("Invalid channel mode %u", mode
);
392 pa_log_warn("Invalid sampling freq %u", freq
);
397 static int setup_a2dp(struct userdata
*u
) {
398 sbc_capabilities_t
*cap
;
401 static const struct {
405 { 16000U, BT_SBC_SAMPLING_FREQ_16000
},
406 { 32000U, BT_SBC_SAMPLING_FREQ_32000
},
407 { 44100U, BT_SBC_SAMPLING_FREQ_44100
},
408 { 48000U, BT_SBC_SAMPLING_FREQ_48000
}
412 pa_assert(u
->profile
== PROFILE_A2DP
);
414 cap
= &u
->a2dp
.sbc_capabilities
;
416 /* Find the lowest freq that is at least as high as the requested
418 for (i
= 0; (unsigned) i
< PA_ELEMENTSOF(freq_table
); i
++)
419 if (freq_table
[i
].rate
>= u
->sample_spec
.rate
&& (cap
->frequency
& freq_table
[i
].cap
)) {
420 u
->sample_spec
.rate
= freq_table
[i
].rate
;
421 cap
->frequency
= freq_table
[i
].cap
;
425 if ((unsigned) i
>= PA_ELEMENTSOF(freq_table
)) {
426 for (; i
>= 0; i
--) {
427 if (cap
->frequency
& freq_table
[i
].cap
) {
428 u
->sample_spec
.rate
= freq_table
[i
].rate
;
429 cap
->frequency
= freq_table
[i
].cap
;
435 pa_log("Not suitable sample rate");
440 if (u
->sample_spec
.channels
<= 1) {
441 if (cap
->channel_mode
& BT_A2DP_CHANNEL_MODE_MONO
) {
442 cap
->channel_mode
= BT_A2DP_CHANNEL_MODE_MONO
;
443 u
->sample_spec
.channels
= 1;
445 u
->sample_spec
.channels
= 2;
448 if (u
->sample_spec
.channels
>= 2) {
449 u
->sample_spec
.channels
= 2;
451 if (cap
->channel_mode
& BT_A2DP_CHANNEL_MODE_JOINT_STEREO
)
452 cap
->channel_mode
= BT_A2DP_CHANNEL_MODE_JOINT_STEREO
;
453 else if (cap
->channel_mode
& BT_A2DP_CHANNEL_MODE_STEREO
)
454 cap
->channel_mode
= BT_A2DP_CHANNEL_MODE_STEREO
;
455 else if (cap
->channel_mode
& BT_A2DP_CHANNEL_MODE_DUAL_CHANNEL
)
456 cap
->channel_mode
= BT_A2DP_CHANNEL_MODE_DUAL_CHANNEL
;
457 else if (cap
->channel_mode
& BT_A2DP_CHANNEL_MODE_MONO
) {
458 cap
->channel_mode
= BT_A2DP_CHANNEL_MODE_MONO
;
459 u
->sample_spec
.channels
= 1;
461 pa_log("No supported channel modes");
466 if (cap
->block_length
& BT_A2DP_BLOCK_LENGTH_16
)
467 cap
->block_length
= BT_A2DP_BLOCK_LENGTH_16
;
468 else if (cap
->block_length
& BT_A2DP_BLOCK_LENGTH_12
)
469 cap
->block_length
= BT_A2DP_BLOCK_LENGTH_12
;
470 else if (cap
->block_length
& BT_A2DP_BLOCK_LENGTH_8
)
471 cap
->block_length
= BT_A2DP_BLOCK_LENGTH_8
;
472 else if (cap
->block_length
& BT_A2DP_BLOCK_LENGTH_4
)
473 cap
->block_length
= BT_A2DP_BLOCK_LENGTH_4
;
475 pa_log_error("No supported block lengths");
479 if (cap
->subbands
& BT_A2DP_SUBBANDS_8
)
480 cap
->subbands
= BT_A2DP_SUBBANDS_8
;
481 else if (cap
->subbands
& BT_A2DP_SUBBANDS_4
)
482 cap
->subbands
= BT_A2DP_SUBBANDS_4
;
484 pa_log_error("No supported subbands");
488 if (cap
->allocation_method
& BT_A2DP_ALLOCATION_LOUDNESS
)
489 cap
->allocation_method
= BT_A2DP_ALLOCATION_LOUDNESS
;
490 else if (cap
->allocation_method
& BT_A2DP_ALLOCATION_SNR
)
491 cap
->allocation_method
= BT_A2DP_ALLOCATION_SNR
;
493 cap
->min_bitpool
= (uint8_t) PA_MAX(MIN_BITPOOL
, cap
->min_bitpool
);
494 cap
->max_bitpool
= (uint8_t) PA_MIN(a2dp_default_bitpool(cap
->frequency
, cap
->channel_mode
), cap
->max_bitpool
);
499 static void setup_sbc(struct a2dp_info
*a2dp
) {
500 sbc_capabilities_t
*active_capabilities
;
504 active_capabilities
= &a2dp
->sbc_capabilities
;
506 if (a2dp
->sbc_initialized
)
507 sbc_reinit(&a2dp
->sbc
, 0);
509 sbc_init(&a2dp
->sbc
, 0);
510 a2dp
->sbc_initialized
= TRUE
;
512 switch (active_capabilities
->frequency
) {
513 case BT_SBC_SAMPLING_FREQ_16000
:
514 a2dp
->sbc
.frequency
= SBC_FREQ_16000
;
516 case BT_SBC_SAMPLING_FREQ_32000
:
517 a2dp
->sbc
.frequency
= SBC_FREQ_32000
;
519 case BT_SBC_SAMPLING_FREQ_44100
:
520 a2dp
->sbc
.frequency
= SBC_FREQ_44100
;
522 case BT_SBC_SAMPLING_FREQ_48000
:
523 a2dp
->sbc
.frequency
= SBC_FREQ_48000
;
526 pa_assert_not_reached();
529 switch (active_capabilities
->channel_mode
) {
530 case BT_A2DP_CHANNEL_MODE_MONO
:
531 a2dp
->sbc
.mode
= SBC_MODE_MONO
;
533 case BT_A2DP_CHANNEL_MODE_DUAL_CHANNEL
:
534 a2dp
->sbc
.mode
= SBC_MODE_DUAL_CHANNEL
;
536 case BT_A2DP_CHANNEL_MODE_STEREO
:
537 a2dp
->sbc
.mode
= SBC_MODE_STEREO
;
539 case BT_A2DP_CHANNEL_MODE_JOINT_STEREO
:
540 a2dp
->sbc
.mode
= SBC_MODE_JOINT_STEREO
;
543 pa_assert_not_reached();
546 switch (active_capabilities
->allocation_method
) {
547 case BT_A2DP_ALLOCATION_SNR
:
548 a2dp
->sbc
.allocation
= SBC_AM_SNR
;
550 case BT_A2DP_ALLOCATION_LOUDNESS
:
551 a2dp
->sbc
.allocation
= SBC_AM_LOUDNESS
;
554 pa_assert_not_reached();
557 switch (active_capabilities
->subbands
) {
558 case BT_A2DP_SUBBANDS_4
:
559 a2dp
->sbc
.subbands
= SBC_SB_4
;
561 case BT_A2DP_SUBBANDS_8
:
562 a2dp
->sbc
.subbands
= SBC_SB_8
;
565 pa_assert_not_reached();
568 switch (active_capabilities
->block_length
) {
569 case BT_A2DP_BLOCK_LENGTH_4
:
570 a2dp
->sbc
.blocks
= SBC_BLK_4
;
572 case BT_A2DP_BLOCK_LENGTH_8
:
573 a2dp
->sbc
.blocks
= SBC_BLK_8
;
575 case BT_A2DP_BLOCK_LENGTH_12
:
576 a2dp
->sbc
.blocks
= SBC_BLK_12
;
578 case BT_A2DP_BLOCK_LENGTH_16
:
579 a2dp
->sbc
.blocks
= SBC_BLK_16
;
582 pa_assert_not_reached();
585 a2dp
->sbc
.bitpool
= active_capabilities
->max_bitpool
;
586 a2dp
->codesize
= (uint16_t) sbc_get_codesize(&a2dp
->sbc
);
589 static int set_conf(struct userdata
*u
) {
591 struct bt_set_configuration_req setconf_req
;
592 struct bt_set_configuration_rsp setconf_rsp
;
593 bt_audio_error_t error
;
594 uint8_t buf
[BT_SUGGESTED_BUFFER_SIZE
];
597 if (u
->profile
== PROFILE_A2DP
) {
598 u
->sample_spec
.format
= PA_SAMPLE_S16LE
;
600 if (setup_a2dp(u
) < 0)
603 pa_assert(u
->profile
== PROFILE_HSP
);
605 u
->sample_spec
.format
= PA_SAMPLE_S16LE
;
606 u
->sample_spec
.channels
= 1;
607 u
->sample_spec
.rate
= 8000;
610 memset(&msg
, 0, sizeof(msg
));
611 msg
.setconf_req
.h
.type
= BT_REQUEST
;
612 msg
.setconf_req
.h
.name
= BT_SET_CONFIGURATION
;
613 msg
.setconf_req
.h
.length
= sizeof(msg
.setconf_req
);
615 pa_strlcpy(msg
.setconf_req
.device
, u
->device
->address
, sizeof(msg
.setconf_req
.device
));
616 msg
.setconf_req
.access_mode
= u
->profile
== PROFILE_A2DP
? BT_CAPABILITIES_ACCESS_MODE_WRITE
: BT_CAPABILITIES_ACCESS_MODE_READWRITE
;
618 msg
.setconf_req
.codec
.transport
= u
->profile
== PROFILE_A2DP
? BT_CAPABILITIES_TRANSPORT_A2DP
: BT_CAPABILITIES_TRANSPORT_SCO
;
620 if (u
->profile
== PROFILE_A2DP
) {
621 memcpy(&msg
.setconf_req
.codec
, &u
->a2dp
.sbc_capabilities
, sizeof(u
->a2dp
.sbc_capabilities
));
622 msg
.setconf_req
.h
.length
+= msg
.setconf_req
.codec
.length
- sizeof(msg
.setconf_req
.codec
);
625 if (service_send(u
, &msg
.setconf_req
.h
) < 0)
628 if (service_expect(u
, &msg
.setconf_rsp
.h
, sizeof(msg
), BT_SET_CONFIGURATION
, sizeof(msg
.setconf_rsp
)) < 0)
631 if ((u
->profile
== PROFILE_A2DP
&& msg
.setconf_rsp
.transport
!= BT_CAPABILITIES_TRANSPORT_A2DP
) ||
632 (u
->profile
== PROFILE_HSP
&& msg
.setconf_rsp
.transport
!= BT_CAPABILITIES_TRANSPORT_SCO
)) {
633 pa_log("Transport doesn't match what we requested.");
637 if ((u
->profile
== PROFILE_A2DP
&& msg
.setconf_rsp
.access_mode
!= BT_CAPABILITIES_ACCESS_MODE_WRITE
) ||
638 (u
->profile
== PROFILE_HSP
&& msg
.setconf_rsp
.access_mode
!= BT_CAPABILITIES_ACCESS_MODE_READWRITE
)) {
639 pa_log("Access mode doesn't match what we requested.");
643 u
->link_mtu
= msg
.setconf_rsp
.link_mtu
;
645 /* setup SBC encoder now we agree on parameters */
646 if (u
->profile
== PROFILE_A2DP
) {
648 u
->block_size
= u
->a2dp
.codesize
;
649 pa_log_info("SBC parameters:\n\tallocation=%u\n\tsubbands=%u\n\tblocks=%u\n\tbitpool=%u\n",
650 u
->a2dp
.sbc
.allocation
, u
->a2dp
.sbc
.subbands
, u
->a2dp
.sbc
.blocks
, u
->a2dp
.sbc
.bitpool
);
652 u
->block_size
= u
->link_mtu
;
657 /* from IO thread, except in SCO over PCM */
658 static int start_stream_fd(struct userdata
*u
) {
660 bt_audio_msg_header_t rsp
;
661 struct bt_start_stream_req start_req
;
662 struct bt_start_stream_rsp start_rsp
;
663 struct bt_new_stream_ind streamfd_ind
;
664 bt_audio_error_t error
;
665 uint8_t buf
[BT_SUGGESTED_BUFFER_SIZE
];
667 struct pollfd
*pollfd
;
670 pa_assert(u
->rtpoll
);
671 pa_assert(!u
->rtpoll_item
);
672 pa_assert(u
->stream_fd
< 0);
674 memset(msg
.buf
, 0, BT_SUGGESTED_BUFFER_SIZE
);
675 msg
.start_req
.h
.type
= BT_REQUEST
;
676 msg
.start_req
.h
.name
= BT_START_STREAM
;
677 msg
.start_req
.h
.length
= sizeof(msg
.start_req
);
679 if (service_send(u
, &msg
.start_req
.h
) < 0)
682 if (service_expect(u
, &msg
.rsp
, sizeof(msg
), BT_START_STREAM
, sizeof(msg
.start_rsp
)) < 0)
685 if (service_expect(u
, &msg
.rsp
, sizeof(msg
), BT_NEW_STREAM
, sizeof(msg
.streamfd_ind
)) < 0)
688 if ((u
->stream_fd
= bt_audio_service_get_data_fd(u
->service_fd
)) < 0) {
689 pa_log("Failed to get stream fd from audio service.");
693 pa_make_fd_nonblock(u
->stream_fd
);
694 pa_make_socket_low_delay(u
->stream_fd
);
696 u
->rtpoll_item
= pa_rtpoll_item_new(u
->rtpoll
, PA_RTPOLL_NEVER
, 1);
697 pollfd
= pa_rtpoll_item_get_pollfd(u
->rtpoll_item
, NULL
);
698 pollfd
->fd
= u
->stream_fd
;
699 pollfd
->events
= pollfd
->revents
= 0;
708 static int stop_stream_fd(struct userdata
*u
) {
710 bt_audio_msg_header_t rsp
;
711 struct bt_stop_stream_req start_req
;
712 struct bt_stop_stream_rsp start_rsp
;
713 bt_audio_error_t error
;
714 uint8_t buf
[BT_SUGGESTED_BUFFER_SIZE
];
719 pa_assert(u
->rtpoll
);
720 pa_assert(u
->rtpoll_item
);
721 pa_assert(u
->stream_fd
>= 0);
723 pa_rtpoll_item_free(u
->rtpoll_item
);
724 u
->rtpoll_item
= NULL
;
726 memset(msg
.buf
, 0, BT_SUGGESTED_BUFFER_SIZE
);
727 msg
.start_req
.h
.type
= BT_REQUEST
;
728 msg
.start_req
.h
.name
= BT_STOP_STREAM
;
729 msg
.start_req
.h
.length
= sizeof(msg
.start_req
);
731 if (service_send(u
, &msg
.start_req
.h
) < 0 ||
732 service_expect(u
, &msg
.rsp
, sizeof(msg
), BT_STOP_STREAM
, sizeof(msg
.start_rsp
)) < 0)
735 pa_close(u
->stream_fd
);
741 static int sink_process_msg(pa_msgobject
*o
, int code
, void *data
, int64_t offset
, pa_memchunk
*chunk
) {
742 struct userdata
*u
= PA_SINK(o
)->userdata
;
743 pa_bool_t failed
= FALSE
;
746 pa_assert(u
->sink
== PA_SINK(o
));
748 pa_log_debug("got message: %d", code
);
751 case PA_SINK_MESSAGE_SET_STATE
:
753 switch ((pa_sink_state_t
) PA_PTR_TO_UINT(data
)) {
755 case PA_SINK_SUSPENDED
:
756 pa_assert(PA_SINK_IS_OPENED(u
->sink
->thread_info
.state
));
758 /* Stop the device if the source is suspended as well */
759 if (!u
->source
|| u
->source
->state
== PA_SOURCE_SUSPENDED
)
760 /* We deliberately ignore whether stopping
761 * actually worked. Since the stream_fd is
762 * closed it doesn't really matter */
768 case PA_SINK_RUNNING
:
769 if (u
->sink
->thread_info
.state
!= PA_SINK_SUSPENDED
)
772 /* Resume the device if the source was suspended as well */
773 if (!u
->source
|| u
->source
->state
== PA_SOURCE_SUSPENDED
)
774 if (start_stream_fd(u
) < 0)
777 u
->started_at
= pa_rtclock_usec();
780 case PA_SINK_UNLINKED
:
782 case PA_SINK_INVALID_STATE
:
787 case PA_SINK_MESSAGE_GET_LATENCY
: {
788 *((pa_usec_t
*) data
) = 0;
793 r
= pa_sink_process_msg(o
, code
, data
, offset
, chunk
);
795 return (r
< 0 || !failed
) ? r
: -1;
798 static int source_process_msg(pa_msgobject
*o
, int code
, void *data
, int64_t offset
, pa_memchunk
*chunk
) {
799 struct userdata
*u
= PA_SOURCE(o
)->userdata
;
800 pa_bool_t failed
= FALSE
;
803 pa_assert(u
->source
== PA_SOURCE(o
));
805 pa_log_debug("got message: %d", code
);
808 case PA_SOURCE_MESSAGE_SET_STATE
:
810 switch ((pa_source_state_t
) PA_PTR_TO_UINT(data
)) {
812 case PA_SOURCE_SUSPENDED
:
813 pa_assert(PA_SOURCE_IS_OPENED(u
->source
->thread_info
.state
));
815 /* Stop the device if the sink is suspended as well */
816 if (!u
->sink
|| u
->sink
->state
== PA_SINK_SUSPENDED
)
819 pa_smoother_pause(u
->read_smoother
, pa_rtclock_usec());
823 case PA_SOURCE_RUNNING
:
824 if (u
->source
->thread_info
.state
!= PA_SOURCE_SUSPENDED
)
827 /* Resume the device if the sink was suspended as well */
828 if (!u
->sink
|| u
->sink
->thread_info
.state
== PA_SINK_SUSPENDED
)
829 if (start_stream_fd(u
) < 0)
832 pa_smoother_resume(u
->read_smoother
, pa_rtclock_usec());
835 case PA_SOURCE_UNLINKED
:
837 case PA_SOURCE_INVALID_STATE
:
842 case PA_SOURCE_MESSAGE_GET_LATENCY
: {
843 *((pa_usec_t
*) data
) = 0;
849 r
= pa_source_process_msg(o
, code
, data
, offset
, chunk
);
851 return (r
< 0 || !failed
) ? r
: -1;
854 static int hsp_process_render(struct userdata
*u
) {
856 pa_memchunk memchunk
;
859 pa_assert(u
->profile
== PROFILE_HSP
);
862 pa_sink_render_full(u
->sink
, u
->block_size
, &memchunk
);
868 p
= (const uint8_t*) pa_memblock_acquire(memchunk
.memblock
) + memchunk
.index
;
869 l
= pa_write(u
->stream_fd
, p
, memchunk
.length
, &u
->stream_write_type
);
870 pa_memblock_release(memchunk
.memblock
);
872 pa_log_debug("Memblock written to socket: %lli bytes", (long long) l
);
877 if (errno
== EINTR
|| errno
== EAGAIN
) /*** FIXME: EAGAIN handling borked ***/
880 pa_log_error("Failed to write data to SCO socket: %s", pa_cstrerror(errno
));
885 pa_assert((size_t) l
<= memchunk
.length
);
887 memchunk
.index
+= (size_t) l
;
888 memchunk
.length
-= (size_t) l
;
890 u
->write_index
+= (uint64_t) l
;
892 if (memchunk
.length
<= 0)
897 pa_memblock_unref(memchunk
.memblock
);
902 static int hsp_process_push(struct userdata
*u
) {
904 pa_memchunk memchunk
;
907 pa_assert(u
->profile
== PROFILE_HSP
);
908 pa_assert(u
->source
);
910 memchunk
.memblock
= pa_memblock_new(u
->core
->mempool
, u
->block_size
);
911 memchunk
.index
= memchunk
.length
= 0;
917 p
= pa_memblock_acquire(memchunk
.memblock
);
918 l
= pa_read(u
->stream_fd
, p
, pa_memblock_get_length(memchunk
.memblock
), &u
->stream_read_type
);
919 pa_memblock_release(memchunk
.memblock
);
922 if (l
< 0 && (errno
== EINTR
|| errno
== EAGAIN
)) /*** FIXME: EAGAIN handling borked ***/
925 pa_log_error("Failed to read data from SCO socket: %s", l
< 0 ? pa_cstrerror(errno
) : "EOF");
930 memchunk
.length
= (size_t) l
;
931 u
->read_index
+= (uint64_t) l
;
933 pa_source_post(u
->source
, &memchunk
);
938 pa_memblock_unref(memchunk
.memblock
);
943 static int a2dp_process_render(struct userdata
*u
) {
945 struct a2dp_info
*a2dp
;
946 struct rtp_header
*header
;
947 struct rtp_payload
*payload
;
951 unsigned frame_count
;
956 pa_assert(u
->profile
== PROFILE_A2DP
);
961 if (a2dp
->buffer_size
< u
->link_mtu
) {
962 a2dp
->buffer_size
= 2*u
->link_mtu
;
963 pa_xfree(a2dp
->buffer
);
964 a2dp
->buffer
= pa_xmalloc(a2dp
->buffer_size
);
967 header
= (struct rtp_header
*) a2dp
->buffer
;
968 payload
= (struct rtp_payload
*) ((uint8_t*) a2dp
->buffer
+ sizeof(*header
));
969 d
= (uint8_t*) a2dp
->buffer
+ sizeof(*header
) + sizeof(*payload
);
970 left
= a2dp
->buffer_size
- sizeof(*header
) - sizeof(*payload
);
972 frame_size
= sbc_get_frame_length(&a2dp
->sbc
);
975 writing_at
= u
->write_index
;
980 if (!u
->write_memchunk
.memblock
)
981 pa_sink_render_full(u
->sink
, u
->block_size
, &u
->write_memchunk
);
983 p
= (const uint8_t*) pa_memblock_acquire(u
->write_memchunk
.memblock
) + u
->write_memchunk
.index
;
984 encoded
= sbc_encode(&a2dp
->sbc
,
985 p
, u
->write_memchunk
.length
,
990 pa_log_debug("Using SBC encoder implementation: %s", pa_strnull(sbc_get_implementation_info(&a2dp
->sbc
)));
993 pa_memblock_release(u
->write_memchunk
.memblock
);
996 pa_log_error("SBC encoding error (%d)", encoded
);
1000 pa_assert((size_t) encoded
<= u
->write_memchunk
.length
);
1001 pa_assert((size_t) encoded
== sbc_get_codesize(&a2dp
->sbc
));
1003 pa_assert((size_t) written
<= left
);
1004 pa_assert((size_t) written
== sbc_get_frame_length(&a2dp
->sbc
));
1006 /* pa_log_debug("SBC: encoded: %d; written: %d", encoded, written); */
1008 u
->write_memchunk
.index
+= encoded
;
1009 u
->write_memchunk
.length
-= encoded
;
1011 if (u
->write_memchunk
.length
<= 0) {
1012 pa_memblock_unref(u
->write_memchunk
.memblock
);
1013 pa_memchunk_reset(&u
->write_memchunk
);
1016 u
->write_index
+= encoded
;
1018 d
= (uint8_t*) d
+ written
;
1023 } while (((uint8_t*) d
- ((uint8_t*) a2dp
->buffer
+ sbc_get_frame_length(&a2dp
->sbc
))) < (ptrdiff_t) u
->link_mtu
);
1025 /* write it to the fifo */
1026 memset(a2dp
->buffer
, 0, sizeof(*header
) + sizeof(*payload
));
1027 payload
->frame_count
= frame_count
;
1030 header
->sequence_number
= htons(a2dp
->seq_num
++);
1031 header
->timestamp
= htonl(writing_at
/ frame_size
);
1032 header
->ssrc
= htonl(1);
1035 left
= (uint8_t*) d
- (uint8_t*) a2dp
->buffer
;
1040 l
= pa_write(u
->stream_fd
, p
, left
, &u
->stream_write_type
);
1041 /* pa_log_debug("write: requested %lu bytes; written %li bytes; mtu=%li", (unsigned long) left, (long) l, (unsigned long) u->link_mtu); */
1046 if (errno
== EINTR
|| errno
== EAGAIN
) /*** FIXME: EAGAIN handling borked ***/
1049 pa_log_error("Failed to write data to socket: %s", pa_cstrerror(errno
));
1053 pa_assert((size_t) l
<= left
);
1055 d
= (uint8_t*) d
+ l
;
1066 static void thread_func(void *userdata
) {
1067 struct userdata
*u
= userdata
;
1068 pa_bool_t do_write
= FALSE
, writable
= FALSE
;
1072 pa_log_debug("IO Thread starting up");
1074 if (u
->core
->realtime_scheduling
)
1075 pa_make_realtime(u
->core
->realtime_priority
);
1077 if (start_stream_fd(u
) < 0)
1080 pa_thread_mq_install(&u
->thread_mq
);
1081 pa_rtpoll_install(u
->rtpoll
);
1083 pa_smoother_set_time_offset(u
->read_smoother
, pa_rtclock_usec());
1086 struct pollfd
*pollfd
;
1088 pa_bool_t disable_timer
= TRUE
;
1090 pollfd
= u
->rtpoll_item
? pa_rtpoll_item_get_pollfd(u
->rtpoll_item
, NULL
) : NULL
;
1092 if (u
->source
&& PA_SOURCE_IS_LINKED(u
->source
->thread_info
.state
)) {
1094 if (pollfd
&& (pollfd
->revents
& POLLIN
)) {
1096 if (hsp_process_push(u
) < 0)
1099 /* We just read something, so we are supposed to write something, too */
1104 if (u
->sink
&& PA_SINK_IS_LINKED(u
->sink
->thread_info
.state
)) {
1106 if (u
->sink
->thread_info
.rewind_requested
)
1107 pa_sink_process_rewind(u
->sink
, 0);
1110 if (pollfd
->revents
& POLLOUT
)
1113 if ((!u
->source
|| !PA_SOURCE_IS_LINKED(u
->source
->thread_info
.state
)) && !do_write
&& writable
) {
1114 pa_usec_t time_passed
;
1115 uint64_t should_have_written
;
1117 /* Hmm, there is no input stream we could synchronize
1118 * to. So let's do things by time */
1120 time_passed
= pa_rtclock_usec() - u
->started_at
;
1121 should_have_written
= pa_usec_to_bytes(time_passed
, &u
->sink
->sample_spec
);
1123 do_write
= u
->write_index
<= should_have_written
;
1124 /* pa_log_debug("Time has come: %s", pa_yes_no(do_write)); */
1127 if (writable
&& do_write
) {
1128 if (u
->write_index
== 0)
1129 u
->started_at
= pa_rtclock_usec();
1131 if (u
->profile
== PROFILE_A2DP
) {
1132 if (a2dp_process_render(u
) < 0)
1135 if (hsp_process_render(u
) < 0)
1143 if ((!u
->source
|| !PA_SOURCE_IS_LINKED(u
->source
->thread_info
.state
)) && !do_write
) {
1144 pa_usec_t time_passed
, next_write_at
, sleep_for
;
1146 /* Hmm, there is no input stream we could synchronize
1147 * to. So let's estimate when we need to wake up the latest */
1149 time_passed
= pa_rtclock_usec() - u
->started_at
;
1150 next_write_at
= pa_bytes_to_usec(u
->write_index
, &u
->sink
->sample_spec
);
1151 sleep_for
= time_passed
< next_write_at
? next_write_at
- time_passed
: 0;
1153 /* 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); */
1155 pa_rtpoll_set_timer_relative(u
->rtpoll
, sleep_for
);
1156 disable_timer
= FALSE
;
1162 pa_rtpoll_set_timer_disabled(u
->rtpoll
);
1164 /* Hmm, nothing to do. Let's sleep */
1166 pollfd
->events
= (short) (((u
->sink
&& PA_SINK_IS_LINKED(u
->sink
->thread_info
.state
) && !writable
) ? POLLOUT
: 0) |
1167 (u
->source
&& PA_SOURCE_IS_LINKED(u
->source
->thread_info
.state
) ? POLLIN
: 0));
1169 if ((ret
= pa_rtpoll_run(u
->rtpoll
, TRUE
)) < 0)
1175 pollfd
= u
->rtpoll_item
? pa_rtpoll_item_get_pollfd(u
->rtpoll_item
, NULL
) : NULL
;
1177 if (pollfd
&& (pollfd
->revents
& ~(POLLOUT
|POLLIN
))) {
1178 pa_log_error("FD error.");
1184 /* If this was no regular exit from the loop we have to continue processing messages until we receive PA_MESSAGE_SHUTDOWN */
1185 pa_log_debug("IO thread failed");
1186 pa_asyncmsgq_post(u
->thread_mq
.outq
, PA_MSGOBJECT(u
->core
), PA_CORE_MESSAGE_UNLOAD_MODULE
, u
->module
, 0, NULL
, NULL
);
1187 pa_asyncmsgq_wait_for(u
->thread_mq
.inq
, PA_MESSAGE_SHUTDOWN
);
1190 pa_log_debug("IO thread shutting down");
1193 /* static DBusHandlerResult filter_cb(DBusConnection *bus, DBusMessage *msg, void *userdata) { */
1194 /* DBusMessageIter arg_i; */
1195 /* DBusError err; */
1196 /* const char *value; */
1197 /* struct userdata *u; */
1199 /* pa_assert(bus); */
1200 /* pa_assert(msg); */
1201 /* pa_assert(userdata); */
1204 /* pa_log_debug("dbus: interface=%s, path=%s, member=%s\n", */
1205 /* dbus_message_get_interface(msg), */
1206 /* dbus_message_get_path(msg), */
1207 /* dbus_message_get_member(msg)); */
1209 /* dbus_error_init(&err); */
1211 /* if (!dbus_message_has_path(msg, u->path)) */
1214 /* if (dbus_message_is_signal(msg, "org.bluez.Headset", "PropertyChanged") || */
1215 /* dbus_message_is_signal(msg, "org.bluez.AudioSink", "PropertyChanged")) { */
1217 /* struct device *d; */
1218 /* const char *profile; */
1219 /* DBusMessageIter variant_i; */
1220 /* dbus_uint16_t gain; */
1222 /* if (!dbus_message_iter_init(msg, &arg_i)) { */
1223 /* pa_log("dbus: message has no parameters"); */
1227 /* if (dbus_message_iter_get_arg_type(&arg_i) != DBUS_TYPE_STRING) { */
1228 /* pa_log("Property name not a string."); */
1232 /* dbus_message_iter_get_basic(&arg_i, &value); */
1234 /* if (!dbus_message_iter_next(&arg_i)) { */
1235 /* pa_log("Property value missing"); */
1239 /* if (dbus_message_iter_get_arg_type(&arg_i) != DBUS_TYPE_VARIANT) { */
1240 /* pa_log("Property value not a variant."); */
1244 /* dbus_message_iter_recurse(&arg_i, &variant_i); */
1246 /* if (dbus_message_iter_get_arg_type(&variant_i) != DBUS_TYPE_UINT16) { */
1247 /* dbus_message_iter_get_basic(&variant_i, &gain); */
1249 /* if (pa_streq(value, "SpeakerGain")) { */
1250 /* pa_log("spk gain: %d", gain); */
1251 /* pa_cvolume_set(&u->sink->virtual_volume, 1, (pa_volume_t) (gain * PA_VOLUME_NORM / 15)); */
1252 /* pa_subscription_post(u->sink->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, u->sink->index); */
1254 /* pa_log("mic gain: %d", gain); */
1255 /* if (!u->source) */
1258 /* pa_cvolume_set(&u->source->virtual_volume, 1, (pa_volume_t) (gain * PA_VOLUME_NORM / 15)); */
1259 /* pa_subscription_post(u->source->core, PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_CHANGE, u->source->index); */
1265 /* dbus_error_free(&err); */
1266 /* return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; */
1269 /* static int sink_get_volume_cb(pa_sink *s) { */
1270 /* struct userdata *u = s->userdata; */
1273 /* /\* refresh? *\/ */
1278 /* static int source_get_volume_cb(pa_source *s) { */
1279 /* struct userdata *u = s->userdata; */
1282 /* /\* refresh? *\/ */
1287 /* static int sink_set_volume_cb(pa_sink *s) { */
1289 /* DBusMessage *m, *r; */
1290 /* DBusMessageIter it, itvar; */
1291 /* dbus_uint16_t vol; */
1292 /* const char *spkgain = "SpeakerGain"; */
1293 /* struct userdata *u = s->userdata; */
1296 /* dbus_error_init(&e); */
1298 /* vol = ((float) pa_cvolume_max(&s->virtual_volume) / PA_VOLUME_NORM) * 15; */
1299 /* pa_log_debug("set headset volume: %d", vol); */
1301 /* pa_assert_se(m = dbus_message_new_method_call("org.bluez", u->path, "org.bluez.Headset", "SetProperty")); */
1302 /* dbus_message_iter_init_append(m, &it); */
1303 /* dbus_message_iter_append_basic(&it, DBUS_TYPE_STRING, &spkgain); */
1304 /* dbus_message_iter_open_container(&it, DBUS_TYPE_VARIANT, DBUS_TYPE_UINT16_AS_STRING, &itvar); */
1305 /* dbus_message_iter_append_basic(&itvar, DBUS_TYPE_UINT16, &vol); */
1306 /* dbus_message_iter_close_container(&it, &itvar); */
1308 /* r = dbus_connection_send_with_reply_and_block(pa_dbus_connection_get(u->conn), m, -1, &e); */
1312 /* dbus_message_unref(m); */
1314 /* dbus_message_unref(r); */
1316 /* dbus_error_free(&e); */
1321 /* static int source_set_volume_cb(pa_source *s) { */
1322 /* dbus_uint16_t vol; */
1323 /* struct userdata *u = s->userdata; */
1326 /* vol = ((float)pa_cvolume_max(&s->virtual_volume) / PA_VOLUME_NORM) * 15; */
1328 /* pa_log_debug("set headset mic volume: %d (not implemented yet)", vol); */
1333 static char *get_name(const char *type
, pa_modargs
*ma
, const char *device_id
, pa_bool_t
*namereg_fail
) {
1339 pa_assert(device_id
);
1340 pa_assert(namereg_fail
);
1342 t
= pa_sprintf_malloc("%s_name", type
);
1343 n
= pa_modargs_get_value(ma
, t
, NULL
);
1347 *namereg_fail
= TRUE
;
1348 return pa_xstrdup(n
);
1351 if ((n
= pa_modargs_get_value(ma
, "name", NULL
)))
1352 *namereg_fail
= TRUE
;
1355 *namereg_fail
= FALSE
;
1358 return pa_sprintf_malloc("bluez_%s.%s", type
, n
);
1361 static void sco_over_pcm_state_update(struct userdata
*u
) {
1363 pa_assert(USE_SCO_OVER_PCM(u
));
1365 if (PA_SINK_IS_OPENED(pa_sink_get_state(u
->hsp
.sco_sink
)) ||
1366 PA_SOURCE_IS_OPENED(pa_source_get_state(u
->hsp
.sco_source
))) {
1368 if (u
->service_fd
>= 0)
1371 pa_log_debug("Resuming SCO over PCM");
1372 if ((init_bt(u
) < 0) || (init_profile(u
) < 0))
1373 pa_log("Can't resume SCO over PCM");
1378 if (u
->service_fd
< 0)
1383 pa_log_debug("Closing SCO over PCM");
1384 pa_close(u
->service_fd
);
1389 static pa_hook_result_t
sink_state_changed_cb(pa_core
*c
, pa_sink
*s
, struct userdata
*u
) {
1391 pa_sink_assert_ref(s
);
1394 if (s
!= u
->hsp
.sco_sink
)
1397 sco_over_pcm_state_update(u
);
1402 static pa_hook_result_t
source_state_changed_cb(pa_core
*c
, pa_source
*s
, struct userdata
*u
) {
1404 pa_source_assert_ref(s
);
1407 if (s
!= u
->hsp
.sco_source
)
1410 sco_over_pcm_state_update(u
);
1415 static int add_sink(struct userdata
*u
) {
1417 if (USE_SCO_OVER_PCM(u
)) {
1420 u
->sink
= u
->hsp
.sco_sink
;
1421 p
= pa_proplist_new();
1422 pa_proplist_sets(p
, "bluetooth.protocol", "sco");
1423 pa_proplist_update(u
->sink
->proplist
, PA_UPDATE_MERGE
, p
);
1424 pa_proplist_free(p
);
1426 if (!u
->hsp
.sink_state_changed_slot
)
1427 u
->hsp
.sink_state_changed_slot
= pa_hook_connect(&u
->core
->hooks
[PA_CORE_HOOK_SINK_STATE_CHANGED
], PA_HOOK_NORMAL
, (pa_hook_cb_t
) sink_state_changed_cb
, u
);
1430 pa_sink_new_data data
;
1433 pa_sink_new_data_init(&data
);
1434 data
.driver
= __FILE__
;
1435 data
.module
= u
->module
;
1436 pa_sink_new_data_set_sample_spec(&data
, &u
->sample_spec
);
1437 pa_proplist_sets(data
.proplist
, "bluetooth.protocol", u
->profile
== PROFILE_A2DP
? "a2dp" : "sco");
1438 data
.card
= u
->card
;
1439 data
.name
= get_name("sink", u
->modargs
, u
->device
->address
, &b
);
1440 data
.namereg_fail
= b
;
1442 u
->sink
= pa_sink_new(u
->core
, &data
, PA_SINK_HARDWARE
|PA_SINK_LATENCY
);
1443 pa_sink_new_data_done(&data
);
1446 pa_log_error("Failed to create sink");
1450 u
->sink
->userdata
= u
;
1451 u
->sink
->parent
.process_msg
= sink_process_msg
;
1454 /* u->sink->get_volume = sink_get_volume_cb; */
1455 /* u->sink->set_volume = sink_set_volume_cb; */
1460 static int add_source(struct userdata
*u
) {
1463 if (USE_SCO_OVER_PCM(u
)) {
1464 u
->source
= u
->hsp
.sco_source
;
1465 p
= pa_proplist_new();
1466 pa_proplist_sets(p
, "bluetooth.protocol", "sco");
1467 pa_proplist_update(u
->source
->proplist
, PA_UPDATE_MERGE
, p
);
1468 pa_proplist_free(p
);
1470 if (!u
->hsp
.source_state_changed_slot
)
1471 u
->hsp
.source_state_changed_slot
= pa_hook_connect(&u
->core
->hooks
[PA_CORE_HOOK_SOURCE_STATE_CHANGED
], PA_HOOK_NORMAL
, (pa_hook_cb_t
) source_state_changed_cb
, u
);
1474 pa_source_new_data data
;
1477 pa_source_new_data_init(&data
);
1478 data
.driver
= __FILE__
;
1479 data
.module
= u
->module
;
1480 pa_source_new_data_set_sample_spec(&data
, &u
->sample_spec
);
1481 pa_proplist_sets(data
.proplist
, "bluetooth.protocol", u
->profile
== PROFILE_A2DP
? "a2dp" : "sco");
1482 data
.card
= u
->card
;
1483 data
.name
= get_name("source", u
->modargs
, u
->device
->address
, &b
);
1484 data
.namereg_fail
= b
;
1486 u
->source
= pa_source_new(u
->core
, &data
, PA_SOURCE_HARDWARE
|PA_SOURCE_LATENCY
);
1487 pa_source_new_data_done(&data
);
1490 pa_log_error("Failed to create source");
1494 u
->source
->userdata
= u
;
1495 u
->source
->parent
.process_msg
= source_process_msg
;
1498 /* u->source->get_volume = source_get_volume_cb; */
1499 /* u->source->set_volume = source_set_volume_cb; */
1501 pa_proplist_sets(u
->source
->proplist
, "bluetooth.nrec", (u
->hsp
.pcm_capabilities
.flags
& BT_PCM_FLAG_NREC
) ? "1" : "0");
1506 static void shutdown_bt(struct userdata
*u
) {
1509 if (u
->stream_fd
>= 0) {
1510 pa_close(u
->stream_fd
);
1514 if (u
->service_fd
>= 0) {
1515 pa_close(u
->service_fd
);
1520 static int init_bt(struct userdata
*u
) {
1525 u
->stream_write_type
= u
->stream_read_type
= 0;
1526 u
->service_write_type
= u
->service_write_type
= 0;
1528 if ((u
->service_fd
= bt_audio_service_open()) < 0) {
1529 pa_log_error("Couldn't connect to bluetooth audio service");
1533 pa_log_debug("Connected to the bluetooth audio service");
1538 static int setup_bt(struct userdata
*u
) {
1541 if (get_caps(u
) < 0)
1544 pa_log_debug("Got device capabilities");
1546 if (set_conf(u
) < 0)
1549 pa_log_debug("Connection to the device configured");
1551 if (USE_SCO_OVER_PCM(u
)) {
1552 pa_log_debug("Configured to use SCO over PCM");
1556 pa_log_debug("Got the stream socket");
1561 static int init_profile(struct userdata
*u
) {
1564 pa_assert(u
->profile
!= PROFILE_OFF
);
1566 if (setup_bt(u
) < 0)
1569 if (u
->profile
== PROFILE_A2DP
||
1570 u
->profile
== PROFILE_HSP
)
1571 if (add_sink(u
) < 0)
1574 if (u
->profile
== PROFILE_HSP
)
1575 if (add_source(u
) < 0)
1581 static void stop_thread(struct userdata
*u
) {
1585 pa_asyncmsgq_send(u
->thread_mq
.inq
, NULL
, PA_MESSAGE_SHUTDOWN
, NULL
, 0, NULL
);
1586 pa_thread_free(u
->thread
);
1590 if (u
->rtpoll_item
) {
1591 pa_rtpoll_item_free(u
->rtpoll_item
);
1592 u
->rtpoll_item
= NULL
;
1595 if (u
->hsp
.sink_state_changed_slot
) {
1596 pa_hook_slot_free(u
->hsp
.sink_state_changed_slot
);
1597 u
->hsp
.sink_state_changed_slot
= NULL
;
1600 if (u
->hsp
.source_state_changed_slot
) {
1601 pa_hook_slot_free(u
->hsp
.source_state_changed_slot
);
1602 u
->hsp
.source_state_changed_slot
= NULL
;
1606 pa_sink_unref(u
->sink
);
1611 pa_source_unref(u
->source
);
1616 pa_thread_mq_done(&u
->thread_mq
);
1618 pa_rtpoll_free(u
->rtpoll
);
1623 static int start_thread(struct userdata
*u
) {
1625 pa_assert(!u
->thread
);
1626 pa_assert(!u
->rtpoll
);
1627 pa_assert(!u
->rtpoll_item
);
1629 u
->rtpoll
= pa_rtpoll_new();
1630 pa_thread_mq_init(&u
->thread_mq
, u
->core
->mainloop
, u
->rtpoll
);
1632 if (USE_SCO_OVER_PCM(u
)) {
1633 if (start_stream_fd(u
) < 0)
1636 pa_sink_ref(u
->sink
);
1637 pa_source_ref(u
->source
);
1638 /* FIXME: monitor stream_fd error */
1642 if (!(u
->thread
= pa_thread_new(thread_func
, u
))) {
1643 pa_log_error("Failed to create IO thread");
1649 pa_sink_set_asyncmsgq(u
->sink
, u
->thread_mq
.inq
);
1650 pa_sink_set_rtpoll(u
->sink
, u
->rtpoll
);
1651 pa_sink_put(u
->sink
);
1655 pa_source_set_asyncmsgq(u
->source
, u
->thread_mq
.inq
);
1656 pa_source_set_rtpoll(u
->source
, u
->rtpoll
);
1657 pa_source_put(u
->source
);
1663 static int card_set_profile(pa_card
*c
, pa_card_profile
*new_profile
) {
1666 pa_queue
*inputs
= NULL
, *outputs
= NULL
;
1669 pa_assert(new_profile
);
1670 pa_assert_se(u
= c
->userdata
);
1672 d
= PA_CARD_PROFILE_DATA(new_profile
);
1675 inputs
= pa_sink_move_all_start(u
->sink
);
1676 if (!USE_SCO_OVER_PCM(u
))
1677 pa_sink_unlink(u
->sink
);
1681 outputs
= pa_source_move_all_start(u
->source
);
1682 if (!USE_SCO_OVER_PCM(u
))
1683 pa_source_unlink(u
->source
);
1689 if (u
->write_memchunk
.memblock
) {
1690 pa_memblock_unref(u
->write_memchunk
.memblock
);
1691 pa_memchunk_reset(&u
->write_memchunk
);
1695 u
->sample_spec
= u
->requested_sample_spec
;
1699 if (u
->profile
!= PROFILE_OFF
)
1702 if (u
->sink
|| u
->source
)
1707 pa_sink_move_all_finish(u
->sink
, inputs
, FALSE
);
1709 pa_sink_move_all_fail(inputs
);
1714 pa_source_move_all_finish(u
->source
, outputs
, FALSE
);
1716 pa_source_move_all_fail(outputs
);
1722 static int add_card(struct userdata
*u
, const char * default_profile
) {
1723 pa_card_new_data data
;
1730 pa_card_new_data_init(&data
);
1731 data
.driver
= __FILE__
;
1732 data
.module
= u
->module
;
1734 n
= pa_bluetooth_cleanup_name(u
->device
->name
);
1735 pa_proplist_sets(data
.proplist
, PA_PROP_DEVICE_DESCRIPTION
, n
);
1737 pa_proplist_sets(data
.proplist
, PA_PROP_DEVICE_STRING
, u
->device
->address
);
1738 pa_proplist_sets(data
.proplist
, PA_PROP_DEVICE_API
, "bluez");
1739 pa_proplist_sets(data
.proplist
, PA_PROP_DEVICE_CLASS
, "sound");
1740 pa_proplist_sets(data
.proplist
, PA_PROP_DEVICE_BUS
, "bluetooth");
1741 if ((ff
= pa_bluetooth_get_form_factor(u
->device
->class)))
1742 pa_proplist_sets(data
.proplist
, PA_PROP_DEVICE_FORM_FACTOR
, ff
);
1743 pa_proplist_sets(data
.proplist
, "bluez.path", u
->device
->path
);
1744 pa_proplist_setf(data
.proplist
, "bluez.class", "0x%06x", (unsigned) u
->device
->class);
1745 pa_proplist_sets(data
.proplist
, "bluez.name", u
->device
->name
);
1746 data
.name
= get_name("card", u
->modargs
, u
->device
->address
, &b
);
1747 data
.namereg_fail
= b
;
1749 data
.profiles
= pa_hashmap_new(pa_idxset_string_hash_func
, pa_idxset_string_compare_func
);
1751 if (u
->device
->audio_sink_info_valid
> 0) {
1752 p
= pa_card_profile_new("a2dp", _("High Fidelity Playback (A2DP)"), sizeof(enum profile
));
1756 p
->max_sink_channels
= 2;
1757 p
->max_source_channels
= 0;
1759 d
= PA_CARD_PROFILE_DATA(p
);
1762 pa_hashmap_put(data
.profiles
, p
->name
, p
);
1765 if (u
->device
->headset_info_valid
> 0) {
1766 p
= pa_card_profile_new("hsp", _("Telephony Duplex (HSP/HFP)"), sizeof(enum profile
));
1770 p
->max_sink_channels
= 1;
1771 p
->max_source_channels
= 1;
1773 d
= PA_CARD_PROFILE_DATA(p
);
1776 pa_hashmap_put(data
.profiles
, p
->name
, p
);
1779 pa_assert(!pa_hashmap_isempty(data
.profiles
));
1781 p
= pa_card_profile_new("off", _("Off"), sizeof(enum profile
));
1782 d
= PA_CARD_PROFILE_DATA(p
);
1784 pa_hashmap_put(data
.profiles
, p
->name
, p
);
1786 if (default_profile
) {
1787 if (pa_hashmap_get(data
.profiles
, default_profile
))
1788 pa_card_new_data_set_profile(&data
, default_profile
);
1790 pa_log_warn("Profile '%s' not valid or not supported by device.", default_profile
);
1793 u
->card
= pa_card_new(u
->core
, &data
);
1794 pa_card_new_data_done(&data
);
1797 pa_log("Failed to allocate card.");
1801 u
->card
->userdata
= u
;
1802 u
->card
->set_profile
= card_set_profile
;
1804 d
= PA_CARD_PROFILE_DATA(u
->card
->active_profile
);
1810 static int setup_dbus(struct userdata
*u
) {
1813 dbus_error_init(&error
);
1815 u
->connection
= pa_dbus_bus_get(u
->core
, DBUS_BUS_SYSTEM
, &error
);
1816 if (dbus_error_is_set(&error
) || (!u
->connection
)) {
1817 pa_log("Failed to get D-Bus connection: %s", error
.message
);
1818 dbus_error_free(&error
);
1825 static int find_device(struct userdata
*u
, const char *address
, const char *path
) {
1828 if (!address
&& !path
) {
1829 pa_log_error("Failed to get device address/path from module arguments.");
1834 if (!(u
->device
= pa_bluetooth_get_device(pa_dbus_connection_get(u
->connection
), path
))) {
1835 pa_log_error("%s is not a valid BlueZ audio device.", path
);
1839 if (address
&& !(pa_streq(u
->device
->address
, address
))) {
1840 pa_log_error("Passed path %s and address %s don't match.", path
, address
);
1844 if (!(u
->device
= pa_bluetooth_find_device(pa_dbus_connection_get(u
->connection
), address
))) {
1845 pa_log_error("%s is not known.", address
);
1853 int pa__init(pa_module
* m
) {
1857 const char *address
, *path
;
1861 if (!(ma
= pa_modargs_new(m
->argument
, valid_modargs
))) {
1862 pa_log_error("Failed to parse module arguments");
1866 m
->userdata
= u
= pa_xnew0(struct userdata
, 1);
1871 u
->read_smoother
= pa_smoother_new(PA_USEC_PER_SEC
, PA_USEC_PER_SEC
*2, TRUE
, 10);
1872 u
->sample_spec
= m
->core
->default_sample_spec
;
1875 if (pa_modargs_get_value(ma
, "sco_sink", NULL
) &&
1876 !(u
->hsp
.sco_sink
= pa_namereg_get(m
->core
, pa_modargs_get_value(ma
, "sco_sink", NULL
), PA_NAMEREG_SINK
))) {
1877 pa_log("SCO sink not found");
1881 if (pa_modargs_get_value(ma
, "sco_source", NULL
) &&
1882 !(u
->hsp
.sco_source
= pa_namereg_get(m
->core
, pa_modargs_get_value(ma
, "sco_source", NULL
), PA_NAMEREG_SOURCE
))) {
1883 pa_log("SCO source not found");
1887 if (pa_modargs_get_value_u32(ma
, "rate", &u
->sample_spec
.rate
) < 0 ||
1888 u
->sample_spec
.rate
<= 0 || u
->sample_spec
.rate
> PA_RATE_MAX
) {
1889 pa_log_error("Failed to get rate from module arguments");
1893 channels
= u
->sample_spec
.channels
;
1894 if (pa_modargs_get_value_u32(ma
, "channels", &channels
) < 0 ||
1895 channels
<= 0 || channels
> PA_CHANNELS_MAX
) {
1896 pa_log_error("Failed to get channels from module arguments");
1899 u
->sample_spec
.channels
= (uint8_t) channels
;
1900 u
->requested_sample_spec
= u
->sample_spec
;
1902 if (setup_dbus(u
) < 0)
1905 address
= pa_modargs_get_value(ma
, "address", NULL
);
1906 path
= pa_modargs_get_value(ma
, "path", NULL
);
1908 if (find_device(u
, address
, path
) < 0)
1911 pa_assert(u
->device
);
1913 /* Add the card structure. This will also initialize the default profile */
1914 if (add_card(u
, pa_modargs_get_value(ma
, "profile", NULL
)) < 0)
1917 /* Connect to the BT service and query capabilities */
1921 if (u
->profile
!= PROFILE_OFF
)
1922 if (init_profile(u
) < 0)
1925 /* if (u->path) { */
1926 /* DBusError err; */
1927 /* dbus_error_init(&err); */
1931 /* if (!dbus_connection_add_filter(pa_dbus_connection_get(u->conn), filter_cb, u, NULL)) { */
1932 /* pa_log_error("Failed to add filter function"); */
1936 /* if (u->transport == BT_CAPABILITIES_TRANSPORT_SCO || */
1937 /* u->transport == BT_CAPABILITIES_TRANSPORT_ANY) { */
1938 /* t = pa_sprintf_malloc("type='signal',sender='org.bluez',interface='org.bluez.Headset',member='PropertyChanged',path='%s'", u->path); */
1939 /* dbus_bus_add_match(pa_dbus_connection_get(u->conn), t, &err); */
1942 /* if (dbus_error_is_set(&err)) { */
1943 /* pa_log_error("Unable to subscribe to org.bluez.Headset signals: %s: %s", err.name, err.message); */
1948 /* if (u->transport == BT_CAPABILITIES_TRANSPORT_A2DP || */
1949 /* u->transport == BT_CAPABILITIES_TRANSPORT_ANY) { */
1950 /* t = pa_sprintf_malloc("type='signal',sender='org.bluez',interface='org.bluez.AudioSink',member='PropertyChanged',path='%s'", u->path); */
1951 /* dbus_bus_add_match(pa_dbus_connection_get(u->conn), t, &err); */
1954 /* if (dbus_error_is_set(&err)) { */
1955 /* pa_log_error("Unable to subscribe to org.bluez.AudioSink signals: %s: %s", err.name, err.message); */
1961 if (u
->sink
|| u
->source
)
1962 if (start_thread(u
) < 0)
1972 int pa__get_n_used(pa_module
*m
) {
1976 pa_assert_se(u
= m
->userdata
);
1979 (u
->sink
? pa_sink_linked_by(u
->sink
) : 0) +
1980 (u
->source
? pa_source_linked_by(u
->source
) : 0);
1983 void pa__done(pa_module
*m
) {
1987 if (!(u
= m
->userdata
))
1990 if (u
->sink
&& !USE_SCO_OVER_PCM(u
))
1991 pa_sink_unlink(u
->sink
);
1993 if (u
->source
&& !USE_SCO_OVER_PCM(u
))
1994 pa_source_unlink(u
->source
);
1998 if (u
->connection
) {
1999 /* DBusError error; */
2002 /* if (u->transport == BT_CAPABILITIES_TRANSPORT_SCO || */
2003 /* u->transport == BT_CAPABILITIES_TRANSPORT_ANY) { */
2005 /* t = pa_sprintf_malloc("type='signal',sender='org.bluez',interface='org.bluez.Headset',member='PropertyChanged',path='%s'", u->path); */
2006 /* dbus_error_init(&error); */
2007 /* dbus_bus_remove_match(pa_dbus_connection_get(u->conn), t, &error); */
2008 /* dbus_error_free(&error); */
2012 /* if (u->transport == BT_CAPABILITIES_TRANSPORT_A2DP || */
2013 /* u->transport == BT_CAPABILITIES_TRANSPORT_ANY) { */
2015 /* t = pa_sprintf_malloc("type='signal',sender='org.bluez',interface='org.bluez.AudioSink',member='PropertyChanged',path='%s'", u->path); */
2016 /* dbus_error_init(&error); */
2017 /* dbus_bus_remove_match(pa_dbus_connection_get(u->conn), t, &error); */
2018 /* dbus_error_free(&error); */
2022 /* dbus_connection_remove_filter(pa_dbus_connection_get(u->conn), filter_cb, u); */
2023 pa_dbus_connection_unref(u
->connection
);
2027 pa_card_free(u
->card
);
2029 if (u
->read_smoother
)
2030 pa_smoother_free(u
->read_smoother
);
2035 pa_bluetooth_device_free(u
->device
);
2037 if (u
->write_memchunk
.memblock
)
2038 pa_memblock_unref(u
->write_memchunk
.memblock
);
2041 pa_xfree(u
->a2dp
.buffer
);
2043 sbc_finish(&u
->a2dp
.sbc
);
2046 pa_modargs_free(u
->modargs
);