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             pa_log_debug("pa_rtpoll_run failed with: %d", ret);
1736             goto fail;
1737         }
1738         if (ret == 0) {
1739             pa_log_debug("IO thread shutdown requested, stopping cleanly");
1740             if (u->transport)
1741                 bt_transport_release(u);
1742             else
1743                 stop_stream_fd(u);
1744             goto finish;
1745         }
1746
1747         pollfd = u->rtpoll_item ? pa_rtpoll_item_get_pollfd(u->rtpoll_item, NULL) : NULL;
1748
1749         if (pollfd && (pollfd->revents & ~(POLLOUT|POLLIN))) {
1750             pa_log_info("FD error: %s%s%s%s",
1751                         pollfd->revents & POLLERR ? "POLLERR " :"",
1752                         pollfd->revents & POLLHUP ? "POLLHUP " :"",
1753                         pollfd->revents & POLLPRI ? "POLLPRI " :"",
1754                         pollfd->revents & POLLNVAL ? "POLLNVAL " :"");
1755             goto fail;
1756         }
1757     }
1758
1759 fail:
1760     /* If this was no regular exit from the loop we have to continue processing messages until we receive PA_MESSAGE_SHUTDOWN */
1761     pa_log_debug("IO thread failed");
1762     pa_asyncmsgq_post(pa_thread_mq_get()->outq, PA_MSGOBJECT(u->msg), BLUETOOTH_MESSAGE_IO_THREAD_FAILED, NULL, 0, NULL, NULL);
1763     pa_asyncmsgq_wait_for(u->thread_mq.inq, PA_MESSAGE_SHUTDOWN);
1764
1765 finish:
1766     pa_log_debug("IO thread shutting down");
1767 }
1768
1769 /* Run from main thread */
1770 static DBusHandlerResult filter_cb(DBusConnection *bus, DBusMessage *m, void *userdata) {
1771     DBusError err;
1772     struct userdata *u;
1773
1774     pa_assert(bus);
1775     pa_assert(m);
1776     pa_assert_se(u = userdata);
1777
1778     dbus_error_init(&err);
1779
1780     pa_log_debug("dbus: interface=%s, path=%s, member=%s\n",
1781                  dbus_message_get_interface(m),
1782                  dbus_message_get_path(m),
1783                  dbus_message_get_member(m));
1784
1785     if (!dbus_message_has_path(m, u->path) && !dbus_message_has_path(m, u->transport))
1786         goto fail;
1787
1788     if (dbus_message_is_signal(m, "org.bluez.Headset", "SpeakerGainChanged") ||
1789         dbus_message_is_signal(m, "org.bluez.Headset", "MicrophoneGainChanged")) {
1790
1791         dbus_uint16_t gain;
1792         pa_cvolume v;
1793
1794         if (!dbus_message_get_args(m, &err, DBUS_TYPE_UINT16, &gain, DBUS_TYPE_INVALID) || gain > HSP_MAX_GAIN) {
1795             pa_log("Failed to parse org.bluez.Headset.{Speaker|Microphone}GainChanged: %s", err.message);
1796             goto fail;
1797         }
1798
1799         if (u->profile == PROFILE_HSP) {
1800             if (u->sink && dbus_message_is_signal(m, "org.bluez.Headset", "SpeakerGainChanged")) {
1801                 pa_volume_t volume = (pa_volume_t) (gain * PA_VOLUME_NORM / HSP_MAX_GAIN);
1802
1803                 /* increment volume by one to correct rounding errors */
1804                 if (volume < PA_VOLUME_NORM)
1805                     volume++;
1806
1807                 pa_cvolume_set(&v, u->sample_spec.channels, volume);
1808                 pa_sink_volume_changed(u->sink, &v);
1809
1810             } else if (u->source && dbus_message_is_signal(m, "org.bluez.Headset", "MicrophoneGainChanged")) {
1811                 pa_volume_t volume = (pa_volume_t) (gain * PA_VOLUME_NORM / HSP_MAX_GAIN);
1812
1813                 /* increment volume by one to correct rounding errors */
1814                 if (volume < PA_VOLUME_NORM)
1815                     volume++;
1816
1817                 pa_cvolume_set(&v, u->sample_spec.channels, volume);
1818                 pa_source_volume_changed(u->source, &v);
1819             }
1820         }
1821     } else if (dbus_message_is_signal(m, "org.bluez.MediaTransport", "PropertyChanged")) {
1822         DBusMessageIter arg_i;
1823         pa_bluetooth_transport *t;
1824         pa_bool_t nrec;
1825
1826         t = (pa_bluetooth_transport *) pa_bluetooth_discovery_get_transport(u->discovery, u->transport);
1827         pa_assert(t);
1828
1829         if (!dbus_message_iter_init(m, &arg_i)) {
1830             pa_log("Failed to parse PropertyChanged: %s", err.message);
1831             goto fail;
1832         }
1833
1834         nrec = t->nrec;
1835
1836         if (pa_bluetooth_transport_parse_property(t, &arg_i) < 0)
1837             goto fail;
1838
1839         if (nrec != t->nrec) {
1840             pa_log_debug("dbus: property 'NREC' changed to value '%s'", t->nrec ? "True" : "False");
1841             pa_proplist_sets(u->source->proplist, "bluetooth.nrec", t->nrec ? "1" : "0");
1842         }
1843     } else if (dbus_message_is_signal(m, "org.bluez.HandsfreeGateway", "PropertyChanged")) {
1844         const char *key;
1845         DBusMessageIter iter;
1846         DBusMessageIter variant;
1847         pa_bt_audio_state_t state = PA_BT_AUDIO_STATE_INVALID;
1848
1849         if (!dbus_message_iter_init(m, &iter)) {
1850             pa_log("Failed to parse PropertyChanged: %s", err.message);
1851             goto fail;
1852         }
1853
1854         if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING) {
1855             pa_log("Property name not a string.");
1856             goto fail;
1857         }
1858
1859         dbus_message_iter_get_basic(&iter, &key);
1860
1861         if (!dbus_message_iter_next(&iter)) {
1862             pa_log("Property value missing");
1863             goto fail;
1864         }
1865
1866         dbus_message_iter_recurse(&iter, &variant);
1867
1868         if (dbus_message_iter_get_arg_type(&variant) == DBUS_TYPE_STRING) {
1869             const char *value;
1870             dbus_message_iter_get_basic(&variant, &value);
1871
1872             if (pa_streq(key, "State")) {
1873                 pa_log_debug("dbus: HSHFAG property 'State' changed to value '%s'", value);
1874                 state = pa_bt_audio_state_from_string(value);
1875             }
1876         }
1877
1878         switch(state) {
1879             case PA_BT_AUDIO_STATE_INVALID:
1880             case PA_BT_AUDIO_STATE_DISCONNECTED:
1881             case PA_BT_AUDIO_STATE_CONNECTED:
1882             case PA_BT_AUDIO_STATE_CONNECTING:
1883                 goto fail;
1884
1885             case PA_BT_AUDIO_STATE_PLAYING:
1886                 if (u->card) {
1887                     pa_log_debug("Changing profile to hfgw");
1888                     if (pa_card_set_profile(u->card, "hfgw", FALSE) < 0)
1889                         pa_log("Failed to change profile to hfgw");
1890                 }
1891                 break;
1892         }
1893     }
1894
1895 fail:
1896     dbus_error_free(&err);
1897
1898     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1899 }
1900
1901 /* Run from main thread */
1902 static void sink_set_volume_cb(pa_sink *s) {
1903     DBusMessage *m;
1904     dbus_uint16_t gain;
1905     pa_volume_t volume;
1906     struct userdata *u;
1907     char *k;
1908
1909     pa_assert(s);
1910     pa_assert(s->core);
1911
1912     k = pa_sprintf_malloc("bluetooth-device@%p", (void*) s);
1913     u = pa_shared_get(s->core, k);
1914     pa_xfree(k);
1915
1916     pa_assert(u);
1917     pa_assert(u->sink == s);
1918     pa_assert(u->profile == PROFILE_HSP);
1919
1920     gain = (pa_cvolume_max(&s->real_volume) * HSP_MAX_GAIN) / PA_VOLUME_NORM;
1921
1922     if (gain > HSP_MAX_GAIN)
1923         gain = HSP_MAX_GAIN;
1924
1925     volume = (pa_volume_t) (gain * PA_VOLUME_NORM / HSP_MAX_GAIN);
1926
1927     /* increment volume by one to correct rounding errors */
1928     if (volume < PA_VOLUME_NORM)
1929         volume++;
1930
1931     pa_cvolume_set(&s->real_volume, u->sample_spec.channels, volume);
1932
1933     pa_assert_se(m = dbus_message_new_method_call("org.bluez", u->path, "org.bluez.Headset", "SetSpeakerGain"));
1934     pa_assert_se(dbus_message_append_args(m, DBUS_TYPE_UINT16, &gain, DBUS_TYPE_INVALID));
1935     pa_assert_se(dbus_connection_send(pa_dbus_connection_get(u->connection), m, NULL));
1936     dbus_message_unref(m);
1937 }
1938
1939 /* Run from main thread */
1940 static void source_set_volume_cb(pa_source *s) {
1941     DBusMessage *m;
1942     dbus_uint16_t gain;
1943     pa_volume_t volume;
1944     struct userdata *u;
1945     char *k;
1946
1947     pa_assert(s);
1948     pa_assert(s->core);
1949
1950     k = pa_sprintf_malloc("bluetooth-device@%p", (void*) s);
1951     u = pa_shared_get(s->core, k);
1952     pa_xfree(k);
1953
1954     pa_assert(u);
1955     pa_assert(u->source == s);
1956     pa_assert(u->profile == PROFILE_HSP);
1957
1958     gain = (pa_cvolume_max(&s->real_volume) * HSP_MAX_GAIN) / PA_VOLUME_NORM;
1959
1960     if (gain > HSP_MAX_GAIN)
1961         gain = HSP_MAX_GAIN;
1962
1963     volume = (pa_volume_t) (gain * PA_VOLUME_NORM / HSP_MAX_GAIN);
1964
1965     /* increment volume by one to correct rounding errors */
1966     if (volume < PA_VOLUME_NORM)
1967         volume++;
1968
1969     pa_cvolume_set(&s->real_volume, u->sample_spec.channels, volume);
1970
1971     pa_assert_se(m = dbus_message_new_method_call("org.bluez", u->path, "org.bluez.Headset", "SetMicrophoneGain"));
1972     pa_assert_se(dbus_message_append_args(m, DBUS_TYPE_UINT16, &gain, DBUS_TYPE_INVALID));
1973     pa_assert_se(dbus_connection_send(pa_dbus_connection_get(u->connection), m, NULL));
1974     dbus_message_unref(m);
1975 }
1976
1977 /* Run from main thread */
1978 static char *get_name(const char *type, pa_modargs *ma, const char *device_id, pa_bool_t *namereg_fail) {
1979     char *t;
1980     const char *n;
1981
1982     pa_assert(type);
1983     pa_assert(ma);
1984     pa_assert(device_id);
1985     pa_assert(namereg_fail);
1986
1987     t = pa_sprintf_malloc("%s_name", type);
1988     n = pa_modargs_get_value(ma, t, NULL);
1989     pa_xfree(t);
1990
1991     if (n) {
1992         *namereg_fail = TRUE;
1993         return pa_xstrdup(n);
1994     }
1995
1996     if ((n = pa_modargs_get_value(ma, "name", NULL)))
1997         *namereg_fail = TRUE;
1998     else {
1999         n = device_id;
2000         *namereg_fail = FALSE;
2001     }
2002
2003     return pa_sprintf_malloc("bluez_%s.%s", type, n);
2004 }
2005
2006 static int sco_over_pcm_state_update(struct userdata *u, pa_bool_t changed) {
2007     pa_assert(u);
2008     pa_assert(USE_SCO_OVER_PCM(u));
2009
2010     if (PA_SINK_IS_OPENED(pa_sink_get_state(u->hsp.sco_sink)) ||
2011         PA_SOURCE_IS_OPENED(pa_source_get_state(u->hsp.sco_source))) {
2012
2013         if (u->service_fd >= 0 && u->stream_fd >= 0)
2014             return 0;
2015
2016         init_bt(u);
2017
2018         pa_log_debug("Resuming SCO over PCM");
2019         if (init_profile(u) < 0) {
2020             pa_log("Can't resume SCO over PCM");
2021             return -1;
2022         }
2023
2024         if (u->transport)
2025             return bt_transport_acquire(u, TRUE);
2026
2027         return start_stream_fd(u);
2028     }
2029
2030     if (changed) {
2031         if (u->service_fd < 0 && u->stream_fd < 0)
2032             return 0;
2033
2034         pa_log_debug("Closing SCO over PCM");
2035
2036         if (u->transport)
2037             bt_transport_release(u);
2038         else if (u->stream_fd >= 0)
2039             stop_stream_fd(u);
2040
2041         if (u->service_fd >= 0) {
2042             pa_close(u->service_fd);
2043             u->service_fd = -1;
2044         }
2045     }
2046
2047     return 0;
2048 }
2049
2050 static pa_hook_result_t sink_state_changed_cb(pa_core *c, pa_sink *s, struct userdata *u) {
2051     pa_assert(c);
2052     pa_sink_assert_ref(s);
2053     pa_assert(u);
2054
2055     if (s != u->hsp.sco_sink)
2056         return PA_HOOK_OK;
2057
2058     sco_over_pcm_state_update(u, TRUE);
2059
2060     return PA_HOOK_OK;
2061 }
2062
2063 static pa_hook_result_t source_state_changed_cb(pa_core *c, pa_source *s, struct userdata *u) {
2064     pa_assert(c);
2065     pa_source_assert_ref(s);
2066     pa_assert(u);
2067
2068     if (s != u->hsp.sco_source)
2069         return PA_HOOK_OK;
2070
2071     sco_over_pcm_state_update(u, TRUE);
2072
2073     return PA_HOOK_OK;
2074 }
2075
2076 /* Run from main thread */
2077 static int add_sink(struct userdata *u) {
2078     char *k;
2079
2080     if (USE_SCO_OVER_PCM(u)) {
2081         pa_proplist *p;
2082
2083         u->sink = u->hsp.sco_sink;
2084         p = pa_proplist_new();
2085         pa_proplist_sets(p, "bluetooth.protocol", "sco");
2086         pa_proplist_update(u->sink->proplist, PA_UPDATE_MERGE, p);
2087         pa_proplist_free(p);
2088
2089         if (!u->hsp.sink_state_changed_slot)
2090             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);
2091
2092     } else {
2093         pa_sink_new_data data;
2094         pa_bool_t b;
2095
2096         pa_sink_new_data_init(&data);
2097         data.driver = __FILE__;
2098         data.module = u->module;
2099         pa_sink_new_data_set_sample_spec(&data, &u->sample_spec);
2100         pa_proplist_sets(data.proplist, "bluetooth.protocol", u->profile == PROFILE_A2DP ? "a2dp" : "sco");
2101         if (u->profile == PROFILE_HSP)
2102             pa_proplist_sets(data.proplist, PA_PROP_DEVICE_INTENDED_ROLES, "phone");
2103         data.card = u->card;
2104         data.name = get_name("sink", u->modargs, u->address, &b);
2105         data.namereg_fail = b;
2106
2107         if (pa_modargs_get_proplist(u->modargs, "sink_properties", data.proplist, PA_UPDATE_REPLACE) < 0) {
2108             pa_log("Invalid properties");
2109             pa_sink_new_data_done(&data);
2110             return -1;
2111         }
2112
2113         u->sink = pa_sink_new(u->core, &data, PA_SINK_HARDWARE|PA_SINK_LATENCY);
2114         pa_sink_new_data_done(&data);
2115
2116         if (!u->sink) {
2117             pa_log_error("Failed to create sink");
2118             return -1;
2119         }
2120
2121         u->sink->userdata = u;
2122         u->sink->parent.process_msg = sink_process_msg;
2123
2124         pa_sink_set_max_request(u->sink, u->block_size);
2125         pa_sink_set_fixed_latency(u->sink,
2126                                   (u->profile == PROFILE_A2DP ? FIXED_LATENCY_PLAYBACK_A2DP : FIXED_LATENCY_PLAYBACK_HSP) +
2127                                   pa_bytes_to_usec(u->block_size, &u->sample_spec));
2128     }
2129
2130     if (u->profile == PROFILE_HSP) {
2131         pa_sink_set_set_volume_callback(u->sink, sink_set_volume_cb);
2132         u->sink->n_volume_steps = 16;
2133
2134         k = pa_sprintf_malloc("bluetooth-device@%p", (void*) u->sink);
2135         pa_shared_set(u->core, k, u);
2136         pa_xfree(k);
2137     }
2138
2139     return 0;
2140 }
2141
2142 /* Run from main thread */
2143 static int add_source(struct userdata *u) {
2144     char *k;
2145
2146     if (USE_SCO_OVER_PCM(u)) {
2147         u->source = u->hsp.sco_source;
2148         pa_proplist_sets(u->source->proplist, "bluetooth.protocol", "hsp");
2149
2150         if (!u->hsp.source_state_changed_slot)
2151             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);
2152
2153     } else {
2154         pa_source_new_data data;
2155         pa_bool_t b;
2156
2157         pa_source_new_data_init(&data);
2158         data.driver = __FILE__;
2159         data.module = u->module;
2160         pa_source_new_data_set_sample_spec(&data, &u->sample_spec);
2161         pa_proplist_sets(data.proplist, "bluetooth.protocol", u->profile == PROFILE_A2DP_SOURCE ? "a2dp_source" : "hsp");
2162         if ((u->profile == PROFILE_HSP) || (u->profile == PROFILE_HFGW))
2163             pa_proplist_sets(data.proplist, PA_PROP_DEVICE_INTENDED_ROLES, "phone");
2164
2165         data.card = u->card;
2166         data.name = get_name("source", u->modargs, u->address, &b);
2167         data.namereg_fail = b;
2168
2169         if (pa_modargs_get_proplist(u->modargs, "source_properties", data.proplist, PA_UPDATE_REPLACE) < 0) {
2170             pa_log("Invalid properties");
2171             pa_source_new_data_done(&data);
2172             return -1;
2173         }
2174
2175         u->source = pa_source_new(u->core, &data, PA_SOURCE_HARDWARE|PA_SOURCE_LATENCY);
2176         pa_source_new_data_done(&data);
2177
2178         if (!u->source) {
2179             pa_log_error("Failed to create source");
2180             return -1;
2181         }
2182
2183         u->source->userdata = u;
2184         u->source->parent.process_msg = source_process_msg;
2185
2186         pa_source_set_fixed_latency(u->source,
2187                                     (u->profile == PROFILE_A2DP_SOURCE ? FIXED_LATENCY_RECORD_A2DP : FIXED_LATENCY_RECORD_HSP) +
2188                                     pa_bytes_to_usec(u->block_size, &u->sample_spec));
2189     }
2190
2191     if ((u->profile == PROFILE_HSP) || (u->profile == PROFILE_HFGW)) {
2192         if (u->transport) {
2193             const pa_bluetooth_transport *t;
2194             t = pa_bluetooth_discovery_get_transport(u->discovery, u->transport);
2195             pa_assert(t);
2196             pa_proplist_sets(u->source->proplist, "bluetooth.nrec", t->nrec ? "1" : "0");
2197         } else
2198             pa_proplist_sets(u->source->proplist, "bluetooth.nrec", (u->hsp.pcm_capabilities.flags & BT_PCM_FLAG_NREC) ? "1" : "0");
2199     }
2200
2201     if (u->profile == PROFILE_HSP) {
2202         pa_source_set_set_volume_callback(u->source, source_set_volume_cb);
2203         u->source->n_volume_steps = 16;
2204
2205         k = pa_sprintf_malloc("bluetooth-device@%p", (void*) u->source);
2206         pa_shared_set(u->core, k, u);
2207         pa_xfree(k);
2208     }
2209
2210     return 0;
2211 }
2212
2213 /* Run from main thread */
2214 static void shutdown_bt(struct userdata *u) {
2215     pa_assert(u);
2216
2217     if (u->stream_fd >= 0) {
2218         pa_close(u->stream_fd);
2219         u->stream_fd = -1;
2220
2221         u->stream_write_type = 0;
2222     }
2223
2224     if (u->service_fd >= 0) {
2225         pa_close(u->service_fd);
2226         u->service_fd = -1;
2227         u->service_write_type = 0;
2228         u->service_read_type = 0;
2229     }
2230
2231     if (u->write_memchunk.memblock) {
2232         pa_memblock_unref(u->write_memchunk.memblock);
2233         pa_memchunk_reset(&u->write_memchunk);
2234     }
2235 }
2236
2237 static int bt_transport_config_a2dp(struct userdata *u) {
2238     const pa_bluetooth_transport *t;
2239     struct a2dp_info *a2dp = &u->a2dp;
2240     a2dp_sbc_t *config;
2241
2242     t = pa_bluetooth_discovery_get_transport(u->discovery, u->transport);
2243     pa_assert(t);
2244
2245     config = (a2dp_sbc_t *) t->config;
2246
2247     u->sample_spec.format = PA_SAMPLE_S16LE;
2248
2249     if (a2dp->sbc_initialized)
2250         sbc_reinit(&a2dp->sbc, 0);
2251     else
2252         sbc_init(&a2dp->sbc, 0);
2253     a2dp->sbc_initialized = TRUE;
2254
2255     switch (config->frequency) {
2256         case BT_SBC_SAMPLING_FREQ_16000:
2257             a2dp->sbc.frequency = SBC_FREQ_16000;
2258             u->sample_spec.rate = 16000U;
2259             break;
2260         case BT_SBC_SAMPLING_FREQ_32000:
2261             a2dp->sbc.frequency = SBC_FREQ_32000;
2262             u->sample_spec.rate = 32000U;
2263             break;
2264         case BT_SBC_SAMPLING_FREQ_44100:
2265             a2dp->sbc.frequency = SBC_FREQ_44100;
2266             u->sample_spec.rate = 44100U;
2267             break;
2268         case BT_SBC_SAMPLING_FREQ_48000:
2269             a2dp->sbc.frequency = SBC_FREQ_48000;
2270             u->sample_spec.rate = 48000U;
2271             break;
2272         default:
2273             pa_assert_not_reached();
2274     }
2275
2276     switch (config->channel_mode) {
2277         case BT_A2DP_CHANNEL_MODE_MONO:
2278             a2dp->sbc.mode = SBC_MODE_MONO;
2279             u->sample_spec.channels = 1;
2280             break;
2281         case BT_A2DP_CHANNEL_MODE_DUAL_CHANNEL:
2282             a2dp->sbc.mode = SBC_MODE_DUAL_CHANNEL;
2283             u->sample_spec.channels = 2;
2284             break;
2285         case BT_A2DP_CHANNEL_MODE_STEREO:
2286             a2dp->sbc.mode = SBC_MODE_STEREO;
2287             u->sample_spec.channels = 2;
2288             break;
2289         case BT_A2DP_CHANNEL_MODE_JOINT_STEREO:
2290             a2dp->sbc.mode = SBC_MODE_JOINT_STEREO;
2291             u->sample_spec.channels = 2;
2292             break;
2293         default:
2294             pa_assert_not_reached();
2295     }
2296
2297     switch (config->allocation_method) {
2298         case BT_A2DP_ALLOCATION_SNR:
2299             a2dp->sbc.allocation = SBC_AM_SNR;
2300             break;
2301         case BT_A2DP_ALLOCATION_LOUDNESS:
2302             a2dp->sbc.allocation = SBC_AM_LOUDNESS;
2303             break;
2304         default:
2305             pa_assert_not_reached();
2306     }
2307
2308     switch (config->subbands) {
2309         case BT_A2DP_SUBBANDS_4:
2310             a2dp->sbc.subbands = SBC_SB_4;
2311             break;
2312         case BT_A2DP_SUBBANDS_8:
2313             a2dp->sbc.subbands = SBC_SB_8;
2314             break;
2315         default:
2316             pa_assert_not_reached();
2317     }
2318
2319     switch (config->block_length) {
2320         case BT_A2DP_BLOCK_LENGTH_4:
2321             a2dp->sbc.blocks = SBC_BLK_4;
2322             break;
2323         case BT_A2DP_BLOCK_LENGTH_8:
2324             a2dp->sbc.blocks = SBC_BLK_8;
2325             break;
2326         case BT_A2DP_BLOCK_LENGTH_12:
2327             a2dp->sbc.blocks = SBC_BLK_12;
2328             break;
2329         case BT_A2DP_BLOCK_LENGTH_16:
2330             a2dp->sbc.blocks = SBC_BLK_16;
2331             break;
2332         default:
2333             pa_assert_not_reached();
2334     }
2335
2336     a2dp->min_bitpool = config->min_bitpool;
2337     a2dp->max_bitpool = config->max_bitpool;
2338
2339     /* Set minimum bitpool for source to get the maximum possible block_size */
2340     a2dp->sbc.bitpool = u->profile == PROFILE_A2DP ? a2dp->max_bitpool : a2dp->min_bitpool;
2341     a2dp->codesize = sbc_get_codesize(&a2dp->sbc);
2342     a2dp->frame_length = sbc_get_frame_length(&a2dp->sbc);
2343
2344     u->block_size =
2345         ((u->link_mtu - sizeof(struct rtp_header) - sizeof(struct rtp_payload))
2346         / a2dp->frame_length
2347         * a2dp->codesize);
2348
2349     pa_log_info("SBC parameters:\n\tallocation=%u\n\tsubbands=%u\n\tblocks=%u\n\tbitpool=%u\n",
2350                 a2dp->sbc.allocation, a2dp->sbc.subbands, a2dp->sbc.blocks, a2dp->sbc.bitpool);
2351
2352     return 0;
2353 }
2354
2355 static int bt_transport_config(struct userdata *u) {
2356     if (u->profile == PROFILE_HSP || u->profile == PROFILE_HFGW) {
2357         u->block_size = u->link_mtu;
2358         u->sample_spec.format = PA_SAMPLE_S16LE;
2359         u->sample_spec.channels = 1;
2360         u->sample_spec.rate = 8000;
2361         return 0;
2362     }
2363
2364     return bt_transport_config_a2dp(u);
2365 }
2366
2367 /* Run from main thread */
2368 static int bt_transport_open(struct userdata *u) {
2369     if (bt_transport_acquire(u, FALSE) < 0)
2370         return -1;
2371
2372     return bt_transport_config(u);
2373 }
2374
2375 /* Run from main thread */
2376 static int init_bt(struct userdata *u) {
2377     pa_assert(u);
2378
2379     shutdown_bt(u);
2380
2381     u->stream_write_type = 0;
2382     u->service_write_type = 0;
2383     u->service_read_type = 0;
2384
2385     if ((u->service_fd = bt_audio_service_open()) < 0) {
2386         pa_log_warn("Bluetooth audio service not available");
2387         return -1;
2388     }
2389
2390     pa_log_debug("Connected to the bluetooth audio service");
2391
2392     return 0;
2393 }
2394
2395 /* Run from main thread */
2396 static int setup_bt(struct userdata *u) {
2397     const pa_bluetooth_device *d;
2398     const pa_bluetooth_transport *t;
2399
2400     pa_assert(u);
2401
2402     if (!(d = pa_bluetooth_discovery_get_by_path(u->discovery, u->path))) {
2403         pa_log_error("Failed to get device object.");
2404         return -1;
2405     }
2406
2407     /* release transport if exist */
2408     if (u->transport) {
2409         bt_transport_release(u);
2410         pa_xfree(u->transport);
2411         u->transport = NULL;
2412     }
2413
2414     /* check if profile has a transport */
2415     t = pa_bluetooth_device_get_transport(d, u->profile);
2416     if (t) {
2417         u->transport = pa_xstrdup(t->path);
2418         return bt_transport_open(u);
2419     }
2420
2421     if (get_caps(u, 0) < 0)
2422         return -1;
2423
2424     pa_log_debug("Got device capabilities");
2425
2426     if (set_conf(u) < 0)
2427         return -1;
2428
2429     pa_log_debug("Connection to the device configured");
2430
2431     if (USE_SCO_OVER_PCM(u)) {
2432         pa_log_debug("Configured to use SCO over PCM");
2433         return 0;
2434     }
2435
2436     pa_log_debug("Got the stream socket");
2437
2438     return 0;
2439 }
2440
2441 /* Run from main thread */
2442 static int init_profile(struct userdata *u) {
2443     int r = 0;
2444     pa_assert(u);
2445     pa_assert(u->profile != PROFILE_OFF);
2446
2447     if (setup_bt(u) < 0)
2448         return -1;
2449
2450     if (u->profile == PROFILE_A2DP ||
2451         u->profile == PROFILE_HSP ||
2452         u->profile == PROFILE_HFGW)
2453         if (add_sink(u) < 0)
2454             r = -1;
2455
2456     if (u->profile == PROFILE_HSP ||
2457         u->profile == PROFILE_A2DP_SOURCE ||
2458         u->profile == PROFILE_HFGW)
2459         if (add_source(u) < 0)
2460             r = -1;
2461
2462     return r;
2463 }
2464
2465 /* Run from main thread */
2466 static void stop_thread(struct userdata *u) {
2467     char *k;
2468
2469     pa_assert(u);
2470
2471     if (u->thread) {
2472         pa_asyncmsgq_send(u->thread_mq.inq, NULL, PA_MESSAGE_SHUTDOWN, NULL, 0, NULL);
2473         pa_thread_free(u->thread);
2474         u->thread = NULL;
2475     }
2476
2477     if (u->rtpoll_item) {
2478         pa_rtpoll_item_free(u->rtpoll_item);
2479         u->rtpoll_item = NULL;
2480     }
2481
2482     if (u->hsp.sink_state_changed_slot) {
2483         pa_hook_slot_free(u->hsp.sink_state_changed_slot);
2484         u->hsp.sink_state_changed_slot = NULL;
2485     }
2486
2487     if (u->hsp.source_state_changed_slot) {
2488         pa_hook_slot_free(u->hsp.source_state_changed_slot);
2489         u->hsp.source_state_changed_slot = NULL;
2490     }
2491
2492     if (u->sink) {
2493         if (u->profile == PROFILE_HSP) {
2494             k = pa_sprintf_malloc("bluetooth-device@%p", (void*) u->sink);
2495             pa_shared_remove(u->core, k);
2496             pa_xfree(k);
2497         }
2498
2499         pa_sink_unref(u->sink);
2500         u->sink = NULL;
2501     }
2502
2503     if (u->source) {
2504         if (u->profile == PROFILE_HSP) {
2505             k = pa_sprintf_malloc("bluetooth-device@%p", (void*) u->source);
2506             pa_shared_remove(u->core, k);
2507             pa_xfree(k);
2508         }
2509
2510         pa_source_unref(u->source);
2511         u->source = NULL;
2512     }
2513
2514     if (u->rtpoll) {
2515         pa_thread_mq_done(&u->thread_mq);
2516
2517         pa_rtpoll_free(u->rtpoll);
2518         u->rtpoll = NULL;
2519     }
2520
2521     if (u->read_smoother) {
2522         pa_smoother_free(u->read_smoother);
2523         u->read_smoother = NULL;
2524     }
2525 }
2526
2527 /* Run from main thread */
2528 static int start_thread(struct userdata *u) {
2529     pa_assert(u);
2530     pa_assert(!u->thread);
2531     pa_assert(!u->rtpoll);
2532     pa_assert(!u->rtpoll_item);
2533
2534     u->rtpoll = pa_rtpoll_new();
2535     pa_thread_mq_init(&u->thread_mq, u->core->mainloop, u->rtpoll);
2536
2537     if (USE_SCO_OVER_PCM(u)) {
2538         if (sco_over_pcm_state_update(u, FALSE) < 0) {
2539             char *k;
2540
2541             if (u->sink) {
2542                 k = pa_sprintf_malloc("bluetooth-device@%p", (void*) u->sink);
2543                 pa_shared_remove(u->core, k);
2544                 pa_xfree(k);
2545                 u->sink = NULL;
2546             }
2547             if (u->source) {
2548                 k = pa_sprintf_malloc("bluetooth-device@%p", (void*) u->source);
2549                 pa_shared_remove(u->core, k);
2550                 pa_xfree(k);
2551                 u->source = NULL;
2552             }
2553             return -1;
2554         }
2555
2556         pa_sink_ref(u->sink);
2557         pa_source_ref(u->source);
2558         /* FIXME: monitor stream_fd error */
2559         return 0;
2560     }
2561
2562     if (!(u->thread = pa_thread_new("bluetooth", thread_func, u))) {
2563         pa_log_error("Failed to create IO thread");
2564         stop_thread(u);
2565         return -1;
2566     }
2567
2568     if (u->sink) {
2569         pa_sink_set_asyncmsgq(u->sink, u->thread_mq.inq);
2570         pa_sink_set_rtpoll(u->sink, u->rtpoll);
2571         pa_sink_put(u->sink);
2572
2573         if (u->sink->set_volume)
2574             u->sink->set_volume(u->sink);
2575     }
2576
2577     if (u->source) {
2578         pa_source_set_asyncmsgq(u->source, u->thread_mq.inq);
2579         pa_source_set_rtpoll(u->source, u->rtpoll);
2580         pa_source_put(u->source);
2581
2582         if (u->source->set_volume)
2583             u->source->set_volume(u->source);
2584     }
2585
2586     return 0;
2587 }
2588
2589 static void save_sco_volume_callbacks(struct userdata *u) {
2590     pa_assert(u);
2591     pa_assert(USE_SCO_OVER_PCM(u));
2592
2593     u->hsp.sco_sink_set_volume = u->hsp.sco_sink->set_volume;
2594     u->hsp.sco_source_set_volume = u->hsp.sco_source->set_volume;
2595 }
2596
2597 static void restore_sco_volume_callbacks(struct userdata *u) {
2598     pa_assert(u);
2599     pa_assert(USE_SCO_OVER_PCM(u));
2600
2601     pa_sink_set_set_volume_callback(u->hsp.sco_sink, u->hsp.sco_sink_set_volume);
2602     pa_source_set_set_volume_callback(u->hsp.sco_source, u->hsp.sco_source_set_volume);
2603 }
2604
2605 /* Run from main thread */
2606 static int card_set_profile(pa_card *c, pa_card_profile *new_profile) {
2607     struct userdata *u;
2608     enum profile *d;
2609     pa_queue *inputs = NULL, *outputs = NULL;
2610     const pa_bluetooth_device *device;
2611
2612     pa_assert(c);
2613     pa_assert(new_profile);
2614     pa_assert_se(u = c->userdata);
2615
2616     d = PA_CARD_PROFILE_DATA(new_profile);
2617
2618     if (!(device = pa_bluetooth_discovery_get_by_path(u->discovery, u->path))) {
2619         pa_log_error("Failed to get device object.");
2620         return -PA_ERR_IO;
2621     }
2622
2623     /* The state signal is sent by bluez, so it is racy to check
2624        strictly for CONNECTED, we should also accept STREAMING state
2625        as being good enough. However, if the profile is used
2626        concurrently (which is unlikely), ipc will fail later on, and
2627        module will be unloaded. */
2628     if (device->headset_state < PA_BT_AUDIO_STATE_CONNECTED && *d == PROFILE_HSP) {
2629         pa_log_warn("HSP is not connected, refused to switch profile");
2630         return -PA_ERR_IO;
2631     }
2632     else if (device->audio_sink_state < PA_BT_AUDIO_STATE_CONNECTED && *d == PROFILE_A2DP) {
2633         pa_log_warn("A2DP is not connected, refused to switch profile");
2634         return -PA_ERR_IO;
2635     }
2636     else if (device->hfgw_state < PA_BT_AUDIO_STATE_CONNECTED && *d == PROFILE_HFGW) {
2637         pa_log_warn("HandsfreeGateway is not connected, refused to switch profile");
2638         return -PA_ERR_IO;
2639     }
2640
2641     if (u->sink) {
2642         inputs = pa_sink_move_all_start(u->sink, NULL);
2643
2644         if (!USE_SCO_OVER_PCM(u))
2645             pa_sink_unlink(u->sink);
2646     }
2647
2648     if (u->source) {
2649         outputs = pa_source_move_all_start(u->source, NULL);
2650
2651         if (!USE_SCO_OVER_PCM(u))
2652             pa_source_unlink(u->source);
2653     }
2654
2655     stop_thread(u);
2656
2657     if (u->profile != PROFILE_OFF && u->transport) {
2658         bt_transport_release(u);
2659         pa_xfree(u->transport);
2660         u->transport = NULL;
2661     }
2662
2663     shutdown_bt(u);
2664
2665     if (USE_SCO_OVER_PCM(u))
2666         restore_sco_volume_callbacks(u);
2667
2668     u->profile = *d;
2669     u->sample_spec = u->requested_sample_spec;
2670
2671     if (USE_SCO_OVER_PCM(u))
2672         save_sco_volume_callbacks(u);
2673
2674     init_bt(u);
2675
2676     if (u->profile != PROFILE_OFF)
2677         init_profile(u);
2678
2679     if (u->sink || u->source)
2680         start_thread(u);
2681
2682     if (inputs) {
2683         if (u->sink)
2684             pa_sink_move_all_finish(u->sink, inputs, FALSE);
2685         else
2686             pa_sink_move_all_fail(inputs);
2687     }
2688
2689     if (outputs) {
2690         if (u->source)
2691             pa_source_move_all_finish(u->source, outputs, FALSE);
2692         else
2693             pa_source_move_all_fail(outputs);
2694     }
2695
2696     return 0;
2697 }
2698
2699 /* Run from main thread */
2700 static int add_card(struct userdata *u, const pa_bluetooth_device *device) {
2701     pa_card_new_data data;
2702     pa_bool_t b;
2703     pa_card_profile *p;
2704     enum profile *d;
2705     const char *ff;
2706     char *n;
2707     const char *default_profile;
2708
2709     pa_assert(u);
2710     pa_assert(device);
2711
2712     pa_card_new_data_init(&data);
2713     data.driver = __FILE__;
2714     data.module = u->module;
2715
2716     n = pa_bluetooth_cleanup_name(device->name);
2717     pa_proplist_sets(data.proplist, PA_PROP_DEVICE_DESCRIPTION, n);
2718     pa_xfree(n);
2719     pa_proplist_sets(data.proplist, PA_PROP_DEVICE_STRING, device->address);
2720     pa_proplist_sets(data.proplist, PA_PROP_DEVICE_API, "bluez");
2721     pa_proplist_sets(data.proplist, PA_PROP_DEVICE_CLASS, "sound");
2722     pa_proplist_sets(data.proplist, PA_PROP_DEVICE_BUS, "bluetooth");
2723     if ((ff = pa_bluetooth_get_form_factor(device->class)))
2724         pa_proplist_sets(data.proplist, PA_PROP_DEVICE_FORM_FACTOR, ff);
2725     pa_proplist_sets(data.proplist, "bluez.path", device->path);
2726     pa_proplist_setf(data.proplist, "bluez.class", "0x%06x", (unsigned) device->class);
2727     pa_proplist_sets(data.proplist, "bluez.name", device->name);
2728     data.name = get_name("card", u->modargs, device->address, &b);
2729     data.namereg_fail = b;
2730
2731     if (pa_modargs_get_proplist(u->modargs, "card_properties", data.proplist, PA_UPDATE_REPLACE) < 0) {
2732         pa_log("Invalid properties");
2733         pa_card_new_data_done(&data);
2734         return -1;
2735     }
2736
2737     data.profiles = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
2738
2739     /* we base hsp/a2dp availability on UUIDs.
2740        Ideally, it would be based on "Connected" state, but
2741        we can't afford to wait for this information when
2742        we are loaded with profile="hsp", for instance */
2743     if (pa_bluetooth_uuid_has(device->uuids, A2DP_SINK_UUID)) {
2744         p = pa_card_profile_new("a2dp", _("High Fidelity Playback (A2DP)"), sizeof(enum profile));
2745         p->priority = 10;
2746         p->n_sinks = 1;
2747         p->n_sources = 0;
2748         p->max_sink_channels = 2;
2749         p->max_source_channels = 0;
2750
2751         d = PA_CARD_PROFILE_DATA(p);
2752         *d = PROFILE_A2DP;
2753
2754         pa_hashmap_put(data.profiles, p->name, p);
2755     }
2756
2757     if (pa_bluetooth_uuid_has(device->uuids, A2DP_SOURCE_UUID)) {
2758         p = pa_card_profile_new("a2dp_source", _("High Fidelity Capture (A2DP)"), sizeof(enum profile));
2759         p->priority = 10;
2760         p->n_sinks = 0;
2761         p->n_sources = 1;
2762         p->max_sink_channels = 0;
2763         p->max_source_channels = 2;
2764
2765         d = PA_CARD_PROFILE_DATA(p);
2766         *d = PROFILE_A2DP_SOURCE;
2767
2768         pa_hashmap_put(data.profiles, p->name, p);
2769     }
2770
2771     if (pa_bluetooth_uuid_has(device->uuids, HSP_HS_UUID) ||
2772         pa_bluetooth_uuid_has(device->uuids, HFP_HS_UUID)) {
2773         p = pa_card_profile_new("hsp", _("Telephony Duplex (HSP/HFP)"), sizeof(enum profile));
2774         p->priority = 20;
2775         p->n_sinks = 1;
2776         p->n_sources = 1;
2777         p->max_sink_channels = 1;
2778         p->max_source_channels = 1;
2779
2780         d = PA_CARD_PROFILE_DATA(p);
2781         *d = PROFILE_HSP;
2782
2783         pa_hashmap_put(data.profiles, p->name, p);
2784     }
2785
2786     if (pa_bluetooth_uuid_has(device->uuids, HFP_AG_UUID)) {
2787         p = pa_card_profile_new("hfgw", _("Handsfree Gateway"), sizeof(enum profile));
2788         p->priority = 20;
2789         p->n_sinks = 1;
2790         p->n_sources = 1;
2791         p->max_sink_channels = 1;
2792         p->max_source_channels = 1;
2793
2794         d = PA_CARD_PROFILE_DATA(p);
2795         *d = PROFILE_HFGW;
2796
2797         pa_hashmap_put(data.profiles, p->name, p);
2798     }
2799
2800     pa_assert(!pa_hashmap_isempty(data.profiles));
2801
2802     p = pa_card_profile_new("off", _("Off"), sizeof(enum profile));
2803     d = PA_CARD_PROFILE_DATA(p);
2804     *d = PROFILE_OFF;
2805     pa_hashmap_put(data.profiles, p->name, p);
2806
2807     if ((default_profile = pa_modargs_get_value(u->modargs, "profile", NULL))) {
2808         if (pa_hashmap_get(data.profiles, default_profile))
2809             pa_card_new_data_set_profile(&data, default_profile);
2810         else
2811             pa_log_warn("Profile '%s' not valid or not supported by device.", default_profile);
2812     }
2813
2814     u->card = pa_card_new(u->core, &data);
2815     pa_card_new_data_done(&data);
2816
2817     if (!u->card) {
2818         pa_log("Failed to allocate card.");
2819         return -1;
2820     }
2821
2822     u->card->userdata = u;
2823     u->card->set_profile = card_set_profile;
2824
2825     d = PA_CARD_PROFILE_DATA(u->card->active_profile);
2826
2827     if ((device->headset_state < PA_BT_AUDIO_STATE_CONNECTED && *d == PROFILE_HSP) ||
2828         (device->audio_sink_state < PA_BT_AUDIO_STATE_CONNECTED && *d == PROFILE_A2DP) ||
2829         (device->hfgw_state < PA_BT_AUDIO_STATE_CONNECTED && *d == PROFILE_HFGW)) {
2830         pa_log_warn("Default profile not connected, selecting off profile");
2831         u->card->active_profile = pa_hashmap_get(u->card->profiles, "off");
2832         u->card->save_profile = FALSE;
2833     }
2834
2835     d = PA_CARD_PROFILE_DATA(u->card->active_profile);
2836     u->profile = *d;
2837
2838     if (USE_SCO_OVER_PCM(u))
2839         save_sco_volume_callbacks(u);
2840
2841     return 0;
2842 }
2843
2844 /* Run from main thread */
2845 static const pa_bluetooth_device* find_device(struct userdata *u, const char *address, const char *path) {
2846     const pa_bluetooth_device *d = NULL;
2847
2848     pa_assert(u);
2849
2850     if (!address && !path) {
2851         pa_log_error("Failed to get device address/path from module arguments.");
2852         return NULL;
2853     }
2854
2855     if (path) {
2856         if (!(d = pa_bluetooth_discovery_get_by_path(u->discovery, path))) {
2857             pa_log_error("%s is not a valid BlueZ audio device.", path);
2858             return NULL;
2859         }
2860
2861         if (address && !(pa_streq(d->address, address))) {
2862             pa_log_error("Passed path %s address %s != %s don't match.", path, d->address, address);
2863             return NULL;
2864         }
2865
2866     } else {
2867         if (!(d = pa_bluetooth_discovery_get_by_address(u->discovery, address))) {
2868             pa_log_error("%s is not known.", address);
2869             return NULL;
2870         }
2871     }
2872
2873     if (d) {
2874         u->address = pa_xstrdup(d->address);
2875         u->path = pa_xstrdup(d->path);
2876     }
2877
2878     return d;
2879 }
2880
2881 /* Run from main thread */
2882 static int setup_dbus(struct userdata *u) {
2883     DBusError err;
2884
2885     dbus_error_init(&err);
2886
2887     u->connection = pa_dbus_bus_get(u->core, DBUS_BUS_SYSTEM, &err);
2888
2889     if (dbus_error_is_set(&err) || !u->connection) {
2890         pa_log("Failed to get D-Bus connection: %s", err.message);
2891         dbus_error_free(&err);
2892         return -1;
2893     }
2894
2895     return 0;
2896 }
2897
2898 int pa__init(pa_module* m) {
2899     pa_modargs *ma;
2900     uint32_t channels;
2901     struct userdata *u;
2902     const char *address, *path;
2903     DBusError err;
2904     char *mike, *speaker;
2905     const pa_bluetooth_device *device;
2906
2907     pa_assert(m);
2908
2909     dbus_error_init(&err);
2910
2911     if (!(ma = pa_modargs_new(m->argument, valid_modargs))) {
2912         pa_log_error("Failed to parse module arguments");
2913         goto fail;
2914     }
2915
2916     m->userdata = u = pa_xnew0(struct userdata, 1);
2917     u->module = m;
2918     u->core = m->core;
2919     u->service_fd = -1;
2920     u->stream_fd = -1;
2921     u->sample_spec = m->core->default_sample_spec;
2922     u->modargs = ma;
2923
2924     if (pa_modargs_get_value(ma, "sco_sink", NULL) &&
2925         !(u->hsp.sco_sink = pa_namereg_get(m->core, pa_modargs_get_value(ma, "sco_sink", NULL), PA_NAMEREG_SINK))) {
2926         pa_log("SCO sink not found");
2927         goto fail;
2928     }
2929
2930     if (pa_modargs_get_value(ma, "sco_source", NULL) &&
2931         !(u->hsp.sco_source = pa_namereg_get(m->core, pa_modargs_get_value(ma, "sco_source", NULL), PA_NAMEREG_SOURCE))) {
2932         pa_log("SCO source not found");
2933         goto fail;
2934     }
2935
2936     if (pa_modargs_get_value_u32(ma, "rate", &u->sample_spec.rate) < 0 ||
2937         u->sample_spec.rate <= 0 || u->sample_spec.rate > PA_RATE_MAX) {
2938         pa_log_error("Failed to get rate from module arguments");
2939         goto fail;
2940     }
2941
2942     u->auto_connect = TRUE;
2943     if (pa_modargs_get_value_boolean(ma, "auto_connect", &u->auto_connect)) {
2944         pa_log("Failed to parse auto_connect= argument");
2945         goto fail;
2946     }
2947
2948     channels = u->sample_spec.channels;
2949     if (pa_modargs_get_value_u32(ma, "channels", &channels) < 0 ||
2950         channels <= 0 || channels > PA_CHANNELS_MAX) {
2951         pa_log_error("Failed to get channels from module arguments");
2952         goto fail;
2953     }
2954     u->sample_spec.channels = (uint8_t) channels;
2955     u->requested_sample_spec = u->sample_spec;
2956
2957     address = pa_modargs_get_value(ma, "address", NULL);
2958     path = pa_modargs_get_value(ma, "path", NULL);
2959
2960     if (setup_dbus(u) < 0)
2961         goto fail;
2962
2963     if (!(u->discovery = pa_bluetooth_discovery_get(m->core)))
2964         goto fail;
2965
2966     if (!(device = find_device(u, address, path)))
2967         goto fail;
2968
2969     /* Add the card structure. This will also initialize the default profile */
2970     if (add_card(u, device) < 0)
2971         goto fail;
2972
2973     if (!(u->msg = pa_msgobject_new(bluetooth_msg)))
2974         goto fail;
2975
2976     u->msg->parent.process_msg = device_process_msg;
2977     u->msg->card = u->card;
2978
2979     if (!dbus_connection_add_filter(pa_dbus_connection_get(u->connection), filter_cb, u, NULL)) {
2980         pa_log_error("Failed to add filter function");
2981         goto fail;
2982     }
2983     u->filter_added = TRUE;
2984
2985     speaker = pa_sprintf_malloc("type='signal',sender='org.bluez',interface='org.bluez.Headset',member='SpeakerGainChanged',path='%s'", u->path);
2986     mike = pa_sprintf_malloc("type='signal',sender='org.bluez',interface='org.bluez.Headset',member='MicrophoneGainChanged',path='%s'", u->path);
2987
2988     if (pa_dbus_add_matches(
2989                 pa_dbus_connection_get(u->connection), &err,
2990                 speaker,
2991                 mike,
2992                 "type='signal',sender='org.bluez',interface='org.bluez.MediaTransport',member='PropertyChanged'",
2993                 "type='signal',sender='org.bluez',interface='org.bluez.HandsfreeGateway',member='PropertyChanged'",
2994                 NULL) < 0) {
2995
2996         pa_xfree(speaker);
2997         pa_xfree(mike);
2998
2999         pa_log("Failed to add D-Bus matches: %s", err.message);
3000         goto fail;
3001     }
3002
3003     pa_xfree(speaker);
3004     pa_xfree(mike);
3005
3006     /* Connect to the BT service */
3007     init_bt(u);
3008
3009     if (u->profile != PROFILE_OFF)
3010         if (init_profile(u) < 0)
3011             goto fail;
3012
3013     if (u->sink || u->source)
3014         if (start_thread(u) < 0)
3015             goto fail;
3016
3017     return 0;
3018
3019 fail:
3020
3021     pa__done(m);
3022
3023     dbus_error_free(&err);
3024
3025     return -1;
3026 }
3027
3028 int pa__get_n_used(pa_module *m) {
3029     struct userdata *u;
3030
3031     pa_assert(m);
3032     pa_assert_se(u = m->userdata);
3033
3034     return
3035         (u->sink ? pa_sink_linked_by(u->sink) : 0) +
3036         (u->source ? pa_source_linked_by(u->source) : 0);
3037 }
3038
3039 void pa__done(pa_module *m) {
3040     struct userdata *u;
3041
3042     pa_assert(m);
3043
3044     if (!(u = m->userdata))
3045         return;
3046
3047     if (u->sink && !USE_SCO_OVER_PCM(u))
3048         pa_sink_unlink(u->sink);
3049
3050     if (u->source && !USE_SCO_OVER_PCM(u))
3051         pa_source_unlink(u->source);
3052
3053     stop_thread(u);
3054
3055     if (USE_SCO_OVER_PCM(u))
3056         restore_sco_volume_callbacks(u);
3057
3058     if (u->connection) {
3059
3060         if (u->path) {
3061             char *speaker, *mike;
3062             speaker = pa_sprintf_malloc("type='signal',sender='org.bluez',interface='org.bluez.Headset',member='SpeakerGainChanged',path='%s'", u->path);
3063             mike = pa_sprintf_malloc("type='signal',sender='org.bluez',interface='org.bluez.Headset',member='MicrophoneGainChanged',path='%s'", u->path);
3064
3065             pa_dbus_remove_matches(pa_dbus_connection_get(u->connection), speaker, mike,
3066                 "type='signal',sender='org.bluez',interface='org.bluez.MediaTransport',member='PropertyChanged'",
3067                 "type='signal',sender='org.bluez',interface='org.bluez.HandsfreeGateway',member='PropertyChanged'",
3068                 NULL);
3069
3070             pa_xfree(speaker);
3071             pa_xfree(mike);
3072         }
3073
3074         if (u->filter_added)
3075             dbus_connection_remove_filter(pa_dbus_connection_get(u->connection), filter_cb, u);
3076
3077         pa_dbus_connection_unref(u->connection);
3078     }
3079
3080     if (u->msg)
3081         pa_xfree(u->msg);
3082
3083     if (u->card)
3084         pa_card_free(u->card);
3085
3086     if (u->read_smoother)
3087         pa_smoother_free(u->read_smoother);
3088
3089     shutdown_bt(u);
3090
3091     if (u->a2dp.buffer)
3092         pa_xfree(u->a2dp.buffer);
3093
3094     sbc_finish(&u->a2dp.sbc);
3095
3096     if (u->modargs)
3097         pa_modargs_free(u->modargs);
3098
3099     pa_xfree(u->address);
3100     pa_xfree(u->path);
3101
3102     if (u->transport) {
3103         bt_transport_release(u);
3104         pa_xfree(u->transport);
3105     }
3106
3107     if (u->discovery)
3108         pa_bluetooth_discovery_unref(u->discovery);
3109
3110     pa_xfree(u);
3111 }