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