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