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