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 static pa_port_available_t audio_state_to_availability(pa_bt_audio_state_t state) {
1233     if (state < PA_BT_AUDIO_STATE_CONNECTED)
1234         return PA_PORT_AVAILABLE_NO;
1235     else if (state >= PA_BT_AUDIO_STATE_PLAYING)
1236         return PA_PORT_AVAILABLE_YES;
1237     else
1238         return PA_PORT_AVAILABLE_UNKNOWN;
1239 }
1240
1241 /* Run from main thread */
1242 static DBusHandlerResult filter_cb(DBusConnection *bus, DBusMessage *m, void *userdata) {
1243     DBusError err;
1244     struct userdata *u;
1245     bool acquire = FALSE;
1246
1247     pa_assert(bus);
1248     pa_assert(m);
1249     pa_assert_se(u = userdata);
1250
1251     dbus_error_init(&err);
1252
1253     pa_log_debug("dbus: interface=%s, path=%s, member=%s\n",
1254                  dbus_message_get_interface(m),
1255                  dbus_message_get_path(m),
1256                  dbus_message_get_member(m));
1257
1258     if (!dbus_message_has_path(m, u->path) && !dbus_message_has_path(m, u->transport))
1259         goto fail;
1260
1261     if (dbus_message_is_signal(m, "org.bluez.Headset", "SpeakerGainChanged") ||
1262         dbus_message_is_signal(m, "org.bluez.Headset", "MicrophoneGainChanged")) {
1263
1264         dbus_uint16_t gain;
1265         pa_cvolume v;
1266
1267         if (!dbus_message_get_args(m, &err, DBUS_TYPE_UINT16, &gain, DBUS_TYPE_INVALID) || gain > HSP_MAX_GAIN) {
1268             pa_log("Failed to parse org.bluez.Headset.{Speaker|Microphone}GainChanged: %s", err.message);
1269             goto fail;
1270         }
1271
1272         if (u->profile == PROFILE_HSP) {
1273             if (u->sink && dbus_message_is_signal(m, "org.bluez.Headset", "SpeakerGainChanged")) {
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_sink_volume_changed(u->sink, &v);
1282
1283             } else if (u->source && dbus_message_is_signal(m, "org.bluez.Headset", "MicrophoneGainChanged")) {
1284                 pa_volume_t volume = (pa_volume_t) (gain * PA_VOLUME_NORM / HSP_MAX_GAIN);
1285
1286                 /* increment volume by one to correct rounding errors */
1287                 if (volume < PA_VOLUME_NORM)
1288                     volume++;
1289
1290                 pa_cvolume_set(&v, u->sample_spec.channels, volume);
1291                 pa_source_volume_changed(u->source, &v);
1292             }
1293         }
1294     } else if (dbus_message_is_signal(m, "org.bluez.HandsfreeGateway", "PropertyChanged")) {
1295         pa_bt_audio_state_t state = parse_state_property_change(m);
1296
1297         switch(state) {
1298             case PA_BT_AUDIO_STATE_INVALID:
1299             case PA_BT_AUDIO_STATE_DISCONNECTED:
1300             case PA_BT_AUDIO_STATE_CONNECTED:
1301             case PA_BT_AUDIO_STATE_CONNECTING:
1302                 goto fail;
1303
1304             case PA_BT_AUDIO_STATE_PLAYING:
1305                 if (u->card) {
1306                     pa_log_debug("Changing profile to hfgw");
1307                     if (pa_card_set_profile(u->card, "hfgw", FALSE) < 0)
1308                         pa_log("Failed to change profile to hfgw");
1309                 }
1310                 break;
1311         }
1312
1313         if (state != PA_BT_AUDIO_STATE_INVALID) {
1314             pa_device_port *port;
1315             pa_port_available_t available = audio_state_to_availability(state);
1316
1317             pa_assert_se(port = pa_hashmap_get(u->card->ports, "hfgw-output"));
1318             pa_device_port_set_available(port, available);
1319
1320             pa_assert_se(port = pa_hashmap_get(u->card->ports, "hfgw-input"));
1321             pa_device_port_set_available(port, available);
1322
1323             acquire = (available == PA_PORT_AVAILABLE_YES && u->profile == PROFILE_HFGW);
1324         }
1325     } else if (dbus_message_is_signal(m, "org.bluez.Headset", "PropertyChanged")) {
1326         pa_bt_audio_state_t state = parse_state_property_change(m);
1327
1328         if (state != PA_BT_AUDIO_STATE_INVALID) {
1329             pa_device_port *port;
1330             pa_port_available_t available = audio_state_to_availability(state);
1331
1332             pa_assert_se(port = pa_hashmap_get(u->card->ports, "hsp-output"));
1333             pa_device_port_set_available(port, available);
1334
1335             pa_assert_se(port = pa_hashmap_get(u->card->ports, "hsp-input"));
1336             pa_device_port_set_available(port, available);
1337
1338             acquire = (available == PA_PORT_AVAILABLE_YES && u->profile == PROFILE_HSP);
1339         }
1340     } else if (dbus_message_is_signal(m, "org.bluez.AudioSource", "PropertyChanged")) {
1341         pa_bt_audio_state_t state = parse_state_property_change(m);
1342
1343         if (state != PA_BT_AUDIO_STATE_INVALID) {
1344             pa_device_port *port;
1345             pa_port_available_t available = audio_state_to_availability(state);
1346
1347             pa_assert_se(port = pa_hashmap_get(u->card->ports, "a2dp-input"));
1348             pa_device_port_set_available(port, available);
1349
1350             acquire = (available == PA_PORT_AVAILABLE_YES && u->profile == PROFILE_A2DP_SOURCE);
1351         }
1352     } else if (dbus_message_is_signal(m, "org.bluez.AudioSink", "PropertyChanged")) {
1353         pa_bt_audio_state_t state = parse_state_property_change(m);
1354
1355         if (state != PA_BT_AUDIO_STATE_INVALID) {
1356             pa_device_port *port;
1357             pa_port_available_t available = audio_state_to_availability(state);
1358
1359             pa_assert_se(port = pa_hashmap_get(u->card->ports, "a2dp-output"));
1360             pa_device_port_set_available(port, available);
1361
1362             acquire = (available == PA_PORT_AVAILABLE_YES && u->profile == PROFILE_A2DP);
1363         }
1364     }
1365
1366     if (acquire)
1367         if (bt_transport_acquire(u, FALSE) >= 0) {
1368             if (u->source)
1369                 pa_source_suspend(u->source, FALSE, PA_SUSPEND_IDLE|PA_SUSPEND_USER);
1370
1371             if (u->sink)
1372                 pa_sink_suspend(u->sink, FALSE, PA_SUSPEND_IDLE|PA_SUSPEND_USER);
1373         }
1374
1375 fail:
1376     dbus_error_free(&err);
1377
1378     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1379 }
1380
1381 /* Run from main thread */
1382 static void sink_set_volume_cb(pa_sink *s) {
1383     DBusMessage *m;
1384     dbus_uint16_t gain;
1385     pa_volume_t volume;
1386     struct userdata *u;
1387     char *k;
1388
1389     pa_assert(s);
1390     pa_assert(s->core);
1391
1392     k = pa_sprintf_malloc("bluetooth-device@%p", (void*) s);
1393     u = pa_shared_get(s->core, k);
1394     pa_xfree(k);
1395
1396     pa_assert(u);
1397     pa_assert(u->sink == s);
1398     pa_assert(u->profile == PROFILE_HSP);
1399
1400     gain = (pa_cvolume_max(&s->real_volume) * HSP_MAX_GAIN) / PA_VOLUME_NORM;
1401
1402     if (gain > HSP_MAX_GAIN)
1403         gain = HSP_MAX_GAIN;
1404
1405     volume = (pa_volume_t) (gain * PA_VOLUME_NORM / HSP_MAX_GAIN);
1406
1407     /* increment volume by one to correct rounding errors */
1408     if (volume < PA_VOLUME_NORM)
1409         volume++;
1410
1411     pa_cvolume_set(&s->real_volume, u->sample_spec.channels, volume);
1412
1413     pa_assert_se(m = dbus_message_new_method_call("org.bluez", u->path, "org.bluez.Headset", "SetSpeakerGain"));
1414     pa_assert_se(dbus_message_append_args(m, DBUS_TYPE_UINT16, &gain, DBUS_TYPE_INVALID));
1415     pa_assert_se(dbus_connection_send(pa_dbus_connection_get(u->connection), m, NULL));
1416     dbus_message_unref(m);
1417 }
1418
1419 /* Run from main thread */
1420 static void source_set_volume_cb(pa_source *s) {
1421     DBusMessage *m;
1422     dbus_uint16_t gain;
1423     pa_volume_t volume;
1424     struct userdata *u;
1425     char *k;
1426
1427     pa_assert(s);
1428     pa_assert(s->core);
1429
1430     k = pa_sprintf_malloc("bluetooth-device@%p", (void*) s);
1431     u = pa_shared_get(s->core, k);
1432     pa_xfree(k);
1433
1434     pa_assert(u);
1435     pa_assert(u->source == s);
1436     pa_assert(u->profile == PROFILE_HSP);
1437
1438     gain = (pa_cvolume_max(&s->real_volume) * HSP_MAX_GAIN) / PA_VOLUME_NORM;
1439
1440     if (gain > HSP_MAX_GAIN)
1441         gain = HSP_MAX_GAIN;
1442
1443     volume = (pa_volume_t) (gain * PA_VOLUME_NORM / HSP_MAX_GAIN);
1444
1445     /* increment volume by one to correct rounding errors */
1446     if (volume < PA_VOLUME_NORM)
1447         volume++;
1448
1449     pa_cvolume_set(&s->real_volume, u->sample_spec.channels, volume);
1450
1451     pa_assert_se(m = dbus_message_new_method_call("org.bluez", u->path, "org.bluez.Headset", "SetMicrophoneGain"));
1452     pa_assert_se(dbus_message_append_args(m, DBUS_TYPE_UINT16, &gain, DBUS_TYPE_INVALID));
1453     pa_assert_se(dbus_connection_send(pa_dbus_connection_get(u->connection), m, NULL));
1454     dbus_message_unref(m);
1455 }
1456
1457 /* Run from main thread */
1458 static char *get_name(const char *type, pa_modargs *ma, const char *device_id, pa_bool_t *namereg_fail) {
1459     char *t;
1460     const char *n;
1461
1462     pa_assert(type);
1463     pa_assert(ma);
1464     pa_assert(device_id);
1465     pa_assert(namereg_fail);
1466
1467     t = pa_sprintf_malloc("%s_name", type);
1468     n = pa_modargs_get_value(ma, t, NULL);
1469     pa_xfree(t);
1470
1471     if (n) {
1472         *namereg_fail = TRUE;
1473         return pa_xstrdup(n);
1474     }
1475
1476     if ((n = pa_modargs_get_value(ma, "name", NULL)))
1477         *namereg_fail = TRUE;
1478     else {
1479         n = device_id;
1480         *namereg_fail = FALSE;
1481     }
1482
1483     return pa_sprintf_malloc("bluez_%s.%s", type, n);
1484 }
1485
1486 static int sco_over_pcm_state_update(struct userdata *u, pa_bool_t changed) {
1487     pa_assert(u);
1488     pa_assert(USE_SCO_OVER_PCM(u));
1489
1490     if (PA_SINK_IS_OPENED(pa_sink_get_state(u->hsp.sco_sink)) ||
1491         PA_SOURCE_IS_OPENED(pa_source_get_state(u->hsp.sco_source))) {
1492
1493         if (u->stream_fd >= 0)
1494             return 0;
1495
1496         pa_log_debug("Resuming SCO over PCM");
1497         if (init_profile(u) < 0) {
1498             pa_log("Can't resume SCO over PCM");
1499             return -1;
1500         }
1501
1502         return bt_transport_acquire(u, TRUE);
1503     }
1504
1505     if (changed) {
1506         if (u->stream_fd < 0)
1507             return 0;
1508
1509         pa_log_debug("Closing SCO over PCM");
1510
1511         bt_transport_release(u);
1512     }
1513
1514     return 0;
1515 }
1516
1517 static pa_hook_result_t sink_state_changed_cb(pa_core *c, pa_sink *s, struct userdata *u) {
1518     pa_assert(c);
1519     pa_sink_assert_ref(s);
1520     pa_assert(u);
1521
1522     if (s != u->hsp.sco_sink)
1523         return PA_HOOK_OK;
1524
1525     sco_over_pcm_state_update(u, TRUE);
1526
1527     return PA_HOOK_OK;
1528 }
1529
1530 static pa_hook_result_t source_state_changed_cb(pa_core *c, pa_source *s, struct userdata *u) {
1531     pa_assert(c);
1532     pa_source_assert_ref(s);
1533     pa_assert(u);
1534
1535     if (s != u->hsp.sco_source)
1536         return PA_HOOK_OK;
1537
1538     sco_over_pcm_state_update(u, TRUE);
1539
1540     return PA_HOOK_OK;
1541 }
1542
1543 static pa_hook_result_t nrec_changed_cb(pa_bluetooth_transport *t, void *call_data, struct userdata *u) {
1544     pa_proplist *p;
1545
1546     pa_assert(t);
1547     pa_assert(u);
1548
1549     p = pa_proplist_new();
1550     pa_proplist_sets(p, "bluetooth.nrec", t->nrec ? "1" : "0");
1551     pa_source_update_proplist(u->source, PA_UPDATE_REPLACE, p);
1552     pa_proplist_free(p);
1553
1554     return PA_HOOK_OK;
1555 }
1556
1557 static void connect_ports(struct userdata *u, void *sink_or_source_new_data, pa_direction_t direction) {
1558     union {
1559         pa_sink_new_data *sink_new_data;
1560         pa_source_new_data *source_new_data;
1561     } data;
1562     pa_device_port *port;
1563
1564     if (direction == PA_DIRECTION_OUTPUT) {
1565         data.sink_new_data = sink_or_source_new_data;
1566         data.sink_new_data->ports = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
1567     } else {
1568         data.source_new_data = sink_or_source_new_data;
1569         data.source_new_data->ports = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
1570     }
1571
1572     switch (u->profile) {
1573         case PROFILE_A2DP:
1574             pa_assert_se(port = pa_hashmap_get(u->card->ports, "a2dp-output"));
1575             pa_assert_se(pa_hashmap_put(data.sink_new_data->ports, port->name, port) >= 0);
1576             pa_device_port_ref(port);
1577             break;
1578
1579         case PROFILE_A2DP_SOURCE:
1580             pa_assert_se(port = pa_hashmap_get(u->card->ports, "a2dp-input"));
1581             pa_assert_se(pa_hashmap_put(data.source_new_data->ports, port->name, port) >= 0);
1582             pa_device_port_ref(port);
1583             break;
1584
1585         case PROFILE_HSP:
1586             if (direction == PA_DIRECTION_OUTPUT) {
1587                 pa_assert_se(port = pa_hashmap_get(u->card->ports, "hsp-output"));
1588                 pa_assert_se(pa_hashmap_put(data.sink_new_data->ports, port->name, port) >= 0);
1589             } else {
1590                 pa_assert_se(port = pa_hashmap_get(u->card->ports, "hsp-input"));
1591                 pa_assert_se(pa_hashmap_put(data.source_new_data->ports, port->name, port) >= 0);
1592             }
1593             pa_device_port_ref(port);
1594             break;
1595
1596         case PROFILE_HFGW:
1597             if (direction == PA_DIRECTION_OUTPUT) {
1598                 pa_assert_se(port = pa_hashmap_get(u->card->ports, "hfgw-output"));
1599                 pa_assert_se(pa_hashmap_put(data.sink_new_data->ports, port->name, port) >= 0);
1600             } else {
1601                 pa_assert_se(port = pa_hashmap_get(u->card->ports, "hfgw-input"));
1602                 pa_assert_se(pa_hashmap_put(data.source_new_data->ports, port->name, port) >= 0);
1603             }
1604             pa_device_port_ref(port);
1605             break;
1606
1607         default:
1608             pa_assert_not_reached();
1609         }
1610 }
1611
1612 static const char *profile_to_string(enum profile profile) {
1613     switch(profile) {
1614         case PROFILE_A2DP:
1615             return "a2dp";
1616         case PROFILE_A2DP_SOURCE:
1617             return "a2dp_source";
1618         case PROFILE_HSP:
1619             return "hsp";
1620         case PROFILE_HFGW:
1621             return "hfgw";
1622         default:
1623             pa_assert_not_reached();
1624     }
1625 }
1626
1627 static int sink_set_port_cb(pa_sink *s, pa_device_port *p) {
1628     return 0;
1629 }
1630
1631 static int source_set_port_cb(pa_source *s, pa_device_port *p) {
1632     return 0;
1633 }
1634
1635 /* Run from main thread */
1636 static int add_sink(struct userdata *u) {
1637     char *k;
1638
1639     if (USE_SCO_OVER_PCM(u)) {
1640         pa_proplist *p;
1641
1642         u->sink = u->hsp.sco_sink;
1643         p = pa_proplist_new();
1644         pa_proplist_sets(p, "bluetooth.protocol", profile_to_string(u->profile));
1645         pa_proplist_update(u->sink->proplist, PA_UPDATE_MERGE, p);
1646         pa_proplist_free(p);
1647
1648         if (!u->hsp.sink_state_changed_slot)
1649             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);
1650
1651     } else {
1652         pa_sink_new_data data;
1653         pa_bool_t b;
1654
1655         pa_sink_new_data_init(&data);
1656         data.driver = __FILE__;
1657         data.module = u->module;
1658         pa_sink_new_data_set_sample_spec(&data, &u->sample_spec);
1659         pa_proplist_sets(data.proplist, "bluetooth.protocol", profile_to_string(u->profile));
1660         if (u->profile == PROFILE_HSP)
1661             pa_proplist_sets(data.proplist, PA_PROP_DEVICE_INTENDED_ROLES, "phone");
1662         data.card = u->card;
1663         data.name = get_name("sink", u->modargs, u->address, &b);
1664         data.namereg_fail = b;
1665
1666         if (pa_modargs_get_proplist(u->modargs, "sink_properties", data.proplist, PA_UPDATE_REPLACE) < 0) {
1667             pa_log("Invalid properties");
1668             pa_sink_new_data_done(&data);
1669             return -1;
1670         }
1671         connect_ports(u, &data, PA_DIRECTION_OUTPUT);
1672
1673         u->sink = pa_sink_new(u->core, &data, PA_SINK_HARDWARE|PA_SINK_LATENCY);
1674         pa_sink_new_data_done(&data);
1675
1676         if (!u->sink) {
1677             pa_log_error("Failed to create sink");
1678             return -1;
1679         }
1680
1681         u->sink->userdata = u;
1682         u->sink->parent.process_msg = sink_process_msg;
1683         u->sink->set_port = sink_set_port_cb;
1684     }
1685
1686     if (u->profile == PROFILE_HSP) {
1687         pa_sink_set_set_volume_callback(u->sink, sink_set_volume_cb);
1688         u->sink->n_volume_steps = 16;
1689
1690         k = pa_sprintf_malloc("bluetooth-device@%p", (void*) u->sink);
1691         pa_shared_set(u->core, k, u);
1692         pa_xfree(k);
1693     }
1694
1695     return 0;
1696 }
1697
1698 /* Run from main thread */
1699 static int add_source(struct userdata *u) {
1700     char *k;
1701
1702     if (USE_SCO_OVER_PCM(u)) {
1703         u->source = u->hsp.sco_source;
1704         pa_proplist_sets(u->source->proplist, "bluetooth.protocol", profile_to_string(u->profile));
1705
1706         if (!u->hsp.source_state_changed_slot)
1707             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);
1708
1709     } else {
1710         pa_source_new_data data;
1711         pa_bool_t b;
1712
1713         pa_source_new_data_init(&data);
1714         data.driver = __FILE__;
1715         data.module = u->module;
1716         pa_source_new_data_set_sample_spec(&data, &u->sample_spec);
1717         pa_proplist_sets(data.proplist, "bluetooth.protocol", profile_to_string(u->profile));
1718         if (u->profile == PROFILE_HSP)
1719             pa_proplist_sets(data.proplist, PA_PROP_DEVICE_INTENDED_ROLES, "phone");
1720
1721         data.card = u->card;
1722         data.name = get_name("source", u->modargs, u->address, &b);
1723         data.namereg_fail = b;
1724
1725         if (pa_modargs_get_proplist(u->modargs, "source_properties", data.proplist, PA_UPDATE_REPLACE) < 0) {
1726             pa_log("Invalid properties");
1727             pa_source_new_data_done(&data);
1728             return -1;
1729         }
1730
1731         connect_ports(u, &data, PA_DIRECTION_INPUT);
1732         u->source = pa_source_new(u->core, &data, PA_SOURCE_HARDWARE|PA_SOURCE_LATENCY);
1733         pa_source_new_data_done(&data);
1734
1735         if (!u->source) {
1736             pa_log_error("Failed to create source");
1737             return -1;
1738         }
1739
1740         u->source->userdata = u;
1741         u->source->parent.process_msg = source_process_msg;
1742         u->source->set_port = source_set_port_cb;
1743     }
1744
1745     if ((u->profile == PROFILE_HSP) || (u->profile == PROFILE_HFGW)) {
1746         pa_bluetooth_transport *t;
1747         t = pa_bluetooth_discovery_get_transport(u->discovery, u->transport);
1748         pa_assert(t);
1749         pa_proplist_sets(u->source->proplist, "bluetooth.nrec", t->nrec ? "1" : "0");
1750
1751         if (!u->hsp.nrec_changed_slot)
1752             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);
1753     }
1754
1755     if (u->profile == PROFILE_HSP) {
1756         pa_source_set_set_volume_callback(u->source, source_set_volume_cb);
1757         u->source->n_volume_steps = 16;
1758
1759         k = pa_sprintf_malloc("bluetooth-device@%p", (void*) u->source);
1760         pa_shared_set(u->core, k, u);
1761         pa_xfree(k);
1762     }
1763
1764     return 0;
1765 }
1766
1767 static void bt_transport_config_a2dp(struct userdata *u) {
1768     const pa_bluetooth_transport *t;
1769     struct a2dp_info *a2dp = &u->a2dp;
1770     a2dp_sbc_t *config;
1771
1772     t = pa_bluetooth_discovery_get_transport(u->discovery, u->transport);
1773     pa_assert(t);
1774
1775     config = (a2dp_sbc_t *) t->config;
1776
1777     u->sample_spec.format = PA_SAMPLE_S16LE;
1778
1779     if (a2dp->sbc_initialized)
1780         sbc_reinit(&a2dp->sbc, 0);
1781     else
1782         sbc_init(&a2dp->sbc, 0);
1783     a2dp->sbc_initialized = TRUE;
1784
1785     switch (config->frequency) {
1786         case BT_SBC_SAMPLING_FREQ_16000:
1787             a2dp->sbc.frequency = SBC_FREQ_16000;
1788             u->sample_spec.rate = 16000U;
1789             break;
1790         case BT_SBC_SAMPLING_FREQ_32000:
1791             a2dp->sbc.frequency = SBC_FREQ_32000;
1792             u->sample_spec.rate = 32000U;
1793             break;
1794         case BT_SBC_SAMPLING_FREQ_44100:
1795             a2dp->sbc.frequency = SBC_FREQ_44100;
1796             u->sample_spec.rate = 44100U;
1797             break;
1798         case BT_SBC_SAMPLING_FREQ_48000:
1799             a2dp->sbc.frequency = SBC_FREQ_48000;
1800             u->sample_spec.rate = 48000U;
1801             break;
1802         default:
1803             pa_assert_not_reached();
1804     }
1805
1806     switch (config->channel_mode) {
1807         case BT_A2DP_CHANNEL_MODE_MONO:
1808             a2dp->sbc.mode = SBC_MODE_MONO;
1809             u->sample_spec.channels = 1;
1810             break;
1811         case BT_A2DP_CHANNEL_MODE_DUAL_CHANNEL:
1812             a2dp->sbc.mode = SBC_MODE_DUAL_CHANNEL;
1813             u->sample_spec.channels = 2;
1814             break;
1815         case BT_A2DP_CHANNEL_MODE_STEREO:
1816             a2dp->sbc.mode = SBC_MODE_STEREO;
1817             u->sample_spec.channels = 2;
1818             break;
1819         case BT_A2DP_CHANNEL_MODE_JOINT_STEREO:
1820             a2dp->sbc.mode = SBC_MODE_JOINT_STEREO;
1821             u->sample_spec.channels = 2;
1822             break;
1823         default:
1824             pa_assert_not_reached();
1825     }
1826
1827     switch (config->allocation_method) {
1828         case BT_A2DP_ALLOCATION_SNR:
1829             a2dp->sbc.allocation = SBC_AM_SNR;
1830             break;
1831         case BT_A2DP_ALLOCATION_LOUDNESS:
1832             a2dp->sbc.allocation = SBC_AM_LOUDNESS;
1833             break;
1834         default:
1835             pa_assert_not_reached();
1836     }
1837
1838     switch (config->subbands) {
1839         case BT_A2DP_SUBBANDS_4:
1840             a2dp->sbc.subbands = SBC_SB_4;
1841             break;
1842         case BT_A2DP_SUBBANDS_8:
1843             a2dp->sbc.subbands = SBC_SB_8;
1844             break;
1845         default:
1846             pa_assert_not_reached();
1847     }
1848
1849     switch (config->block_length) {
1850         case BT_A2DP_BLOCK_LENGTH_4:
1851             a2dp->sbc.blocks = SBC_BLK_4;
1852             break;
1853         case BT_A2DP_BLOCK_LENGTH_8:
1854             a2dp->sbc.blocks = SBC_BLK_8;
1855             break;
1856         case BT_A2DP_BLOCK_LENGTH_12:
1857             a2dp->sbc.blocks = SBC_BLK_12;
1858             break;
1859         case BT_A2DP_BLOCK_LENGTH_16:
1860             a2dp->sbc.blocks = SBC_BLK_16;
1861             break;
1862         default:
1863             pa_assert_not_reached();
1864     }
1865
1866     a2dp->min_bitpool = config->min_bitpool;
1867     a2dp->max_bitpool = config->max_bitpool;
1868
1869     /* Set minimum bitpool for source to get the maximum possible block_size */
1870     a2dp->sbc.bitpool = u->profile == PROFILE_A2DP ? a2dp->max_bitpool : a2dp->min_bitpool;
1871     a2dp->codesize = sbc_get_codesize(&a2dp->sbc);
1872     a2dp->frame_length = sbc_get_frame_length(&a2dp->sbc);
1873
1874     pa_log_info("SBC parameters:\n\tallocation=%u\n\tsubbands=%u\n\tblocks=%u\n\tbitpool=%u\n",
1875                 a2dp->sbc.allocation, a2dp->sbc.subbands, a2dp->sbc.blocks, a2dp->sbc.bitpool);
1876 }
1877
1878 static void bt_transport_config(struct userdata *u) {
1879     if (u->profile == PROFILE_HSP || u->profile == PROFILE_HFGW) {
1880         u->sample_spec.format = PA_SAMPLE_S16LE;
1881         u->sample_spec.channels = 1;
1882         u->sample_spec.rate = 8000;
1883     } else
1884         bt_transport_config_a2dp(u);
1885 }
1886
1887 /* Run from main thread */
1888 static int setup_bt(struct userdata *u) {
1889     const pa_bluetooth_device *d;
1890     const pa_bluetooth_transport *t;
1891
1892     pa_assert(u);
1893
1894     if (!(d = pa_bluetooth_discovery_get_by_path(u->discovery, u->path))) {
1895         pa_log_error("Failed to get device object.");
1896         return -1;
1897     }
1898
1899     /* release transport if exist */
1900     if (u->transport) {
1901         bt_transport_release(u);
1902         pa_xfree(u->transport);
1903         u->transport = NULL;
1904     }
1905
1906     /* check if profile has a transport */
1907     t = pa_bluetooth_device_get_transport(d, u->profile);
1908     if (t == NULL) {
1909         pa_log_warn("Profile has no transport");
1910         return -1;
1911     }
1912
1913     u->transport = pa_xstrdup(t->path);
1914
1915     if (bt_transport_acquire(u, FALSE) < 0)
1916         return -1;
1917
1918     bt_transport_config(u);
1919
1920     return 0;
1921 }
1922
1923 /* Run from main thread */
1924 static int init_profile(struct userdata *u) {
1925     int r = 0;
1926     pa_assert(u);
1927     pa_assert(u->profile != PROFILE_OFF);
1928
1929     if (setup_bt(u) < 0)
1930         return -1;
1931
1932     if (u->profile == PROFILE_A2DP ||
1933         u->profile == PROFILE_HSP ||
1934         u->profile == PROFILE_HFGW)
1935         if (add_sink(u) < 0)
1936             r = -1;
1937
1938     if (u->profile == PROFILE_HSP ||
1939         u->profile == PROFILE_A2DP_SOURCE ||
1940         u->profile == PROFILE_HFGW)
1941         if (add_source(u) < 0)
1942             r = -1;
1943
1944     return r;
1945 }
1946
1947 /* Run from main thread */
1948 static void stop_thread(struct userdata *u) {
1949     char *k;
1950
1951     pa_assert(u);
1952
1953     if (u->thread) {
1954         pa_asyncmsgq_send(u->thread_mq.inq, NULL, PA_MESSAGE_SHUTDOWN, NULL, 0, NULL);
1955         pa_thread_free(u->thread);
1956         u->thread = NULL;
1957     }
1958
1959     if (u->rtpoll_item) {
1960         pa_rtpoll_item_free(u->rtpoll_item);
1961         u->rtpoll_item = NULL;
1962     }
1963
1964     if (u->hsp.sink_state_changed_slot) {
1965         pa_hook_slot_free(u->hsp.sink_state_changed_slot);
1966         u->hsp.sink_state_changed_slot = NULL;
1967     }
1968
1969     if (u->hsp.source_state_changed_slot) {
1970         pa_hook_slot_free(u->hsp.source_state_changed_slot);
1971         u->hsp.source_state_changed_slot = NULL;
1972     }
1973
1974     if (u->hsp.nrec_changed_slot) {
1975         pa_hook_slot_free(u->hsp.nrec_changed_slot);
1976         u->hsp.nrec_changed_slot = NULL;
1977     }
1978
1979     if (u->sink) {
1980         if (u->profile == PROFILE_HSP) {
1981             k = pa_sprintf_malloc("bluetooth-device@%p", (void*) u->sink);
1982             pa_shared_remove(u->core, k);
1983             pa_xfree(k);
1984         }
1985
1986         pa_sink_unref(u->sink);
1987         u->sink = NULL;
1988     }
1989
1990     if (u->source) {
1991         if (u->profile == PROFILE_HSP) {
1992             k = pa_sprintf_malloc("bluetooth-device@%p", (void*) u->source);
1993             pa_shared_remove(u->core, k);
1994             pa_xfree(k);
1995         }
1996
1997         pa_source_unref(u->source);
1998         u->source = NULL;
1999     }
2000
2001     if (u->rtpoll) {
2002         pa_thread_mq_done(&u->thread_mq);
2003
2004         pa_rtpoll_free(u->rtpoll);
2005         u->rtpoll = NULL;
2006     }
2007
2008     if (u->read_smoother) {
2009         pa_smoother_free(u->read_smoother);
2010         u->read_smoother = NULL;
2011     }
2012 }
2013
2014 /* Run from main thread */
2015 static int start_thread(struct userdata *u) {
2016     pa_assert(u);
2017     pa_assert(!u->thread);
2018     pa_assert(!u->rtpoll);
2019     pa_assert(!u->rtpoll_item);
2020
2021     u->rtpoll = pa_rtpoll_new();
2022     pa_thread_mq_init(&u->thread_mq, u->core->mainloop, u->rtpoll);
2023
2024     if (USE_SCO_OVER_PCM(u)) {
2025         if (sco_over_pcm_state_update(u, FALSE) < 0) {
2026             char *k;
2027
2028             if (u->sink) {
2029                 k = pa_sprintf_malloc("bluetooth-device@%p", (void*) u->sink);
2030                 pa_shared_remove(u->core, k);
2031                 pa_xfree(k);
2032                 u->sink = NULL;
2033             }
2034             if (u->source) {
2035                 k = pa_sprintf_malloc("bluetooth-device@%p", (void*) u->source);
2036                 pa_shared_remove(u->core, k);
2037                 pa_xfree(k);
2038                 u->source = NULL;
2039             }
2040             return -1;
2041         }
2042
2043         pa_sink_ref(u->sink);
2044         pa_source_ref(u->source);
2045         /* FIXME: monitor stream_fd error */
2046         return 0;
2047     }
2048
2049     if (!(u->thread = pa_thread_new("bluetooth", thread_func, u))) {
2050         pa_log_error("Failed to create IO thread");
2051         stop_thread(u);
2052         return -1;
2053     }
2054
2055     if (u->sink) {
2056         pa_sink_set_asyncmsgq(u->sink, u->thread_mq.inq);
2057         pa_sink_set_rtpoll(u->sink, u->rtpoll);
2058         pa_sink_put(u->sink);
2059
2060         if (u->sink->set_volume)
2061             u->sink->set_volume(u->sink);
2062     }
2063
2064     if (u->source) {
2065         pa_source_set_asyncmsgq(u->source, u->thread_mq.inq);
2066         pa_source_set_rtpoll(u->source, u->rtpoll);
2067         pa_source_put(u->source);
2068
2069         if (u->source->set_volume)
2070             u->source->set_volume(u->source);
2071     }
2072
2073     return 0;
2074 }
2075
2076 static void save_sco_volume_callbacks(struct userdata *u) {
2077     pa_assert(u);
2078     pa_assert(USE_SCO_OVER_PCM(u));
2079
2080     u->hsp.sco_sink_set_volume = u->hsp.sco_sink->set_volume;
2081     u->hsp.sco_source_set_volume = u->hsp.sco_source->set_volume;
2082 }
2083
2084 static void restore_sco_volume_callbacks(struct userdata *u) {
2085     pa_assert(u);
2086     pa_assert(USE_SCO_OVER_PCM(u));
2087
2088     pa_sink_set_set_volume_callback(u->hsp.sco_sink, u->hsp.sco_sink_set_volume);
2089     pa_source_set_set_volume_callback(u->hsp.sco_source, u->hsp.sco_source_set_volume);
2090 }
2091
2092 /* Run from main thread */
2093 static int card_set_profile(pa_card *c, pa_card_profile *new_profile) {
2094     struct userdata *u;
2095     enum profile *d;
2096     pa_queue *inputs = NULL, *outputs = NULL;
2097     const pa_bluetooth_device *device;
2098
2099     pa_assert(c);
2100     pa_assert(new_profile);
2101     pa_assert_se(u = c->userdata);
2102
2103     d = PA_CARD_PROFILE_DATA(new_profile);
2104
2105     if (!(device = pa_bluetooth_discovery_get_by_path(u->discovery, u->path))) {
2106         pa_log_error("Failed to get device object.");
2107         return -PA_ERR_IO;
2108     }
2109
2110     /* The state signal is sent by bluez, so it is racy to check
2111        strictly for CONNECTED, we should also accept STREAMING state
2112        as being good enough. However, if the profile is used
2113        concurrently (which is unlikely), ipc will fail later on, and
2114        module will be unloaded. */
2115     if (device->headset_state < PA_BT_AUDIO_STATE_CONNECTED && *d == PROFILE_HSP) {
2116         pa_log_warn("HSP is not connected, refused to switch profile");
2117         return -PA_ERR_IO;
2118     } else if (device->audio_sink_state < PA_BT_AUDIO_STATE_CONNECTED && *d == PROFILE_A2DP) {
2119         pa_log_warn("A2DP Sink is not connected, refused to switch profile");
2120         return -PA_ERR_IO;
2121     } else if (device->audio_source_state < PA_BT_AUDIO_STATE_CONNECTED && *d == PROFILE_A2DP_SOURCE) {
2122         pa_log_warn("A2DP Source is not connected, refused to switch profile");
2123         return -PA_ERR_IO;
2124     } else if (device->hfgw_state < PA_BT_AUDIO_STATE_CONNECTED && *d == PROFILE_HFGW) {
2125         pa_log_warn("HandsfreeGateway is not connected, refused to switch profile");
2126         return -PA_ERR_IO;
2127     }
2128
2129     if (u->sink) {
2130         inputs = pa_sink_move_all_start(u->sink, NULL);
2131
2132         if (!USE_SCO_OVER_PCM(u))
2133             pa_sink_unlink(u->sink);
2134     }
2135
2136     if (u->source) {
2137         outputs = pa_source_move_all_start(u->source, NULL);
2138
2139         if (!USE_SCO_OVER_PCM(u))
2140             pa_source_unlink(u->source);
2141     }
2142
2143     stop_thread(u);
2144
2145     if (u->profile != PROFILE_OFF && u->transport) {
2146         bt_transport_release(u);
2147         pa_xfree(u->transport);
2148         u->transport = NULL;
2149     }
2150
2151     if (USE_SCO_OVER_PCM(u))
2152         restore_sco_volume_callbacks(u);
2153
2154     u->profile = *d;
2155     u->sample_spec = u->requested_sample_spec;
2156
2157     if (USE_SCO_OVER_PCM(u))
2158         save_sco_volume_callbacks(u);
2159
2160     if (u->profile != PROFILE_OFF)
2161         init_profile(u);
2162
2163     if (u->sink || u->source)
2164         start_thread(u);
2165
2166     if (inputs) {
2167         if (u->sink)
2168             pa_sink_move_all_finish(u->sink, inputs, FALSE);
2169         else
2170             pa_sink_move_all_fail(inputs);
2171     }
2172
2173     if (outputs) {
2174         if (u->source)
2175             pa_source_move_all_finish(u->source, outputs, FALSE);
2176         else
2177             pa_source_move_all_fail(outputs);
2178     }
2179
2180     return 0;
2181 }
2182
2183 static void create_ports_for_profile(struct userdata *u, const pa_bluetooth_device *device, pa_card_new_data *card_new_data, pa_card_profile *profile) {
2184     pa_device_port *port;
2185     enum profile *d;
2186
2187     d = PA_CARD_PROFILE_DATA(profile);
2188
2189     switch (*d) {
2190         case PROFILE_A2DP:
2191             pa_assert_se(port = pa_device_port_new(u->core, "a2dp-output", _("Bluetooth High Quality (A2DP)"), 0));
2192             pa_assert_se(pa_hashmap_put(card_new_data->ports, port->name, port) >= 0);
2193             port->is_output = 1;
2194             port->is_input = 0;
2195             port->priority = profile->priority * 100;
2196             port->available = audio_state_to_availability(device->audio_sink_state);
2197             pa_hashmap_put(port->profiles, profile->name, profile);
2198             break;
2199
2200         case PROFILE_A2DP_SOURCE:
2201             pa_assert_se(port = pa_device_port_new(u->core, "a2dp-input", _("Bluetooth High Quality (A2DP)"), 0));
2202             pa_assert_se(pa_hashmap_put(card_new_data->ports, port->name, port) >= 0);
2203             port->is_output = 0;
2204             port->is_input = 1;
2205             port->priority = profile->priority * 100;
2206             port->available = audio_state_to_availability(device->audio_source_state);
2207             pa_hashmap_put(port->profiles, profile->name, profile);
2208             break;
2209
2210         case PROFILE_HSP:
2211             pa_assert_se(port = pa_device_port_new(u->core, "hsp-output", _("Bluetooth Telephony (HSP/HFP)"), 0));
2212             pa_assert_se(pa_hashmap_put(card_new_data->ports, port->name, port) >= 0);
2213             port->is_output = 1;
2214             port->is_input = 0;
2215             port->priority = profile->priority * 100;
2216             port->available = audio_state_to_availability(device->headset_state);
2217             pa_hashmap_put(port->profiles, profile->name, profile);
2218
2219             pa_assert_se(port = pa_device_port_new(u->core, "hsp-input", _("Bluetooth Telephony (HSP/HFP)"), 0));
2220             pa_assert_se(pa_hashmap_put(card_new_data->ports, port->name, port) >= 0);
2221             port->is_output = 0;
2222             port->is_input = 1;
2223             port->priority = profile->priority * 100;
2224             port->available = audio_state_to_availability(device->headset_state);
2225             pa_hashmap_put(port->profiles, profile->name, profile);
2226             break;
2227
2228         case PROFILE_HFGW:
2229             pa_assert_se(port = pa_device_port_new(u->core, "hfgw-output", _("Bluetooth Handsfree Gateway"), 0));
2230             pa_assert_se(pa_hashmap_put(card_new_data->ports, port->name, port) >= 0);
2231             port->is_output = 1;
2232             port->is_input = 0;
2233             port->priority = profile->priority * 100;
2234             port->available = audio_state_to_availability(device->hfgw_state);
2235             pa_hashmap_put(port->profiles, profile->name, profile);
2236
2237             pa_assert_se(port = pa_device_port_new(u->core, "hfgw-input", _("Bluetooth Handsfree Gateway"), 0));
2238             pa_assert_se(pa_hashmap_put(card_new_data->ports, port->name, port) >= 0);
2239             port->is_output = 0;
2240             port->is_input = 1;
2241             port->priority = profile->priority * 100;
2242             port->available = audio_state_to_availability(device->hfgw_state);
2243             pa_hashmap_put(port->profiles, profile->name, profile);
2244             break;
2245
2246         default:
2247             pa_assert_not_reached();
2248     }
2249
2250 }
2251
2252 /* Run from main thread */
2253 static int add_card(struct userdata *u, const pa_bluetooth_device *device) {
2254     pa_card_new_data data;
2255     pa_bool_t b;
2256     pa_card_profile *p;
2257     enum profile *d;
2258     const char *ff;
2259     char *n;
2260     const char *default_profile;
2261
2262     pa_assert(u);
2263     pa_assert(device);
2264
2265     pa_card_new_data_init(&data);
2266     data.driver = __FILE__;
2267     data.module = u->module;
2268
2269     n = pa_bluetooth_cleanup_name(device->name);
2270     pa_proplist_sets(data.proplist, PA_PROP_DEVICE_DESCRIPTION, n);
2271     pa_xfree(n);
2272     pa_proplist_sets(data.proplist, PA_PROP_DEVICE_STRING, device->address);
2273     pa_proplist_sets(data.proplist, PA_PROP_DEVICE_API, "bluez");
2274     pa_proplist_sets(data.proplist, PA_PROP_DEVICE_CLASS, "sound");
2275     pa_proplist_sets(data.proplist, PA_PROP_DEVICE_BUS, "bluetooth");
2276     if ((ff = pa_bluetooth_get_form_factor(device->class)))
2277         pa_proplist_sets(data.proplist, PA_PROP_DEVICE_FORM_FACTOR, ff);
2278     pa_proplist_sets(data.proplist, "bluez.path", device->path);
2279     pa_proplist_setf(data.proplist, "bluez.class", "0x%06x", (unsigned) device->class);
2280     pa_proplist_sets(data.proplist, "bluez.name", device->name);
2281     data.name = get_name("card", u->modargs, device->address, &b);
2282     data.namereg_fail = b;
2283
2284     if (pa_modargs_get_proplist(u->modargs, "card_properties", data.proplist, PA_UPDATE_REPLACE) < 0) {
2285         pa_log("Invalid properties");
2286         pa_card_new_data_done(&data);
2287         return -1;
2288     }
2289
2290     data.profiles = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
2291
2292     /* we base hsp/a2dp availability on UUIDs.
2293        Ideally, it would be based on "Connected" state, but
2294        we can't afford to wait for this information when
2295        we are loaded with profile="hsp", for instance */
2296     if (pa_bluetooth_uuid_has(device->uuids, A2DP_SINK_UUID)) {
2297         p = pa_card_profile_new("a2dp", _("High Fidelity Playback (A2DP)"), sizeof(enum profile));
2298         p->priority = 10;
2299         p->n_sinks = 1;
2300         p->n_sources = 0;
2301         p->max_sink_channels = 2;
2302         p->max_source_channels = 0;
2303
2304         d = PA_CARD_PROFILE_DATA(p);
2305         *d = PROFILE_A2DP;
2306         create_ports_for_profile(u, device, &data, p);
2307
2308         pa_hashmap_put(data.profiles, p->name, p);
2309     }
2310
2311     if (pa_bluetooth_uuid_has(device->uuids, A2DP_SOURCE_UUID)) {
2312         p = pa_card_profile_new("a2dp_source", _("High Fidelity Capture (A2DP)"), sizeof(enum profile));
2313         p->priority = 10;
2314         p->n_sinks = 0;
2315         p->n_sources = 1;
2316         p->max_sink_channels = 0;
2317         p->max_source_channels = 2;
2318
2319         d = PA_CARD_PROFILE_DATA(p);
2320         *d = PROFILE_A2DP_SOURCE;
2321         create_ports_for_profile(u, device, &data, p);
2322
2323         pa_hashmap_put(data.profiles, p->name, p);
2324     }
2325
2326     if (pa_bluetooth_uuid_has(device->uuids, HSP_HS_UUID) ||
2327         pa_bluetooth_uuid_has(device->uuids, HFP_HS_UUID)) {
2328         p = pa_card_profile_new("hsp", _("Telephony Duplex (HSP/HFP)"), sizeof(enum profile));
2329         p->priority = 20;
2330         p->n_sinks = 1;
2331         p->n_sources = 1;
2332         p->max_sink_channels = 1;
2333         p->max_source_channels = 1;
2334
2335         d = PA_CARD_PROFILE_DATA(p);
2336         *d = PROFILE_HSP;
2337         create_ports_for_profile(u, device, &data, p);
2338
2339         pa_hashmap_put(data.profiles, p->name, p);
2340     }
2341
2342     if (pa_bluetooth_uuid_has(device->uuids, HFP_AG_UUID)) {
2343         p = pa_card_profile_new("hfgw", _("Handsfree Gateway"), sizeof(enum profile));
2344         p->priority = 20;
2345         p->n_sinks = 1;
2346         p->n_sources = 1;
2347         p->max_sink_channels = 1;
2348         p->max_source_channels = 1;
2349
2350         d = PA_CARD_PROFILE_DATA(p);
2351         *d = PROFILE_HFGW;
2352         create_ports_for_profile(u, device, &data, p);
2353
2354         pa_hashmap_put(data.profiles, p->name, p);
2355     }
2356
2357     pa_assert(!pa_hashmap_isempty(data.profiles));
2358
2359     p = pa_card_profile_new("off", _("Off"), sizeof(enum profile));
2360     d = PA_CARD_PROFILE_DATA(p);
2361     *d = PROFILE_OFF;
2362     pa_hashmap_put(data.profiles, p->name, p);
2363
2364     if ((default_profile = pa_modargs_get_value(u->modargs, "profile", NULL))) {
2365         if (pa_hashmap_get(data.profiles, default_profile))
2366             pa_card_new_data_set_profile(&data, default_profile);
2367         else
2368             pa_log_warn("Profile '%s' not valid or not supported by device.", default_profile);
2369     }
2370
2371     u->card = pa_card_new(u->core, &data);
2372     pa_card_new_data_done(&data);
2373
2374     if (!u->card) {
2375         pa_log("Failed to allocate card.");
2376         return -1;
2377     }
2378
2379     u->card->userdata = u;
2380     u->card->set_profile = card_set_profile;
2381
2382     d = PA_CARD_PROFILE_DATA(u->card->active_profile);
2383
2384     if ((device->headset_state < PA_BT_AUDIO_STATE_CONNECTED && *d == PROFILE_HSP) ||
2385         (device->audio_sink_state < PA_BT_AUDIO_STATE_CONNECTED && *d == PROFILE_A2DP) ||
2386         (device->audio_source_state < PA_BT_AUDIO_STATE_CONNECTED && *d == PROFILE_A2DP_SOURCE) ||
2387         (device->hfgw_state < PA_BT_AUDIO_STATE_CONNECTED && *d == PROFILE_HFGW)) {
2388         pa_log_warn("Default profile not connected, selecting off profile");
2389         u->card->active_profile = pa_hashmap_get(u->card->profiles, "off");
2390         u->card->save_profile = FALSE;
2391     }
2392
2393     d = PA_CARD_PROFILE_DATA(u->card->active_profile);
2394     u->profile = *d;
2395
2396     if (USE_SCO_OVER_PCM(u))
2397         save_sco_volume_callbacks(u);
2398
2399     return 0;
2400 }
2401
2402 /* Run from main thread */
2403 static const pa_bluetooth_device* find_device(struct userdata *u, const char *address, const char *path) {
2404     const pa_bluetooth_device *d = NULL;
2405
2406     pa_assert(u);
2407
2408     if (!address && !path) {
2409         pa_log_error("Failed to get device address/path from module arguments.");
2410         return NULL;
2411     }
2412
2413     if (path) {
2414         if (!(d = pa_bluetooth_discovery_get_by_path(u->discovery, path))) {
2415             pa_log_error("%s is not a valid BlueZ audio device.", path);
2416             return NULL;
2417         }
2418
2419         if (address && !(pa_streq(d->address, address))) {
2420             pa_log_error("Passed path %s address %s != %s don't match.", path, d->address, address);
2421             return NULL;
2422         }
2423
2424     } else {
2425         if (!(d = pa_bluetooth_discovery_get_by_address(u->discovery, address))) {
2426             pa_log_error("%s is not known.", address);
2427             return NULL;
2428         }
2429     }
2430
2431     if (d) {
2432         u->address = pa_xstrdup(d->address);
2433         u->path = pa_xstrdup(d->path);
2434     }
2435
2436     return d;
2437 }
2438
2439 /* Run from main thread */
2440 static int setup_dbus(struct userdata *u) {
2441     DBusError err;
2442
2443     dbus_error_init(&err);
2444
2445     u->connection = pa_dbus_bus_get(u->core, DBUS_BUS_SYSTEM, &err);
2446
2447     if (dbus_error_is_set(&err) || !u->connection) {
2448         pa_log("Failed to get D-Bus connection: %s", err.message);
2449         dbus_error_free(&err);
2450         return -1;
2451     }
2452
2453     return 0;
2454 }
2455
2456 int pa__init(pa_module* m) {
2457     pa_modargs *ma;
2458     uint32_t channels;
2459     struct userdata *u;
2460     const char *address, *path;
2461     DBusError err;
2462     char *mike, *speaker;
2463     const pa_bluetooth_device *device;
2464
2465     pa_assert(m);
2466
2467     dbus_error_init(&err);
2468
2469     if (!(ma = pa_modargs_new(m->argument, valid_modargs))) {
2470         pa_log_error("Failed to parse module arguments");
2471         goto fail;
2472     }
2473
2474     m->userdata = u = pa_xnew0(struct userdata, 1);
2475     u->module = m;
2476     u->core = m->core;
2477     u->stream_fd = -1;
2478     u->sample_spec = m->core->default_sample_spec;
2479     u->modargs = ma;
2480
2481     if (pa_modargs_get_value(ma, "sco_sink", NULL) &&
2482         !(u->hsp.sco_sink = pa_namereg_get(m->core, pa_modargs_get_value(ma, "sco_sink", NULL), PA_NAMEREG_SINK))) {
2483         pa_log("SCO sink not found");
2484         goto fail;
2485     }
2486
2487     if (pa_modargs_get_value(ma, "sco_source", NULL) &&
2488         !(u->hsp.sco_source = pa_namereg_get(m->core, pa_modargs_get_value(ma, "sco_source", NULL), PA_NAMEREG_SOURCE))) {
2489         pa_log("SCO source not found");
2490         goto fail;
2491     }
2492
2493     if (pa_modargs_get_value_u32(ma, "rate", &u->sample_spec.rate) < 0 ||
2494         u->sample_spec.rate <= 0 || u->sample_spec.rate > PA_RATE_MAX) {
2495         pa_log_error("Failed to get rate from module arguments");
2496         goto fail;
2497     }
2498
2499     u->auto_connect = TRUE;
2500     if (pa_modargs_get_value_boolean(ma, "auto_connect", &u->auto_connect)) {
2501         pa_log("Failed to parse auto_connect= argument");
2502         goto fail;
2503     }
2504
2505     channels = u->sample_spec.channels;
2506     if (pa_modargs_get_value_u32(ma, "channels", &channels) < 0 ||
2507         channels <= 0 || channels > PA_CHANNELS_MAX) {
2508         pa_log_error("Failed to get channels from module arguments");
2509         goto fail;
2510     }
2511     u->sample_spec.channels = (uint8_t) channels;
2512     u->requested_sample_spec = u->sample_spec;
2513
2514     address = pa_modargs_get_value(ma, "address", NULL);
2515     path = pa_modargs_get_value(ma, "path", NULL);
2516
2517     if (setup_dbus(u) < 0)
2518         goto fail;
2519
2520     if (!(u->discovery = pa_bluetooth_discovery_get(m->core)))
2521         goto fail;
2522
2523     if (!(device = find_device(u, address, path)))
2524         goto fail;
2525
2526     /* Add the card structure. This will also initialize the default profile */
2527     if (add_card(u, device) < 0)
2528         goto fail;
2529
2530     if (!(u->msg = pa_msgobject_new(bluetooth_msg)))
2531         goto fail;
2532
2533     u->msg->parent.process_msg = device_process_msg;
2534     u->msg->card = u->card;
2535
2536     if (!dbus_connection_add_filter(pa_dbus_connection_get(u->connection), filter_cb, u, NULL)) {
2537         pa_log_error("Failed to add filter function");
2538         goto fail;
2539     }
2540     u->filter_added = TRUE;
2541
2542     speaker = pa_sprintf_malloc("type='signal',sender='org.bluez',interface='org.bluez.Headset',member='SpeakerGainChanged',path='%s'", u->path);
2543     mike = pa_sprintf_malloc("type='signal',sender='org.bluez',interface='org.bluez.Headset',member='MicrophoneGainChanged',path='%s'", u->path);
2544
2545     if (pa_dbus_add_matches(
2546                 pa_dbus_connection_get(u->connection), &err,
2547                 speaker,
2548                 mike,
2549                 "type='signal',sender='org.bluez',interface='org.bluez.MediaTransport',member='PropertyChanged'",
2550                 "type='signal',sender='org.bluez',interface='org.bluez.HandsfreeGateway',member='PropertyChanged'",
2551                 "type='signal',sender='org.bluez',interface='org.bluez.Headset',member='PropertyChanged'",
2552                 "type='signal',sender='org.bluez',interface='org.bluez.AudioSource',member='PropertyChanged'",
2553                 "type='signal',sender='org.bluez',interface='org.bluez.AudioSink',member='PropertyChanged'",
2554                 NULL) < 0) {
2555
2556         pa_xfree(speaker);
2557         pa_xfree(mike);
2558
2559         pa_log("Failed to add D-Bus matches: %s", err.message);
2560         goto fail;
2561     }
2562
2563     pa_xfree(speaker);
2564     pa_xfree(mike);
2565
2566     if (u->profile != PROFILE_OFF)
2567         if (init_profile(u) < 0)
2568             goto fail;
2569
2570     if (u->sink || u->source)
2571         if (start_thread(u) < 0)
2572             goto fail;
2573
2574     return 0;
2575
2576 fail:
2577
2578     pa__done(m);
2579
2580     dbus_error_free(&err);
2581
2582     return -1;
2583 }
2584
2585 int pa__get_n_used(pa_module *m) {
2586     struct userdata *u;
2587
2588     pa_assert(m);
2589     pa_assert_se(u = m->userdata);
2590
2591     return
2592         (u->sink ? pa_sink_linked_by(u->sink) : 0) +
2593         (u->source ? pa_source_linked_by(u->source) : 0);
2594 }
2595
2596 void pa__done(pa_module *m) {
2597     struct userdata *u;
2598
2599     pa_assert(m);
2600
2601     if (!(u = m->userdata))
2602         return;
2603
2604     if (u->sink && !USE_SCO_OVER_PCM(u))
2605         pa_sink_unlink(u->sink);
2606
2607     if (u->source && !USE_SCO_OVER_PCM(u))
2608         pa_source_unlink(u->source);
2609
2610     stop_thread(u);
2611
2612     if (USE_SCO_OVER_PCM(u))
2613         restore_sco_volume_callbacks(u);
2614
2615     if (u->connection) {
2616
2617         if (u->path) {
2618             char *speaker, *mike;
2619             speaker = pa_sprintf_malloc("type='signal',sender='org.bluez',interface='org.bluez.Headset',member='SpeakerGainChanged',path='%s'", u->path);
2620             mike = pa_sprintf_malloc("type='signal',sender='org.bluez',interface='org.bluez.Headset',member='MicrophoneGainChanged',path='%s'", u->path);
2621
2622             pa_dbus_remove_matches(pa_dbus_connection_get(u->connection), speaker, mike,
2623                 "type='signal',sender='org.bluez',interface='org.bluez.MediaTransport',member='PropertyChanged'",
2624                 "type='signal',sender='org.bluez',interface='org.bluez.HandsfreeGateway',member='PropertyChanged'",
2625                 NULL);
2626
2627             pa_xfree(speaker);
2628             pa_xfree(mike);
2629         }
2630
2631         if (u->filter_added)
2632             dbus_connection_remove_filter(pa_dbus_connection_get(u->connection), filter_cb, u);
2633
2634         pa_dbus_connection_unref(u->connection);
2635     }
2636
2637     if (u->msg)
2638         pa_xfree(u->msg);
2639
2640     if (u->card)
2641         pa_card_free(u->card);
2642
2643     if (u->read_smoother)
2644         pa_smoother_free(u->read_smoother);
2645
2646     if (u->a2dp.buffer)
2647         pa_xfree(u->a2dp.buffer);
2648
2649     sbc_finish(&u->a2dp.sbc);
2650
2651     if (u->modargs)
2652         pa_modargs_free(u->modargs);
2653
2654     pa_xfree(u->address);
2655     pa_xfree(u->path);
2656
2657     if (u->transport) {
2658         bt_transport_release(u);
2659         pa_xfree(u->transport);
2660     }
2661
2662     if (u->discovery)
2663         pa_bluetooth_discovery_unref(u->discovery);
2664
2665     pa_xfree(u);
2666 }