src/modules/bluetooth/module-bluetooth-device.c

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