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