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