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