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