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