]> code.delx.au - pulseaudio/blob - src/modules/bluetooth/module-bluetooth-device.c
delx.au / code / pulseaudio / blob


f82033aa24bec922771ff7c7418cc2cded025f54
[pulseaudio] / src / modules / bluetooth / module-bluetooth-device.c
1 /***
2 This file is part of PulseAudio.
3
4 Copyright 2008-2009 Joao Paulo Rechi Vita
5 Copyright 2011-2012 BMW Car IT GmbH.
6
7 PulseAudio is free software; you can redistribute it and/or modify
8 it under the terms of the GNU Lesser General Public License as
9 published by the Free Software Foundation; either version 2.1 of the
10 License, or (at your option) any later version.
11
12 PulseAudio is distributed in the hope that it will be useful, but
13 WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 General Public License for more details.
16
17 You should have received a copy of the GNU Lesser General Public
18 License along with PulseAudio; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
20 USA.
21 ***/
22
23 #ifdef HAVE_CONFIG_H
24 #include <config.h>
25 #endif
26
27 #include <string.h>
28 #include <errno.h>
29 #include <math.h>
30 #include <linux/sockios.h>
31 #include <arpa/inet.h>
32
33 #include <pulse/rtclock.h>
34 #include <pulse/sample.h>
35 #include <pulse/timeval.h>
36 #include <pulse/xmalloc.h>
37
38 #include <pulsecore/i18n.h>
39 #include <pulsecore/module.h>
40 #include <pulsecore/modargs.h>
41 #include <pulsecore/core-rtclock.h>
42 #include <pulsecore/core-util.h>
43 #include <pulsecore/core-error.h>
44 #include <pulsecore/shared.h>
45 #include <pulsecore/socket-util.h>
46 #include <pulsecore/thread.h>
47 #include <pulsecore/thread-mq.h>
48 #include <pulsecore/poll.h>
49 #include <pulsecore/rtpoll.h>
50 #include <pulsecore/time-smoother.h>
51 #include <pulsecore/namereg.h>
52
53 #include <sbc/sbc.h>
54
55 #include "module-bluetooth-device-symdef.h"
56 #include "a2dp-codecs.h"
57 #include "rtp.h"
58 #include "bluetooth-util.h"
59
60 #define BITPOOL_DEC_LIMIT 32
61 #define BITPOOL_DEC_STEP 5
62
63 PA_MODULE_AUTHOR("Joao Paulo Rechi Vita");
64 PA_MODULE_DESCRIPTION("Bluetooth audio sink and source");
65 PA_MODULE_VERSION(PACKAGE_VERSION);
66 PA_MODULE_LOAD_ONCE(false);
67 PA_MODULE_USAGE(
68 "name=<name for the card/sink/source, to be prefixed> "
69 "card_name=<name for the card> "
70 "card_properties=<properties for the card> "
71 "sink_name=<name for the sink> "
72 "sink_properties=<properties for the sink> "
73 "source_name=<name for the source> "
74 "source_properties=<properties for the source> "
75 "address=<address of the device> "
76 "profile=<a2dp|hsp|hfgw> "
77 "rate=<sample rate> "
78 "channels=<number of channels> "
79 "path=<device object path> "
80 "auto_connect=<automatically connect?> "
81 "sco_sink=<SCO over PCM sink name> "
82 "sco_source=<SCO over PCM source name>");
83
84 /* TODO: not close fd when entering suspend mode in a2dp */
85
86 static const char* const valid_modargs[] = {
87 "name",
88 "card_name",
89 "card_properties",
90 "sink_name",
91 "sink_properties",
92 "source_name",
93 "source_properties",
94 "address",
95 "profile",
96 "rate",
97 "channels",
98 "path",
99 "auto_connect",
100 "sco_sink",
101 "sco_source",
102 NULL
103 };
104
105 struct a2dp_info {
106 sbc_t sbc; /* Codec data */
107 bool sbc_initialized; /* Keep track if the encoder is initialized */
108 size_t codesize, frame_length; /* SBC Codesize, frame_length. We simply cache those values here */
109
110 void* buffer; /* Codec transfer buffer */
111 size_t buffer_size; /* Size of the buffer */
112
113 uint16_t seq_num; /* Cumulative packet sequence */
114 uint8_t min_bitpool;
115 uint8_t max_bitpool;
116 };
117
118 struct hsp_info {
119 pa_sink *sco_sink;
120 void (*sco_sink_set_volume)(pa_sink *s);
121 pa_source *sco_source;
122 void (*sco_source_set_volume)(pa_source *s);
123 };
124
125 struct bluetooth_msg {
126 pa_msgobject parent;
127 pa_card *card;
128 };
129
130 typedef struct bluetooth_msg bluetooth_msg;
131 PA_DEFINE_PRIVATE_CLASS(bluetooth_msg, pa_msgobject);
132 #define BLUETOOTH_MSG(o) (bluetooth_msg_cast(o))
133
134 struct userdata {
135 pa_core *core;
136 pa_module *module;
137
138 pa_bluetooth_device *device;
139 pa_hook_slot *uuid_added_slot;
140 char *address;
141 char *path;
142 pa_bluetooth_transport *transport;
143 bool transport_acquired;
144 pa_hook_slot *discovery_slot;
145 pa_hook_slot *sink_state_changed_slot;
146 pa_hook_slot *source_state_changed_slot;
147 pa_hook_slot *transport_state_changed_slot;
148 pa_hook_slot *transport_nrec_changed_slot;
149 pa_hook_slot *transport_microphone_changed_slot;
150 pa_hook_slot *transport_speaker_changed_slot;
151
152 pa_bluetooth_discovery *discovery;
153 bool auto_connect;
154
155 char *output_port_name;
156 char *input_port_name;
157
158 pa_card *card;
159 pa_sink *sink;
160 pa_source *source;
161
162 pa_thread_mq thread_mq;
163 pa_rtpoll *rtpoll;
164 pa_rtpoll_item *rtpoll_item;
165 pa_thread *thread;
166 bluetooth_msg *msg;
167
168 uint64_t read_index, write_index;
169 pa_usec_t started_at;
170 pa_smoother *read_smoother;
171
172 pa_memchunk write_memchunk;
173
174 pa_sample_spec sample_spec, requested_sample_spec;
175
176 int stream_fd;
177
178 size_t read_link_mtu;
179 size_t read_block_size;
180
181 size_t write_link_mtu;
182 size_t write_block_size;
183
184 struct a2dp_info a2dp;
185 struct hsp_info hsp;
186
187 enum profile profile;
188
189 pa_modargs *modargs;
190
191 int stream_write_type;
192 };
193
194 enum {
195 BLUETOOTH_MESSAGE_IO_THREAD_FAILED,
196 BLUETOOTH_MESSAGE_MAX
197 };
198
199 #define FIXED_LATENCY_PLAYBACK_A2DP (25*PA_USEC_PER_MSEC)
200 #define FIXED_LATENCY_RECORD_A2DP (25*PA_USEC_PER_MSEC)
201 #define FIXED_LATENCY_PLAYBACK_HSP (125*PA_USEC_PER_MSEC)
202 #define FIXED_LATENCY_RECORD_HSP (25*PA_USEC_PER_MSEC)
203
204 #define MAX_PLAYBACK_CATCH_UP_USEC (100*PA_USEC_PER_MSEC)
205
206 #define USE_SCO_OVER_PCM(u) (u->profile == PROFILE_HSP && (u->hsp.sco_sink && u->hsp.sco_source))
207
208 static int init_profile(struct userdata *u);
209
210 /* from IO thread */
211 static void a2dp_set_bitpool(struct userdata *u, uint8_t bitpool)
212 {
213 struct a2dp_info *a2dp;
214
215 pa_assert(u);
216
217 a2dp = &u->a2dp;
218
219 if (a2dp->sbc.bitpool == bitpool)
220 return;
221
222 if (bitpool > a2dp->max_bitpool)
223 bitpool = a2dp->max_bitpool;
224 else if (bitpool < a2dp->min_bitpool)
225 bitpool = a2dp->min_bitpool;
226
227 a2dp->sbc.bitpool = bitpool;
228
229 a2dp->codesize = sbc_get_codesize(&a2dp->sbc);
230 a2dp->frame_length = sbc_get_frame_length(&a2dp->sbc);
231
232 pa_log_debug("Bitpool has changed to %u", a2dp->sbc.bitpool);
233
234 u->read_block_size =
235 (u->read_link_mtu - sizeof(struct rtp_header) - sizeof(struct rtp_payload))
236 / a2dp->frame_length * a2dp->codesize;
237
238 u->write_block_size =
239 (u->write_link_mtu - sizeof(struct rtp_header) - sizeof(struct rtp_payload))
240 / a2dp->frame_length * a2dp->codesize;
241
242 pa_sink_set_max_request_within_thread(u->sink, u->write_block_size);
243 pa_sink_set_fixed_latency_within_thread(u->sink,
244 FIXED_LATENCY_PLAYBACK_A2DP + pa_bytes_to_usec(u->write_block_size, &u->sample_spec));
245 }
246
247 /* from IO thread, except in SCO over PCM */
248 static void bt_transport_config_mtu(struct userdata *u) {
249 /* Calculate block sizes */
250 if (u->profile == PROFILE_HSP || u->profile == PROFILE_HFGW) {
251 u->read_block_size = u->read_link_mtu;
252 u->write_block_size = u->write_link_mtu;
253 } else {
254 u->read_block_size =
255 (u->read_link_mtu - sizeof(struct rtp_header) - sizeof(struct rtp_payload))
256 / u->a2dp.frame_length * u->a2dp.codesize;
257
258 u->write_block_size =
259 (u->write_link_mtu - sizeof(struct rtp_header) - sizeof(struct rtp_payload))
260 / u->a2dp.frame_length * u->a2dp.codesize;
261 }
262
263 if (USE_SCO_OVER_PCM(u))
264 return;
265
266 if (u->sink) {
267 pa_sink_set_max_request_within_thread(u->sink, u->write_block_size);
268 pa_sink_set_fixed_latency_within_thread(u->sink,
269 (u->profile == PROFILE_A2DP ?
270 FIXED_LATENCY_PLAYBACK_A2DP : FIXED_LATENCY_PLAYBACK_HSP) +
271 pa_bytes_to_usec(u->write_block_size, &u->sample_spec));
272 }
273
274 if (u->source)
275 pa_source_set_fixed_latency_within_thread(u->source,
276 (u->profile == PROFILE_A2DP_SOURCE ?
277 FIXED_LATENCY_RECORD_A2DP : FIXED_LATENCY_RECORD_HSP) +
278 pa_bytes_to_usec(u->read_block_size, &u->sample_spec));
279 }
280
281 /* from IO thread, except in SCO over PCM */
282
283 static void setup_stream(struct userdata *u) {
284 struct pollfd *pollfd;
285 int one;
286
287 pa_log_info("Transport %s resuming", u->transport->path);
288
289 bt_transport_config_mtu(u);
290
291 pa_make_fd_nonblock(u->stream_fd);
292 pa_make_socket_low_delay(u->stream_fd);
293
294 one = 1;
295 if (setsockopt(u->stream_fd, SOL_SOCKET, SO_TIMESTAMP, &one, sizeof(one)) < 0)
296 pa_log_warn("Failed to enable SO_TIMESTAMP: %s", pa_cstrerror(errno));
297
298 pa_log_debug("Stream properly set up, we're ready to roll!");
299
300 if (u->profile == PROFILE_A2DP)
301 a2dp_set_bitpool(u, u->a2dp.max_bitpool);
302
303 u->rtpoll_item = pa_rtpoll_item_new(u->rtpoll, PA_RTPOLL_NEVER, 1);
304 pollfd = pa_rtpoll_item_get_pollfd(u->rtpoll_item, NULL);
305 pollfd->fd = u->stream_fd;
306 pollfd->events = pollfd->revents = 0;
307
308 u->read_index = u->write_index = 0;
309 u->started_at = 0;
310
311 if (u->source)
312 u->read_smoother = pa_smoother_new(
313 PA_USEC_PER_SEC,
314 PA_USEC_PER_SEC*2,
315 true,
316 true,
317 10,
318 pa_rtclock_now(),
319 true);
320 }
321
322 static void teardown_stream(struct userdata *u) {
323 if (u->rtpoll_item) {
324 pa_rtpoll_item_free(u->rtpoll_item);
325 u->rtpoll_item = NULL;
326 }
327
328 if (u->stream_fd >= 0) {
329 pa_close(u->stream_fd);
330 u->stream_fd = -1;
331 }
332
333 if (u->read_smoother) {
334 pa_smoother_free(u->read_smoother);
335 u->read_smoother = NULL;
336 }
337
338 if (u->write_memchunk.memblock) {
339 pa_memblock_unref(u->write_memchunk.memblock);
340 pa_memchunk_reset(&u->write_memchunk);
341 }
342
343 pa_log_debug("Audio stream torn down");
344 }
345
346 static void bt_transport_release(struct userdata *u) {
347 pa_assert(u->transport);
348
349 /* Ignore if already released */
350 if (!u->transport_acquired)
351 return;
352
353 pa_log_debug("Releasing transport %s", u->transport->path);
354
355 pa_bluetooth_transport_release(u->transport);
356
357 u->transport_acquired = false;
358
359 teardown_stream(u);
360 }
361
362 static int bt_transport_acquire(struct userdata *u, bool optional) {
363 pa_assert(u->transport);
364
365 if (u->transport_acquired)
366 return 0;
367
368 pa_log_debug("Acquiring transport %s", u->transport->path);
369
370 u->stream_fd = pa_bluetooth_transport_acquire(u->transport, optional, &u->read_link_mtu, &u->write_link_mtu);
371 if (u->stream_fd < 0)
372 return -1;
373
374 u->transport_acquired = true;
375 pa_log_info("Transport %s acquired: fd %d", u->transport->path, u->stream_fd);
376
377 return 0;
378 }
379
380 /* Run from IO thread */
381 static int sink_process_msg(pa_msgobject *o, int code, void *data, int64_t offset, pa_memchunk *chunk) {
382 struct userdata *u = PA_SINK(o)->userdata;
383 bool failed = false;
384 int r;
385
386 pa_assert(u->sink == PA_SINK(o));
387 pa_assert(u->transport);
388
389 switch (code) {
390
391 case PA_SINK_MESSAGE_SET_STATE:
392
393 switch ((pa_sink_state_t) PA_PTR_TO_UINT(data)) {
394
395 case PA_SINK_SUSPENDED:
396 /* Ignore if transition is PA_SINK_INIT->PA_SINK_SUSPENDED */
397 if (!PA_SINK_IS_OPENED(u->sink->thread_info.state))
398 break;
399
400 /* Stop the device if the source is suspended as well */
401 if (!u->source || u->source->state == PA_SOURCE_SUSPENDED)
402 /* We deliberately ignore whether stopping
403 * actually worked. Since the stream_fd is
404 * closed it doesn't really matter */
405 bt_transport_release(u);
406
407 break;
408
409 case PA_SINK_IDLE:
410 case PA_SINK_RUNNING:
411 if (u->sink->thread_info.state != PA_SINK_SUSPENDED)
412 break;
413
414 /* Resume the device if the source was suspended as well */
415 if (!u->source || !PA_SOURCE_IS_OPENED(u->source->thread_info.state)) {
416 if (bt_transport_acquire(u, false) < 0)
417 failed = true;
418 else
419 setup_stream(u);
420 }
421 break;
422
423 case PA_SINK_UNLINKED:
424 case PA_SINK_INIT:
425 case PA_SINK_INVALID_STATE:
426 ;
427 }
428 break;
429
430 case PA_SINK_MESSAGE_GET_LATENCY: {
431
432 if (u->read_smoother) {
433 pa_usec_t wi, ri;
434
435 ri = pa_smoother_get(u->read_smoother, pa_rtclock_now());
436 wi = pa_bytes_to_usec(u->write_index + u->write_block_size, &u->sample_spec);
437
438 *((pa_usec_t*) data) = wi > ri ? wi - ri : 0;
439 } else {
440 pa_usec_t ri, wi;
441
442 ri = pa_rtclock_now() - u->started_at;
443 wi = pa_bytes_to_usec(u->write_index, &u->sample_spec);
444
445 *((pa_usec_t*) data) = wi > ri ? wi - ri : 0;
446 }
447
448 *((pa_usec_t*) data) += u->sink->thread_info.fixed_latency;
449 return 0;
450 }
451 }
452
453 r = pa_sink_process_msg(o, code, data, offset, chunk);
454
455 return (r < 0 || !failed) ? r : -1;
456 }
457
458 /* Run from IO thread */
459 static int source_process_msg(pa_msgobject *o, int code, void *data, int64_t offset, pa_memchunk *chunk) {
460 struct userdata *u = PA_SOURCE(o)->userdata;
461 bool failed = false;
462 int r;
463
464 pa_assert(u->source == PA_SOURCE(o));
465 pa_assert(u->transport);
466
467 switch (code) {
468
469 case PA_SOURCE_MESSAGE_SET_STATE:
470
471 switch ((pa_source_state_t) PA_PTR_TO_UINT(data)) {
472
473 case PA_SOURCE_SUSPENDED:
474 /* Ignore if transition is PA_SOURCE_INIT->PA_SOURCE_SUSPENDED */
475 if (!PA_SOURCE_IS_OPENED(u->source->thread_info.state))
476 break;
477
478 /* Stop the device if the sink is suspended as well */
479 if (!u->sink || u->sink->state == PA_SINK_SUSPENDED)
480 bt_transport_release(u);
481
482 if (u->read_smoother)
483 pa_smoother_pause(u->read_smoother, pa_rtclock_now());
484 break;
485
486 case PA_SOURCE_IDLE:
487 case PA_SOURCE_RUNNING:
488 if (u->source->thread_info.state != PA_SOURCE_SUSPENDED)
489 break;
490
491 /* Resume the device if the sink was suspended as well */
492 if (!u->sink || !PA_SINK_IS_OPENED(u->sink->thread_info.state)) {
493 if (bt_transport_acquire(u, false) < 0)
494 failed = true;
495 else
496 setup_stream(u);
497 }
498 /* We don't resume the smoother here. Instead we
499 * wait until the first packet arrives */
500 break;
501
502 case PA_SOURCE_UNLINKED:
503 case PA_SOURCE_INIT:
504 case PA_SOURCE_INVALID_STATE:
505 ;
506 }
507 break;
508
509 case PA_SOURCE_MESSAGE_GET_LATENCY: {
510 pa_usec_t wi, ri;
511
512 if (u->read_smoother) {
513 wi = pa_smoother_get(u->read_smoother, pa_rtclock_now());
514 ri = pa_bytes_to_usec(u->read_index, &u->sample_spec);
515
516 *((pa_usec_t*) data) = (wi > ri ? wi - ri : 0) + u->source->thread_info.fixed_latency;
517 } else
518 *((pa_usec_t*) data) = 0;
519
520 return 0;
521 }
522
523 }
524
525 r = pa_source_process_msg(o, code, data, offset, chunk);
526
527 return (r < 0 || !failed) ? r : -1;
528 }
529
530 /* Called from main thread context */
531 static int device_process_msg(pa_msgobject *obj, int code, void *data, int64_t offset, pa_memchunk *chunk) {
532 struct bluetooth_msg *u = BLUETOOTH_MSG(obj);
533
534 switch (code) {
535 case BLUETOOTH_MESSAGE_IO_THREAD_FAILED: {
536 if (u->card->module->unload_requested)
537 break;
538
539 pa_log_debug("Switching the profile to off due to IO thread failure.");
540
541 pa_assert_se(pa_card_set_profile(u->card, "off", false) >= 0);
542 break;
543 }
544 }
545 return 0;
546 }
547
548 /* Run from IO thread */
549 static int hsp_process_render(struct userdata *u) {
550 int ret = 0;
551
552 pa_assert(u);
553 pa_assert(u->profile == PROFILE_HSP || u->profile == PROFILE_HFGW);
554 pa_assert(u->sink);
555
556 /* First, render some data */
557 if (!u->write_memchunk.memblock)
558 pa_sink_render_full(u->sink, u->write_block_size, &u->write_memchunk);
559
560 pa_assert(u->write_memchunk.length == u->write_block_size);
561
562 for (;;) {
563 ssize_t l;
564 const void *p;
565
566 /* Now write that data to the socket. The socket is of type
567 * SEQPACKET, and we generated the data of the MTU size, so this
568 * should just work. */
569
570 p = (const uint8_t *) pa_memblock_acquire_chunk(&u->write_memchunk);
571 l = pa_write(u->stream_fd, p, u->write_memchunk.length, &u->stream_write_type);
572 pa_memblock_release(u->write_memchunk.memblock);
573
574 pa_assert(l != 0);
575
576 if (l < 0) {
577
578 if (errno == EINTR)
579 /* Retry right away if we got interrupted */
580 continue;
581
582 else if (errno == EAGAIN)
583 /* Hmm, apparently the socket was not writable, give up for now */
584 break;
585
586 pa_log_error("Failed to write data to SCO socket: %s", pa_cstrerror(errno));
587 ret = -1;
588 break;
589 }
590
591 pa_assert((size_t) l <= u->write_memchunk.length);
592
593 if ((size_t) l != u->write_memchunk.length) {
594 pa_log_error("Wrote memory block to socket only partially! %llu written, wanted to write %llu.",
595 (unsigned long long) l,
596 (unsigned long long) u->write_memchunk.length);
597 ret = -1;
598 break;
599 }
600
601 u->write_index += (uint64_t) u->write_memchunk.length;
602 pa_memblock_unref(u->write_memchunk.memblock);
603 pa_memchunk_reset(&u->write_memchunk);
604
605 ret = 1;
606 break;
607 }
608
609 return ret;
610 }
611
612 /* Run from IO thread */
613 static int hsp_process_push(struct userdata *u) {
614 int ret = 0;
615 pa_memchunk memchunk;
616
617 pa_assert(u);
618 pa_assert(u->profile == PROFILE_HSP || u->profile == PROFILE_HFGW);
619 pa_assert(u->source);
620 pa_assert(u->read_smoother);
621
622 memchunk.memblock = pa_memblock_new(u->core->mempool, u->read_block_size);
623 memchunk.index = memchunk.length = 0;
624
625 for (;;) {
626 ssize_t l;
627 void *p;
628 struct msghdr m;
629 struct cmsghdr *cm;
630 uint8_t aux[1024];
631 struct iovec iov;
632 bool found_tstamp = false;
633 pa_usec_t tstamp;
634
635 memset(&m, 0, sizeof(m));
636 memset(&aux, 0, sizeof(aux));
637 memset(&iov, 0, sizeof(iov));
638
639 m.msg_iov = &iov;
640 m.msg_iovlen = 1;
641 m.msg_control = aux;
642 m.msg_controllen = sizeof(aux);
643
644 p = pa_memblock_acquire(memchunk.memblock);
645 iov.iov_base = p;
646 iov.iov_len = pa_memblock_get_length(memchunk.memblock);
647 l = recvmsg(u->stream_fd, &m, 0);
648 pa_memblock_release(memchunk.memblock);
649
650 if (l <= 0) {
651
652 if (l < 0 && errno == EINTR)
653 /* Retry right away if we got interrupted */
654 continue;
655
656 else if (l < 0 && errno == EAGAIN)
657 /* Hmm, apparently the socket was not readable, give up for now. */
658 break;
659
660 pa_log_error("Failed to read data from SCO socket: %s", l < 0 ? pa_cstrerror(errno) : "EOF");
661 ret = -1;
662 break;
663 }
664
665 pa_assert((size_t) l <= pa_memblock_get_length(memchunk.memblock));
666
667 /* In some rare occasions, we might receive packets of a very strange
668 * size. This could potentially be possible if the SCO packet was
669 * received partially over-the-air, or more probably due to hardware
670 * issues in our Bluetooth adapter. In these cases, in order to avoid
671 * an assertion failure due to unaligned data, just discard the whole
672 * packet */
673 if (!pa_frame_aligned(l, &u->sample_spec)) {
674 pa_log_warn("SCO packet received of unaligned size: %zu", l);
675 break;
676 }
677
678 memchunk.length = (size_t) l;
679 u->read_index += (uint64_t) l;
680
681 for (cm = CMSG_FIRSTHDR(&m); cm; cm = CMSG_NXTHDR(&m, cm))
682 if (cm->cmsg_level == SOL_SOCKET && cm->cmsg_type == SO_TIMESTAMP) {
683 struct timeval *tv = (struct timeval*) CMSG_DATA(cm);
684 pa_rtclock_from_wallclock(tv);
685 tstamp = pa_timeval_load(tv);
686 found_tstamp = true;
687 break;
688 }
689
690 if (!found_tstamp) {
691 pa_log_warn("Couldn't find SO_TIMESTAMP data in auxiliary recvmsg() data!");
692 tstamp = pa_rtclock_now();
693 }
694
695 pa_smoother_put(u->read_smoother, tstamp, pa_bytes_to_usec(u->read_index, &u->sample_spec));
696 pa_smoother_resume(u->read_smoother, tstamp, true);
697
698 pa_source_post(u->source, &memchunk);
699
700 ret = l;
701 break;
702 }
703
704 pa_memblock_unref(memchunk.memblock);
705
706 return ret;
707 }
708
709 /* Run from IO thread */
710 static void a2dp_prepare_buffer(struct userdata *u) {
711 size_t min_buffer_size = PA_MAX(u->read_link_mtu, u->write_link_mtu);
712
713 pa_assert(u);
714
715 if (u->a2dp.buffer_size >= min_buffer_size)
716 return;
717
718 u->a2dp.buffer_size = 2 * min_buffer_size;
719 pa_xfree(u->a2dp.buffer);
720 u->a2dp.buffer = pa_xmalloc(u->a2dp.buffer_size);
721 }
722
723 /* Run from IO thread */
724 static int a2dp_process_render(struct userdata *u) {
725 struct a2dp_info *a2dp;
726 struct rtp_header *header;
727 struct rtp_payload *payload;
728 size_t nbytes;
729 void *d;
730 const void *p;
731 size_t to_write, to_encode;
732 unsigned frame_count;
733 int ret = 0;
734
735 pa_assert(u);
736 pa_assert(u->profile == PROFILE_A2DP);
737 pa_assert(u->sink);
738
739 /* First, render some data */
740 if (!u->write_memchunk.memblock)
741 pa_sink_render_full(u->sink, u->write_block_size, &u->write_memchunk);
742
743 pa_assert(u->write_memchunk.length == u->write_block_size);
744
745 a2dp_prepare_buffer(u);
746
747 a2dp = &u->a2dp;
748 header = a2dp->buffer;
749 payload = (struct rtp_payload*) ((uint8_t*) a2dp->buffer + sizeof(*header));
750
751 frame_count = 0;
752
753 /* Try to create a packet of the full MTU */
754
755 p = (const uint8_t *) pa_memblock_acquire_chunk(&u->write_memchunk);
756 to_encode = u->write_memchunk.length;
757
758 d = (uint8_t*) a2dp->buffer + sizeof(*header) + sizeof(*payload);
759 to_write = a2dp->buffer_size - sizeof(*header) - sizeof(*payload);
760
761 while (PA_LIKELY(to_encode > 0 && to_write > 0)) {
762 ssize_t written;
763 ssize_t encoded;
764
765 encoded = sbc_encode(&a2dp->sbc,
766 p, to_encode,
767 d, to_write,
768 &written);
769
770 if (PA_UNLIKELY(encoded <= 0)) {
771 pa_log_error("SBC encoding error (%li)", (long) encoded);
772 pa_memblock_release(u->write_memchunk.memblock);
773 return -1;
774 }
775
776 /* pa_log_debug("SBC: encoded: %lu; written: %lu", (unsigned long) encoded, (unsigned long) written); */
777 /* pa_log_debug("SBC: codesize: %lu; frame_length: %lu", (unsigned long) a2dp->codesize, (unsigned long) a2dp->frame_length); */
778
779 pa_assert_fp((size_t) encoded <= to_encode);
780 pa_assert_fp((size_t) encoded == a2dp->codesize);
781
782 pa_assert_fp((size_t) written <= to_write);
783 pa_assert_fp((size_t) written == a2dp->frame_length);
784
785 p = (const uint8_t*) p + encoded;
786 to_encode -= encoded;
787
788 d = (uint8_t*) d + written;
789 to_write -= written;
790
791 frame_count++;
792 }
793
794 pa_memblock_release(u->write_memchunk.memblock);
795
796 pa_assert(to_encode == 0);
797
798 PA_ONCE_BEGIN {
799 pa_log_debug("Using SBC encoder implementation: %s", pa_strnull(sbc_get_implementation_info(&a2dp->sbc)));
800 } PA_ONCE_END;
801
802 /* write it to the fifo */
803 memset(a2dp->buffer, 0, sizeof(*header) + sizeof(*payload));
804 header->v = 2;
805 header->pt = 1;
806 header->sequence_number = htons(a2dp->seq_num++);
807 header->timestamp = htonl(u->write_index / pa_frame_size(&u->sample_spec));
808 header->ssrc = htonl(1);
809 payload->frame_count = frame_count;
810
811 nbytes = (uint8_t*) d - (uint8_t*) a2dp->buffer;
812
813 for (;;) {
814 ssize_t l;
815
816 l = pa_write(u->stream_fd, a2dp->buffer, nbytes, &u->stream_write_type);
817
818 pa_assert(l != 0);
819
820 if (l < 0) {
821
822 if (errno == EINTR)
823 /* Retry right away if we got interrupted */
824 continue;
825
826 else if (errno == EAGAIN)
827 /* Hmm, apparently the socket was not writable, give up for now */
828 break;
829
830 pa_log_error("Failed to write data to socket: %s", pa_cstrerror(errno));
831 ret = -1;
832 break;
833 }
834
835 pa_assert((size_t) l <= nbytes);
836
837 if ((size_t) l != nbytes) {
838 pa_log_warn("Wrote memory block to socket only partially! %llu written, wanted to write %llu.",
839 (unsigned long long) l,
840 (unsigned long long) nbytes);
841 ret = -1;
842 break;
843 }
844
845 u->write_index += (uint64_t) u->write_memchunk.length;
846 pa_memblock_unref(u->write_memchunk.memblock);
847 pa_memchunk_reset(&u->write_memchunk);
848
849 ret = 1;
850
851 break;
852 }
853
854 return ret;
855 }
856
857 static int a2dp_process_push(struct userdata *u) {
858 int ret = 0;
859 pa_memchunk memchunk;
860
861 pa_assert(u);
862 pa_assert(u->profile == PROFILE_A2DP_SOURCE);
863 pa_assert(u->source);
864 pa_assert(u->read_smoother);
865
866 memchunk.memblock = pa_memblock_new(u->core->mempool, u->read_block_size);
867 memchunk.index = memchunk.length = 0;
868
869 for (;;) {
870 bool found_tstamp = false;
871 pa_usec_t tstamp;
872 struct a2dp_info *a2dp;
873 struct rtp_header *header;
874 struct rtp_payload *payload;
875 const void *p;
876 void *d;
877 ssize_t l;
878 size_t to_write, to_decode;
879
880 a2dp_prepare_buffer(u);
881
882 a2dp = &u->a2dp;
883 header = a2dp->buffer;
884 payload = (struct rtp_payload*) ((uint8_t*) a2dp->buffer + sizeof(*header));
885
886 l = pa_read(u->stream_fd, a2dp->buffer, a2dp->buffer_size, &u->stream_write_type);
887
888 if (l <= 0) {
889
890 if (l < 0 && errno == EINTR)
891 /* Retry right away if we got interrupted */
892 continue;
893
894 else if (l < 0 && errno == EAGAIN)
895 /* Hmm, apparently the socket was not readable, give up for now. */
896 break;
897
898 pa_log_error("Failed to read data from socket: %s", l < 0 ? pa_cstrerror(errno) : "EOF");
899 ret = -1;
900 break;
901 }
902
903 pa_assert((size_t) l <= a2dp->buffer_size);
904
905 u->read_index += (uint64_t) l;
906
907 /* TODO: get timestamp from rtp */
908 if (!found_tstamp) {
909 /* pa_log_warn("Couldn't find SO_TIMESTAMP data in auxiliary recvmsg() data!"); */
910 tstamp = pa_rtclock_now();
911 }
912
913 pa_smoother_put(u->read_smoother, tstamp, pa_bytes_to_usec(u->read_index, &u->sample_spec));
914 pa_smoother_resume(u->read_smoother, tstamp, true);
915
916 p = (uint8_t*) a2dp->buffer + sizeof(*header) + sizeof(*payload);
917 to_decode = l - sizeof(*header) - sizeof(*payload);
918
919 d = pa_memblock_acquire(memchunk.memblock);
920 to_write = memchunk.length = pa_memblock_get_length(memchunk.memblock);
921
922 while (PA_LIKELY(to_decode > 0)) {
923 size_t written;
924 ssize_t decoded;
925
926 decoded = sbc_decode(&a2dp->sbc,
927 p, to_decode,
928 d, to_write,
929 &written);
930
931 if (PA_UNLIKELY(decoded <= 0)) {
932 pa_log_error("SBC decoding error (%li)", (long) decoded);
933 pa_memblock_release(memchunk.memblock);
934 pa_memblock_unref(memchunk.memblock);
935 return -1;
936 }
937
938 /* pa_log_debug("SBC: decoded: %lu; written: %lu", (unsigned long) decoded, (unsigned long) written); */
939 /* pa_log_debug("SBC: frame_length: %lu; codesize: %lu", (unsigned long) a2dp->frame_length, (unsigned long) a2dp->codesize); */
940
941 /* Reset frame length, it can be changed due to bitpool change */
942 a2dp->frame_length = sbc_get_frame_length(&a2dp->sbc);
943
944 pa_assert_fp((size_t) decoded <= to_decode);
945 pa_assert_fp((size_t) decoded == a2dp->frame_length);
946
947 pa_assert_fp((size_t) written == a2dp->codesize);
948
949 p = (const uint8_t*) p + decoded;
950 to_decode -= decoded;
951
952 d = (uint8_t*) d + written;
953 to_write -= written;
954 }
955
956 memchunk.length -= to_write;
957
958 pa_memblock_release(memchunk.memblock);
959
960 pa_source_post(u->source, &memchunk);
961
962 ret = l;
963 break;
964 }
965
966 pa_memblock_unref(memchunk.memblock);
967
968 return ret;
969 }
970
971 static void a2dp_reduce_bitpool(struct userdata *u)
972 {
973 struct a2dp_info *a2dp;
974 uint8_t bitpool;
975
976 pa_assert(u);
977
978 a2dp = &u->a2dp;
979
980 /* Check if bitpool is already at its limit */
981 if (a2dp->sbc.bitpool <= BITPOOL_DEC_LIMIT)
982 return;
983
984 bitpool = a2dp->sbc.bitpool - BITPOOL_DEC_STEP;
985
986 if (bitpool < BITPOOL_DEC_LIMIT)
987 bitpool = BITPOOL_DEC_LIMIT;
988
989 a2dp_set_bitpool(u, bitpool);
990 }
991
992 static void thread_func(void *userdata) {
993 struct userdata *u = userdata;
994 unsigned do_write = 0;
995 unsigned pending_read_bytes = 0;
996 bool writable = false;
997
998 pa_assert(u);
999 pa_assert(u->transport);
1000
1001 pa_log_debug("IO Thread starting up");
1002
1003 if (u->core->realtime_scheduling)
1004 pa_make_realtime(u->core->realtime_priority);
1005
1006 pa_thread_mq_install(&u->thread_mq);
1007
1008 /* Setup the stream only if the transport was already acquired */
1009 if (u->transport_acquired)
1010 setup_stream(u);
1011
1012 for (;;) {
1013 struct pollfd *pollfd;
1014 int ret;
1015 bool disable_timer = true;
1016
1017 pollfd = u->rtpoll_item ? pa_rtpoll_item_get_pollfd(u->rtpoll_item, NULL) : NULL;
1018
1019 if (u->source && PA_SOURCE_IS_LINKED(u->source->thread_info.state)) {
1020
1021 /* We should send two blocks to the device before we expect
1022 * a response. */
1023
1024 if (u->write_index == 0 && u->read_index <= 0)
1025 do_write = 2;
1026
1027 if (pollfd && (pollfd->revents & POLLIN)) {
1028 int n_read;
1029
1030 if (u->profile == PROFILE_HSP || u->profile == PROFILE_HFGW)
1031 n_read = hsp_process_push(u);
1032 else
1033 n_read = a2dp_process_push(u);
1034
1035 if (n_read < 0)
1036 goto io_fail;
1037
1038 /* We just read something, so we are supposed to write something, too */
1039 pending_read_bytes += n_read;
1040 do_write += pending_read_bytes / u->write_block_size;
1041 pending_read_bytes = pending_read_bytes % u->write_block_size;
1042 }
1043 }
1044
1045 if (u->sink && PA_SINK_IS_LINKED(u->sink->thread_info.state)) {
1046
1047 if (PA_UNLIKELY(u->sink->thread_info.rewind_requested))
1048 pa_sink_process_rewind(u->sink, 0);
1049
1050 if (pollfd) {
1051 if (pollfd->revents & POLLOUT)
1052 writable = true;
1053
1054 if ((!u->source || !PA_SOURCE_IS_LINKED(u->source->thread_info.state)) && do_write <= 0 && writable) {
1055 pa_usec_t time_passed;
1056 pa_usec_t audio_sent;
1057
1058 /* Hmm, there is no input stream we could synchronize
1059 * to. So let's do things by time */
1060
1061 time_passed = pa_rtclock_now() - u->started_at;
1062 audio_sent = pa_bytes_to_usec(u->write_index, &u->sample_spec);
1063
1064 if (audio_sent <= time_passed) {
1065 pa_usec_t audio_to_send = time_passed - audio_sent;
1066
1067 /* Never try to catch up for more than 100ms */
1068 if (u->write_index > 0 && audio_to_send > MAX_PLAYBACK_CATCH_UP_USEC) {
1069 pa_usec_t skip_usec;
1070 uint64_t skip_bytes;
1071
1072 skip_usec = audio_to_send - MAX_PLAYBACK_CATCH_UP_USEC;
1073 skip_bytes = pa_usec_to_bytes(skip_usec, &u->sample_spec);
1074
1075 if (skip_bytes > 0) {
1076 pa_memchunk tmp;
1077
1078 pa_log_warn("Skipping %llu us (= %llu bytes) in audio stream",
1079 (unsigned long long) skip_usec,
1080 (unsigned long long) skip_bytes);
1081
1082 pa_sink_render_full(u->sink, skip_bytes, &tmp);
1083 pa_memblock_unref(tmp.memblock);
1084 u->write_index += skip_bytes;
1085
1086 if (u->profile == PROFILE_A2DP)
1087 a2dp_reduce_bitpool(u);
1088 }
1089 }
1090
1091 do_write = 1;
1092 pending_read_bytes = 0;
1093 }
1094 }
1095
1096 if (writable && do_write > 0) {
1097 int n_written;
1098
1099 if (u->write_index <= 0)
1100 u->started_at = pa_rtclock_now();
1101
1102 if (u->profile == PROFILE_A2DP) {
1103 if ((n_written = a2dp_process_render(u)) < 0)
1104 goto io_fail;
1105 } else {
1106 if ((n_written = hsp_process_render(u)) < 0)
1107 goto io_fail;
1108 }
1109
1110 if (n_written == 0)
1111 pa_log("Broken kernel: we got EAGAIN on write() after POLLOUT!");
1112
1113 do_write -= n_written;
1114 writable = false;
1115 }
1116
1117 if ((!u->source || !PA_SOURCE_IS_LINKED(u->source->thread_info.state)) && do_write <= 0) {
1118 pa_usec_t sleep_for;
1119 pa_usec_t time_passed, next_write_at;
1120
1121 if (writable) {
1122 /* Hmm, there is no input stream we could synchronize
1123 * to. So let's estimate when we need to wake up the latest */
1124 time_passed = pa_rtclock_now() - u->started_at;
1125 next_write_at = pa_bytes_to_usec(u->write_index, &u->sample_spec);
1126 sleep_for = time_passed < next_write_at ? next_write_at - time_passed : 0;
1127 /* 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); */
1128 } else
1129 /* drop stream every 500 ms */
1130 sleep_for = PA_USEC_PER_MSEC * 500;
1131
1132 pa_rtpoll_set_timer_relative(u->rtpoll, sleep_for);
1133 disable_timer = false;
1134 }
1135 }
1136 }
1137
1138 if (disable_timer)
1139 pa_rtpoll_set_timer_disabled(u->rtpoll);
1140
1141 /* Hmm, nothing to do. Let's sleep */
1142 if (pollfd)
1143 pollfd->events = (short) (((u->sink && PA_SINK_IS_LINKED(u->sink->thread_info.state) && !writable) ? POLLOUT : 0) |
1144 (u->source && PA_SOURCE_IS_LINKED(u->source->thread_info.state) ? POLLIN : 0));
1145
1146 if ((ret = pa_rtpoll_run(u->rtpoll, true)) < 0) {
1147 pa_log_debug("pa_rtpoll_run failed with: %d", ret);
1148 goto fail;
1149 }
1150 if (ret == 0) {
1151 pa_log_debug("IO thread shutdown requested, stopping cleanly");
1152 bt_transport_release(u);
1153 goto finish;
1154 }
1155
1156 pollfd = u->rtpoll_item ? pa_rtpoll_item_get_pollfd(u->rtpoll_item, NULL) : NULL;
1157
1158 if (pollfd && (pollfd->revents & ~(POLLOUT|POLLIN))) {
1159 pa_log_info("FD error: %s%s%s%s",
1160 pollfd->revents & POLLERR ? "POLLERR " :"",
1161 pollfd->revents & POLLHUP ? "POLLHUP " :"",
1162 pollfd->revents & POLLPRI ? "POLLPRI " :"",
1163 pollfd->revents & POLLNVAL ? "POLLNVAL " :"");
1164 goto io_fail;
1165 }
1166
1167 continue;
1168
1169 io_fail:
1170 /* In case of HUP, just tear down the streams */
1171 if (!pollfd || (pollfd->revents & POLLHUP) == 0)
1172 goto fail;
1173
1174 do_write = 0;
1175 pending_read_bytes = 0;
1176 writable = false;
1177
1178 teardown_stream(u);
1179 }
1180
1181 fail:
1182 /* If this was no regular exit from the loop we have to continue processing messages until we receive PA_MESSAGE_SHUTDOWN */
1183 pa_log_debug("IO thread failed");
1184 pa_asyncmsgq_post(pa_thread_mq_get()->outq, PA_MSGOBJECT(u->msg), BLUETOOTH_MESSAGE_IO_THREAD_FAILED, NULL, 0, NULL, NULL);
1185 pa_asyncmsgq_wait_for(u->thread_mq.inq, PA_MESSAGE_SHUTDOWN);
1186
1187 finish:
1188 pa_log_debug("IO thread shutting down");
1189 }
1190
1191 static pa_available_t transport_state_to_availability(pa_bluetooth_transport_state_t state) {
1192 if (state == PA_BLUETOOTH_TRANSPORT_STATE_DISCONNECTED)
1193 return PA_AVAILABLE_NO;
1194 else if (state >= PA_BLUETOOTH_TRANSPORT_STATE_PLAYING)
1195 return PA_AVAILABLE_YES;
1196 else
1197 return PA_AVAILABLE_UNKNOWN;
1198 }
1199
1200 static pa_direction_t get_profile_direction(enum profile p) {
1201 static const pa_direction_t profile_direction[] = {
1202 [PROFILE_A2DP] = PA_DIRECTION_OUTPUT,
1203 [PROFILE_A2DP_SOURCE] = PA_DIRECTION_INPUT,
1204 [PROFILE_HSP] = PA_DIRECTION_INPUT | PA_DIRECTION_OUTPUT,
1205 [PROFILE_HFGW] = PA_DIRECTION_INPUT | PA_DIRECTION_OUTPUT,
1206 [PROFILE_OFF] = 0
1207 };
1208
1209 return profile_direction[p];
1210 }
1211
1212 /* Run from main thread */
1213 static pa_available_t get_port_availability(struct userdata *u, pa_direction_t direction) {
1214 pa_available_t result = PA_AVAILABLE_NO;
1215 unsigned i;
1216
1217 pa_assert(u);
1218 pa_assert(u->device);
1219
1220 for (i = 0; i < PA_BLUETOOTH_PROFILE_COUNT; i++) {
1221 pa_bluetooth_transport *transport;
1222
1223 if (!(get_profile_direction(i) & direction))
1224 continue;
1225
1226 if (!(transport = u->device->transports[i]))
1227 continue;
1228
1229 switch(transport->state) {
1230 case PA_BLUETOOTH_TRANSPORT_STATE_DISCONNECTED:
1231 continue;
1232
1233 case PA_BLUETOOTH_TRANSPORT_STATE_IDLE:
1234 if (result == PA_AVAILABLE_NO)
1235 result = PA_AVAILABLE_UNKNOWN;
1236
1237 break;
1238
1239 case PA_BLUETOOTH_TRANSPORT_STATE_PLAYING:
1240 return PA_AVAILABLE_YES;
1241 }
1242 }
1243
1244 return result;
1245 }
1246
1247 /* Run from main thread */
1248 static void handle_transport_state_change(struct userdata *u, struct pa_bluetooth_transport *transport) {
1249 bool acquire = false;
1250 bool release = false;
1251 enum profile profile;
1252 pa_card_profile *cp;
1253 pa_bluetooth_transport_state_t state;
1254 pa_device_port *port;
1255
1256 pa_assert(u);
1257 pa_assert(transport);
1258
1259 profile = transport->profile;
1260 state = transport->state;
1261
1262 /* Update profile availability */
1263 if (!(cp = pa_hashmap_get(u->card->profiles, pa_bt_profile_to_string(profile))))
1264 return;
1265
1266 pa_card_profile_set_available(cp, transport_state_to_availability(state));
1267
1268 /* Update port availability */
1269 pa_assert_se(port = pa_hashmap_get(u->card->ports, u->output_port_name));
1270 pa_device_port_set_available(port, get_port_availability(u, PA_DIRECTION_OUTPUT));
1271
1272 pa_assert_se(port = pa_hashmap_get(u->card->ports, u->input_port_name));
1273 pa_device_port_set_available(port, get_port_availability(u, PA_DIRECTION_INPUT));
1274
1275 /* Acquire or release transport as needed */
1276 acquire = (state == PA_BLUETOOTH_TRANSPORT_STATE_PLAYING && u->profile == profile);
1277 release = (state != PA_BLUETOOTH_TRANSPORT_STATE_PLAYING && u->profile == profile);
1278
1279 if (acquire)
1280 if (bt_transport_acquire(u, true) >= 0) {
1281 if (u->source) {
1282 pa_log_debug("Resuming source %s, because the bluetooth audio state changed to 'playing'.", u->source->name);
1283 pa_source_suspend(u->source, false, PA_SUSPEND_IDLE|PA_SUSPEND_USER);
1284 }
1285
1286 if (u->sink) {
1287 pa_log_debug("Resuming sink %s, because the bluetooth audio state changed to 'playing'.", u->sink->name);
1288 pa_sink_suspend(u->sink, false, PA_SUSPEND_IDLE|PA_SUSPEND_USER);
1289 }
1290 }
1291
1292 if (release && u->transport_acquired) {
1293 /* FIXME: this release is racy, since the audio stream might have
1294 been set up again in the meantime (but not processed yet by PA).
1295 BlueZ should probably release the transport automatically, and
1296 in that case we would just mark the transport as released */
1297
1298 /* Remote side closed the stream so we consider it PA_SUSPEND_USER */
1299 if (u->source) {
1300 pa_log_debug("Suspending source %s, because the remote end closed the stream.", u->source->name);
1301 pa_source_suspend(u->source, true, PA_SUSPEND_USER);
1302 }
1303
1304 if (u->sink) {
1305 pa_log_debug("Suspending sink %s, because the remote end closed the stream.", u->sink->name);
1306 pa_sink_suspend(u->sink, true, PA_SUSPEND_USER);
1307 }
1308 }
1309 }
1310
1311 /* Run from main thread */
1312 static void sink_set_volume_cb(pa_sink *s) {
1313 uint16_t gain;
1314 pa_volume_t volume;
1315 struct userdata *u;
1316 char *k;
1317
1318 pa_assert(s);
1319 pa_assert(s->core);
1320
1321 k = pa_sprintf_malloc("bluetooth-device@%p", (void*) s);
1322 u = pa_shared_get(s->core, k);
1323 pa_xfree(k);
1324
1325 pa_assert(u);
1326 pa_assert(u->sink == s);
1327 pa_assert(u->profile == PROFILE_HSP);
1328 pa_assert(u->transport);
1329
1330 gain = (dbus_uint16_t) round((double) pa_cvolume_max(&s->real_volume) * HSP_MAX_GAIN / PA_VOLUME_NORM);
1331 volume = (pa_volume_t) round((double) gain * PA_VOLUME_NORM / HSP_MAX_GAIN);
1332
1333 pa_cvolume_set(&s->real_volume, u->sample_spec.channels, volume);
1334
1335 pa_bluetooth_transport_set_speaker_gain(u->transport, gain);
1336 }
1337
1338 /* Run from main thread */
1339 static void source_set_volume_cb(pa_source *s) {
1340 uint16_t gain;
1341 pa_volume_t volume;
1342 struct userdata *u;
1343 char *k;
1344
1345 pa_assert(s);
1346 pa_assert(s->core);
1347
1348 k = pa_sprintf_malloc("bluetooth-device@%p", (void*) s);
1349 u = pa_shared_get(s->core, k);
1350 pa_xfree(k);
1351
1352 pa_assert(u);
1353 pa_assert(u->source == s);
1354 pa_assert(u->profile == PROFILE_HSP);
1355 pa_assert(u->transport);
1356
1357 gain = (dbus_uint16_t) round((double) pa_cvolume_max(&s->real_volume) * HSP_MAX_GAIN / PA_VOLUME_NORM);
1358 volume = (pa_volume_t) round((double) gain * PA_VOLUME_NORM / HSP_MAX_GAIN);
1359
1360 pa_cvolume_set(&s->real_volume, u->sample_spec.channels, volume);
1361
1362 pa_bluetooth_transport_set_microphone_gain(u->transport, gain);
1363 }
1364
1365 /* Run from main thread */
1366 static char *get_name(const char *type, pa_modargs *ma, const char *device_id, bool *namereg_fail) {
1367 char *t;
1368 const char *n;
1369
1370 pa_assert(type);
1371 pa_assert(ma);
1372 pa_assert(device_id);
1373 pa_assert(namereg_fail);
1374
1375 t = pa_sprintf_malloc("%s_name", type);
1376 n = pa_modargs_get_value(ma, t, NULL);
1377 pa_xfree(t);
1378
1379 if (n) {
1380 *namereg_fail = true;
1381 return pa_xstrdup(n);
1382 }
1383
1384 if ((n = pa_modargs_get_value(ma, "name", NULL)))
1385 *namereg_fail = true;
1386 else {
1387 n = device_id;
1388 *namereg_fail = false;
1389 }
1390
1391 return pa_sprintf_malloc("bluez_%s.%s", type, n);
1392 }
1393
1394 static int sco_over_pcm_state_update(struct userdata *u, bool changed) {
1395 pa_assert(u);
1396 pa_assert(USE_SCO_OVER_PCM(u));
1397
1398 if (PA_SINK_IS_OPENED(pa_sink_get_state(u->hsp.sco_sink)) ||
1399 PA_SOURCE_IS_OPENED(pa_source_get_state(u->hsp.sco_source))) {
1400
1401 if (u->stream_fd >= 0)
1402 return 0;
1403
1404 pa_log_debug("Resuming SCO over PCM");
1405 if (init_profile(u) < 0) {
1406 pa_log("Can't resume SCO over PCM");
1407 return -1;
1408 }
1409
1410 if (bt_transport_acquire(u, false) < 0)
1411 return -1;
1412
1413 setup_stream(u);
1414
1415 return 0;
1416 }
1417
1418 if (changed) {
1419 if (u->stream_fd < 0)
1420 return 0;
1421
1422 pa_log_debug("Closing SCO over PCM");
1423
1424 bt_transport_release(u);
1425 }
1426
1427 return 0;
1428 }
1429
1430 static pa_hook_result_t sink_state_changed_cb(pa_core *c, pa_sink *s, struct userdata *u) {
1431 pa_assert(c);
1432 pa_sink_assert_ref(s);
1433 pa_assert(u);
1434
1435 if (!USE_SCO_OVER_PCM(u) || s != u->hsp.sco_sink)
1436 return PA_HOOK_OK;
1437
1438 sco_over_pcm_state_update(u, true);
1439
1440 return PA_HOOK_OK;
1441 }
1442
1443 static pa_hook_result_t source_state_changed_cb(pa_core *c, pa_source *s, struct userdata *u) {
1444 pa_assert(c);
1445 pa_source_assert_ref(s);
1446 pa_assert(u);
1447
1448 if (!USE_SCO_OVER_PCM(u) || s != u->hsp.sco_source)
1449 return PA_HOOK_OK;
1450
1451 sco_over_pcm_state_update(u, true);
1452
1453 return PA_HOOK_OK;
1454 }
1455
1456 static pa_hook_result_t transport_nrec_changed_cb(pa_bluetooth_discovery *y, pa_bluetooth_transport *t, struct userdata *u) {
1457 pa_proplist *p;
1458
1459 pa_assert(t);
1460 pa_assert(u);
1461
1462 if (t != u->transport)
1463 return PA_HOOK_OK;
1464
1465 p = pa_proplist_new();
1466 pa_proplist_sets(p, "bluetooth.nrec", t->nrec ? "1" : "0");
1467 pa_source_update_proplist(u->source, PA_UPDATE_REPLACE, p);
1468 pa_proplist_free(p);
1469
1470 return PA_HOOK_OK;
1471 }
1472
1473 static pa_hook_result_t transport_microphone_gain_changed_cb(pa_bluetooth_discovery *y, pa_bluetooth_transport *t,
1474 struct userdata *u) {
1475 pa_cvolume v;
1476
1477 pa_assert(t);
1478 pa_assert(u);
1479
1480 if (t != u->transport)
1481 return PA_HOOK_OK;
1482
1483 pa_assert(u->source);
1484
1485 pa_cvolume_set(&v, u->sample_spec.channels,
1486 (pa_volume_t) round((double) t->microphone_gain * PA_VOLUME_NORM / HSP_MAX_GAIN));
1487 pa_source_volume_changed(u->source, &v);
1488
1489 return PA_HOOK_OK;
1490 }
1491
1492 static pa_hook_result_t transport_speaker_gain_changed_cb(pa_bluetooth_discovery *y, pa_bluetooth_transport *t,
1493 struct userdata *u) {
1494 pa_cvolume v;
1495
1496 pa_assert(t);
1497 pa_assert(u);
1498
1499 if (t != u->transport)
1500 return PA_HOOK_OK;
1501
1502 pa_assert(u->sink);
1503
1504 pa_cvolume_set(&v, u->sample_spec.channels, (pa_volume_t) round((double) t->speaker_gain * PA_VOLUME_NORM / HSP_MAX_GAIN));
1505 pa_sink_volume_changed(u->sink, &v);
1506
1507 return PA_HOOK_OK;
1508 }
1509
1510 static void connect_ports(struct userdata *u, void *sink_or_source_new_data, pa_direction_t direction) {
1511 pa_device_port *port;
1512
1513 if (direction == PA_DIRECTION_OUTPUT) {
1514 pa_sink_new_data *sink_new_data = sink_or_source_new_data;
1515
1516 pa_assert_se(port = pa_hashmap_get(u->card->ports, u->output_port_name));
1517 pa_assert_se(pa_hashmap_put(sink_new_data->ports, port->name, port) >= 0);
1518 pa_device_port_ref(port);
1519 } else {
1520 pa_source_new_data *source_new_data = sink_or_source_new_data;
1521
1522 pa_assert_se(port = pa_hashmap_get(u->card->ports, u->input_port_name));
1523 pa_assert_se(pa_hashmap_put(source_new_data->ports, port->name, port) >= 0);
1524 pa_device_port_ref(port);
1525 }
1526 }
1527
1528 static int sink_set_port_cb(pa_sink *s, pa_device_port *p) {
1529 return 0;
1530 }
1531
1532 static int source_set_port_cb(pa_source *s, pa_device_port *p) {
1533 return 0;
1534 }
1535
1536 /* Run from main thread */
1537 static int add_sink(struct userdata *u) {
1538 char *k;
1539
1540 pa_assert(u->transport);
1541
1542 if (USE_SCO_OVER_PCM(u)) {
1543 pa_proplist *p;
1544
1545 u->sink = u->hsp.sco_sink;
1546 p = pa_proplist_new();
1547 pa_proplist_sets(p, "bluetooth.protocol", pa_bt_profile_to_string(u->profile));
1548 pa_proplist_update(u->sink->proplist, PA_UPDATE_MERGE, p);
1549 pa_proplist_free(p);
1550 } else {
1551 pa_sink_new_data data;
1552 bool b;
1553
1554 pa_sink_new_data_init(&data);
1555 data.driver = __FILE__;
1556 data.module = u->module;
1557 pa_sink_new_data_set_sample_spec(&data, &u->sample_spec);
1558 pa_proplist_sets(data.proplist, "bluetooth.protocol", pa_bt_profile_to_string(u->profile));
1559 if (u->profile == PROFILE_HSP)
1560 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_INTENDED_ROLES, "phone");
1561 data.card = u->card;
1562 data.name = get_name("sink", u->modargs, u->address, &b);
1563 data.namereg_fail = b;
1564
1565 if (pa_modargs_get_proplist(u->modargs, "sink_properties", data.proplist, PA_UPDATE_REPLACE) < 0) {
1566 pa_log("Invalid properties");
1567 pa_sink_new_data_done(&data);
1568 return -1;
1569 }
1570 connect_ports(u, &data, PA_DIRECTION_OUTPUT);
1571
1572 if (!u->transport_acquired)
1573 switch (u->profile) {
1574 case PROFILE_A2DP:
1575 case PROFILE_HSP:
1576 pa_assert_not_reached(); /* Profile switch should have failed */
1577 break;
1578 case PROFILE_HFGW:
1579 data.suspend_cause = PA_SUSPEND_USER;
1580 break;
1581 case PROFILE_A2DP_SOURCE:
1582 case PROFILE_OFF:
1583 pa_assert_not_reached();
1584 }
1585
1586 u->sink = pa_sink_new(u->core, &data, PA_SINK_HARDWARE|PA_SINK_LATENCY);
1587 pa_sink_new_data_done(&data);
1588
1589 if (!u->sink) {
1590 pa_log_error("Failed to create sink");
1591 return -1;
1592 }
1593
1594 u->sink->userdata = u;
1595 u->sink->parent.process_msg = sink_process_msg;
1596 u->sink->set_port = sink_set_port_cb;
1597 }
1598
1599 if (u->profile == PROFILE_HSP) {
1600 pa_sink_set_set_volume_callback(u->sink, sink_set_volume_cb);
1601 u->sink->n_volume_steps = 16;
1602
1603 k = pa_sprintf_malloc("bluetooth-device@%p", (void*) u->sink);
1604 pa_shared_set(u->core, k, u);
1605 pa_xfree(k);
1606 }
1607
1608 return 0;
1609 }
1610
1611 /* Run from main thread */
1612 static int add_source(struct userdata *u) {
1613 char *k;
1614
1615 pa_assert(u->transport);
1616
1617 if (USE_SCO_OVER_PCM(u)) {
1618 u->source = u->hsp.sco_source;
1619 pa_proplist_sets(u->source->proplist, "bluetooth.protocol", pa_bt_profile_to_string(u->profile));
1620 } else {
1621 pa_source_new_data data;
1622 bool b;
1623
1624 pa_source_new_data_init(&data);
1625 data.driver = __FILE__;
1626 data.module = u->module;
1627 pa_source_new_data_set_sample_spec(&data, &u->sample_spec);
1628 pa_proplist_sets(data.proplist, "bluetooth.protocol", pa_bt_profile_to_string(u->profile));
1629 if (u->profile == PROFILE_HSP)
1630 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_INTENDED_ROLES, "phone");
1631
1632 data.card = u->card;
1633 data.name = get_name("source", u->modargs, u->address, &b);
1634 data.namereg_fail = b;
1635
1636 if (pa_modargs_get_proplist(u->modargs, "source_properties", data.proplist, PA_UPDATE_REPLACE) < 0) {
1637 pa_log("Invalid properties");
1638 pa_source_new_data_done(&data);
1639 return -1;
1640 }
1641
1642 connect_ports(u, &data, PA_DIRECTION_INPUT);
1643
1644 if (!u->transport_acquired)
1645 switch (u->profile) {
1646 case PROFILE_HSP:
1647 pa_assert_not_reached(); /* Profile switch should have failed */
1648 break;
1649 case PROFILE_A2DP_SOURCE:
1650 case PROFILE_HFGW:
1651 data.suspend_cause = PA_SUSPEND_USER;
1652 break;
1653 case PROFILE_A2DP:
1654 case PROFILE_OFF:
1655 pa_assert_not_reached();
1656 }
1657
1658 u->source = pa_source_new(u->core, &data, PA_SOURCE_HARDWARE|PA_SOURCE_LATENCY);
1659 pa_source_new_data_done(&data);
1660
1661 if (!u->source) {
1662 pa_log_error("Failed to create source");
1663 return -1;
1664 }
1665
1666 u->source->userdata = u;
1667 u->source->parent.process_msg = source_process_msg;
1668 u->source->set_port = source_set_port_cb;
1669 }
1670
1671 if ((u->profile == PROFILE_HSP) || (u->profile == PROFILE_HFGW)) {
1672 pa_bluetooth_transport *t = u->transport;
1673 pa_proplist_sets(u->source->proplist, "bluetooth.nrec", t->nrec ? "1" : "0");
1674 }
1675
1676 if (u->profile == PROFILE_HSP) {
1677 pa_source_set_set_volume_callback(u->source, source_set_volume_cb);
1678 u->source->n_volume_steps = 16;
1679
1680 k = pa_sprintf_malloc("bluetooth-device@%p", (void*) u->source);
1681 pa_shared_set(u->core, k, u);
1682 pa_xfree(k);
1683 }
1684
1685 return 0;
1686 }
1687
1688 static void bt_transport_config_a2dp(struct userdata *u) {
1689 const pa_bluetooth_transport *t;
1690 struct a2dp_info *a2dp = &u->a2dp;
1691 a2dp_sbc_t *config;
1692
1693 t = u->transport;
1694 pa_assert(t);
1695
1696 config = (a2dp_sbc_t *) t->config;
1697
1698 u->sample_spec.format = PA_SAMPLE_S16LE;
1699
1700 if (a2dp->sbc_initialized)
1701 sbc_reinit(&a2dp->sbc, 0);
1702 else
1703 sbc_init(&a2dp->sbc, 0);
1704 a2dp->sbc_initialized = true;
1705
1706 switch (config->frequency) {
1707 case SBC_SAMPLING_FREQ_16000:
1708 a2dp->sbc.frequency = SBC_FREQ_16000;
1709 u->sample_spec.rate = 16000U;
1710 break;
1711 case SBC_SAMPLING_FREQ_32000:
1712 a2dp->sbc.frequency = SBC_FREQ_32000;
1713 u->sample_spec.rate = 32000U;
1714 break;
1715 case SBC_SAMPLING_FREQ_44100:
1716 a2dp->sbc.frequency = SBC_FREQ_44100;
1717 u->sample_spec.rate = 44100U;
1718 break;
1719 case SBC_SAMPLING_FREQ_48000:
1720 a2dp->sbc.frequency = SBC_FREQ_48000;
1721 u->sample_spec.rate = 48000U;
1722 break;
1723 default:
1724 pa_assert_not_reached();
1725 }
1726
1727 switch (config->channel_mode) {
1728 case SBC_CHANNEL_MODE_MONO:
1729 a2dp->sbc.mode = SBC_MODE_MONO;
1730 u->sample_spec.channels = 1;
1731 break;
1732 case SBC_CHANNEL_MODE_DUAL_CHANNEL:
1733 a2dp->sbc.mode = SBC_MODE_DUAL_CHANNEL;
1734 u->sample_spec.channels = 2;
1735 break;
1736 case SBC_CHANNEL_MODE_STEREO:
1737 a2dp->sbc.mode = SBC_MODE_STEREO;
1738 u->sample_spec.channels = 2;
1739 break;
1740 case SBC_CHANNEL_MODE_JOINT_STEREO:
1741 a2dp->sbc.mode = SBC_MODE_JOINT_STEREO;
1742 u->sample_spec.channels = 2;
1743 break;
1744 default:
1745 pa_assert_not_reached();
1746 }
1747
1748 switch (config->allocation_method) {
1749 case SBC_ALLOCATION_SNR:
1750 a2dp->sbc.allocation = SBC_AM_SNR;
1751 break;
1752 case SBC_ALLOCATION_LOUDNESS:
1753 a2dp->sbc.allocation = SBC_AM_LOUDNESS;
1754 break;
1755 default:
1756 pa_assert_not_reached();
1757 }
1758
1759 switch (config->subbands) {
1760 case SBC_SUBBANDS_4:
1761 a2dp->sbc.subbands = SBC_SB_4;
1762 break;
1763 case SBC_SUBBANDS_8:
1764 a2dp->sbc.subbands = SBC_SB_8;
1765 break;
1766 default:
1767 pa_assert_not_reached();
1768 }
1769
1770 switch (config->block_length) {
1771 case SBC_BLOCK_LENGTH_4:
1772 a2dp->sbc.blocks = SBC_BLK_4;
1773 break;
1774 case SBC_BLOCK_LENGTH_8:
1775 a2dp->sbc.blocks = SBC_BLK_8;
1776 break;
1777 case SBC_BLOCK_LENGTH_12:
1778 a2dp->sbc.blocks = SBC_BLK_12;
1779 break;
1780 case SBC_BLOCK_LENGTH_16:
1781 a2dp->sbc.blocks = SBC_BLK_16;
1782 break;
1783 default:
1784 pa_assert_not_reached();
1785 }
1786
1787 a2dp->min_bitpool = config->min_bitpool;
1788 a2dp->max_bitpool = config->max_bitpool;
1789
1790 /* Set minimum bitpool for source to get the maximum possible block_size */
1791 a2dp->sbc.bitpool = u->profile == PROFILE_A2DP ? a2dp->max_bitpool : a2dp->min_bitpool;
1792 a2dp->codesize = sbc_get_codesize(&a2dp->sbc);
1793 a2dp->frame_length = sbc_get_frame_length(&a2dp->sbc);
1794
1795 pa_log_info("SBC parameters:\n\tallocation=%u\n\tsubbands=%u\n\tblocks=%u\n\tbitpool=%u\n",
1796 a2dp->sbc.allocation, a2dp->sbc.subbands, a2dp->sbc.blocks, a2dp->sbc.bitpool);
1797 }
1798
1799 static void bt_transport_config(struct userdata *u) {
1800 if (u->profile == PROFILE_HSP || u->profile == PROFILE_HFGW) {
1801 u->sample_spec.format = PA_SAMPLE_S16LE;
1802 u->sample_spec.channels = 1;
1803 u->sample_spec.rate = 8000;
1804 } else
1805 bt_transport_config_a2dp(u);
1806 }
1807
1808 /* Run from main thread */
1809 static pa_hook_result_t transport_state_changed_cb(pa_bluetooth_discovery *y, pa_bluetooth_transport *t, struct userdata *u) {
1810 pa_assert(t);
1811 pa_assert(u);
1812
1813 if (t == u->transport && t->state == PA_BLUETOOTH_TRANSPORT_STATE_DISCONNECTED)
1814 pa_assert_se(pa_card_set_profile(u->card, "off", false) >= 0);
1815
1816 if (t->device == u->device)
1817 handle_transport_state_change(u, t);
1818
1819 return PA_HOOK_OK;
1820 }
1821
1822 /* Run from main thread */
1823 static int setup_transport(struct userdata *u) {
1824 pa_bluetooth_transport *t;
1825
1826 pa_assert(u);
1827 pa_assert(!u->transport);
1828 pa_assert(u->profile != PROFILE_OFF);
1829
1830 /* check if profile has a transport */
1831 t = u->device->transports[u->profile];
1832 if (!t || t->state == PA_BLUETOOTH_TRANSPORT_STATE_DISCONNECTED) {
1833 pa_log_warn("Profile has no transport");
1834 return -1;
1835 }
1836
1837 u->transport = t;
1838
1839 if (u->profile == PROFILE_A2DP_SOURCE || u->profile == PROFILE_HFGW)
1840 bt_transport_acquire(u, true); /* In case of error, the sink/sources will be created suspended */
1841 else if (bt_transport_acquire(u, false) < 0)
1842 return -1; /* We need to fail here until the interactions with module-suspend-on-idle and alike get improved */
1843
1844 bt_transport_config(u);
1845
1846 return 0;
1847 }
1848
1849 /* Run from main thread */
1850 static int init_profile(struct userdata *u) {
1851 int r = 0;
1852 pa_assert(u);
1853 pa_assert(u->profile != PROFILE_OFF);
1854
1855 if (setup_transport(u) < 0)
1856 return -1;
1857
1858 pa_assert(u->transport);
1859
1860 if (u->profile == PROFILE_A2DP ||
1861 u->profile == PROFILE_HSP ||
1862 u->profile == PROFILE_HFGW)
1863 if (add_sink(u) < 0)
1864 r = -1;
1865
1866 if (u->profile == PROFILE_HSP ||
1867 u->profile == PROFILE_A2DP_SOURCE ||
1868 u->profile == PROFILE_HFGW)
1869 if (add_source(u) < 0)
1870 r = -1;
1871
1872 return r;
1873 }
1874
1875 /* Run from main thread */
1876 static void stop_thread(struct userdata *u) {
1877 char *k;
1878
1879 pa_assert(u);
1880
1881 if (u->sink && !USE_SCO_OVER_PCM(u))
1882 pa_sink_unlink(u->sink);
1883
1884 if (u->source && !USE_SCO_OVER_PCM(u))
1885 pa_source_unlink(u->source);
1886
1887 if (u->thread) {
1888 pa_asyncmsgq_send(u->thread_mq.inq, NULL, PA_MESSAGE_SHUTDOWN, NULL, 0, NULL);
1889 pa_thread_free(u->thread);
1890 u->thread = NULL;
1891 }
1892
1893 if (u->rtpoll_item) {
1894 pa_rtpoll_item_free(u->rtpoll_item);
1895 u->rtpoll_item = NULL;
1896 }
1897
1898 if (u->rtpoll) {
1899 pa_thread_mq_done(&u->thread_mq);
1900
1901 pa_rtpoll_free(u->rtpoll);
1902 u->rtpoll = NULL;
1903 }
1904
1905 if (u->transport) {
1906 bt_transport_release(u);
1907 u->transport = NULL;
1908 }
1909
1910 if (u->sink) {
1911 if (u->profile == PROFILE_HSP) {
1912 k = pa_sprintf_malloc("bluetooth-device@%p", (void*) u->sink);
1913 pa_shared_remove(u->core, k);
1914 pa_xfree(k);
1915 }
1916
1917 pa_sink_unref(u->sink);
1918 u->sink = NULL;
1919 }
1920
1921 if (u->source) {
1922 if (u->profile == PROFILE_HSP) {
1923 k = pa_sprintf_malloc("bluetooth-device@%p", (void*) u->source);
1924 pa_shared_remove(u->core, k);
1925 pa_xfree(k);
1926 }
1927
1928 pa_source_unref(u->source);
1929 u->source = NULL;
1930 }
1931
1932 if (u->read_smoother) {
1933 pa_smoother_free(u->read_smoother);
1934 u->read_smoother = NULL;
1935 }
1936 }
1937
1938 /* Run from main thread */
1939 static int start_thread(struct userdata *u) {
1940 pa_assert(u);
1941 pa_assert(!u->thread);
1942 pa_assert(!u->rtpoll);
1943 pa_assert(!u->rtpoll_item);
1944
1945 u->rtpoll = pa_rtpoll_new();
1946 pa_thread_mq_init(&u->thread_mq, u->core->mainloop, u->rtpoll);
1947
1948 if (USE_SCO_OVER_PCM(u)) {
1949 if (sco_over_pcm_state_update(u, false) < 0) {
1950 char *k;
1951
1952 if (u->sink) {
1953 k = pa_sprintf_malloc("bluetooth-device@%p", (void*) u->sink);
1954 pa_shared_remove(u->core, k);
1955 pa_xfree(k);
1956 u->sink = NULL;
1957 }
1958 if (u->source) {
1959 k = pa_sprintf_malloc("bluetooth-device@%p", (void*) u->source);
1960 pa_shared_remove(u->core, k);
1961 pa_xfree(k);
1962 u->source = NULL;
1963 }
1964 return -1;
1965 }
1966
1967 pa_sink_ref(u->sink);
1968 pa_source_ref(u->source);
1969 /* FIXME: monitor stream_fd error */
1970 return 0;
1971 }
1972
1973 if (!(u->thread = pa_thread_new("bluetooth", thread_func, u))) {
1974 pa_log_error("Failed to create IO thread");
1975 return -1;
1976 }
1977
1978 if (u->sink) {
1979 pa_sink_set_asyncmsgq(u->sink, u->thread_mq.inq);
1980 pa_sink_set_rtpoll(u->sink, u->rtpoll);
1981 pa_sink_put(u->sink);
1982
1983 if (u->sink->set_volume)
1984 u->sink->set_volume(u->sink);
1985 }
1986
1987 if (u->source) {
1988 pa_source_set_asyncmsgq(u->source, u->thread_mq.inq);
1989 pa_source_set_rtpoll(u->source, u->rtpoll);
1990 pa_source_put(u->source);
1991
1992 if (u->source->set_volume)
1993 u->source->set_volume(u->source);
1994 }
1995
1996 return 0;
1997 }
1998
1999 static void save_sco_volume_callbacks(struct userdata *u) {
2000 pa_assert(u);
2001 pa_assert(USE_SCO_OVER_PCM(u));
2002
2003 u->hsp.sco_sink_set_volume = u->hsp.sco_sink->set_volume;
2004 u->hsp.sco_source_set_volume = u->hsp.sco_source->set_volume;
2005 }
2006
2007 static void restore_sco_volume_callbacks(struct userdata *u) {
2008 pa_assert(u);
2009 pa_assert(USE_SCO_OVER_PCM(u));
2010
2011 pa_sink_set_set_volume_callback(u->hsp.sco_sink, u->hsp.sco_sink_set_volume);
2012 pa_source_set_set_volume_callback(u->hsp.sco_source, u->hsp.sco_source_set_volume);
2013 }
2014
2015 /* Run from main thread */
2016 static int card_set_profile(pa_card *c, pa_card_profile *new_profile) {
2017 struct userdata *u;
2018 enum profile *d;
2019
2020 pa_assert(c);
2021 pa_assert(new_profile);
2022 pa_assert_se(u = c->userdata);
2023
2024 d = PA_CARD_PROFILE_DATA(new_profile);
2025
2026 if (*d != PROFILE_OFF) {
2027 const pa_bluetooth_device *device = u->device;
2028
2029 if (!device->transports[*d] || device->transports[*d]->state == PA_BLUETOOTH_TRANSPORT_STATE_DISCONNECTED) {
2030 pa_log_warn("Profile not connected, refused to switch profile to %s", new_profile->name);
2031 return -PA_ERR_IO;
2032 }
2033 }
2034
2035 stop_thread(u);
2036
2037 if (USE_SCO_OVER_PCM(u))
2038 restore_sco_volume_callbacks(u);
2039
2040 u->profile = *d;
2041 u->sample_spec = u->requested_sample_spec;
2042
2043 if (USE_SCO_OVER_PCM(u))
2044 save_sco_volume_callbacks(u);
2045
2046 if (u->profile != PROFILE_OFF)
2047 if (init_profile(u) < 0)
2048 goto off;
2049
2050 if (u->sink || u->source)
2051 if (start_thread(u) < 0)
2052 goto off;
2053
2054 return 0;
2055
2056 off:
2057 stop_thread(u);
2058
2059 pa_assert_se(pa_card_set_profile(u->card, "off", false) >= 0);
2060
2061 return -PA_ERR_IO;
2062 }
2063
2064 /* Run from main thread */
2065 static void create_card_ports(struct userdata *u, pa_hashmap *ports) {
2066 pa_device_port *port;
2067 pa_device_port_new_data port_data;
2068
2069 const char *name_prefix = NULL;
2070 const char *input_description = NULL;
2071 const char *output_description = NULL;
2072
2073 pa_assert(u);
2074 pa_assert(ports);
2075 pa_assert(u->device);
2076
2077 switch (pa_bluetooth_get_form_factor(u->device->class)) {
2078 case PA_BT_FORM_FACTOR_UNKNOWN:
2079 break;
2080
2081 case PA_BT_FORM_FACTOR_HEADSET:
2082 name_prefix = "headset";
2083 input_description = output_description = _("Headset");
2084 break;
2085
2086 case PA_BT_FORM_FACTOR_HANDSFREE:
2087 name_prefix = "handsfree";
2088 input_description = output_description = _("Handsfree");
2089 break;
2090
2091 case PA_BT_FORM_FACTOR_MICROPHONE:
2092 name_prefix = "microphone";
2093 input_description = _("Microphone");
2094 break;
2095
2096 case PA_BT_FORM_FACTOR_SPEAKER:
2097 name_prefix = "speaker";
2098 output_description = _("Speaker");
2099 break;
2100
2101 case PA_BT_FORM_FACTOR_HEADPHONE:
2102 name_prefix = "headphone";
2103 output_description = _("Headphone");
2104 break;
2105
2106 case PA_BT_FORM_FACTOR_PORTABLE:
2107 name_prefix = "portable";
2108 input_description = output_description = _("Portable");
2109 break;
2110
2111 case PA_BT_FORM_FACTOR_CAR:
2112 name_prefix = "car";
2113 input_description = output_description = _("Car");
2114 break;
2115
2116 case PA_BT_FORM_FACTOR_HIFI:
2117 name_prefix = "hifi";
2118 input_description = output_description = _("HiFi");
2119 break;
2120
2121 case PA_BT_FORM_FACTOR_PHONE:
2122 name_prefix = "phone";
2123 input_description = output_description = _("Phone");
2124 break;
2125 }
2126
2127 if (!name_prefix)
2128 name_prefix = "unknown";
2129
2130 if (!output_description)
2131 output_description = _("Bluetooth Output");
2132
2133 if (!input_description)
2134 input_description = _("Bluetooth Input");
2135
2136 u->output_port_name = pa_sprintf_malloc("%s-output", name_prefix);
2137 u->input_port_name = pa_sprintf_malloc("%s-input", name_prefix);
2138
2139 pa_device_port_new_data_init(&port_data);
2140 pa_device_port_new_data_set_name(&port_data, u->output_port_name);
2141 pa_device_port_new_data_set_description(&port_data, output_description);
2142 pa_device_port_new_data_set_direction(&port_data, PA_DIRECTION_OUTPUT);
2143 pa_device_port_new_data_set_available(&port_data, get_port_availability(u, PA_DIRECTION_OUTPUT));
2144 pa_assert_se(port = pa_device_port_new(u->core, &port_data, 0));
2145 pa_assert_se(pa_hashmap_put(ports, port->name, port) >= 0);
2146 pa_device_port_new_data_done(&port_data);
2147
2148 pa_device_port_new_data_init(&port_data);
2149 pa_device_port_new_data_set_name(&port_data, u->input_port_name);
2150 pa_device_port_new_data_set_description(&port_data, input_description);
2151 pa_device_port_new_data_set_direction(&port_data, PA_DIRECTION_INPUT);
2152 pa_device_port_new_data_set_available(&port_data, get_port_availability(u, PA_DIRECTION_INPUT));
2153 pa_assert_se(port = pa_device_port_new(u->core, &port_data, 0));
2154 pa_assert_se(pa_hashmap_put(ports, port->name, port) >= 0);
2155 pa_device_port_new_data_done(&port_data);
2156 }
2157
2158 /* Run from main thread */
2159 static pa_card_profile *create_card_profile(struct userdata *u, const char *uuid, pa_hashmap *ports) {
2160 pa_device_port *input_port, *output_port;
2161 pa_card_profile *p = NULL;
2162 enum profile *d;
2163
2164 pa_assert(u->input_port_name);
2165 pa_assert(u->output_port_name);
2166 pa_assert_se(input_port = pa_hashmap_get(ports, u->input_port_name));
2167 pa_assert_se(output_port = pa_hashmap_get(ports, u->output_port_name));
2168
2169 if (pa_streq(uuid, A2DP_SINK_UUID)) {
2170 p = pa_card_profile_new("a2dp", _("High Fidelity Playback (A2DP)"), sizeof(enum profile));
2171 p->priority = 10;
2172 p->n_sinks = 1;
2173 p->n_sources = 0;
2174 p->max_sink_channels = 2;
2175 p->max_source_channels = 0;
2176 pa_hashmap_put(output_port->profiles, p->name, p);
2177
2178 d = PA_CARD_PROFILE_DATA(p);
2179 *d = PROFILE_A2DP;
2180 } else if (pa_streq(uuid, A2DP_SOURCE_UUID)) {
2181 p = pa_card_profile_new("a2dp_source", _("High Fidelity Capture (A2DP)"), sizeof(enum profile));
2182 p->priority = 10;
2183 p->n_sinks = 0;
2184 p->n_sources = 1;
2185 p->max_sink_channels = 0;
2186 p->max_source_channels = 2;
2187 pa_hashmap_put(input_port->profiles, p->name, p);
2188
2189 d = PA_CARD_PROFILE_DATA(p);
2190 *d = PROFILE_A2DP_SOURCE;
2191 } else if (pa_streq(uuid, HSP_HS_UUID) || pa_streq(uuid, HFP_HS_UUID)) {
2192 p = pa_card_profile_new("hsp", _("Telephony Duplex (HSP/HFP)"), sizeof(enum profile));
2193 p->priority = 20;
2194 p->n_sinks = 1;
2195 p->n_sources = 1;
2196 p->max_sink_channels = 1;
2197 p->max_source_channels = 1;
2198 pa_hashmap_put(input_port->profiles, p->name, p);
2199 pa_hashmap_put(output_port->profiles, p->name, p);
2200
2201 d = PA_CARD_PROFILE_DATA(p);
2202 *d = PROFILE_HSP;
2203 } else if (pa_streq(uuid, HFP_AG_UUID)) {
2204 p = pa_card_profile_new("hfgw", _("Handsfree Gateway"), sizeof(enum profile));
2205 p->priority = 20;
2206 p->n_sinks = 1;
2207 p->n_sources = 1;
2208 p->max_sink_channels = 1;
2209 p->max_source_channels = 1;
2210 pa_hashmap_put(input_port->profiles, p->name, p);
2211 pa_hashmap_put(output_port->profiles, p->name, p);
2212
2213 d = PA_CARD_PROFILE_DATA(p);
2214 *d = PROFILE_HFGW;
2215 }
2216
2217 if (p) {
2218 pa_bluetooth_transport *t;
2219
2220 if ((t = u->device->transports[*d]))
2221 p->available = transport_state_to_availability(t->state);
2222 }
2223
2224 return p;
2225 }
2226
2227 /* Run from main thread */
2228 static int add_card(struct userdata *u) {
2229 pa_card_new_data data;
2230 bool b;
2231 pa_card_profile *p;
2232 enum profile *d;
2233 pa_bt_form_factor_t ff;
2234 char *n;
2235 const char *default_profile;
2236 const pa_bluetooth_device *device = u->device;
2237 const pa_bluetooth_uuid *uuid;
2238
2239 pa_assert(u);
2240 pa_assert(device);
2241
2242 pa_card_new_data_init(&data);
2243 data.driver = __FILE__;
2244 data.module = u->module;
2245
2246 n = pa_bluetooth_cleanup_name(device->alias);
2247 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_DESCRIPTION, n);
2248 pa_xfree(n);
2249 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_STRING, device->address);
2250 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_API, "bluez");
2251 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_CLASS, "sound");
2252 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_BUS, "bluetooth");
2253
2254 if ((ff = pa_bluetooth_get_form_factor(device->class)) != PA_BT_FORM_FACTOR_UNKNOWN)
2255 pa_proplist_sets(data.proplist, PA_PROP_DEVICE_FORM_FACTOR, pa_bt_form_factor_to_string(ff));
2256
2257 pa_proplist_sets(data.proplist, "bluez.path", device->path);
2258 pa_proplist_setf(data.proplist, "bluez.class", "0x%06x", (unsigned) device->class);
2259 pa_proplist_sets(data.proplist, "bluez.alias", device->alias);
2260 data.name = get_name("card", u->modargs, device->address, &b);
2261 data.namereg_fail = b;
2262
2263 if (pa_modargs_get_proplist(u->modargs, "card_properties", data.proplist, PA_UPDATE_REPLACE) < 0) {
2264 pa_log("Invalid properties");
2265 pa_card_new_data_done(&data);
2266 return -1;
2267 }
2268
2269 create_card_ports(u, data.ports);
2270
2271 PA_LLIST_FOREACH(uuid, device->uuids) {
2272 p = create_card_profile(u, uuid->uuid, data.ports);
2273
2274 if (!p)
2275 continue;
2276
2277 if (pa_hashmap_get(data.profiles, p->name)) {
2278 pa_card_profile_free(p);
2279 continue;
2280 }
2281
2282 pa_hashmap_put(data.profiles, p->name, p);
2283 }
2284
2285 pa_assert(!pa_hashmap_isempty(data.profiles));
2286
2287 p = pa_card_profile_new("off", _("Off"), sizeof(enum profile));
2288 p->available = PA_AVAILABLE_YES;
2289 d = PA_CARD_PROFILE_DATA(p);
2290 *d = PROFILE_OFF;
2291 pa_hashmap_put(data.profiles, p->name, p);
2292
2293 if ((default_profile = pa_modargs_get_value(u->modargs, "profile", NULL))) {
2294 if (pa_hashmap_get(data.profiles, default_profile))
2295 pa_card_new_data_set_profile(&data, default_profile);
2296 else
2297 pa_log_warn("Profile '%s' not valid or not supported by device.", default_profile);
2298 }
2299
2300 u->card = pa_card_new(u->core, &data);
2301 pa_card_new_data_done(&data);
2302
2303 if (!u->card) {
2304 pa_log("Failed to allocate card.");
2305 return -1;
2306 }
2307
2308 u->card->userdata = u;
2309 u->card->set_profile = card_set_profile;
2310
2311 d = PA_CARD_PROFILE_DATA(u->card->active_profile);
2312
2313 if (*d != PROFILE_OFF && (!device->transports[*d] ||
2314 device->transports[*d]->state == PA_BLUETOOTH_TRANSPORT_STATE_DISCONNECTED)) {
2315 pa_log_warn("Default profile not connected, selecting off profile");
2316 u->card->active_profile = pa_hashmap_get(u->card->profiles, "off");
2317 u->card->save_profile = false;
2318 }
2319
2320 d = PA_CARD_PROFILE_DATA(u->card->active_profile);
2321 u->profile = *d;
2322
2323 if (USE_SCO_OVER_PCM(u))
2324 save_sco_volume_callbacks(u);
2325
2326 return 0;
2327 }
2328
2329 /* Run from main thread */
2330 static pa_bluetooth_device* find_device(struct userdata *u, const char *address, const char *path) {
2331 pa_bluetooth_device *d = NULL;
2332
2333 pa_assert(u);
2334
2335 if (!address && !path) {
2336 pa_log_error("Failed to get device address/path from module arguments.");
2337 return NULL;
2338 }
2339
2340 if (path) {
2341 if (!(d = pa_bluetooth_discovery_get_by_path(u->discovery, path))) {
2342 pa_log_error("%s is not a valid BlueZ audio device.", path);
2343 return NULL;
2344 }
2345
2346 if (address && !(pa_streq(d->address, address))) {
2347 pa_log_error("Passed path %s address %s != %s don't match.", path, d->address, address);
2348 return NULL;
2349 }
2350
2351 } else {
2352 if (!(d = pa_bluetooth_discovery_get_by_address(u->discovery, address))) {
2353 pa_log_error("%s is not known.", address);
2354 return NULL;
2355 }
2356 }
2357
2358 if (d) {
2359 u->address = pa_xstrdup(d->address);
2360 u->path = pa_xstrdup(d->path);
2361 }
2362
2363 return d;
2364 }
2365
2366 /* Run from main thread */
2367 static pa_hook_result_t uuid_added_cb(pa_bluetooth_discovery *y, const struct pa_bluetooth_hook_uuid_data *data,
2368 struct userdata *u) {
2369 pa_card_profile *p;
2370
2371 pa_assert(data);
2372 pa_assert(data->device);
2373 pa_assert(data->uuid);
2374 pa_assert(u);
2375
2376 if (data->device != u->device)
2377 return PA_HOOK_OK;
2378
2379 p = create_card_profile(u, data->uuid, u->card->ports);
2380
2381 if (!p)
2382 return PA_HOOK_OK;
2383
2384 if (pa_hashmap_get(u->card->profiles, p->name)) {
2385 pa_card_profile_free(p);
2386 return PA_HOOK_OK;
2387 }
2388
2389 pa_card_add_profile(u->card, p);
2390
2391 return PA_HOOK_OK;
2392 }
2393
2394 /* Run from main thread */
2395 static pa_hook_result_t discovery_hook_cb(pa_bluetooth_discovery *y, const pa_bluetooth_device *d, struct userdata *u) {
2396 pa_assert(u);
2397 pa_assert(d);
2398
2399 if (d != u->device)
2400 return PA_HOOK_OK;
2401
2402 if (d->dead)
2403 pa_log_debug("Device %s removed: unloading module", d->path);
2404 else if (!pa_bluetooth_device_any_audio_connected(d))
2405 pa_log_debug("Unloading module, because device %s doesn't have any audio profiles connected anymore.", d->path);
2406 else
2407 return PA_HOOK_OK;
2408
2409 pa_module_unload(u->core, u->module, true);
2410
2411 return PA_HOOK_OK;
2412 }
2413
2414 int pa__init(pa_module* m) {
2415 pa_modargs *ma;
2416 uint32_t channels;
2417 struct userdata *u;
2418 const char *address, *path;
2419 pa_bluetooth_device *device;
2420
2421 pa_assert(m);
2422
2423 if (!(ma = pa_modargs_new(m->argument, valid_modargs))) {
2424 pa_log_error("Failed to parse module arguments");
2425 goto fail;
2426 }
2427
2428 m->userdata = u = pa_xnew0(struct userdata, 1);
2429 u->module = m;
2430 u->core = m->core;
2431 u->stream_fd = -1;
2432 u->sample_spec = m->core->default_sample_spec;
2433 u->modargs = ma;
2434
2435 if (pa_modargs_get_value(ma, "sco_sink", NULL) &&
2436 !(u->hsp.sco_sink = pa_namereg_get(m->core, pa_modargs_get_value(ma, "sco_sink", NULL), PA_NAMEREG_SINK))) {
2437 pa_log("SCO sink not found");
2438 goto fail;
2439 }
2440
2441 if (pa_modargs_get_value(ma, "sco_source", NULL) &&
2442 !(u->hsp.sco_source = pa_namereg_get(m->core, pa_modargs_get_value(ma, "sco_source", NULL), PA_NAMEREG_SOURCE))) {
2443 pa_log("SCO source not found");
2444 goto fail;
2445 }
2446
2447 if (pa_modargs_get_value_u32(ma, "rate", &u->sample_spec.rate) < 0 ||
2448 u->sample_spec.rate <= 0 || u->sample_spec.rate > PA_RATE_MAX) {
2449 pa_log_error("Failed to get rate from module arguments");
2450 goto fail;
2451 }
2452
2453 u->auto_connect = true;
2454 if (pa_modargs_get_value_boolean(ma, "auto_connect", &u->auto_connect)) {
2455 pa_log("Failed to parse auto_connect= argument");
2456 goto fail;
2457 }
2458
2459 channels = u->sample_spec.channels;
2460 if (pa_modargs_get_value_u32(ma, "channels", &channels) < 0 ||
2461 channels <= 0 || channels > PA_CHANNELS_MAX) {
2462 pa_log_error("Failed to get channels from module arguments");
2463 goto fail;
2464 }
2465 u->sample_spec.channels = (uint8_t) channels;
2466 u->requested_sample_spec = u->sample_spec;
2467
2468 address = pa_modargs_get_value(ma, "address", NULL);
2469 path = pa_modargs_get_value(ma, "path", NULL);
2470
2471 if (!(u->discovery = pa_bluetooth_discovery_get(m->core)))
2472 goto fail;
2473
2474 if (!(device = find_device(u, address, path)))
2475 goto fail;
2476
2477 u->device = device;
2478
2479 u->discovery_slot =
2480 pa_hook_connect(pa_bluetooth_discovery_hook(u->discovery, PA_BLUETOOTH_HOOK_DEVICE_CONNECTION_CHANGED),
2481 PA_HOOK_NORMAL, (pa_hook_cb_t) discovery_hook_cb, u);
2482
2483 u->uuid_added_slot =
2484 pa_hook_connect(pa_bluetooth_discovery_hook(u->discovery, PA_BLUETOOTH_HOOK_DEVICE_UUID_ADDED),
2485 PA_HOOK_NORMAL, (pa_hook_cb_t) uuid_added_cb, u);
2486
2487 u->sink_state_changed_slot =
2488 pa_hook_connect(&u->core->hooks[PA_CORE_HOOK_SINK_STATE_CHANGED],
2489 PA_HOOK_NORMAL, (pa_hook_cb_t) sink_state_changed_cb, u);
2490
2491 u->source_state_changed_slot =
2492 pa_hook_connect(&u->core->hooks[PA_CORE_HOOK_SOURCE_STATE_CHANGED],
2493 PA_HOOK_NORMAL, (pa_hook_cb_t) source_state_changed_cb, u);
2494
2495 u->transport_state_changed_slot =
2496 pa_hook_connect(pa_bluetooth_discovery_hook(u->discovery, PA_BLUETOOTH_HOOK_TRANSPORT_STATE_CHANGED),
2497 PA_HOOK_NORMAL, (pa_hook_cb_t) transport_state_changed_cb, u);
2498
2499 u->transport_nrec_changed_slot =
2500 pa_hook_connect(pa_bluetooth_discovery_hook(u->discovery, PA_BLUETOOTH_HOOK_TRANSPORT_NREC_CHANGED),
2501 PA_HOOK_NORMAL, (pa_hook_cb_t) transport_nrec_changed_cb, u);
2502
2503 u->transport_microphone_changed_slot =
2504 pa_hook_connect(pa_bluetooth_discovery_hook(u->discovery, PA_BLUETOOTH_HOOK_TRANSPORT_MICROPHONE_GAIN_CHANGED),
2505 PA_HOOK_NORMAL, (pa_hook_cb_t) transport_microphone_gain_changed_cb, u);
2506
2507 u->transport_speaker_changed_slot =
2508 pa_hook_connect(pa_bluetooth_discovery_hook(u->discovery, PA_BLUETOOTH_HOOK_TRANSPORT_SPEAKER_GAIN_CHANGED),
2509 PA_HOOK_NORMAL, (pa_hook_cb_t) transport_speaker_gain_changed_cb, u);
2510
2511 /* Add the card structure. This will also initialize the default profile */
2512 if (add_card(u) < 0)
2513 goto fail;
2514
2515 if (!(u->msg = pa_msgobject_new(bluetooth_msg)))
2516 goto fail;
2517
2518 u->msg->parent.process_msg = device_process_msg;
2519 u->msg->card = u->card;
2520
2521 if (u->profile != PROFILE_OFF)
2522 if (init_profile(u) < 0)
2523 goto off;
2524
2525 if (u->sink || u->source)
2526 if (start_thread(u) < 0)
2527 goto off;
2528
2529 return 0;
2530
2531 off:
2532 stop_thread(u);
2533
2534 pa_assert_se(pa_card_set_profile(u->card, "off", false) >= 0);
2535
2536 return 0;
2537
2538 fail:
2539
2540 pa__done(m);
2541
2542 return -1;
2543 }
2544
2545 int pa__get_n_used(pa_module *m) {
2546 struct userdata *u;
2547
2548 pa_assert(m);
2549 pa_assert_se(u = m->userdata);
2550
2551 return
2552 (u->sink ? pa_sink_linked_by(u->sink) : 0) +
2553 (u->source ? pa_source_linked_by(u->source) : 0);
2554 }
2555
2556 void pa__done(pa_module *m) {
2557 struct userdata *u;
2558
2559 pa_assert(m);
2560
2561 if (!(u = m->userdata))
2562 return;
2563
2564 stop_thread(u);
2565
2566 if (u->discovery_slot)
2567 pa_hook_slot_free(u->discovery_slot);
2568
2569 if (u->uuid_added_slot)
2570 pa_hook_slot_free(u->uuid_added_slot);
2571
2572 if (u->sink_state_changed_slot)
2573 pa_hook_slot_free(u->sink_state_changed_slot);
2574
2575 if (u->source_state_changed_slot)
2576 pa_hook_slot_free(u->source_state_changed_slot);
2577
2578 if (u->transport_state_changed_slot)
2579 pa_hook_slot_free(u->transport_state_changed_slot);
2580
2581 if (u->transport_nrec_changed_slot)
2582 pa_hook_slot_free(u->transport_nrec_changed_slot);
2583
2584 if (u->transport_microphone_changed_slot)
2585 pa_hook_slot_free(u->transport_microphone_changed_slot);
2586
2587 if (u->transport_speaker_changed_slot)
2588 pa_hook_slot_free(u->transport_speaker_changed_slot);
2589
2590 if (USE_SCO_OVER_PCM(u))
2591 restore_sco_volume_callbacks(u);
2592
2593 if (u->msg)
2594 pa_xfree(u->msg);
2595
2596 if (u->card)
2597 pa_card_free(u->card);
2598
2599 if (u->a2dp.buffer)
2600 pa_xfree(u->a2dp.buffer);
2601
2602 sbc_finish(&u->a2dp.sbc);
2603
2604 if (u->modargs)
2605 pa_modargs_free(u->modargs);
2606
2607 pa_xfree(u->output_port_name);
2608 pa_xfree(u->input_port_name);
2609
2610 pa_xfree(u->address);
2611 pa_xfree(u->path);
2612
2613 if (u->discovery)
2614 pa_bluetooth_discovery_unref(u->discovery);
2615
2616 pa_xfree(u);
2617 }