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


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