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