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