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