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