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>
49 #include <pulsecore/dbus-shared.h>
51 #include "module-bluetooth-device-symdef.h"
55 #include "bluetooth-util.h"
57 #define MAX_BITPOOL 64
58 #define MIN_BITPOOL 2U
60 PA_MODULE_AUTHOR("Joao Paulo Rechi Vita");
61 PA_MODULE_DESCRIPTION("Bluetooth audio sink and source");
62 PA_MODULE_VERSION(PACKAGE_VERSION
);
63 PA_MODULE_LOAD_ONCE(FALSE
);
65 "name=<name for the card/sink/source, to be prefixed> "
66 "card_name=<name for the card> "
67 "card_properties=<properties for the card> "
68 "sink_name=<name for the sink> "
69 "sink_properties=<properties for the sink> "
70 "source_name=<name for the source> "
71 "source_properties=<properties for the source> "
72 "address=<address of the device> "
75 "channels=<number of channels> "
76 "path=<device object path>");
80 "sco_sink=<SCO over PCM sink name> "
81 "sco_source=<SCO over PCM source name>"
85 /* TODO: not close fd when entering suspend mode in a2dp */
87 static const char* const valid_modargs
[] = {
108 sbc_capabilities_t sbc_capabilities
;
109 sbc_t sbc
; /* Codec data */
110 pa_bool_t sbc_initialized
; /* Keep track if the encoder is initialized */
111 size_t codesize
, frame_length
; /* SBC Codesize, frame_length. We simply cache those values here */
113 void* buffer
; /* Codec transfer buffer */
114 size_t buffer_size
; /* Size of the buffer */
116 uint16_t seq_num
; /* Cumulative packet sequence */
120 pcm_capabilities_t pcm_capabilities
;
123 pa_source
*sco_source
;
125 pa_hook_slot
*sink_state_changed_slot
;
126 pa_hook_slot
*source_state_changed_slot
;
141 pa_bluetooth_discovery
*discovery
;
143 pa_dbus_connection
*connection
;
149 pa_thread_mq thread_mq
;
151 pa_rtpoll_item
*rtpoll_item
;
154 uint64_t read_index
, write_index
;
155 pa_usec_t started_at
;
156 pa_smoother
*read_smoother
;
158 pa_memchunk write_memchunk
;
160 pa_sample_spec sample_spec
, requested_sample_spec
;
168 struct a2dp_info a2dp
;
171 enum profile profile
;
175 int stream_write_type
;
176 int service_write_type
, service_read_type
;
179 #define FIXED_LATENCY_PLAYBACK_A2DP (25*PA_USEC_PER_MSEC)
180 #define FIXED_LATENCY_PLAYBACK_HSP (125*PA_USEC_PER_MSEC)
181 #define FIXED_LATENCY_RECORD_HSP (25*PA_USEC_PER_MSEC)
183 #define MAX_PLAYBACK_CATCH_UP_USEC (100*PA_USEC_PER_MSEC)
186 #define USE_SCO_OVER_PCM(u) (u->profile == PROFILE_HSP && (u->hsp.sco_sink && u->hsp.sco_source))
189 static int init_bt(struct userdata
*u
);
190 static int init_profile(struct userdata
*u
);
192 static int service_send(struct userdata
*u
, const bt_audio_msg_header_t
*msg
) {
196 pa_assert(u
->service_fd
>= 0);
198 pa_assert(msg
->length
> 0);
200 pa_log_debug("Sending %s -> %s",
201 pa_strnull(bt_audio_strtype(msg
->type
)),
202 pa_strnull(bt_audio_strname(msg
->name
)));
204 if ((r
= pa_loop_write(u
->service_fd
, msg
, msg
->length
, &u
->service_write_type
)) == (ssize_t
) msg
->length
)
208 pa_log_error("Error sending data to audio service: %s", pa_cstrerror(errno
));
210 pa_log_error("Short write()");
215 static int service_recv(struct userdata
*u
, bt_audio_msg_header_t
*msg
, size_t room
) {
219 pa_assert(u
->service_fd
>= 0);
223 room
= BT_SUGGESTED_BUFFER_SIZE
;
225 pa_log_debug("Trying to receive message from audio service...");
227 /* First, read the header */
228 if ((r
= pa_loop_read(u
->service_fd
, msg
, sizeof(*msg
), &u
->service_read_type
)) != sizeof(*msg
))
231 if (msg
->length
< sizeof(*msg
)) {
232 pa_log_error("Invalid message size.");
236 /* Secondly, read the payload */
237 if (msg
->length
> sizeof(*msg
)) {
239 size_t remains
= msg
->length
- sizeof(*msg
);
241 if ((r
= pa_loop_read(u
->service_fd
,
242 (uint8_t*) msg
+ sizeof(*msg
),
244 &u
->service_read_type
)) != (ssize_t
) remains
)
248 pa_log_debug("Received %s <- %s",
249 pa_strnull(bt_audio_strtype(msg
->type
)),
250 pa_strnull(bt_audio_strname(msg
->name
)));
257 pa_log_error("Error receiving data from audio service: %s", pa_cstrerror(errno
));
259 pa_log_error("Short read()");
264 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
) {
268 pa_assert(u
->service_fd
>= 0);
271 if ((r
= service_recv(u
, rsp
, room
)) < 0)
274 if ((rsp
->type
!= BT_INDICATION
&& rsp
->type
!= BT_RESPONSE
) ||
275 rsp
->name
!= expected_name
||
276 (expected_size
> 0 && rsp
->length
!= expected_size
)) {
278 if (rsp
->type
== BT_ERROR
&& rsp
->length
== sizeof(bt_audio_error_t
))
279 pa_log_error("Received error condition: %s", pa_cstrerror(((bt_audio_error_t
*) rsp
)->posix_errno
));
281 pa_log_error("Bogus message %s received while %s was expected",
282 pa_strnull(bt_audio_strname(rsp
->name
)),
283 pa_strnull(bt_audio_strname(expected_name
)));
290 /* Run from main thread */
291 static int parse_caps(struct userdata
*u
, uint8_t seid
, const struct bt_get_capabilities_rsp
*rsp
) {
293 const codec_capabilities_t
*codec
;
298 bytes_left
= rsp
->h
.length
- sizeof(*rsp
);
300 if (bytes_left
< sizeof(codec_capabilities_t
)) {
301 pa_log_error("Packet too small to store codec information.");
305 codec
= (codec_capabilities_t
*) rsp
->data
; /** ALIGNMENT? **/
307 pa_log_debug("Payload size is %lu %lu", (unsigned long) bytes_left
, (unsigned long) sizeof(*codec
));
309 if ((u
->profile
== PROFILE_A2DP
&& codec
->transport
!= BT_CAPABILITIES_TRANSPORT_A2DP
) ||
310 (u
->profile
== PROFILE_HSP
&& codec
->transport
!= BT_CAPABILITIES_TRANSPORT_SCO
)) {
311 pa_log_error("Got capabilities for wrong codec.");
315 if (u
->profile
== PROFILE_HSP
) {
317 if (bytes_left
<= 0 || codec
->length
!= sizeof(u
->hsp
.pcm_capabilities
))
320 pa_assert(codec
->type
== BT_HFP_CODEC_PCM
);
322 if (codec
->configured
&& seid
== 0)
325 memcpy(&u
->hsp
.pcm_capabilities
, codec
, sizeof(u
->hsp
.pcm_capabilities
));
327 } else if (u
->profile
== PROFILE_A2DP
) {
329 while (bytes_left
> 0) {
330 if ((codec
->type
== BT_A2DP_SBC_SINK
) && !codec
->lock
)
333 bytes_left
-= codec
->length
;
334 codec
= (const codec_capabilities_t
*) ((const uint8_t*) codec
+ codec
->length
);
337 if (bytes_left
<= 0 || codec
->length
!= sizeof(u
->a2dp
.sbc_capabilities
))
340 pa_assert(codec
->type
== BT_A2DP_SBC_SINK
);
342 if (codec
->configured
&& seid
== 0)
345 memcpy(&u
->a2dp
.sbc_capabilities
, codec
, sizeof(u
->a2dp
.sbc_capabilities
));
351 /* Run from main thread */
352 static int get_caps(struct userdata
*u
, uint8_t seid
) {
354 struct bt_get_capabilities_req getcaps_req
;
355 struct bt_get_capabilities_rsp getcaps_rsp
;
356 bt_audio_error_t error
;
357 uint8_t buf
[BT_SUGGESTED_BUFFER_SIZE
];
363 memset(&msg
, 0, sizeof(msg
));
364 msg
.getcaps_req
.h
.type
= BT_REQUEST
;
365 msg
.getcaps_req
.h
.name
= BT_GET_CAPABILITIES
;
366 msg
.getcaps_req
.h
.length
= sizeof(msg
.getcaps_req
);
367 msg
.getcaps_req
.seid
= seid
;
369 pa_strlcpy(msg
.getcaps_req
.object
, u
->path
, sizeof(msg
.getcaps_req
.object
));
370 if (u
->profile
== PROFILE_A2DP
)
371 msg
.getcaps_req
.transport
= BT_CAPABILITIES_TRANSPORT_A2DP
;
373 pa_assert(u
->profile
== PROFILE_HSP
);
374 msg
.getcaps_req
.transport
= BT_CAPABILITIES_TRANSPORT_SCO
;
376 msg
.getcaps_req
.flags
= BT_FLAG_AUTOCONNECT
;
378 if (service_send(u
, &msg
.getcaps_req
.h
) < 0)
381 if (service_expect(u
, &msg
.getcaps_rsp
.h
, sizeof(msg
), BT_GET_CAPABILITIES
, 0) < 0)
384 ret
= parse_caps(u
, seid
, &msg
.getcaps_rsp
);
388 return get_caps(u
, ret
);
391 /* Run from main thread */
392 static uint8_t a2dp_default_bitpool(uint8_t freq
, uint8_t mode
) {
395 case BT_SBC_SAMPLING_FREQ_16000
:
396 case BT_SBC_SAMPLING_FREQ_32000
:
399 case BT_SBC_SAMPLING_FREQ_44100
:
402 case BT_A2DP_CHANNEL_MODE_MONO
:
403 case BT_A2DP_CHANNEL_MODE_DUAL_CHANNEL
:
406 case BT_A2DP_CHANNEL_MODE_STEREO
:
407 case BT_A2DP_CHANNEL_MODE_JOINT_STEREO
:
411 pa_log_warn("Invalid channel mode %u", mode
);
415 case BT_SBC_SAMPLING_FREQ_48000
:
418 case BT_A2DP_CHANNEL_MODE_MONO
:
419 case BT_A2DP_CHANNEL_MODE_DUAL_CHANNEL
:
422 case BT_A2DP_CHANNEL_MODE_STEREO
:
423 case BT_A2DP_CHANNEL_MODE_JOINT_STEREO
:
427 pa_log_warn("Invalid channel mode %u", mode
);
432 pa_log_warn("Invalid sampling freq %u", freq
);
437 /* Run from main thread */
438 static int setup_a2dp(struct userdata
*u
) {
439 sbc_capabilities_t
*cap
;
442 static const struct {
446 { 16000U, BT_SBC_SAMPLING_FREQ_16000
},
447 { 32000U, BT_SBC_SAMPLING_FREQ_32000
},
448 { 44100U, BT_SBC_SAMPLING_FREQ_44100
},
449 { 48000U, BT_SBC_SAMPLING_FREQ_48000
}
453 pa_assert(u
->profile
== PROFILE_A2DP
);
455 cap
= &u
->a2dp
.sbc_capabilities
;
457 /* Find the lowest freq that is at least as high as the requested
459 for (i
= 0; (unsigned) i
< PA_ELEMENTSOF(freq_table
); i
++)
460 if (freq_table
[i
].rate
>= u
->sample_spec
.rate
&& (cap
->frequency
& freq_table
[i
].cap
)) {
461 u
->sample_spec
.rate
= freq_table
[i
].rate
;
462 cap
->frequency
= freq_table
[i
].cap
;
466 if ((unsigned) i
== PA_ELEMENTSOF(freq_table
)) {
467 for (--i
; i
>= 0; i
--) {
468 if (cap
->frequency
& freq_table
[i
].cap
) {
469 u
->sample_spec
.rate
= freq_table
[i
].rate
;
470 cap
->frequency
= freq_table
[i
].cap
;
476 pa_log("Not suitable sample rate");
481 pa_assert((unsigned) i
< PA_ELEMENTSOF(freq_table
));
483 if (cap
->capability
.configured
)
486 if (u
->sample_spec
.channels
<= 1) {
487 if (cap
->channel_mode
& BT_A2DP_CHANNEL_MODE_MONO
) {
488 cap
->channel_mode
= BT_A2DP_CHANNEL_MODE_MONO
;
489 u
->sample_spec
.channels
= 1;
491 u
->sample_spec
.channels
= 2;
494 if (u
->sample_spec
.channels
>= 2) {
495 u
->sample_spec
.channels
= 2;
497 if (cap
->channel_mode
& BT_A2DP_CHANNEL_MODE_JOINT_STEREO
)
498 cap
->channel_mode
= BT_A2DP_CHANNEL_MODE_JOINT_STEREO
;
499 else if (cap
->channel_mode
& BT_A2DP_CHANNEL_MODE_STEREO
)
500 cap
->channel_mode
= BT_A2DP_CHANNEL_MODE_STEREO
;
501 else if (cap
->channel_mode
& BT_A2DP_CHANNEL_MODE_DUAL_CHANNEL
)
502 cap
->channel_mode
= BT_A2DP_CHANNEL_MODE_DUAL_CHANNEL
;
503 else if (cap
->channel_mode
& BT_A2DP_CHANNEL_MODE_MONO
) {
504 cap
->channel_mode
= BT_A2DP_CHANNEL_MODE_MONO
;
505 u
->sample_spec
.channels
= 1;
507 pa_log("No supported channel modes");
512 if (cap
->block_length
& BT_A2DP_BLOCK_LENGTH_16
)
513 cap
->block_length
= BT_A2DP_BLOCK_LENGTH_16
;
514 else if (cap
->block_length
& BT_A2DP_BLOCK_LENGTH_12
)
515 cap
->block_length
= BT_A2DP_BLOCK_LENGTH_12
;
516 else if (cap
->block_length
& BT_A2DP_BLOCK_LENGTH_8
)
517 cap
->block_length
= BT_A2DP_BLOCK_LENGTH_8
;
518 else if (cap
->block_length
& BT_A2DP_BLOCK_LENGTH_4
)
519 cap
->block_length
= BT_A2DP_BLOCK_LENGTH_4
;
521 pa_log_error("No supported block lengths");
525 if (cap
->subbands
& BT_A2DP_SUBBANDS_8
)
526 cap
->subbands
= BT_A2DP_SUBBANDS_8
;
527 else if (cap
->subbands
& BT_A2DP_SUBBANDS_4
)
528 cap
->subbands
= BT_A2DP_SUBBANDS_4
;
530 pa_log_error("No supported subbands");
534 if (cap
->allocation_method
& BT_A2DP_ALLOCATION_LOUDNESS
)
535 cap
->allocation_method
= BT_A2DP_ALLOCATION_LOUDNESS
;
536 else if (cap
->allocation_method
& BT_A2DP_ALLOCATION_SNR
)
537 cap
->allocation_method
= BT_A2DP_ALLOCATION_SNR
;
539 cap
->min_bitpool
= (uint8_t) PA_MAX(MIN_BITPOOL
, cap
->min_bitpool
);
540 cap
->max_bitpool
= (uint8_t) PA_MIN(a2dp_default_bitpool(cap
->frequency
, cap
->channel_mode
), cap
->max_bitpool
);
545 /* Run from main thread */
546 static void setup_sbc(struct a2dp_info
*a2dp
) {
547 sbc_capabilities_t
*active_capabilities
;
551 active_capabilities
= &a2dp
->sbc_capabilities
;
553 if (a2dp
->sbc_initialized
)
554 sbc_reinit(&a2dp
->sbc
, 0);
556 sbc_init(&a2dp
->sbc
, 0);
557 a2dp
->sbc_initialized
= TRUE
;
559 switch (active_capabilities
->frequency
) {
560 case BT_SBC_SAMPLING_FREQ_16000
:
561 a2dp
->sbc
.frequency
= SBC_FREQ_16000
;
563 case BT_SBC_SAMPLING_FREQ_32000
:
564 a2dp
->sbc
.frequency
= SBC_FREQ_32000
;
566 case BT_SBC_SAMPLING_FREQ_44100
:
567 a2dp
->sbc
.frequency
= SBC_FREQ_44100
;
569 case BT_SBC_SAMPLING_FREQ_48000
:
570 a2dp
->sbc
.frequency
= SBC_FREQ_48000
;
573 pa_assert_not_reached();
576 switch (active_capabilities
->channel_mode
) {
577 case BT_A2DP_CHANNEL_MODE_MONO
:
578 a2dp
->sbc
.mode
= SBC_MODE_MONO
;
580 case BT_A2DP_CHANNEL_MODE_DUAL_CHANNEL
:
581 a2dp
->sbc
.mode
= SBC_MODE_DUAL_CHANNEL
;
583 case BT_A2DP_CHANNEL_MODE_STEREO
:
584 a2dp
->sbc
.mode
= SBC_MODE_STEREO
;
586 case BT_A2DP_CHANNEL_MODE_JOINT_STEREO
:
587 a2dp
->sbc
.mode
= SBC_MODE_JOINT_STEREO
;
590 pa_assert_not_reached();
593 switch (active_capabilities
->allocation_method
) {
594 case BT_A2DP_ALLOCATION_SNR
:
595 a2dp
->sbc
.allocation
= SBC_AM_SNR
;
597 case BT_A2DP_ALLOCATION_LOUDNESS
:
598 a2dp
->sbc
.allocation
= SBC_AM_LOUDNESS
;
601 pa_assert_not_reached();
604 switch (active_capabilities
->subbands
) {
605 case BT_A2DP_SUBBANDS_4
:
606 a2dp
->sbc
.subbands
= SBC_SB_4
;
608 case BT_A2DP_SUBBANDS_8
:
609 a2dp
->sbc
.subbands
= SBC_SB_8
;
612 pa_assert_not_reached();
615 switch (active_capabilities
->block_length
) {
616 case BT_A2DP_BLOCK_LENGTH_4
:
617 a2dp
->sbc
.blocks
= SBC_BLK_4
;
619 case BT_A2DP_BLOCK_LENGTH_8
:
620 a2dp
->sbc
.blocks
= SBC_BLK_8
;
622 case BT_A2DP_BLOCK_LENGTH_12
:
623 a2dp
->sbc
.blocks
= SBC_BLK_12
;
625 case BT_A2DP_BLOCK_LENGTH_16
:
626 a2dp
->sbc
.blocks
= SBC_BLK_16
;
629 pa_assert_not_reached();
632 a2dp
->sbc
.bitpool
= active_capabilities
->max_bitpool
;
633 a2dp
->codesize
= sbc_get_codesize(&a2dp
->sbc
);
634 a2dp
->frame_length
= sbc_get_frame_length(&a2dp
->sbc
);
637 /* Run from main thread */
638 static int set_conf(struct userdata
*u
) {
640 struct bt_open_req open_req
;
641 struct bt_open_rsp open_rsp
;
642 struct bt_set_configuration_req setconf_req
;
643 struct bt_set_configuration_rsp setconf_rsp
;
644 bt_audio_error_t error
;
645 uint8_t buf
[BT_SUGGESTED_BUFFER_SIZE
];
648 memset(&msg
, 0, sizeof(msg
));
649 msg
.open_req
.h
.type
= BT_REQUEST
;
650 msg
.open_req
.h
.name
= BT_OPEN
;
651 msg
.open_req
.h
.length
= sizeof(msg
.open_req
);
653 pa_strlcpy(msg
.open_req
.object
, u
->path
, sizeof(msg
.open_req
.object
));
654 msg
.open_req
.seid
= u
->profile
== PROFILE_A2DP
? u
->a2dp
.sbc_capabilities
.capability
.seid
: BT_A2DP_SEID_RANGE
+ 1;
655 msg
.open_req
.lock
= u
->profile
== PROFILE_A2DP
? BT_WRITE_LOCK
: BT_READ_LOCK
| BT_WRITE_LOCK
;
657 if (service_send(u
, &msg
.open_req
.h
) < 0)
660 if (service_expect(u
, &msg
.open_rsp
.h
, sizeof(msg
), BT_OPEN
, sizeof(msg
.open_rsp
)) < 0)
663 if (u
->profile
== PROFILE_A2DP
) {
664 u
->sample_spec
.format
= PA_SAMPLE_S16LE
;
666 if (setup_a2dp(u
) < 0)
669 pa_assert(u
->profile
== PROFILE_HSP
);
671 u
->sample_spec
.format
= PA_SAMPLE_S16LE
;
672 u
->sample_spec
.channels
= 1;
673 u
->sample_spec
.rate
= 8000;
676 memset(&msg
, 0, sizeof(msg
));
677 msg
.setconf_req
.h
.type
= BT_REQUEST
;
678 msg
.setconf_req
.h
.name
= BT_SET_CONFIGURATION
;
679 msg
.setconf_req
.h
.length
= sizeof(msg
.setconf_req
);
681 if (u
->profile
== PROFILE_A2DP
) {
682 memcpy(&msg
.setconf_req
.codec
, &u
->a2dp
.sbc_capabilities
, sizeof(u
->a2dp
.sbc_capabilities
));
684 msg
.setconf_req
.codec
.transport
= BT_CAPABILITIES_TRANSPORT_SCO
;
685 msg
.setconf_req
.codec
.seid
= BT_A2DP_SEID_RANGE
+ 1;
686 msg
.setconf_req
.codec
.length
= sizeof(pcm_capabilities_t
);
688 msg
.setconf_req
.h
.length
+= msg
.setconf_req
.codec
.length
- sizeof(msg
.setconf_req
.codec
);
690 if (service_send(u
, &msg
.setconf_req
.h
) < 0)
693 if (service_expect(u
, &msg
.setconf_rsp
.h
, sizeof(msg
), BT_SET_CONFIGURATION
, sizeof(msg
.setconf_rsp
)) < 0)
696 u
->link_mtu
= msg
.setconf_rsp
.link_mtu
;
698 /* setup SBC encoder now we agree on parameters */
699 if (u
->profile
== PROFILE_A2DP
) {
703 ((u
->link_mtu
- sizeof(struct rtp_header
) - sizeof(struct rtp_payload
))
704 / u
->a2dp
.frame_length
707 pa_log_info("SBC parameters:\n\tallocation=%u\n\tsubbands=%u\n\tblocks=%u\n\tbitpool=%u\n",
708 u
->a2dp
.sbc
.allocation
, u
->a2dp
.sbc
.subbands
, u
->a2dp
.sbc
.blocks
, u
->a2dp
.sbc
.bitpool
);
710 u
->block_size
= u
->link_mtu
;
715 /* from IO thread, except in SCO over PCM */
716 static int start_stream_fd(struct userdata
*u
) {
718 bt_audio_msg_header_t rsp
;
719 struct bt_start_stream_req start_req
;
720 struct bt_start_stream_rsp start_rsp
;
721 struct bt_new_stream_ind streamfd_ind
;
722 bt_audio_error_t error
;
723 uint8_t buf
[BT_SUGGESTED_BUFFER_SIZE
];
725 struct pollfd
*pollfd
;
729 pa_assert(u
->rtpoll
);
730 pa_assert(!u
->rtpoll_item
);
731 pa_assert(u
->stream_fd
< 0);
733 memset(msg
.buf
, 0, BT_SUGGESTED_BUFFER_SIZE
);
734 msg
.start_req
.h
.type
= BT_REQUEST
;
735 msg
.start_req
.h
.name
= BT_START_STREAM
;
736 msg
.start_req
.h
.length
= sizeof(msg
.start_req
);
738 if (service_send(u
, &msg
.start_req
.h
) < 0)
741 if (service_expect(u
, &msg
.rsp
, sizeof(msg
), BT_START_STREAM
, sizeof(msg
.start_rsp
)) < 0)
744 if (service_expect(u
, &msg
.rsp
, sizeof(msg
), BT_NEW_STREAM
, sizeof(msg
.streamfd_ind
)) < 0)
747 if ((u
->stream_fd
= bt_audio_service_get_data_fd(u
->service_fd
)) < 0) {
748 pa_log("Failed to get stream fd from audio service.");
752 pa_make_fd_nonblock(u
->stream_fd
);
753 pa_make_socket_low_delay(u
->stream_fd
);
756 if (setsockopt(u
->stream_fd
, SOL_SOCKET
, SO_TIMESTAMP
, &one
, sizeof(one
)) < 0)
757 pa_log_warn("Failed to enable SO_TIMESTAMP: %s", pa_cstrerror(errno
));
759 pa_log_debug("Stream properly set up, we're ready to roll!");
761 u
->rtpoll_item
= pa_rtpoll_item_new(u
->rtpoll
, PA_RTPOLL_NEVER
, 1);
762 pollfd
= pa_rtpoll_item_get_pollfd(u
->rtpoll_item
, NULL
);
763 pollfd
->fd
= u
->stream_fd
;
764 pollfd
->events
= pollfd
->revents
= 0;
766 u
->read_index
= u
->write_index
= 0;
770 u
->read_smoother
= pa_smoother_new(
783 static int stop_stream_fd(struct userdata
*u
) {
785 bt_audio_msg_header_t rsp
;
786 struct bt_stop_stream_req start_req
;
787 struct bt_stop_stream_rsp start_rsp
;
788 bt_audio_error_t error
;
789 uint8_t buf
[BT_SUGGESTED_BUFFER_SIZE
];
794 pa_assert(u
->rtpoll
);
795 pa_assert(u
->rtpoll_item
);
796 pa_assert(u
->stream_fd
>= 0);
798 pa_rtpoll_item_free(u
->rtpoll_item
);
799 u
->rtpoll_item
= NULL
;
801 memset(msg
.buf
, 0, BT_SUGGESTED_BUFFER_SIZE
);
802 msg
.start_req
.h
.type
= BT_REQUEST
;
803 msg
.start_req
.h
.name
= BT_STOP_STREAM
;
804 msg
.start_req
.h
.length
= sizeof(msg
.start_req
);
806 if (service_send(u
, &msg
.start_req
.h
) < 0 ||
807 service_expect(u
, &msg
.rsp
, sizeof(msg
), BT_STOP_STREAM
, sizeof(msg
.start_rsp
)) < 0)
810 pa_close(u
->stream_fd
);
813 if (u
->read_smoother
) {
814 pa_smoother_free(u
->read_smoother
);
815 u
->read_smoother
= NULL
;
821 /* Run from IO thread */
822 static int sink_process_msg(pa_msgobject
*o
, int code
, void *data
, int64_t offset
, pa_memchunk
*chunk
) {
823 struct userdata
*u
= PA_SINK(o
)->userdata
;
824 pa_bool_t failed
= FALSE
;
827 pa_assert(u
->sink
== PA_SINK(o
));
831 case PA_SINK_MESSAGE_SET_STATE
:
833 switch ((pa_sink_state_t
) PA_PTR_TO_UINT(data
)) {
835 case PA_SINK_SUSPENDED
:
836 pa_assert(PA_SINK_IS_OPENED(u
->sink
->thread_info
.state
));
838 /* Stop the device if the source is suspended as well */
839 if (!u
->source
|| u
->source
->state
== PA_SOURCE_SUSPENDED
)
840 /* We deliberately ignore whether stopping
841 * actually worked. Since the stream_fd is
842 * closed it doesn't really matter */
848 case PA_SINK_RUNNING
:
849 if (u
->sink
->thread_info
.state
!= PA_SINK_SUSPENDED
)
852 /* Resume the device if the source was suspended as well */
853 if (!u
->source
|| u
->source
->state
== PA_SOURCE_SUSPENDED
)
854 if (start_stream_fd(u
) < 0)
858 case PA_SINK_UNLINKED
:
860 case PA_SINK_INVALID_STATE
:
865 case PA_SINK_MESSAGE_GET_LATENCY
: {
867 if (u
->read_smoother
) {
870 ri
= pa_smoother_get(u
->read_smoother
, pa_rtclock_usec());
871 wi
= pa_bytes_to_usec(u
->write_index
+ u
->block_size
, &u
->sample_spec
);
873 *((pa_usec_t
*) data
) = wi
> ri
? wi
- ri
: 0;
877 ri
= pa_rtclock_usec() - u
->started_at
;
878 wi
= pa_bytes_to_usec(u
->write_index
, &u
->sample_spec
);
880 *((pa_usec_t
*) data
) = wi
> ri
? wi
- ri
: 0;
883 *((pa_usec_t
*) data
) += u
->sink
->fixed_latency
;
888 r
= pa_sink_process_msg(o
, code
, data
, offset
, chunk
);
890 return (r
< 0 || !failed
) ? r
: -1;
893 /* Run from IO thread */
894 static int source_process_msg(pa_msgobject
*o
, int code
, void *data
, int64_t offset
, pa_memchunk
*chunk
) {
895 struct userdata
*u
= PA_SOURCE(o
)->userdata
;
896 pa_bool_t failed
= FALSE
;
899 pa_assert(u
->source
== PA_SOURCE(o
));
903 case PA_SOURCE_MESSAGE_SET_STATE
:
905 switch ((pa_source_state_t
) PA_PTR_TO_UINT(data
)) {
907 case PA_SOURCE_SUSPENDED
:
908 pa_assert(PA_SOURCE_IS_OPENED(u
->source
->thread_info
.state
));
910 /* Stop the device if the sink is suspended as well */
911 if (!u
->sink
|| u
->sink
->state
== PA_SINK_SUSPENDED
)
914 if (u
->read_smoother
)
915 pa_smoother_pause(u
->read_smoother
, pa_rtclock_usec());
919 case PA_SOURCE_RUNNING
:
920 if (u
->source
->thread_info
.state
!= PA_SOURCE_SUSPENDED
)
923 /* Resume the device if the sink was suspended as well */
924 if (!u
->sink
|| u
->sink
->thread_info
.state
== PA_SINK_SUSPENDED
)
925 if (start_stream_fd(u
) < 0)
928 /* We don't resume the smoother here. Instead we
929 * wait until the first packet arrives */
932 case PA_SOURCE_UNLINKED
:
934 case PA_SOURCE_INVALID_STATE
:
939 case PA_SOURCE_MESSAGE_GET_LATENCY
: {
942 wi
= pa_smoother_get(u
->read_smoother
, pa_rtclock_usec());
943 ri
= pa_bytes_to_usec(u
->read_index
, &u
->sample_spec
);
945 *((pa_usec_t
*) data
) = (wi
> ri
? wi
- ri
: 0) + u
->source
->fixed_latency
;
951 r
= pa_source_process_msg(o
, code
, data
, offset
, chunk
);
953 return (r
< 0 || !failed
) ? r
: -1;
956 /* Run from IO thread */
957 static int hsp_process_render(struct userdata
*u
) {
961 pa_assert(u
->profile
== PROFILE_HSP
);
964 /* First, render some data */
965 if (!u
->write_memchunk
.memblock
)
966 pa_sink_render_full(u
->sink
, u
->block_size
, &u
->write_memchunk
);
968 pa_assert(u
->write_memchunk
.length
== u
->block_size
);
974 /* Now write that data to the socket. The socket is of type
975 * SEQPACKET, and we generated the data of the MTU size, so this
976 * should just work. */
978 p
= (const uint8_t*) pa_memblock_acquire(u
->write_memchunk
.memblock
) + u
->write_memchunk
.index
;
979 l
= pa_write(u
->stream_fd
, p
, u
->write_memchunk
.length
, &u
->stream_write_type
);
980 pa_memblock_release(u
->write_memchunk
.memblock
);
987 /* Retry right away if we got interrupted */
990 else if (errno
== EAGAIN
)
991 /* Hmm, apparently the socket was not writable, give up for now */
994 pa_log_error("Failed to write data to SCO socket: %s", pa_cstrerror(errno
));
999 pa_assert((size_t) l
<= u
->write_memchunk
.length
);
1001 if ((size_t) l
!= u
->write_memchunk
.length
) {
1002 pa_log_error("Wrote memory block to socket only partially! %llu written, wanted to write %llu.",
1003 (unsigned long long) l
,
1004 (unsigned long long) u
->write_memchunk
.length
);
1009 u
->write_index
+= (uint64_t) u
->write_memchunk
.length
;
1010 pa_memblock_unref(u
->write_memchunk
.memblock
);
1011 pa_memchunk_reset(&u
->write_memchunk
);
1020 /* Run from IO thread */
1021 static int hsp_process_push(struct userdata
*u
) {
1023 pa_memchunk memchunk
;
1026 pa_assert(u
->profile
== PROFILE_HSP
);
1027 pa_assert(u
->source
);
1028 pa_assert(u
->read_smoother
);
1030 memchunk
.memblock
= pa_memblock_new(u
->core
->mempool
, u
->block_size
);
1031 memchunk
.index
= memchunk
.length
= 0;
1040 pa_bool_t found_tstamp
= FALSE
;
1043 memset(&m
, 0, sizeof(m
));
1044 memset(&aux
, 0, sizeof(aux
));
1045 memset(&iov
, 0, sizeof(iov
));
1049 m
.msg_control
= aux
;
1050 m
.msg_controllen
= sizeof(aux
);
1052 p
= pa_memblock_acquire(memchunk
.memblock
);
1054 iov
.iov_len
= pa_memblock_get_length(memchunk
.memblock
);
1055 l
= recvmsg(u
->stream_fd
, &m
, 0);
1056 pa_memblock_release(memchunk
.memblock
);
1060 if (l
< 0 && errno
== EINTR
)
1061 /* Retry right away if we got interrupted */
1064 else if (l
< 0 && errno
== EAGAIN
)
1065 /* Hmm, apparently the socket was not readable, give up for now. */
1068 pa_log_error("Failed to read data from SCO socket: %s", l
< 0 ? pa_cstrerror(errno
) : "EOF");
1073 pa_assert((size_t) l
<= pa_memblock_get_length(memchunk
.memblock
));
1075 memchunk
.length
= (size_t) l
;
1076 u
->read_index
+= (uint64_t) l
;
1078 for (cm
= CMSG_FIRSTHDR(&m
); cm
; cm
= CMSG_NXTHDR(&m
, cm
))
1079 if (cm
->cmsg_level
== SOL_SOCKET
&& cm
->cmsg_type
== SO_TIMESTAMP
) {
1080 struct timeval
*tv
= (struct timeval
*) CMSG_DATA(cm
);
1081 pa_rtclock_from_wallclock(tv
);
1082 tstamp
= pa_timeval_load(tv
);
1083 found_tstamp
= TRUE
;
1087 if (!found_tstamp
) {
1088 pa_log_warn("Couldn't find SO_TIMESTAMP data in auxiliary recvmsg() data!");
1089 tstamp
= pa_rtclock_usec();
1092 pa_smoother_put(u
->read_smoother
, tstamp
, pa_bytes_to_usec(u
->read_index
, &u
->sample_spec
));
1093 pa_smoother_resume(u
->read_smoother
, tstamp
, TRUE
);
1095 pa_source_post(u
->source
, &memchunk
);
1101 pa_memblock_unref(memchunk
.memblock
);
1106 /* Run from IO thread */
1107 static void a2dp_prepare_buffer(struct userdata
*u
) {
1110 if (u
->a2dp
.buffer_size
>= u
->link_mtu
)
1113 u
->a2dp
.buffer_size
= 2 * u
->link_mtu
;
1114 pa_xfree(u
->a2dp
.buffer
);
1115 u
->a2dp
.buffer
= pa_xmalloc(u
->a2dp
.buffer_size
);
1118 /* Run from IO thread */
1119 static int a2dp_process_render(struct userdata
*u
) {
1120 struct a2dp_info
*a2dp
;
1121 struct rtp_header
*header
;
1122 struct rtp_payload
*payload
;
1126 size_t to_write
, to_encode
;
1127 unsigned frame_count
;
1131 pa_assert(u
->profile
== PROFILE_A2DP
);
1134 /* First, render some data */
1135 if (!u
->write_memchunk
.memblock
)
1136 pa_sink_render_full(u
->sink
, u
->block_size
, &u
->write_memchunk
);
1138 pa_assert(u
->write_memchunk
.length
== u
->block_size
);
1140 a2dp_prepare_buffer(u
);
1143 header
= a2dp
->buffer
;
1144 payload
= (struct rtp_payload
*) ((uint8_t*) a2dp
->buffer
+ sizeof(*header
));
1148 /* Try to create a packet of the full MTU */
1150 p
= (const uint8_t*) pa_memblock_acquire(u
->write_memchunk
.memblock
) + u
->write_memchunk
.index
;
1151 to_encode
= u
->write_memchunk
.length
;
1153 d
= (uint8_t*) a2dp
->buffer
+ sizeof(*header
) + sizeof(*payload
);
1154 to_write
= a2dp
->buffer_size
- sizeof(*header
) - sizeof(*payload
);
1156 while (PA_LIKELY(to_encode
> 0 && to_write
> 0)) {
1160 encoded
= sbc_encode(&a2dp
->sbc
,
1165 if (PA_UNLIKELY(encoded
<= 0)) {
1166 pa_log_error("SBC encoding error (%li)", (long) encoded
);
1167 pa_memblock_release(u
->write_memchunk
.memblock
);
1171 /* pa_log_debug("SBC: encoded: %lu; written: %lu", (unsigned long) encoded, (unsigned long) written); */
1172 /* pa_log_debug("SBC: codesize: %lu; frame_length: %lu", (unsigned long) a2dp->codesize, (unsigned long) a2dp->frame_length); */
1174 pa_assert_fp((size_t) encoded
<= to_encode
);
1175 pa_assert_fp((size_t) encoded
== a2dp
->codesize
);
1177 pa_assert_fp((size_t) written
<= to_write
);
1178 pa_assert_fp((size_t) written
== a2dp
->frame_length
);
1180 p
= (const uint8_t*) p
+ encoded
;
1181 to_encode
-= encoded
;
1183 d
= (uint8_t*) d
+ written
;
1184 to_write
-= written
;
1189 pa_memblock_release(u
->write_memchunk
.memblock
);
1191 pa_assert(to_encode
== 0);
1194 pa_log_debug("Using SBC encoder implementation: %s", pa_strnull(sbc_get_implementation_info(&a2dp
->sbc
)));
1197 /* write it to the fifo */
1198 memset(a2dp
->buffer
, 0, sizeof(*header
) + sizeof(*payload
));
1201 header
->sequence_number
= htons(a2dp
->seq_num
++);
1202 header
->timestamp
= htonl(u
->write_index
/ pa_frame_size(&u
->sample_spec
));
1203 header
->ssrc
= htonl(1);
1204 payload
->frame_count
= frame_count
;
1206 nbytes
= (uint8_t*) d
- (uint8_t*) a2dp
->buffer
;
1211 l
= pa_write(u
->stream_fd
, a2dp
->buffer
, nbytes
, &u
->stream_write_type
);
1218 /* Retry right away if we got interrupted */
1221 else if (errno
== EAGAIN
)
1222 /* Hmm, apparently the socket was not writable, give up for now */
1225 pa_log_error("Failed to write data to socket: %s", pa_cstrerror(errno
));
1230 pa_assert((size_t) l
<= nbytes
);
1232 if ((size_t) l
!= nbytes
) {
1233 pa_log_warn("Wrote memory block to socket only partially! %llu written, wanted to write %llu.",
1234 (unsigned long long) l
,
1235 (unsigned long long) nbytes
);
1240 u
->write_index
+= (uint64_t) u
->write_memchunk
.length
;
1241 pa_memblock_unref(u
->write_memchunk
.memblock
);
1242 pa_memchunk_reset(&u
->write_memchunk
);
1252 static void thread_func(void *userdata
) {
1253 struct userdata
*u
= userdata
;
1254 unsigned do_write
= 0;
1255 pa_bool_t writable
= FALSE
;
1259 pa_log_debug("IO Thread starting up");
1261 if (u
->core
->realtime_scheduling
)
1262 pa_make_realtime(u
->core
->realtime_priority
);
1264 if (start_stream_fd(u
) < 0)
1267 pa_thread_mq_install(&u
->thread_mq
);
1268 pa_rtpoll_install(u
->rtpoll
);
1271 struct pollfd
*pollfd
;
1273 pa_bool_t disable_timer
= TRUE
;
1275 pollfd
= u
->rtpoll_item
? pa_rtpoll_item_get_pollfd(u
->rtpoll_item
, NULL
) : NULL
;
1277 if (u
->source
&& PA_SOURCE_IS_LINKED(u
->source
->thread_info
.state
)) {
1279 /* We should send two blocks to the device before we expect
1282 if (u
->write_index
== 0 && u
->read_index
<= 0)
1285 if (pollfd
&& (pollfd
->revents
& POLLIN
)) {
1288 if ((n_read
= hsp_process_push(u
)) < 0)
1291 /* We just read something, so we are supposed to write something, too */
1296 if (u
->sink
&& PA_SINK_IS_LINKED(u
->sink
->thread_info
.state
)) {
1298 if (u
->sink
->thread_info
.rewind_requested
)
1299 pa_sink_process_rewind(u
->sink
, 0);
1302 if (pollfd
->revents
& POLLOUT
)
1305 if ((!u
->source
|| !PA_SOURCE_IS_LINKED(u
->source
->thread_info
.state
)) && do_write
<= 0 && writable
) {
1306 pa_usec_t time_passed
;
1307 pa_usec_t audio_sent
;
1309 /* Hmm, there is no input stream we could synchronize
1310 * to. So let's do things by time */
1312 time_passed
= pa_rtclock_usec() - u
->started_at
;
1313 audio_sent
= pa_bytes_to_usec(u
->write_index
, &u
->sample_spec
);
1315 if (audio_sent
<= time_passed
) {
1316 pa_usec_t audio_to_send
= time_passed
- audio_sent
;
1318 /* Never try to catch up for more than 100ms */
1319 if (u
->write_index
> 0 && audio_to_send
> MAX_PLAYBACK_CATCH_UP_USEC
) {
1320 pa_usec_t skip_usec
;
1321 uint64_t skip_bytes
;
1324 skip_usec
= audio_to_send
- MAX_PLAYBACK_CATCH_UP_USEC
;
1325 skip_bytes
= pa_usec_to_bytes(skip_usec
, &u
->sample_spec
);
1327 pa_log_warn("Skipping %llu us (= %llu bytes) in audio stream",
1328 (unsigned long long) skip_usec
,
1329 (unsigned long long) skip_bytes
);
1331 pa_sink_render_full(u
->sink
, skip_bytes
, &tmp
);
1332 pa_memblock_unref(tmp
.memblock
);
1333 u
->write_index
+= skip_bytes
;
1340 if (writable
&& do_write
> 0) {
1343 if (u
->write_index
<= 0)
1344 u
->started_at
= pa_rtclock_usec();
1346 if (u
->profile
== PROFILE_A2DP
) {
1347 if ((n_written
= a2dp_process_render(u
)) < 0)
1350 if ((n_written
= hsp_process_render(u
)) < 0)
1354 do_write
-= n_written
;
1358 if ((!u
->source
|| !PA_SOURCE_IS_LINKED(u
->source
->thread_info
.state
)) && do_write
<= 0) {
1359 pa_usec_t time_passed
, next_write_at
, sleep_for
;
1361 /* Hmm, there is no input stream we could synchronize
1362 * to. So let's estimate when we need to wake up the latest */
1364 time_passed
= pa_rtclock_usec() - u
->started_at
;
1365 next_write_at
= pa_bytes_to_usec(u
->write_index
, &u
->sample_spec
);
1366 sleep_for
= time_passed
< next_write_at
? next_write_at
- time_passed
: 0;
1368 /* 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); */
1370 pa_rtpoll_set_timer_relative(u
->rtpoll
, sleep_for
);
1371 disable_timer
= FALSE
;
1377 pa_rtpoll_set_timer_disabled(u
->rtpoll
);
1379 /* Hmm, nothing to do. Let's sleep */
1381 pollfd
->events
= (short) (((u
->sink
&& PA_SINK_IS_LINKED(u
->sink
->thread_info
.state
) && !writable
) ? POLLOUT
: 0) |
1382 (u
->source
&& PA_SOURCE_IS_LINKED(u
->source
->thread_info
.state
) ? POLLIN
: 0));
1384 if ((ret
= pa_rtpoll_run(u
->rtpoll
, TRUE
)) < 0)
1390 pollfd
= u
->rtpoll_item
? pa_rtpoll_item_get_pollfd(u
->rtpoll_item
, NULL
) : NULL
;
1392 if (pollfd
&& (pollfd
->revents
& ~(POLLOUT
|POLLIN
))) {
1393 pa_log_info("FD error: %s%s%s%s",
1394 pollfd
->revents
& POLLERR
? "POLLERR " :"",
1395 pollfd
->revents
& POLLHUP
? "POLLHUP " :"",
1396 pollfd
->revents
& POLLPRI
? "POLLPRI " :"",
1397 pollfd
->revents
& POLLNVAL
? "POLLNVAL " :"");
1403 /* If this was no regular exit from the loop we have to continue processing messages until we receive PA_MESSAGE_SHUTDOWN */
1404 pa_log_debug("IO thread failed");
1405 pa_asyncmsgq_post(u
->thread_mq
.outq
, PA_MSGOBJECT(u
->core
), PA_CORE_MESSAGE_UNLOAD_MODULE
, u
->module
, 0, NULL
, NULL
);
1406 pa_asyncmsgq_wait_for(u
->thread_mq
.inq
, PA_MESSAGE_SHUTDOWN
);
1409 pa_log_debug("IO thread shutting down");
1412 /* Run from main thread */
1413 static DBusHandlerResult
filter_cb(DBusConnection
*bus
, DBusMessage
*m
, void *userdata
) {
1419 pa_assert_se(u
= userdata
);
1421 dbus_error_init(&err
);
1423 pa_log_debug("dbus: interface=%s, path=%s, member=%s\n",
1424 dbus_message_get_interface(m
),
1425 dbus_message_get_path(m
),
1426 dbus_message_get_member(m
));
1428 if (!dbus_message_has_path(m
, u
->path
))
1431 if (dbus_message_is_signal(m
, "org.bluez.Headset", "SpeakerGainChanged") ||
1432 dbus_message_is_signal(m
, "org.bluez.Headset", "MicrophoneGainChanged")) {
1437 if (!dbus_message_get_args(m
, &err
, DBUS_TYPE_UINT16
, &gain
, DBUS_TYPE_INVALID
) || gain
> 15) {
1438 pa_log("Failed to parse org.bluez.Headset.{Speaker|Microphone}GainChanged: %s", err
.message
);
1442 if (u
->profile
== PROFILE_HSP
) {
1443 if (u
->sink
&& dbus_message_is_signal(m
, "org.bluez.Headset", "SpeakerGainChanged")) {
1445 pa_cvolume_set(&v
, u
->sample_spec
.channels
, (pa_volume_t
) (gain
* PA_VOLUME_NORM
/ 15));
1446 pa_sink_volume_changed(u
->sink
, &v
);
1448 } else if (u
->source
&& dbus_message_is_signal(m
, "org.bluez.Headset", "MicrophoneGainChanged")) {
1450 pa_cvolume_set(&v
, u
->sample_spec
.channels
, (pa_volume_t
) (gain
* PA_VOLUME_NORM
/ 15));
1451 pa_source_volume_changed(u
->source
, &v
);
1457 dbus_error_free(&err
);
1459 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED
;
1462 /* Run from main thread */
1463 static void sink_set_volume_cb(pa_sink
*s
) {
1464 struct userdata
*u
= s
->userdata
;
1470 if (u
->profile
!= PROFILE_HSP
)
1473 gain
= (pa_cvolume_max(&s
->virtual_volume
) * 15) / PA_VOLUME_NORM
;
1478 pa_cvolume_set(&s
->virtual_volume
, u
->sample_spec
.channels
, (pa_volume_t
) (gain
* PA_VOLUME_NORM
/ 15));
1480 pa_assert_se(m
= dbus_message_new_method_call("org.bluez", u
->path
, "org.bluez.Headset", "SetSpeakerGain"));
1481 pa_assert_se(dbus_message_append_args(m
, DBUS_TYPE_UINT16
, &gain
, DBUS_TYPE_INVALID
));
1482 pa_assert_se(dbus_connection_send(pa_dbus_connection_get(u
->connection
), m
, NULL
));
1483 dbus_message_unref(m
);
1486 /* Run from main thread */
1487 static void source_set_volume_cb(pa_source
*s
) {
1488 struct userdata
*u
= s
->userdata
;
1494 if (u
->profile
!= PROFILE_HSP
)
1497 gain
= (pa_cvolume_max(&s
->virtual_volume
) * 15) / PA_VOLUME_NORM
;
1502 pa_cvolume_set(&s
->virtual_volume
, u
->sample_spec
.channels
, (pa_volume_t
) (gain
* PA_VOLUME_NORM
/ 15));
1504 pa_assert_se(m
= dbus_message_new_method_call("org.bluez", u
->path
, "org.bluez.Headset", "SetMicrophoneGain"));
1505 pa_assert_se(dbus_message_append_args(m
, DBUS_TYPE_UINT16
, &gain
, DBUS_TYPE_INVALID
));
1506 pa_assert_se(dbus_connection_send(pa_dbus_connection_get(u
->connection
), m
, NULL
));
1507 dbus_message_unref(m
);
1510 /* Run from main thread */
1511 static char *get_name(const char *type
, pa_modargs
*ma
, const char *device_id
, pa_bool_t
*namereg_fail
) {
1517 pa_assert(device_id
);
1518 pa_assert(namereg_fail
);
1520 t
= pa_sprintf_malloc("%s_name", type
);
1521 n
= pa_modargs_get_value(ma
, t
, NULL
);
1525 *namereg_fail
= TRUE
;
1526 return pa_xstrdup(n
);
1529 if ((n
= pa_modargs_get_value(ma
, "name", NULL
)))
1530 *namereg_fail
= TRUE
;
1533 *namereg_fail
= FALSE
;
1536 return pa_sprintf_malloc("bluez_%s.%s", type
, n
);
1541 static void sco_over_pcm_state_update(struct userdata
*u
) {
1543 pa_assert(USE_SCO_OVER_PCM(u
));
1545 if (PA_SINK_IS_OPENED(pa_sink_get_state(u
->hsp
.sco_sink
)) ||
1546 PA_SOURCE_IS_OPENED(pa_source_get_state(u
->hsp
.sco_source
))) {
1548 if (u
->service_fd
>= 0)
1551 pa_log_debug("Resuming SCO over PCM");
1552 if ((init_bt(u
) < 0) || (init_profile(u
) < 0))
1553 pa_log("Can't resume SCO over PCM");
1558 if (u
->service_fd
< 0)
1563 pa_log_debug("Closing SCO over PCM");
1564 pa_close(u
->service_fd
);
1569 static pa_hook_result_t
sink_state_changed_cb(pa_core
*c
, pa_sink
*s
, struct userdata
*u
) {
1571 pa_sink_assert_ref(s
);
1574 if (s
!= u
->hsp
.sco_sink
)
1577 sco_over_pcm_state_update(u
);
1582 static pa_hook_result_t
source_state_changed_cb(pa_core
*c
, pa_source
*s
, struct userdata
*u
) {
1584 pa_source_assert_ref(s
);
1587 if (s
!= u
->hsp
.sco_source
)
1590 sco_over_pcm_state_update(u
);
1597 /* Run from main thread */
1598 static int add_sink(struct userdata
*u
) {
1601 if (USE_SCO_OVER_PCM(u
)) {
1604 u
->sink
= u
->hsp
.sco_sink
;
1605 p
= pa_proplist_new();
1606 pa_proplist_sets(p
, "bluetooth.protocol", "sco");
1607 pa_proplist_update(u
->sink
->proplist
, PA_UPDATE_MERGE
, p
);
1608 pa_proplist_free(p
);
1610 if (!u
->hsp
.sink_state_changed_slot
)
1611 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
);
1617 pa_sink_new_data data
;
1620 pa_sink_new_data_init(&data
);
1621 data
.driver
= __FILE__
;
1622 data
.module
= u
->module
;
1623 pa_sink_new_data_set_sample_spec(&data
, &u
->sample_spec
);
1624 pa_proplist_sets(data
.proplist
, "bluetooth.protocol", u
->profile
== PROFILE_A2DP
? "a2dp" : "sco");
1625 data
.card
= u
->card
;
1626 data
.name
= get_name("sink", u
->modargs
, u
->address
, &b
);
1627 data
.namereg_fail
= b
;
1629 if (pa_modargs_get_proplist(u
->modargs
, "sink_properties", data
.proplist
, PA_UPDATE_REPLACE
) < 0) {
1630 pa_log("Invalid properties");
1631 pa_sink_new_data_done(&data
);
1635 u
->sink
= pa_sink_new(u
->core
, &data
, PA_SINK_HARDWARE
|PA_SINK_LATENCY
| (u
->profile
== PROFILE_HSP
? PA_SINK_HW_VOLUME_CTRL
: 0));
1636 pa_sink_new_data_done(&data
);
1639 pa_log_error("Failed to create sink");
1643 u
->sink
->userdata
= u
;
1644 u
->sink
->parent
.process_msg
= sink_process_msg
;
1646 pa_sink_set_max_request(u
->sink
, u
->block_size
);
1647 pa_sink_set_fixed_latency(u
->sink
,
1648 (u
->profile
== PROFILE_A2DP
? FIXED_LATENCY_PLAYBACK_A2DP
: FIXED_LATENCY_PLAYBACK_HSP
) +
1649 pa_bytes_to_usec(u
->block_size
, &u
->sample_spec
));
1652 if (u
->profile
== PROFILE_HSP
) {
1653 u
->sink
->set_volume
= sink_set_volume_cb
;
1654 u
->sink
->n_volume_steps
= 16;
1660 /* Run from main thread */
1661 static int add_source(struct userdata
*u
) {
1664 if (USE_SCO_OVER_PCM(u
)) {
1665 u
->source
= u
->hsp
.sco_source
;
1666 pa_proplist_sets(u
->source
->proplist
, "bluetooth.protocol", "hsp");
1668 if (!u
->hsp
.source_state_changed_slot
)
1669 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
);
1675 pa_source_new_data data
;
1678 pa_source_new_data_init(&data
);
1679 data
.driver
= __FILE__
;
1680 data
.module
= u
->module
;
1681 pa_source_new_data_set_sample_spec(&data
, &u
->sample_spec
);
1682 pa_proplist_sets(data
.proplist
, "bluetooth.protocol", u
->profile
== PROFILE_A2DP
? "a2dp" : "hsp");
1683 data
.card
= u
->card
;
1684 data
.name
= get_name("source", u
->modargs
, u
->address
, &b
);
1685 data
.namereg_fail
= b
;
1687 if (pa_modargs_get_proplist(u
->modargs
, "source_properties", data
.proplist
, PA_UPDATE_REPLACE
) < 0) {
1688 pa_log("Invalid properties");
1689 pa_source_new_data_done(&data
);
1693 u
->source
= pa_source_new(u
->core
, &data
, PA_SOURCE_HARDWARE
|PA_SOURCE_LATENCY
| (u
->profile
== PROFILE_HSP
? PA_SOURCE_HW_VOLUME_CTRL
: 0));
1694 pa_source_new_data_done(&data
);
1697 pa_log_error("Failed to create source");
1701 u
->source
->userdata
= u
;
1702 u
->source
->parent
.process_msg
= source_process_msg
;
1704 pa_source_set_fixed_latency(u
->source
,
1705 (/* u->profile == PROFILE_A2DP ? FIXED_LATENCY_RECORD_A2DP : */ FIXED_LATENCY_RECORD_HSP
) +
1706 pa_bytes_to_usec(u
->block_size
, &u
->sample_spec
));
1709 if (u
->profile
== PROFILE_HSP
) {
1710 pa_proplist_sets(u
->source
->proplist
, "bluetooth.nrec", (u
->hsp
.pcm_capabilities
.flags
& BT_PCM_FLAG_NREC
) ? "1" : "0");
1711 u
->source
->set_volume
= source_set_volume_cb
;
1712 u
->source
->n_volume_steps
= 16;
1718 /* Run from main thread */
1719 static void shutdown_bt(struct userdata
*u
) {
1722 if (u
->stream_fd
>= 0) {
1723 pa_close(u
->stream_fd
);
1726 u
->stream_write_type
= 0;
1729 if (u
->service_fd
>= 0) {
1730 pa_close(u
->service_fd
);
1732 u
->service_write_type
= u
->service_write_type
= 0;
1735 if (u
->write_memchunk
.memblock
) {
1736 pa_memblock_unref(u
->write_memchunk
.memblock
);
1737 pa_memchunk_reset(&u
->write_memchunk
);
1741 /* Run from main thread */
1742 static int init_bt(struct userdata
*u
) {
1747 u
->stream_write_type
= 0;
1748 u
->service_write_type
= u
->service_write_type
= 0;
1750 if ((u
->service_fd
= bt_audio_service_open()) < 0) {
1751 pa_log_error("Couldn't connect to bluetooth audio service");
1755 pa_log_debug("Connected to the bluetooth audio service");
1760 /* Run from main thread */
1761 static int setup_bt(struct userdata
*u
) {
1764 if (get_caps(u
, 0) < 0)
1767 pa_log_debug("Got device capabilities");
1769 if (set_conf(u
) < 0)
1772 pa_log_debug("Connection to the device configured");
1775 if (USE_SCO_OVER_PCM(u
)) {
1776 pa_log_debug("Configured to use SCO over PCM");
1781 pa_log_debug("Got the stream socket");
1786 /* Run from main thread */
1787 static int init_profile(struct userdata
*u
) {
1790 pa_assert(u
->profile
!= PROFILE_OFF
);
1792 if (setup_bt(u
) < 0)
1795 if (u
->profile
== PROFILE_A2DP
||
1796 u
->profile
== PROFILE_HSP
)
1797 if (add_sink(u
) < 0)
1800 if (u
->profile
== PROFILE_HSP
)
1801 if (add_source(u
) < 0)
1807 /* Run from main thread */
1808 static void stop_thread(struct userdata
*u
) {
1812 pa_asyncmsgq_send(u
->thread_mq
.inq
, NULL
, PA_MESSAGE_SHUTDOWN
, NULL
, 0, NULL
);
1813 pa_thread_free(u
->thread
);
1817 if (u
->rtpoll_item
) {
1818 pa_rtpoll_item_free(u
->rtpoll_item
);
1819 u
->rtpoll_item
= NULL
;
1822 if (u
->hsp
.sink_state_changed_slot
) {
1823 pa_hook_slot_free(u
->hsp
.sink_state_changed_slot
);
1824 u
->hsp
.sink_state_changed_slot
= NULL
;
1827 if (u
->hsp
.source_state_changed_slot
) {
1828 pa_hook_slot_free(u
->hsp
.source_state_changed_slot
);
1829 u
->hsp
.source_state_changed_slot
= NULL
;
1833 pa_sink_unref(u
->sink
);
1838 pa_source_unref(u
->source
);
1843 pa_thread_mq_done(&u
->thread_mq
);
1845 pa_rtpoll_free(u
->rtpoll
);
1849 if (u
->read_smoother
) {
1850 pa_smoother_free(u
->read_smoother
);
1851 u
->read_smoother
= NULL
;
1855 /* Run from main thread */
1856 static int start_thread(struct userdata
*u
) {
1858 pa_assert(!u
->thread
);
1859 pa_assert(!u
->rtpoll
);
1860 pa_assert(!u
->rtpoll_item
);
1862 u
->rtpoll
= pa_rtpoll_new();
1863 pa_thread_mq_init(&u
->thread_mq
, u
->core
->mainloop
, u
->rtpoll
);
1866 if (USE_SCO_OVER_PCM(u
)) {
1867 if (start_stream_fd(u
) < 0)
1870 pa_sink_ref(u
->sink
);
1871 pa_source_ref(u
->source
);
1872 /* FIXME: monitor stream_fd error */
1877 if (!(u
->thread
= pa_thread_new(thread_func
, u
))) {
1878 pa_log_error("Failed to create IO thread");
1884 pa_sink_set_asyncmsgq(u
->sink
, u
->thread_mq
.inq
);
1885 pa_sink_set_rtpoll(u
->sink
, u
->rtpoll
);
1886 pa_sink_put(u
->sink
);
1888 if (u
->sink
->set_volume
)
1889 u
->sink
->set_volume(u
->sink
);
1893 pa_source_set_asyncmsgq(u
->source
, u
->thread_mq
.inq
);
1894 pa_source_set_rtpoll(u
->source
, u
->rtpoll
);
1895 pa_source_put(u
->source
);
1897 if (u
->source
->set_volume
)
1898 u
->source
->set_volume(u
->source
);
1904 /* Run from main thread */
1905 static int card_set_profile(pa_card
*c
, pa_card_profile
*new_profile
) {
1908 pa_queue
*inputs
= NULL
, *outputs
= NULL
;
1909 const pa_bluetooth_device
*device
;
1912 pa_assert(new_profile
);
1913 pa_assert_se(u
= c
->userdata
);
1915 d
= PA_CARD_PROFILE_DATA(new_profile
);
1917 if (!(device
= pa_bluetooth_discovery_get_by_path(u
->discovery
, u
->path
))) {
1918 pa_log_error("Failed to get device object.");
1922 /* The state signal is sent by bluez, so it is racy to check
1923 strictly for CONNECTED, we should also accept STREAMING state
1924 as being good enough. However, if the profile is used
1925 concurrently (which is unlikely), ipc will fail later on, and
1926 module will be unloaded. */
1927 if (device
->headset_state
< PA_BT_AUDIO_STATE_CONNECTED
&& *d
== PROFILE_HSP
) {
1928 pa_log_warn("HSP is not connected, refused to switch profile");
1931 else if (device
->audio_sink_state
< PA_BT_AUDIO_STATE_CONNECTED
&& *d
== PROFILE_A2DP
) {
1932 pa_log_warn("A2DP is not connected, refused to switch profile");
1937 inputs
= pa_sink_move_all_start(u
->sink
);
1939 if (!USE_SCO_OVER_PCM(u
))
1941 pa_sink_unlink(u
->sink
);
1945 outputs
= pa_source_move_all_start(u
->source
);
1947 if (!USE_SCO_OVER_PCM(u
))
1949 pa_source_unlink(u
->source
);
1956 u
->sample_spec
= u
->requested_sample_spec
;
1960 if (u
->profile
!= PROFILE_OFF
)
1963 if (u
->sink
|| u
->source
)
1968 pa_sink_move_all_finish(u
->sink
, inputs
, FALSE
);
1970 pa_sink_move_all_fail(inputs
);
1975 pa_source_move_all_finish(u
->source
, outputs
, FALSE
);
1977 pa_source_move_all_fail(outputs
);
1983 /* Run from main thread */
1984 static int add_card(struct userdata
*u
, const pa_bluetooth_device
*device
) {
1985 pa_card_new_data data
;
1991 const char *default_profile
;
1996 pa_card_new_data_init(&data
);
1997 data
.driver
= __FILE__
;
1998 data
.module
= u
->module
;
2000 n
= pa_bluetooth_cleanup_name(device
->name
);
2001 pa_proplist_sets(data
.proplist
, PA_PROP_DEVICE_DESCRIPTION
, n
);
2003 pa_proplist_sets(data
.proplist
, PA_PROP_DEVICE_STRING
, device
->address
);
2004 pa_proplist_sets(data
.proplist
, PA_PROP_DEVICE_API
, "bluez");
2005 pa_proplist_sets(data
.proplist
, PA_PROP_DEVICE_CLASS
, "sound");
2006 pa_proplist_sets(data
.proplist
, PA_PROP_DEVICE_BUS
, "bluetooth");
2007 if ((ff
= pa_bluetooth_get_form_factor(device
->class)))
2008 pa_proplist_sets(data
.proplist
, PA_PROP_DEVICE_FORM_FACTOR
, ff
);
2009 pa_proplist_sets(data
.proplist
, "bluez.path", device
->path
);
2010 pa_proplist_setf(data
.proplist
, "bluez.class", "0x%06x", (unsigned) device
->class);
2011 pa_proplist_sets(data
.proplist
, "bluez.name", device
->name
);
2012 data
.name
= get_name("card", u
->modargs
, device
->address
, &b
);
2013 data
.namereg_fail
= b
;
2015 if (pa_modargs_get_proplist(u
->modargs
, "card_properties", data
.proplist
, PA_UPDATE_REPLACE
) < 0) {
2016 pa_log("Invalid properties");
2017 pa_card_new_data_done(&data
);
2021 data
.profiles
= pa_hashmap_new(pa_idxset_string_hash_func
, pa_idxset_string_compare_func
);
2023 /* we base hsp/a2dp availability on UUIDs.
2024 Ideally, it would be based on "Connected" state, but
2025 we can't afford to wait for this information when
2026 we are loaded with profile="hsp", for instance */
2027 if (pa_bluetooth_uuid_has(device
->uuids
, A2DP_SINK_UUID
)) {
2028 p
= pa_card_profile_new("a2dp", _("High Fidelity Playback (A2DP)"), sizeof(enum profile
));
2032 p
->max_sink_channels
= 2;
2033 p
->max_source_channels
= 0;
2035 d
= PA_CARD_PROFILE_DATA(p
);
2038 pa_hashmap_put(data
.profiles
, p
->name
, p
);
2041 if (pa_bluetooth_uuid_has(device
->uuids
, HSP_HS_UUID
) ||
2042 pa_bluetooth_uuid_has(device
->uuids
, HFP_HS_UUID
)) {
2043 p
= pa_card_profile_new("hsp", _("Telephony Duplex (HSP/HFP)"), sizeof(enum profile
));
2047 p
->max_sink_channels
= 1;
2048 p
->max_source_channels
= 1;
2050 d
= PA_CARD_PROFILE_DATA(p
);
2053 pa_hashmap_put(data
.profiles
, p
->name
, p
);
2056 pa_assert(!pa_hashmap_isempty(data
.profiles
));
2058 p
= pa_card_profile_new("off", _("Off"), sizeof(enum profile
));
2059 d
= PA_CARD_PROFILE_DATA(p
);
2061 pa_hashmap_put(data
.profiles
, p
->name
, p
);
2063 if ((default_profile
= pa_modargs_get_value(u
->modargs
, "profile", NULL
))) {
2064 if (pa_hashmap_get(data
.profiles
, default_profile
))
2065 pa_card_new_data_set_profile(&data
, default_profile
);
2067 pa_log_warn("Profile '%s' not valid or not supported by device.", default_profile
);
2070 u
->card
= pa_card_new(u
->core
, &data
);
2071 pa_card_new_data_done(&data
);
2074 pa_log("Failed to allocate card.");
2078 u
->card
->userdata
= u
;
2079 u
->card
->set_profile
= card_set_profile
;
2081 d
= PA_CARD_PROFILE_DATA(u
->card
->active_profile
);
2087 /* Run from main thread */
2088 static const pa_bluetooth_device
* find_device(struct userdata
*u
, const char *address
, const char *path
) {
2089 const pa_bluetooth_device
*d
= NULL
;
2093 if (!address
&& !path
) {
2094 pa_log_error("Failed to get device address/path from module arguments.");
2099 if (!(d
= pa_bluetooth_discovery_get_by_path(u
->discovery
, path
))) {
2100 pa_log_error("%s is not a valid BlueZ audio device.", path
);
2104 if (address
&& !(pa_streq(d
->address
, address
))) {
2105 pa_log_error("Passed path %s and address %s don't match.", path
, address
);
2110 if (!(d
= pa_bluetooth_discovery_get_by_address(u
->discovery
, address
))) {
2111 pa_log_error("%s is not known.", address
);
2117 u
->address
= pa_xstrdup(d
->address
);
2118 u
->path
= pa_xstrdup(d
->path
);
2124 /* Run from main thread */
2125 static int setup_dbus(struct userdata
*u
) {
2128 dbus_error_init(&err
);
2130 u
->connection
= pa_dbus_bus_get(u
->core
, DBUS_BUS_SYSTEM
, &err
);
2132 if (dbus_error_is_set(&err
) || !u
->connection
) {
2133 pa_log("Failed to get D-Bus connection: %s", err
.message
);
2134 dbus_error_free(&err
);
2141 int pa__init(pa_module
* m
) {
2145 const char *address
, *path
;
2147 char *mike
, *speaker
;
2148 const pa_bluetooth_device
*device
;
2152 dbus_error_init(&err
);
2154 if (!(ma
= pa_modargs_new(m
->argument
, valid_modargs
))) {
2155 pa_log_error("Failed to parse module arguments");
2159 m
->userdata
= u
= pa_xnew0(struct userdata
, 1);
2164 u
->sample_spec
= m
->core
->default_sample_spec
;
2168 if (pa_modargs_get_value(ma
, "sco_sink", NULL
) &&
2169 !(u
->hsp
.sco_sink
= pa_namereg_get(m
->core
, pa_modargs_get_value(ma
, "sco_sink", NULL
), PA_NAMEREG_SINK
))) {
2170 pa_log("SCO sink not found");
2174 if (pa_modargs_get_value(ma
, "sco_source", NULL
) &&
2175 !(u
->hsp
.sco_source
= pa_namereg_get(m
->core
, pa_modargs_get_value(ma
, "sco_source", NULL
), PA_NAMEREG_SOURCE
))) {
2176 pa_log("SCO source not found");
2181 if (pa_modargs_get_value_u32(ma
, "rate", &u
->sample_spec
.rate
) < 0 ||
2182 u
->sample_spec
.rate
<= 0 || u
->sample_spec
.rate
> PA_RATE_MAX
) {
2183 pa_log_error("Failed to get rate from module arguments");
2187 channels
= u
->sample_spec
.channels
;
2188 if (pa_modargs_get_value_u32(ma
, "channels", &channels
) < 0 ||
2189 channels
<= 0 || channels
> PA_CHANNELS_MAX
) {
2190 pa_log_error("Failed to get channels from module arguments");
2193 u
->sample_spec
.channels
= (uint8_t) channels
;
2194 u
->requested_sample_spec
= u
->sample_spec
;
2196 address
= pa_modargs_get_value(ma
, "address", NULL
);
2197 path
= pa_modargs_get_value(ma
, "path", NULL
);
2199 if (setup_dbus(u
) < 0)
2202 if (!(u
->discovery
= pa_bluetooth_discovery_get(m
->core
)))
2205 if (!(device
= find_device(u
, address
, path
)))
2208 /* Add the card structure. This will also initialize the default profile */
2209 if (add_card(u
, device
) < 0)
2212 /* Connect to the BT service and query capabilities */
2216 if (!dbus_connection_add_filter(pa_dbus_connection_get(u
->connection
), filter_cb
, u
, NULL
)) {
2217 pa_log_error("Failed to add filter function");
2221 speaker
= pa_sprintf_malloc("type='signal',sender='org.bluez',interface='org.bluez.Headset',member='SpeakerGainChanged',path='%s'", u
->path
);
2222 mike
= pa_sprintf_malloc("type='signal',sender='org.bluez',interface='org.bluez.Headset',member='MicrophoneGainChanged',path='%s'", u
->path
);
2224 if (pa_dbus_add_matches(
2225 pa_dbus_connection_get(u
->connection
), &err
,
2233 pa_log("Failed to add D-Bus matches: %s", err
.message
);
2240 if (u
->profile
!= PROFILE_OFF
)
2241 if (init_profile(u
) < 0)
2244 if (u
->sink
|| u
->source
)
2245 if (start_thread(u
) < 0)
2254 dbus_error_free(&err
);
2259 int pa__get_n_used(pa_module
*m
) {
2263 pa_assert_se(u
= m
->userdata
);
2266 (u
->sink
? pa_sink_linked_by(u
->sink
) : 0) +
2267 (u
->source
? pa_source_linked_by(u
->source
) : 0);
2270 void pa__done(pa_module
*m
) {
2274 if (!(u
= m
->userdata
))
2279 && !USE_SCO_OVER_PCM(u
)
2282 pa_sink_unlink(u
->sink
);
2286 && !USE_SCO_OVER_PCM(u
)
2289 pa_source_unlink(u
->source
);
2293 if (u
->connection
) {
2296 char *speaker
, *mike
;
2297 speaker
= pa_sprintf_malloc("type='signal',sender='org.bluez',interface='org.bluez.Headset',member='SpeakerGainChanged',path='%s'", u
->path
);
2298 mike
= pa_sprintf_malloc("type='signal',sender='org.bluez',interface='org.bluez.Headset',member='MicrophoneGainChanged',path='%s'", u
->path
);
2300 pa_dbus_remove_matches(pa_dbus_connection_get(u
->connection
),
2309 dbus_connection_remove_filter(pa_dbus_connection_get(u
->connection
), filter_cb
, u
);
2310 pa_dbus_connection_unref(u
->connection
);
2314 pa_card_free(u
->card
);
2316 if (u
->read_smoother
)
2317 pa_smoother_free(u
->read_smoother
);
2322 pa_xfree(u
->a2dp
.buffer
);
2324 sbc_finish(&u
->a2dp
.sbc
);
2327 pa_modargs_free(u
->modargs
);
2329 pa_xfree(u
->address
);
2333 pa_bluetooth_discovery_unref(u
->discovery
);