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 /* Run from main thread */
1473 static int add_sink(struct userdata *u) {
1474     char *k;
1475
1476     if (USE_SCO_OVER_PCM(u)) {
1477         pa_proplist *p;
1478
1479         u->sink = u->hsp.sco_sink;
1480         p = pa_proplist_new();
1481         pa_proplist_sets(p, "bluetooth.protocol", "sco");
1482         pa_proplist_update(u->sink->proplist, PA_UPDATE_MERGE, p);
1483         pa_proplist_free(p);
1484
1485         if (!u->hsp.sink_state_changed_slot)
1486             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);
1487
1488     } else {
1489         pa_sink_new_data data;
1490         pa_bool_t b;
1491
1492         pa_sink_new_data_init(&data);
1493         data.driver = __FILE__;
1494         data.module = u->module;
1495         pa_sink_new_data_set_sample_spec(&data, &u->sample_spec);
1496         pa_proplist_sets(data.proplist, "bluetooth.protocol", u->profile == PROFILE_A2DP ? "a2dp" : "sco");
1497         if (u->profile == PROFILE_HSP)
1498             pa_proplist_sets(data.proplist, PA_PROP_DEVICE_INTENDED_ROLES, "phone");
1499         data.card = u->card;
1500         data.name = get_name("sink", u->modargs, u->address, &b);
1501         data.namereg_fail = b;
1502
1503         if (pa_modargs_get_proplist(u->modargs, "sink_properties", data.proplist, PA_UPDATE_REPLACE) < 0) {
1504             pa_log("Invalid properties");
1505             pa_sink_new_data_done(&data);
1506             return -1;
1507         }
1508         connect_ports(u, &data, PA_DIRECTION_OUTPUT);
1509
1510         u->sink = pa_sink_new(u->core, &data, PA_SINK_HARDWARE|PA_SINK_LATENCY);
1511         pa_sink_new_data_done(&data);
1512
1513         if (!u->sink) {
1514             pa_log_error("Failed to create sink");
1515             return -1;
1516         }
1517
1518         u->sink->userdata = u;
1519         u->sink->parent.process_msg = sink_process_msg;
1520
1521         pa_sink_set_max_request(u->sink, u->write_block_size);
1522         pa_sink_set_fixed_latency(u->sink,
1523                                   (u->profile == PROFILE_A2DP ? FIXED_LATENCY_PLAYBACK_A2DP : FIXED_LATENCY_PLAYBACK_HSP) +
1524                                   pa_bytes_to_usec(u->write_block_size, &u->sample_spec));
1525     }
1526
1527     if (u->profile == PROFILE_HSP) {
1528         pa_sink_set_set_volume_callback(u->sink, sink_set_volume_cb);
1529         u->sink->n_volume_steps = 16;
1530
1531         k = pa_sprintf_malloc("bluetooth-device@%p", (void*) u->sink);
1532         pa_shared_set(u->core, k, u);
1533         pa_xfree(k);
1534     }
1535
1536     return 0;
1537 }
1538
1539 /* Run from main thread */
1540 static int add_source(struct userdata *u) {
1541     char *k;
1542
1543     if (USE_SCO_OVER_PCM(u)) {
1544         u->source = u->hsp.sco_source;
1545         pa_proplist_sets(u->source->proplist, "bluetooth.protocol", "hsp");
1546
1547         if (!u->hsp.source_state_changed_slot)
1548             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);
1549
1550     } else {
1551         pa_source_new_data data;
1552         pa_bool_t b;
1553
1554         pa_source_new_data_init(&data);
1555         data.driver = __FILE__;
1556         data.module = u->module;
1557         pa_source_new_data_set_sample_spec(&data, &u->sample_spec);
1558         pa_proplist_sets(data.proplist, "bluetooth.protocol", u->profile == PROFILE_A2DP_SOURCE ? "a2dp_source" : "hsp");
1559         if ((u->profile == PROFILE_HSP) || (u->profile == PROFILE_HFGW))
1560             pa_proplist_sets(data.proplist, PA_PROP_DEVICE_INTENDED_ROLES, "phone");
1561
1562         data.card = u->card;
1563         data.name = get_name("source", u->modargs, u->address, &b);
1564         data.namereg_fail = b;
1565
1566         if (pa_modargs_get_proplist(u->modargs, "source_properties", data.proplist, PA_UPDATE_REPLACE) < 0) {
1567             pa_log("Invalid properties");
1568             pa_source_new_data_done(&data);
1569             return -1;
1570         }
1571
1572         connect_ports(u, &data, PA_DIRECTION_INPUT);
1573         u->source = pa_source_new(u->core, &data, PA_SOURCE_HARDWARE|PA_SOURCE_LATENCY);
1574         pa_source_new_data_done(&data);
1575
1576         if (!u->source) {
1577             pa_log_error("Failed to create source");
1578             return -1;
1579         }
1580
1581         u->source->userdata = u;
1582         u->source->parent.process_msg = source_process_msg;
1583
1584         pa_source_set_fixed_latency(u->source,
1585                                     (u->profile == PROFILE_A2DP_SOURCE ? FIXED_LATENCY_RECORD_A2DP : FIXED_LATENCY_RECORD_HSP) +
1586                                     pa_bytes_to_usec(u->read_block_size, &u->sample_spec));
1587     }
1588
1589     if ((u->profile == PROFILE_HSP) || (u->profile == PROFILE_HFGW)) {
1590         pa_bluetooth_transport *t;
1591         t = pa_bluetooth_discovery_get_transport(u->discovery, u->transport);
1592         pa_assert(t);
1593         pa_proplist_sets(u->source->proplist, "bluetooth.nrec", t->nrec ? "1" : "0");
1594
1595         if (!u->hsp.nrec_changed_slot)
1596             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);
1597     }
1598
1599     if (u->profile == PROFILE_HSP) {
1600         pa_source_set_set_volume_callback(u->source, source_set_volume_cb);
1601         u->source->n_volume_steps = 16;
1602
1603         k = pa_sprintf_malloc("bluetooth-device@%p", (void*) u->source);
1604         pa_shared_set(u->core, k, u);
1605         pa_xfree(k);
1606     }
1607
1608     return 0;
1609 }
1610
1611 static int bt_transport_config_a2dp(struct userdata *u) {
1612     const pa_bluetooth_transport *t;
1613     struct a2dp_info *a2dp = &u->a2dp;
1614     a2dp_sbc_t *config;
1615
1616     t = pa_bluetooth_discovery_get_transport(u->discovery, u->transport);
1617     pa_assert(t);
1618
1619     config = (a2dp_sbc_t *) t->config;
1620
1621     u->sample_spec.format = PA_SAMPLE_S16LE;
1622
1623     if (a2dp->sbc_initialized)
1624         sbc_reinit(&a2dp->sbc, 0);
1625     else
1626         sbc_init(&a2dp->sbc, 0);
1627     a2dp->sbc_initialized = TRUE;
1628
1629     switch (config->frequency) {
1630         case BT_SBC_SAMPLING_FREQ_16000:
1631             a2dp->sbc.frequency = SBC_FREQ_16000;
1632             u->sample_spec.rate = 16000U;
1633             break;
1634         case BT_SBC_SAMPLING_FREQ_32000:
1635             a2dp->sbc.frequency = SBC_FREQ_32000;
1636             u->sample_spec.rate = 32000U;
1637             break;
1638         case BT_SBC_SAMPLING_FREQ_44100:
1639             a2dp->sbc.frequency = SBC_FREQ_44100;
1640             u->sample_spec.rate = 44100U;
1641             break;
1642         case BT_SBC_SAMPLING_FREQ_48000:
1643             a2dp->sbc.frequency = SBC_FREQ_48000;
1644             u->sample_spec.rate = 48000U;
1645             break;
1646         default:
1647             pa_assert_not_reached();
1648     }
1649
1650     switch (config->channel_mode) {
1651         case BT_A2DP_CHANNEL_MODE_MONO:
1652             a2dp->sbc.mode = SBC_MODE_MONO;
1653             u->sample_spec.channels = 1;
1654             break;
1655         case BT_A2DP_CHANNEL_MODE_DUAL_CHANNEL:
1656             a2dp->sbc.mode = SBC_MODE_DUAL_CHANNEL;
1657             u->sample_spec.channels = 2;
1658             break;
1659         case BT_A2DP_CHANNEL_MODE_STEREO:
1660             a2dp->sbc.mode = SBC_MODE_STEREO;
1661             u->sample_spec.channels = 2;
1662             break;
1663         case BT_A2DP_CHANNEL_MODE_JOINT_STEREO:
1664             a2dp->sbc.mode = SBC_MODE_JOINT_STEREO;
1665             u->sample_spec.channels = 2;
1666             break;
1667         default:
1668             pa_assert_not_reached();
1669     }
1670
1671     switch (config->allocation_method) {
1672         case BT_A2DP_ALLOCATION_SNR:
1673             a2dp->sbc.allocation = SBC_AM_SNR;
1674             break;
1675         case BT_A2DP_ALLOCATION_LOUDNESS:
1676             a2dp->sbc.allocation = SBC_AM_LOUDNESS;
1677             break;
1678         default:
1679             pa_assert_not_reached();
1680     }
1681
1682     switch (config->subbands) {
1683         case BT_A2DP_SUBBANDS_4:
1684             a2dp->sbc.subbands = SBC_SB_4;
1685             break;
1686         case BT_A2DP_SUBBANDS_8:
1687             a2dp->sbc.subbands = SBC_SB_8;
1688             break;
1689         default:
1690             pa_assert_not_reached();
1691     }
1692
1693     switch (config->block_length) {
1694         case BT_A2DP_BLOCK_LENGTH_4:
1695             a2dp->sbc.blocks = SBC_BLK_4;
1696             break;
1697         case BT_A2DP_BLOCK_LENGTH_8:
1698             a2dp->sbc.blocks = SBC_BLK_8;
1699             break;
1700         case BT_A2DP_BLOCK_LENGTH_12:
1701             a2dp->sbc.blocks = SBC_BLK_12;
1702             break;
1703         case BT_A2DP_BLOCK_LENGTH_16:
1704             a2dp->sbc.blocks = SBC_BLK_16;
1705             break;
1706         default:
1707             pa_assert_not_reached();
1708     }
1709
1710     a2dp->min_bitpool = config->min_bitpool;
1711     a2dp->max_bitpool = config->max_bitpool;
1712
1713     /* Set minimum bitpool for source to get the maximum possible block_size */
1714     a2dp->sbc.bitpool = u->profile == PROFILE_A2DP ? a2dp->max_bitpool : a2dp->min_bitpool;
1715     a2dp->codesize = sbc_get_codesize(&a2dp->sbc);
1716     a2dp->frame_length = sbc_get_frame_length(&a2dp->sbc);
1717
1718     u->read_block_size =
1719         (u->read_link_mtu - sizeof(struct rtp_header) - sizeof(struct rtp_payload))
1720         / a2dp->frame_length * a2dp->codesize;
1721
1722     u->write_block_size =
1723         (u->write_link_mtu - sizeof(struct rtp_header) - sizeof(struct rtp_payload))
1724         / a2dp->frame_length * a2dp->codesize;
1725
1726     pa_log_info("SBC parameters:\n\tallocation=%u\n\tsubbands=%u\n\tblocks=%u\n\tbitpool=%u\n",
1727                 a2dp->sbc.allocation, a2dp->sbc.subbands, a2dp->sbc.blocks, a2dp->sbc.bitpool);
1728
1729     return 0;
1730 }
1731
1732 static int bt_transport_config(struct userdata *u) {
1733     if (u->profile == PROFILE_HSP || u->profile == PROFILE_HFGW) {
1734         u->read_block_size = u->read_link_mtu;
1735         u->write_block_size = u->write_link_mtu;
1736         u->sample_spec.format = PA_SAMPLE_S16LE;
1737         u->sample_spec.channels = 1;
1738         u->sample_spec.rate = 8000;
1739         return 0;
1740     }
1741
1742     return bt_transport_config_a2dp(u);
1743 }
1744
1745 /* Run from main thread */
1746 static int setup_bt(struct userdata *u) {
1747     const pa_bluetooth_device *d;
1748     const pa_bluetooth_transport *t;
1749
1750     pa_assert(u);
1751
1752     if (!(d = pa_bluetooth_discovery_get_by_path(u->discovery, u->path))) {
1753         pa_log_error("Failed to get device object.");
1754         return -1;
1755     }
1756
1757     /* release transport if exist */
1758     if (u->transport) {
1759         bt_transport_release(u);
1760         pa_xfree(u->transport);
1761         u->transport = NULL;
1762     }
1763
1764     /* check if profile has a transport */
1765     t = pa_bluetooth_device_get_transport(d, u->profile);
1766     if (t == NULL) {
1767         pa_log_warn("Profile has no transport");
1768         return -1;
1769     }
1770
1771     u->transport = pa_xstrdup(t->path);
1772
1773     if (bt_transport_acquire(u, FALSE) < 0)
1774         return -1;
1775
1776     return bt_transport_config(u);
1777 }
1778
1779 /* Run from main thread */
1780 static int init_profile(struct userdata *u) {
1781     int r = 0;
1782     pa_assert(u);
1783     pa_assert(u->profile != PROFILE_OFF);
1784
1785     if (setup_bt(u) < 0)
1786         return -1;
1787
1788     if (u->profile == PROFILE_A2DP ||
1789         u->profile == PROFILE_HSP ||
1790         u->profile == PROFILE_HFGW)
1791         if (add_sink(u) < 0)
1792             r = -1;
1793
1794     if (u->profile == PROFILE_HSP ||
1795         u->profile == PROFILE_A2DP_SOURCE ||
1796         u->profile == PROFILE_HFGW)
1797         if (add_source(u) < 0)
1798             r = -1;
1799
1800     return r;
1801 }
1802
1803 /* Run from main thread */
1804 static void stop_thread(struct userdata *u) {
1805     char *k;
1806
1807     pa_assert(u);
1808
1809     if (u->thread) {
1810         pa_asyncmsgq_send(u->thread_mq.inq, NULL, PA_MESSAGE_SHUTDOWN, NULL, 0, NULL);
1811         pa_thread_free(u->thread);
1812         u->thread = NULL;
1813     }
1814
1815     if (u->rtpoll_item) {
1816         pa_rtpoll_item_free(u->rtpoll_item);
1817         u->rtpoll_item = NULL;
1818     }
1819
1820     if (u->hsp.sink_state_changed_slot) {
1821         pa_hook_slot_free(u->hsp.sink_state_changed_slot);
1822         u->hsp.sink_state_changed_slot = NULL;
1823     }
1824
1825     if (u->hsp.source_state_changed_slot) {
1826         pa_hook_slot_free(u->hsp.source_state_changed_slot);
1827         u->hsp.source_state_changed_slot = NULL;
1828     }
1829
1830     if (u->hsp.nrec_changed_slot) {
1831         pa_hook_slot_free(u->hsp.nrec_changed_slot);
1832         u->hsp.nrec_changed_slot = NULL;
1833     }
1834
1835     if (u->sink) {
1836         if (u->profile == PROFILE_HSP) {
1837             k = pa_sprintf_malloc("bluetooth-device@%p", (void*) u->sink);
1838             pa_shared_remove(u->core, k);
1839             pa_xfree(k);
1840         }
1841
1842         pa_sink_unref(u->sink);
1843         u->sink = NULL;
1844     }
1845
1846     if (u->source) {
1847         if (u->profile == PROFILE_HSP) {
1848             k = pa_sprintf_malloc("bluetooth-device@%p", (void*) u->source);
1849             pa_shared_remove(u->core, k);
1850             pa_xfree(k);
1851         }
1852
1853         pa_source_unref(u->source);
1854         u->source = NULL;
1855     }
1856
1857     if (u->rtpoll) {
1858         pa_thread_mq_done(&u->thread_mq);
1859
1860         pa_rtpoll_free(u->rtpoll);
1861         u->rtpoll = NULL;
1862     }
1863
1864     if (u->read_smoother) {
1865         pa_smoother_free(u->read_smoother);
1866         u->read_smoother = NULL;
1867     }
1868 }
1869
1870 /* Run from main thread */
1871 static int start_thread(struct userdata *u) {
1872     pa_assert(u);
1873     pa_assert(!u->thread);
1874     pa_assert(!u->rtpoll);
1875     pa_assert(!u->rtpoll_item);
1876
1877     u->rtpoll = pa_rtpoll_new();
1878     pa_thread_mq_init(&u->thread_mq, u->core->mainloop, u->rtpoll);
1879
1880     if (USE_SCO_OVER_PCM(u)) {
1881         if (sco_over_pcm_state_update(u, FALSE) < 0) {
1882             char *k;
1883
1884             if (u->sink) {
1885                 k = pa_sprintf_malloc("bluetooth-device@%p", (void*) u->sink);
1886                 pa_shared_remove(u->core, k);
1887                 pa_xfree(k);
1888                 u->sink = NULL;
1889             }
1890             if (u->source) {
1891                 k = pa_sprintf_malloc("bluetooth-device@%p", (void*) u->source);
1892                 pa_shared_remove(u->core, k);
1893                 pa_xfree(k);
1894                 u->source = NULL;
1895             }
1896             return -1;
1897         }
1898
1899         pa_sink_ref(u->sink);
1900         pa_source_ref(u->source);
1901         /* FIXME: monitor stream_fd error */
1902         return 0;
1903     }
1904
1905     if (!(u->thread = pa_thread_new("bluetooth", thread_func, u))) {
1906         pa_log_error("Failed to create IO thread");
1907         stop_thread(u);
1908         return -1;
1909     }
1910
1911     if (u->sink) {
1912         pa_sink_set_asyncmsgq(u->sink, u->thread_mq.inq);
1913         pa_sink_set_rtpoll(u->sink, u->rtpoll);
1914         pa_sink_put(u->sink);
1915
1916         if (u->sink->set_volume)
1917             u->sink->set_volume(u->sink);
1918     }
1919
1920     if (u->source) {
1921         pa_source_set_asyncmsgq(u->source, u->thread_mq.inq);
1922         pa_source_set_rtpoll(u->source, u->rtpoll);
1923         pa_source_put(u->source);
1924
1925         if (u->source->set_volume)
1926             u->source->set_volume(u->source);
1927     }
1928
1929     return 0;
1930 }
1931
1932 static void save_sco_volume_callbacks(struct userdata *u) {
1933     pa_assert(u);
1934     pa_assert(USE_SCO_OVER_PCM(u));
1935
1936     u->hsp.sco_sink_set_volume = u->hsp.sco_sink->set_volume;
1937     u->hsp.sco_source_set_volume = u->hsp.sco_source->set_volume;
1938 }
1939
1940 static void restore_sco_volume_callbacks(struct userdata *u) {
1941     pa_assert(u);
1942     pa_assert(USE_SCO_OVER_PCM(u));
1943
1944     pa_sink_set_set_volume_callback(u->hsp.sco_sink, u->hsp.sco_sink_set_volume);
1945     pa_source_set_set_volume_callback(u->hsp.sco_source, u->hsp.sco_source_set_volume);
1946 }
1947
1948 /* Run from main thread */
1949 static int card_set_profile(pa_card *c, pa_card_profile *new_profile) {
1950     struct userdata *u;
1951     enum profile *d;
1952     pa_queue *inputs = NULL, *outputs = NULL;
1953     const pa_bluetooth_device *device;
1954
1955     pa_assert(c);
1956     pa_assert(new_profile);
1957     pa_assert_se(u = c->userdata);
1958
1959     d = PA_CARD_PROFILE_DATA(new_profile);
1960
1961     if (!(device = pa_bluetooth_discovery_get_by_path(u->discovery, u->path))) {
1962         pa_log_error("Failed to get device object.");
1963         return -PA_ERR_IO;
1964     }
1965
1966     /* The state signal is sent by bluez, so it is racy to check
1967        strictly for CONNECTED, we should also accept STREAMING state
1968        as being good enough. However, if the profile is used
1969        concurrently (which is unlikely), ipc will fail later on, and
1970        module will be unloaded. */
1971     if (device->headset_state < PA_BT_AUDIO_STATE_CONNECTED && *d == PROFILE_HSP) {
1972         pa_log_warn("HSP is not connected, refused to switch profile");
1973         return -PA_ERR_IO;
1974     }
1975     else if (device->audio_sink_state < PA_BT_AUDIO_STATE_CONNECTED && *d == PROFILE_A2DP) {
1976         pa_log_warn("A2DP is not connected, refused to switch profile");
1977         return -PA_ERR_IO;
1978     }
1979     else if (device->hfgw_state < PA_BT_AUDIO_STATE_CONNECTED && *d == PROFILE_HFGW) {
1980         pa_log_warn("HandsfreeGateway is not connected, refused to switch profile");
1981         return -PA_ERR_IO;
1982     }
1983
1984     if (u->sink) {
1985         inputs = pa_sink_move_all_start(u->sink, NULL);
1986
1987         if (!USE_SCO_OVER_PCM(u))
1988             pa_sink_unlink(u->sink);
1989     }
1990
1991     if (u->source) {
1992         outputs = pa_source_move_all_start(u->source, NULL);
1993
1994         if (!USE_SCO_OVER_PCM(u))
1995             pa_source_unlink(u->source);
1996     }
1997
1998     stop_thread(u);
1999
2000     if (u->profile != PROFILE_OFF && u->transport) {
2001         bt_transport_release(u);
2002         pa_xfree(u->transport);
2003         u->transport = NULL;
2004     }
2005
2006     if (USE_SCO_OVER_PCM(u))
2007         restore_sco_volume_callbacks(u);
2008
2009     u->profile = *d;
2010     u->sample_spec = u->requested_sample_spec;
2011
2012     if (USE_SCO_OVER_PCM(u))
2013         save_sco_volume_callbacks(u);
2014
2015     if (u->profile != PROFILE_OFF)
2016         init_profile(u);
2017
2018     if (u->sink || u->source)
2019         start_thread(u);
2020
2021     if (inputs) {
2022         if (u->sink)
2023             pa_sink_move_all_finish(u->sink, inputs, FALSE);
2024         else
2025             pa_sink_move_all_fail(inputs);
2026     }
2027
2028     if (outputs) {
2029         if (u->source)
2030             pa_source_move_all_finish(u->source, outputs, FALSE);
2031         else
2032             pa_source_move_all_fail(outputs);
2033     }
2034
2035     return 0;
2036 }
2037
2038 static void create_ports_for_profile(struct userdata *u, pa_card_new_data *card_new_data, pa_card_profile *profile) {
2039     pa_device_port *port;
2040     enum profile *d;
2041
2042     d = PA_CARD_PROFILE_DATA(profile);
2043
2044     switch (*d) {
2045         case PROFILE_A2DP:
2046             pa_assert_se(port = pa_device_port_new(u->core, "a2dp-output", _("Bluetooth High Quality (A2DP)"), 0));
2047             pa_assert_se(pa_hashmap_put(card_new_data->ports, port->name, port) >= 0);
2048             port->is_output = 1;
2049             port->is_input = 0;
2050             port->priority = profile->priority * 100;
2051             pa_hashmap_put(port->profiles, profile->name, profile);
2052             break;
2053
2054         case PROFILE_A2DP_SOURCE:
2055             pa_assert_se(port = pa_device_port_new(u->core, "a2dp-input", _("Bluetooth High Quality (A2DP)"), 0));
2056             pa_assert_se(pa_hashmap_put(card_new_data->ports, port->name, port) >= 0);
2057             port->is_output = 0;
2058             port->is_input = 1;
2059             port->priority = profile->priority * 100;
2060             pa_hashmap_put(port->profiles, profile->name, profile);
2061             break;
2062
2063         case PROFILE_HSP:
2064             pa_assert_se(port = pa_device_port_new(u->core, "hsp-output", _("Bluetooth Telephony (HSP/HFP)"), 0));
2065             pa_assert_se(pa_hashmap_put(card_new_data->ports, port->name, port) >= 0);
2066             port->is_output = 1;
2067             port->is_input = 0;
2068             port->priority = profile->priority * 100;
2069             pa_hashmap_put(port->profiles, profile->name, profile);
2070
2071             pa_assert_se(port = pa_device_port_new(u->core, "hsp-input", _("Bluetooth Telephony (HSP/HFP)"), 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_HFGW:
2080             pa_assert_se(port = pa_device_port_new(u->core, "hfgw-output", _("Bluetooth Handsfree Gateway"), 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, "hfgw-input", _("Bluetooth Handsfree Gateway"), 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         default:
2096             pa_assert_not_reached();
2097     }
2098
2099 }
2100
2101 /* Run from main thread */
2102 static int add_card(struct userdata *u, const pa_bluetooth_device *device) {
2103     pa_card_new_data data;
2104     pa_bool_t b;
2105     pa_card_profile *p;
2106     enum profile *d;
2107     const char *ff;
2108     char *n;
2109     const char *default_profile;
2110
2111     pa_assert(u);
2112     pa_assert(device);
2113
2114     pa_card_new_data_init(&data);
2115     data.driver = __FILE__;
2116     data.module = u->module;
2117
2118     n = pa_bluetooth_cleanup_name(device->name);
2119     pa_proplist_sets(data.proplist, PA_PROP_DEVICE_DESCRIPTION, n);
2120     pa_xfree(n);
2121     pa_proplist_sets(data.proplist, PA_PROP_DEVICE_STRING, device->address);
2122     pa_proplist_sets(data.proplist, PA_PROP_DEVICE_API, "bluez");
2123     pa_proplist_sets(data.proplist, PA_PROP_DEVICE_CLASS, "sound");
2124     pa_proplist_sets(data.proplist, PA_PROP_DEVICE_BUS, "bluetooth");
2125     if ((ff = pa_bluetooth_get_form_factor(device->class)))
2126         pa_proplist_sets(data.proplist, PA_PROP_DEVICE_FORM_FACTOR, ff);
2127     pa_proplist_sets(data.proplist, "bluez.path", device->path);
2128     pa_proplist_setf(data.proplist, "bluez.class", "0x%06x", (unsigned) device->class);
2129     pa_proplist_sets(data.proplist, "bluez.name", device->name);
2130     data.name = get_name("card", u->modargs, device->address, &b);
2131     data.namereg_fail = b;
2132
2133     if (pa_modargs_get_proplist(u->modargs, "card_properties", data.proplist, PA_UPDATE_REPLACE) < 0) {
2134         pa_log("Invalid properties");
2135         pa_card_new_data_done(&data);
2136         return -1;
2137     }
2138
2139     data.profiles = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
2140
2141     /* we base hsp/a2dp availability on UUIDs.
2142        Ideally, it would be based on "Connected" state, but
2143        we can't afford to wait for this information when
2144        we are loaded with profile="hsp", for instance */
2145     if (pa_bluetooth_uuid_has(device->uuids, A2DP_SINK_UUID)) {
2146         p = pa_card_profile_new("a2dp", _("High Fidelity Playback (A2DP)"), sizeof(enum profile));
2147         p->priority = 10;
2148         p->n_sinks = 1;
2149         p->n_sources = 0;
2150         p->max_sink_channels = 2;
2151         p->max_source_channels = 0;
2152
2153         d = PA_CARD_PROFILE_DATA(p);
2154         *d = PROFILE_A2DP;
2155         create_ports_for_profile(u, &data, p);
2156
2157         pa_hashmap_put(data.profiles, p->name, p);
2158     }
2159
2160     if (pa_bluetooth_uuid_has(device->uuids, A2DP_SOURCE_UUID)) {
2161         p = pa_card_profile_new("a2dp_source", _("High Fidelity Capture (A2DP)"), sizeof(enum profile));
2162         p->priority = 10;
2163         p->n_sinks = 0;
2164         p->n_sources = 1;
2165         p->max_sink_channels = 0;
2166         p->max_source_channels = 2;
2167
2168         d = PA_CARD_PROFILE_DATA(p);
2169         *d = PROFILE_A2DP_SOURCE;
2170         create_ports_for_profile(u, &data, p);
2171
2172         pa_hashmap_put(data.profiles, p->name, p);
2173     }
2174
2175     if (pa_bluetooth_uuid_has(device->uuids, HSP_HS_UUID) ||
2176         pa_bluetooth_uuid_has(device->uuids, HFP_HS_UUID)) {
2177         p = pa_card_profile_new("hsp", _("Telephony Duplex (HSP/HFP)"), sizeof(enum profile));
2178         p->priority = 20;
2179         p->n_sinks = 1;
2180         p->n_sources = 1;
2181         p->max_sink_channels = 1;
2182         p->max_source_channels = 1;
2183
2184         d = PA_CARD_PROFILE_DATA(p);
2185         *d = PROFILE_HSP;
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, HFP_AG_UUID)) {
2192         p = pa_card_profile_new("hfgw", _("Handsfree Gateway"), sizeof(enum profile));
2193         p->priority = 20;
2194         p->n_sinks = 1;
2195         p->n_sources = 1;
2196         p->max_sink_channels = 1;
2197         p->max_source_channels = 1;
2198
2199         d = PA_CARD_PROFILE_DATA(p);
2200         *d = PROFILE_HFGW;
2201         create_ports_for_profile(u, &data, p);
2202
2203         pa_hashmap_put(data.profiles, p->name, p);
2204     }
2205
2206     pa_assert(!pa_hashmap_isempty(data.profiles));
2207
2208     p = pa_card_profile_new("off", _("Off"), sizeof(enum profile));
2209     d = PA_CARD_PROFILE_DATA(p);
2210     *d = PROFILE_OFF;
2211     pa_hashmap_put(data.profiles, p->name, p);
2212
2213     if ((default_profile = pa_modargs_get_value(u->modargs, "profile", NULL))) {
2214         if (pa_hashmap_get(data.profiles, default_profile))
2215             pa_card_new_data_set_profile(&data, default_profile);
2216         else
2217             pa_log_warn("Profile '%s' not valid or not supported by device.", default_profile);
2218     }
2219
2220     u->card = pa_card_new(u->core, &data);
2221     pa_card_new_data_done(&data);
2222
2223     if (!u->card) {
2224         pa_log("Failed to allocate card.");
2225         return -1;
2226     }
2227
2228     u->card->userdata = u;
2229     u->card->set_profile = card_set_profile;
2230
2231     d = PA_CARD_PROFILE_DATA(u->card->active_profile);
2232
2233     if ((device->headset_state < PA_BT_AUDIO_STATE_CONNECTED && *d == PROFILE_HSP) ||
2234         (device->audio_sink_state < PA_BT_AUDIO_STATE_CONNECTED && *d == PROFILE_A2DP) ||
2235         (device->hfgw_state < PA_BT_AUDIO_STATE_CONNECTED && *d == PROFILE_HFGW)) {
2236         pa_log_warn("Default profile not connected, selecting off profile");
2237         u->card->active_profile = pa_hashmap_get(u->card->profiles, "off");
2238         u->card->save_profile = FALSE;
2239     }
2240
2241     d = PA_CARD_PROFILE_DATA(u->card->active_profile);
2242     u->profile = *d;
2243
2244     if (USE_SCO_OVER_PCM(u))
2245         save_sco_volume_callbacks(u);
2246
2247     return 0;
2248 }
2249
2250 /* Run from main thread */
2251 static const pa_bluetooth_device* find_device(struct userdata *u, const char *address, const char *path) {
2252     const pa_bluetooth_device *d = NULL;
2253
2254     pa_assert(u);
2255
2256     if (!address && !path) {
2257         pa_log_error("Failed to get device address/path from module arguments.");
2258         return NULL;
2259     }
2260
2261     if (path) {
2262         if (!(d = pa_bluetooth_discovery_get_by_path(u->discovery, path))) {
2263             pa_log_error("%s is not a valid BlueZ audio device.", path);
2264             return NULL;
2265         }
2266
2267         if (address && !(pa_streq(d->address, address))) {
2268             pa_log_error("Passed path %s address %s != %s don't match.", path, d->address, address);
2269             return NULL;
2270         }
2271
2272     } else {
2273         if (!(d = pa_bluetooth_discovery_get_by_address(u->discovery, address))) {
2274             pa_log_error("%s is not known.", address);
2275             return NULL;
2276         }
2277     }
2278
2279     if (d) {
2280         u->address = pa_xstrdup(d->address);
2281         u->path = pa_xstrdup(d->path);
2282     }
2283
2284     return d;
2285 }
2286
2287 /* Run from main thread */
2288 static int setup_dbus(struct userdata *u) {
2289     DBusError err;
2290
2291     dbus_error_init(&err);
2292
2293     u->connection = pa_dbus_bus_get(u->core, DBUS_BUS_SYSTEM, &err);
2294
2295     if (dbus_error_is_set(&err) || !u->connection) {
2296         pa_log("Failed to get D-Bus connection: %s", err.message);
2297         dbus_error_free(&err);
2298         return -1;
2299     }
2300
2301     return 0;
2302 }
2303
2304 int pa__init(pa_module* m) {
2305     pa_modargs *ma;
2306     uint32_t channels;
2307     struct userdata *u;
2308     const char *address, *path;
2309     DBusError err;
2310     char *mike, *speaker;
2311     const pa_bluetooth_device *device;
2312
2313     pa_assert(m);
2314
2315     dbus_error_init(&err);
2316
2317     if (!(ma = pa_modargs_new(m->argument, valid_modargs))) {
2318         pa_log_error("Failed to parse module arguments");
2319         goto fail;
2320     }
2321
2322     m->userdata = u = pa_xnew0(struct userdata, 1);
2323     u->module = m;
2324     u->core = m->core;
2325     u->stream_fd = -1;
2326     u->sample_spec = m->core->default_sample_spec;
2327     u->modargs = ma;
2328
2329     if (pa_modargs_get_value(ma, "sco_sink", NULL) &&
2330         !(u->hsp.sco_sink = pa_namereg_get(m->core, pa_modargs_get_value(ma, "sco_sink", NULL), PA_NAMEREG_SINK))) {
2331         pa_log("SCO sink not found");
2332         goto fail;
2333     }
2334
2335     if (pa_modargs_get_value(ma, "sco_source", NULL) &&
2336         !(u->hsp.sco_source = pa_namereg_get(m->core, pa_modargs_get_value(ma, "sco_source", NULL), PA_NAMEREG_SOURCE))) {
2337         pa_log("SCO source not found");
2338         goto fail;
2339     }
2340
2341     if (pa_modargs_get_value_u32(ma, "rate", &u->sample_spec.rate) < 0 ||
2342         u->sample_spec.rate <= 0 || u->sample_spec.rate > PA_RATE_MAX) {
2343         pa_log_error("Failed to get rate from module arguments");
2344         goto fail;
2345     }
2346
2347     u->auto_connect = TRUE;
2348     if (pa_modargs_get_value_boolean(ma, "auto_connect", &u->auto_connect)) {
2349         pa_log("Failed to parse auto_connect= argument");
2350         goto fail;
2351     }
2352
2353     channels = u->sample_spec.channels;
2354     if (pa_modargs_get_value_u32(ma, "channels", &channels) < 0 ||
2355         channels <= 0 || channels > PA_CHANNELS_MAX) {
2356         pa_log_error("Failed to get channels from module arguments");
2357         goto fail;
2358     }
2359     u->sample_spec.channels = (uint8_t) channels;
2360     u->requested_sample_spec = u->sample_spec;
2361
2362     address = pa_modargs_get_value(ma, "address", NULL);
2363     path = pa_modargs_get_value(ma, "path", NULL);
2364
2365     if (setup_dbus(u) < 0)
2366         goto fail;
2367
2368     if (!(u->discovery = pa_bluetooth_discovery_get(m->core)))
2369         goto fail;
2370
2371     if (!(device = find_device(u, address, path)))
2372         goto fail;
2373
2374     /* Add the card structure. This will also initialize the default profile */
2375     if (add_card(u, device) < 0)
2376         goto fail;
2377
2378     if (!(u->msg = pa_msgobject_new(bluetooth_msg)))
2379         goto fail;
2380
2381     u->msg->parent.process_msg = device_process_msg;
2382     u->msg->card = u->card;
2383
2384     if (!dbus_connection_add_filter(pa_dbus_connection_get(u->connection), filter_cb, u, NULL)) {
2385         pa_log_error("Failed to add filter function");
2386         goto fail;
2387     }
2388     u->filter_added = TRUE;
2389
2390     speaker = pa_sprintf_malloc("type='signal',sender='org.bluez',interface='org.bluez.Headset',member='SpeakerGainChanged',path='%s'", u->path);
2391     mike = pa_sprintf_malloc("type='signal',sender='org.bluez',interface='org.bluez.Headset',member='MicrophoneGainChanged',path='%s'", u->path);
2392
2393     if (pa_dbus_add_matches(
2394                 pa_dbus_connection_get(u->connection), &err,
2395                 speaker,
2396                 mike,
2397                 "type='signal',sender='org.bluez',interface='org.bluez.MediaTransport',member='PropertyChanged'",
2398                 "type='signal',sender='org.bluez',interface='org.bluez.HandsfreeGateway',member='PropertyChanged'",
2399                 NULL) < 0) {
2400
2401         pa_xfree(speaker);
2402         pa_xfree(mike);
2403
2404         pa_log("Failed to add D-Bus matches: %s", err.message);
2405         goto fail;
2406     }
2407
2408     pa_xfree(speaker);
2409     pa_xfree(mike);
2410
2411     if (u->profile != PROFILE_OFF)
2412         if (init_profile(u) < 0)
2413             goto fail;
2414
2415     if (u->sink || u->source)
2416         if (start_thread(u) < 0)
2417             goto fail;
2418
2419     return 0;
2420
2421 fail:
2422
2423     pa__done(m);
2424
2425     dbus_error_free(&err);
2426
2427     return -1;
2428 }
2429
2430 int pa__get_n_used(pa_module *m) {
2431     struct userdata *u;
2432
2433     pa_assert(m);
2434     pa_assert_se(u = m->userdata);
2435
2436     return
2437         (u->sink ? pa_sink_linked_by(u->sink) : 0) +
2438         (u->source ? pa_source_linked_by(u->source) : 0);
2439 }
2440
2441 void pa__done(pa_module *m) {
2442     struct userdata *u;
2443
2444     pa_assert(m);
2445
2446     if (!(u = m->userdata))
2447         return;
2448
2449     if (u->sink && !USE_SCO_OVER_PCM(u))
2450         pa_sink_unlink(u->sink);
2451
2452     if (u->source && !USE_SCO_OVER_PCM(u))
2453         pa_source_unlink(u->source);
2454
2455     stop_thread(u);
2456
2457     if (USE_SCO_OVER_PCM(u))
2458         restore_sco_volume_callbacks(u);
2459
2460     if (u->connection) {
2461
2462         if (u->path) {
2463             char *speaker, *mike;
2464             speaker = pa_sprintf_malloc("type='signal',sender='org.bluez',interface='org.bluez.Headset',member='SpeakerGainChanged',path='%s'", u->path);
2465             mike = pa_sprintf_malloc("type='signal',sender='org.bluez',interface='org.bluez.Headset',member='MicrophoneGainChanged',path='%s'", u->path);
2466
2467             pa_dbus_remove_matches(pa_dbus_connection_get(u->connection), speaker, mike,
2468                 "type='signal',sender='org.bluez',interface='org.bluez.MediaTransport',member='PropertyChanged'",
2469                 "type='signal',sender='org.bluez',interface='org.bluez.HandsfreeGateway',member='PropertyChanged'",
2470                 NULL);
2471
2472             pa_xfree(speaker);
2473             pa_xfree(mike);
2474         }
2475
2476         if (u->filter_added)
2477             dbus_connection_remove_filter(pa_dbus_connection_get(u->connection), filter_cb, u);
2478
2479         pa_dbus_connection_unref(u->connection);
2480     }
2481
2482     if (u->msg)
2483         pa_xfree(u->msg);
2484
2485     if (u->card)
2486         pa_card_free(u->card);
2487
2488     if (u->read_smoother)
2489         pa_smoother_free(u->read_smoother);
2490
2491     if (u->a2dp.buffer)
2492         pa_xfree(u->a2dp.buffer);
2493
2494     sbc_finish(&u->a2dp.sbc);
2495
2496     if (u->modargs)
2497         pa_modargs_free(u->modargs);
2498
2499     pa_xfree(u->address);
2500     pa_xfree(u->path);
2501
2502     if (u->transport) {
2503         bt_transport_release(u);
2504         pa_xfree(u->transport);
2505     }
2506
2507     if (u->discovery)
2508         pa_bluetooth_discovery_unref(u->discovery);
2509
2510     pa_xfree(u);
2511 }