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     const char *accesstype = "rw";
 862     const pa_bluetooth_transport *t;
 863
 864     /* Ignore if already released */
 865     if (!u->accesstype)
 866         return;
 867
 868     pa_log_debug("Releasing transport %s", u->transport);
 869
 870     t = pa_bluetooth_discovery_get_transport(u->discovery, u->transport);
 871     if (t)
 872         pa_bluetooth_transport_release(t, accesstype);
 873
 874     pa_xfree(u->accesstype);
 875     u->accesstype = NULL;
 876
 877     if (u->rtpoll_item) {
 878         pa_rtpoll_item_free(u->rtpoll_item);
 879         u->rtpoll_item = NULL;
 880     }
 881
 882     if (u->stream_fd >= 0) {
 883         pa_close(u->stream_fd);
 884         u->stream_fd = -1;
 885     }
 886
 887     if (u->read_smoother) {
 888         pa_smoother_free(u->read_smoother);
 889         u->read_smoother = NULL;
 890     }
 891 }
 892
 893 static int bt_transport_acquire(struct userdata *u, pa_bool_t start) {
 894     const char *accesstype = "rw";
 895     const pa_bluetooth_transport *t;
 896
 897     if (u->accesstype) {
 898         if (start)
 899             goto done;
 900         return 0;
 901     }
 902
 903     pa_log_debug("Acquiring transport %s", u->transport);
 904
 905     t = pa_bluetooth_discovery_get_transport(u->discovery, u->transport);
 906     if (!t) {
 907         pa_log("Transport %s no longer available", u->transport);
 908         pa_xfree(u->transport);
 909         u->transport = NULL;
 910         return -1;
 911     }
 912
 913     /* FIXME: Handle in/out MTU properly when unix socket is not longer supported */
 914     u->stream_fd = pa_bluetooth_transport_acquire(t, accesstype, NULL, &u->link_mtu);
 915     if (u->stream_fd < 0)
 916         return -1;
 917
 918     u->accesstype = pa_xstrdup(accesstype);
 919     pa_log_info("Transport %s acquired: fd %d", u->transport, u->stream_fd);
 920
 921     if (!start)
 922         return 0;
 923
 924 done:
 925     pa_log_info("Transport %s resuming", u->transport);
 926     return setup_stream(u);
 927 }
 928
 929 /* Run from IO thread */
 930 static int sink_process_msg(pa_msgobject *o, int code, void *data, int64_t offset, pa_memchunk *chunk) {
 931     struct userdata *u = PA_SINK(o)->userdata;
 932     pa_bool_t failed = FALSE;
 933     int r;
 934
 935     pa_assert(u->sink == PA_SINK(o));
 936
 937     switch (code) {
 938
 939         case PA_SINK_MESSAGE_SET_STATE:
 940
 941             switch ((pa_sink_state_t) PA_PTR_TO_UINT(data)) {
 942
 943                 case PA_SINK_SUSPENDED:
 944                     pa_assert(PA_SINK_IS_OPENED(u->sink->thread_info.state));
 945
 946                     /* Stop the device if the source is suspended as well */
 947                     if (!u->source || u->source->state == PA_SOURCE_SUSPENDED) {
 948                         /* We deliberately ignore whether stopping
 949                          * actually worked. Since the stream_fd is
 950                          * closed it doesn't really matter */
 951                         if (u->transport)
 952                             bt_transport_release(u);
 953                         else
 954                             stop_stream_fd(u);
 955                     }
 956
 957                     break;
 958
 959                 case PA_SINK_IDLE:
 960                 case PA_SINK_RUNNING:
 961                     if (u->sink->thread_info.state != PA_SINK_SUSPENDED)
 962                         break;
 963
 964                     /* Resume the device if the source was suspended as well */
 965                     if (!u->source || u->source->state == PA_SOURCE_SUSPENDED) {
 966                         if (u->transport) {
 967                             if (bt_transport_acquire(u, TRUE) < 0)
 968                                 failed = TRUE;
 969                         } else if (start_stream_fd(u) < 0)
 970                             failed = TRUE;
 971                     }
 972                     break;
 973
 974                 case PA_SINK_UNLINKED:
 975                 case PA_SINK_INIT:
 976                 case PA_SINK_INVALID_STATE:
 977                     ;
 978             }
 979             break;
 980
 981         case PA_SINK_MESSAGE_GET_LATENCY: {
 982
 983             if (u->read_smoother) {
 984                 pa_usec_t wi, ri;
 985
 986                 ri = pa_smoother_get(u->read_smoother, pa_rtclock_now());
 987                 wi = pa_bytes_to_usec(u->write_index + u->block_size, &u->sample_spec);
 988
 989                 *((pa_usec_t*) data) = wi > ri ? wi - ri : 0;
 990             } else {
 991                 pa_usec_t ri, wi;
 992
 993                 ri = pa_rtclock_now() - u->started_at;
 994                 wi = pa_bytes_to_usec(u->write_index, &u->sample_spec);
 995
 996                 *((pa_usec_t*) data) = wi > ri ? wi - ri : 0;
 997             }
 998
 999             *((pa_usec_t*) data) += u->sink->thread_info.fixed_latency;
1000             return 0;
1001         }
1002     }
1003
1004     r = pa_sink_process_msg(o, code, data, offset, chunk);
1005
1006     return (r < 0 || !failed) ? r : -1;
1007 }
1008
1009 /* Run from IO thread */
1010 static int source_process_msg(pa_msgobject *o, int code, void *data, int64_t offset, pa_memchunk *chunk) {
1011     struct userdata *u = PA_SOURCE(o)->userdata;
1012     pa_bool_t failed = FALSE;
1013     int r;
1014
1015     pa_assert(u->source == PA_SOURCE(o));
1016
1017     switch (code) {
1018
1019         case PA_SOURCE_MESSAGE_SET_STATE:
1020
1021             switch ((pa_source_state_t) PA_PTR_TO_UINT(data)) {
1022
1023                 case PA_SOURCE_SUSPENDED:
1024                     pa_assert(PA_SOURCE_IS_OPENED(u->source->thread_info.state));
1025
1026                     /* Stop the device if the sink is suspended as well */
1027                     if (!u->sink || u->sink->state == PA_SINK_SUSPENDED) {
1028                         if (u->transport)
1029                             bt_transport_release(u);
1030                         else
1031                             stop_stream_fd(u);
1032                     }
1033
1034                     if (u->read_smoother)
1035                         pa_smoother_pause(u->read_smoother, pa_rtclock_now());
1036                     break;
1037
1038                 case PA_SOURCE_IDLE:
1039                 case PA_SOURCE_RUNNING:
1040                     if (u->source->thread_info.state != PA_SOURCE_SUSPENDED)
1041                         break;
1042
1043                     /* Resume the device if the sink was suspended as well */
1044                     if (!u->sink || u->sink->thread_info.state == PA_SINK_SUSPENDED) {
1045                         if (u->transport) {
1046                             if (bt_transport_acquire(u, TRUE) < 0)
1047                             failed = TRUE;
1048                         } else if (start_stream_fd(u) < 0)
1049                             failed = TRUE;
1050                     }
1051                     /* We don't resume the smoother here. Instead we
1052                      * wait until the first packet arrives */
1053                     break;
1054
1055                 case PA_SOURCE_UNLINKED:
1056                 case PA_SOURCE_INIT:
1057                 case PA_SOURCE_INVALID_STATE:
1058                     ;
1059             }
1060             break;
1061
1062         case PA_SOURCE_MESSAGE_GET_LATENCY: {
1063             pa_usec_t wi, ri;
1064
1065             if (u->read_smoother) {
1066                 wi = pa_smoother_get(u->read_smoother, pa_rtclock_now());
1067                 ri = pa_bytes_to_usec(u->read_index, &u->sample_spec);
1068
1069                 *((pa_usec_t*) data) = (wi > ri ? wi - ri : 0) + u->source->thread_info.fixed_latency;
1070             } else
1071                 *((pa_usec_t*) data) = 0;
1072
1073             return 0;
1074         }
1075
1076     }
1077
1078     r = pa_source_process_msg(o, code, data, offset, chunk);
1079
1080     return (r < 0 || !failed) ? r : -1;
1081 }
1082
1083 /* Run from IO thread */
1084 static int hsp_process_render(struct userdata *u) {
1085     int ret = 0;
1086
1087     pa_assert(u);
1088     pa_assert(u->profile == PROFILE_HSP || u->profile == PROFILE_HFGW);
1089     pa_assert(u->sink);
1090
1091     /* First, render some data */
1092     if (!u->write_memchunk.memblock)
1093         pa_sink_render_full(u->sink, u->block_size, &u->write_memchunk);
1094
1095     pa_assert(u->write_memchunk.length == u->block_size);
1096
1097     for (;;) {
1098         ssize_t l;
1099         const void *p;
1100
1101         /* Now write that data to the socket. The socket is of type
1102          * SEQPACKET, and we generated the data of the MTU size, so this
1103          * should just work. */
1104
1105         p = (const uint8_t*) pa_memblock_acquire(u->write_memchunk.memblock) + u->write_memchunk.index;
1106         l = pa_write(u->stream_fd, p, u->write_memchunk.length, &u->stream_write_type);
1107         pa_memblock_release(u->write_memchunk.memblock);
1108
1109         pa_assert(l != 0);
1110
1111         if (l < 0) {
1112
1113             if (errno == EINTR)
1114                 /* Retry right away if we got interrupted */
1115                 continue;
1116
1117             else if (errno == EAGAIN)
1118                 /* Hmm, apparently the socket was not writable, give up for now */
1119                 break;
1120
1121             pa_log_error("Failed to write data to SCO socket: %s", pa_cstrerror(errno));
1122             ret = -1;
1123             break;
1124         }
1125
1126         pa_assert((size_t) l <= u->write_memchunk.length);
1127
1128         if ((size_t) l != u->write_memchunk.length) {
1129             pa_log_error("Wrote memory block to socket only partially! %llu written, wanted to write %llu.",
1130                         (unsigned long long) l,
1131                         (unsigned long long) u->write_memchunk.length);
1132             ret = -1;
1133             break;
1134         }
1135
1136         u->write_index += (uint64_t) u->write_memchunk.length;
1137         pa_memblock_unref(u->write_memchunk.memblock);
1138         pa_memchunk_reset(&u->write_memchunk);
1139
1140         ret = 1;
1141         break;
1142     }
1143
1144     return ret;
1145 }
1146
1147 /* Run from IO thread */
1148 static int hsp_process_push(struct userdata *u) {
1149     int ret = 0;
1150     pa_memchunk memchunk;
1151
1152     pa_assert(u);
1153     pa_assert(u->profile == PROFILE_HSP || u->profile == PROFILE_HFGW);
1154     pa_assert(u->source);
1155     pa_assert(u->read_smoother);
1156
1157     memchunk.memblock = pa_memblock_new(u->core->mempool, u->block_size);
1158     memchunk.index = memchunk.length = 0;
1159
1160     for (;;) {
1161         ssize_t l;
1162         void *p;
1163         struct msghdr m;
1164         struct cmsghdr *cm;
1165         uint8_t aux[1024];
1166         struct iovec iov;
1167         pa_bool_t found_tstamp = FALSE;
1168         pa_usec_t tstamp;
1169
1170         memset(&m, 0, sizeof(m));
1171         memset(&aux, 0, sizeof(aux));
1172         memset(&iov, 0, sizeof(iov));
1173
1174         m.msg_iov = &iov;
1175         m.msg_iovlen = 1;
1176         m.msg_control = aux;
1177         m.msg_controllen = sizeof(aux);
1178
1179         p = pa_memblock_acquire(memchunk.memblock);
1180         iov.iov_base = p;
1181         iov.iov_len = pa_memblock_get_length(memchunk.memblock);
1182         l = recvmsg(u->stream_fd, &m, 0);
1183         pa_memblock_release(memchunk.memblock);
1184
1185         if (l <= 0) {
1186
1187             if (l < 0 && errno == EINTR)
1188                 /* Retry right away if we got interrupted */
1189                 continue;
1190
1191             else if (l < 0 && errno == EAGAIN)
1192                 /* Hmm, apparently the socket was not readable, give up for now. */
1193                 break;
1194
1195             pa_log_error("Failed to read data from SCO socket: %s", l < 0 ? pa_cstrerror(errno) : "EOF");
1196             ret = -1;
1197             break;
1198         }
1199
1200         pa_assert((size_t) l <= pa_memblock_get_length(memchunk.memblock));
1201
1202         memchunk.length = (size_t) l;
1203         u->read_index += (uint64_t) l;
1204
1205         for (cm = CMSG_FIRSTHDR(&m); cm; cm = CMSG_NXTHDR(&m, cm))
1206             if (cm->cmsg_level == SOL_SOCKET && cm->cmsg_type == SO_TIMESTAMP) {
1207                 struct timeval *tv = (struct timeval*) CMSG_DATA(cm);
1208                 pa_rtclock_from_wallclock(tv);
1209                 tstamp = pa_timeval_load(tv);
1210                 found_tstamp = TRUE;
1211                 break;
1212             }
1213
1214         if (!found_tstamp) {
1215             pa_log_warn("Couldn't find SO_TIMESTAMP data in auxiliary recvmsg() data!");
1216             tstamp = pa_rtclock_now();
1217         }
1218
1219         pa_smoother_put(u->read_smoother, tstamp, pa_bytes_to_usec(u->read_index, &u->sample_spec));
1220         pa_smoother_resume(u->read_smoother, tstamp, TRUE);
1221
1222         pa_source_post(u->source, &memchunk);
1223
1224         ret = 1;
1225         break;
1226     }
1227
1228     pa_memblock_unref(memchunk.memblock);
1229
1230     return ret;
1231 }
1232
1233 /* Run from IO thread */
1234 static void a2dp_prepare_buffer(struct userdata *u) {
1235     pa_assert(u);
1236
1237     if (u->a2dp.buffer_size >= u->link_mtu)
1238         return;
1239
1240     u->a2dp.buffer_size = 2 * u->link_mtu;
1241     pa_xfree(u->a2dp.buffer);
1242     u->a2dp.buffer = pa_xmalloc(u->a2dp.buffer_size);
1243 }
1244
1245 /* Run from IO thread */
1246 static int a2dp_process_render(struct userdata *u) {
1247     struct a2dp_info *a2dp;
1248     struct rtp_header *header;
1249     struct rtp_payload *payload;
1250     size_t nbytes;
1251     void *d;
1252     const void *p;
1253     size_t to_write, to_encode;
1254     unsigned frame_count;
1255     int ret = 0;
1256
1257     pa_assert(u);
1258     pa_assert(u->profile == PROFILE_A2DP);
1259     pa_assert(u->sink);
1260
1261     /* First, render some data */
1262     if (!u->write_memchunk.memblock)
1263         pa_sink_render_full(u->sink, u->block_size, &u->write_memchunk);
1264
1265     pa_assert(u->write_memchunk.length == u->block_size);
1266
1267     a2dp_prepare_buffer(u);
1268
1269     a2dp = &u->a2dp;
1270     header = a2dp->buffer;
1271     payload = (struct rtp_payload*) ((uint8_t*) a2dp->buffer + sizeof(*header));
1272
1273     frame_count = 0;
1274
1275     /* Try to create a packet of the full MTU */
1276
1277     p = (const uint8_t*) pa_memblock_acquire(u->write_memchunk.memblock) + u->write_memchunk.index;
1278     to_encode = u->write_memchunk.length;
1279
1280     d = (uint8_t*) a2dp->buffer + sizeof(*header) + sizeof(*payload);
1281     to_write = a2dp->buffer_size - sizeof(*header) - sizeof(*payload);
1282
1283     while (PA_LIKELY(to_encode > 0 && to_write > 0)) {
1284         size_t written;
1285         ssize_t encoded;
1286
1287         encoded = sbc_encode(&a2dp->sbc,
1288                              p, to_encode,
1289                              d, to_write,
1290                              &written);
1291
1292         if (PA_UNLIKELY(encoded <= 0)) {
1293             pa_log_error("SBC encoding error (%li)", (long) encoded);
1294             pa_memblock_release(u->write_memchunk.memblock);
1295             return -1;
1296         }
1297
1298 /*         pa_log_debug("SBC: encoded: %lu; written: %lu", (unsigned long) encoded, (unsigned long) written); */
1299 /*         pa_log_debug("SBC: codesize: %lu; frame_length: %lu", (unsigned long) a2dp->codesize, (unsigned long) a2dp->frame_length); */
1300
1301         pa_assert_fp((size_t) encoded <= to_encode);
1302         pa_assert_fp((size_t) encoded == a2dp->codesize);
1303
1304         pa_assert_fp((size_t) written <= to_write);
1305         pa_assert_fp((size_t) written == a2dp->frame_length);
1306
1307         p = (const uint8_t*) p + encoded;
1308         to_encode -= encoded;
1309
1310         d = (uint8_t*) d + written;
1311         to_write -= written;
1312
1313         frame_count++;
1314     }
1315
1316     pa_memblock_release(u->write_memchunk.memblock);
1317
1318     pa_assert(to_encode == 0);
1319
1320     PA_ONCE_BEGIN {
1321         pa_log_debug("Using SBC encoder implementation: %s", pa_strnull(sbc_get_implementation_info(&a2dp->sbc)));
1322     } PA_ONCE_END;
1323
1324     /* write it to the fifo */
1325     memset(a2dp->buffer, 0, sizeof(*header) + sizeof(*payload));
1326     header->v = 2;
1327     header->pt = 1;
1328     header->sequence_number = htons(a2dp->seq_num++);
1329     header->timestamp = htonl(u->write_index / pa_frame_size(&u->sample_spec));
1330     header->ssrc = htonl(1);
1331     payload->frame_count = frame_count;
1332
1333     nbytes = (uint8_t*) d - (uint8_t*) a2dp->buffer;
1334
1335     for (;;) {
1336         ssize_t l;
1337
1338         l = pa_write(u->stream_fd, a2dp->buffer, nbytes, &u->stream_write_type);
1339
1340         pa_assert(l != 0);
1341
1342         if (l < 0) {
1343
1344             if (errno == EINTR)
1345                 /* Retry right away if we got interrupted */
1346                 continue;
1347
1348             else if (errno == EAGAIN)
1349                 /* Hmm, apparently the socket was not writable, give up for now */
1350                 break;
1351
1352             pa_log_error("Failed to write data to socket: %s", pa_cstrerror(errno));
1353             ret  = -1;
1354             break;
1355         }
1356
1357         pa_assert((size_t) l <= nbytes);
1358
1359         if ((size_t) l != nbytes) {
1360             pa_log_warn("Wrote memory block to socket only partially! %llu written, wanted to write %llu.",
1361                         (unsigned long long) l,
1362                         (unsigned long long) nbytes);
1363             ret = -1;
1364             break;
1365         }
1366
1367         u->write_index += (uint64_t) u->write_memchunk.length;
1368         pa_memblock_unref(u->write_memchunk.memblock);
1369         pa_memchunk_reset(&u->write_memchunk);
1370
1371         ret = 1;
1372
1373         break;
1374     }
1375
1376     return ret;
1377 }
1378
1379 static int a2dp_process_push(struct userdata *u) {
1380     int ret = 0;
1381     pa_memchunk memchunk;
1382
1383     pa_assert(u);
1384     pa_assert(u->profile == PROFILE_A2DP_SOURCE);
1385     pa_assert(u->source);
1386     pa_assert(u->read_smoother);
1387
1388     memchunk.memblock = pa_memblock_new(u->core->mempool, u->block_size);
1389     memchunk.index = memchunk.length = 0;
1390
1391     for (;;) {
1392         pa_bool_t found_tstamp = FALSE;
1393         pa_usec_t tstamp;
1394         struct a2dp_info *a2dp;
1395         struct rtp_header *header;
1396         struct rtp_payload *payload;
1397         const void *p;
1398         void *d;
1399         ssize_t l;
1400         size_t to_write, to_decode;
1401         unsigned frame_count;
1402
1403         a2dp_prepare_buffer(u);
1404
1405         a2dp = &u->a2dp;
1406         header = a2dp->buffer;
1407         payload = (struct rtp_payload*) ((uint8_t*) a2dp->buffer + sizeof(*header));
1408
1409         l = pa_read(u->stream_fd, a2dp->buffer, a2dp->buffer_size, &u->stream_write_type);
1410
1411         if (l <= 0) {
1412
1413             if (l < 0 && errno == EINTR)
1414                 /* Retry right away if we got interrupted */
1415                 continue;
1416
1417             else if (l < 0 && errno == EAGAIN)
1418                 /* Hmm, apparently the socket was not readable, give up for now. */
1419                 break;
1420
1421             pa_log_error("Failed to read data from socket: %s", l < 0 ? pa_cstrerror(errno) : "EOF");
1422             ret = -1;
1423             break;
1424         }
1425
1426         pa_assert((size_t) l <= a2dp->buffer_size);
1427
1428         u->read_index += (uint64_t) l;
1429
1430         /* TODO: get timestamp from rtp */
1431         if (!found_tstamp) {
1432             /* pa_log_warn("Couldn't find SO_TIMESTAMP data in auxiliary recvmsg() data!"); */
1433             tstamp = pa_rtclock_now();
1434         }
1435
1436         pa_smoother_put(u->read_smoother, tstamp, pa_bytes_to_usec(u->read_index, &u->sample_spec));
1437         pa_smoother_resume(u->read_smoother, tstamp, TRUE);
1438
1439         p = (uint8_t*) a2dp->buffer + sizeof(*header) + sizeof(*payload);
1440         to_decode = l - sizeof(*header) - sizeof(*payload);
1441
1442         d = pa_memblock_acquire(memchunk.memblock);
1443         to_write = memchunk.length = pa_memblock_get_length(memchunk.memblock);
1444
1445         while (PA_LIKELY(to_decode > 0 && to_write > 0)) {
1446             size_t written;
1447             ssize_t decoded;
1448
1449             decoded = sbc_decode(&a2dp->sbc,
1450                                  p, to_decode,
1451                                  d, to_write,
1452                                  &written);
1453
1454             if (PA_UNLIKELY(decoded <= 0)) {
1455                 pa_log_error("SBC decoding error (%li)", (long) decoded);
1456                 pa_memblock_release(memchunk.memblock);
1457                 pa_memblock_unref(memchunk.memblock);
1458                 return -1;
1459             }
1460
1461 /*             pa_log_debug("SBC: decoded: %lu; written: %lu", (unsigned long) decoded, (unsigned long) written); */
1462 /*             pa_log_debug("SBC: frame_length: %lu; codesize: %lu", (unsigned long) a2dp->frame_length, (unsigned long) a2dp->codesize); */
1463
1464             pa_assert_fp((size_t) decoded <= to_decode);
1465             pa_assert_fp((size_t) decoded == a2dp->frame_length);
1466
1467             pa_assert_fp((size_t) written <= to_write);
1468             pa_assert_fp((size_t) written == a2dp->codesize);
1469
1470             p = (const uint8_t*) p + decoded;
1471             to_decode -= decoded;
1472
1473             d = (uint8_t*) d + written;
1474             to_write -= written;
1475
1476             frame_count++;
1477         }
1478
1479         pa_memblock_release(memchunk.memblock);
1480
1481         pa_source_post(u->source, &memchunk);
1482
1483         ret = 1;
1484         break;
1485     }
1486
1487     pa_memblock_unref(memchunk.memblock);
1488
1489     return ret;
1490 }
1491
1492 static void thread_func(void *userdata) {
1493     struct userdata *u = userdata;
1494     unsigned do_write = 0;
1495     pa_bool_t writable = FALSE;
1496
1497     pa_assert(u);
1498
1499     pa_log_debug("IO Thread starting up");
1500
1501     if (u->core->realtime_scheduling)
1502         pa_make_realtime(u->core->realtime_priority);
1503
1504     pa_thread_mq_install(&u->thread_mq);
1505
1506     if (u->transport) {
1507         if (bt_transport_acquire(u, TRUE) < 0)
1508             goto fail;
1509     } else if (start_stream_fd(u) < 0)
1510         goto fail;
1511
1512     for (;;) {
1513         struct pollfd *pollfd;
1514         int ret;
1515         pa_bool_t disable_timer = TRUE;
1516
1517         pollfd = u->rtpoll_item ? pa_rtpoll_item_get_pollfd(u->rtpoll_item, NULL) : NULL;
1518
1519         if (u->source && PA_SOURCE_IS_LINKED(u->source->thread_info.state)) {
1520
1521             /* We should send two blocks to the device before we expect
1522              * a response. */
1523
1524             if (u->write_index == 0 && u->read_index <= 0)
1525                 do_write = 2;
1526
1527             if (pollfd && (pollfd->revents & POLLIN)) {
1528                 int n_read;
1529
1530                 if (u->profile == PROFILE_HSP || u->profile == PROFILE_HFGW)
1531                     n_read = hsp_process_push(u);
1532                 else
1533                     n_read = a2dp_process_push(u);
1534
1535                 if (n_read < 0)
1536                     goto fail;
1537
1538                 /* We just read something, so we are supposed to write something, too */
1539                 do_write += n_read;
1540             }
1541         }
1542
1543         if (u->sink && PA_SINK_IS_LINKED(u->sink->thread_info.state)) {
1544
1545             if (u->sink->thread_info.rewind_requested)
1546                 pa_sink_process_rewind(u->sink, 0);
1547
1548             if (pollfd) {
1549                 if (pollfd->revents & POLLOUT)
1550                     writable = TRUE;
1551
1552                 if ((!u->source || !PA_SOURCE_IS_LINKED(u->source->thread_info.state)) && do_write <= 0 && writable) {
1553                     pa_usec_t time_passed;
1554                     pa_usec_t audio_sent;
1555
1556                     /* Hmm, there is no input stream we could synchronize
1557                      * to. So let's do things by time */
1558
1559                     time_passed = pa_rtclock_now() - u->started_at;
1560                     audio_sent = pa_bytes_to_usec(u->write_index, &u->sample_spec);
1561
1562                     if (audio_sent <= time_passed) {
1563                         pa_usec_t audio_to_send = time_passed - audio_sent;
1564
1565                         /* Never try to catch up for more than 100ms */
1566                         if (u->write_index > 0 && audio_to_send > MAX_PLAYBACK_CATCH_UP_USEC) {
1567                             pa_usec_t skip_usec;
1568                             uint64_t skip_bytes;
1569
1570                             skip_usec = audio_to_send - MAX_PLAYBACK_CATCH_UP_USEC;
1571                             skip_bytes = pa_usec_to_bytes(skip_usec, &u->sample_spec);
1572
1573                             if (skip_bytes > 0) {
1574                                 pa_memchunk tmp;
1575
1576                                 pa_log_warn("Skipping %llu us (= %llu bytes) in audio stream",
1577                                             (unsigned long long) skip_usec,
1578                                             (unsigned long long) skip_bytes);
1579
1580                                 pa_sink_render_full(u->sink, skip_bytes, &tmp);
1581                                 pa_memblock_unref(tmp.memblock);
1582                                 u->write_index += skip_bytes;
1583                             }
1584                         }
1585
1586                         do_write = 1;
1587                     }
1588                 }
1589
1590                 if (writable && do_write > 0) {
1591                     int n_written;
1592
1593                     if (u->write_index <= 0)
1594                         u->started_at = pa_rtclock_now();
1595
1596                     if (u->profile == PROFILE_A2DP) {
1597                         if ((n_written = a2dp_process_render(u)) < 0)
1598                             goto fail;
1599                     } else {
1600                         if ((n_written = hsp_process_render(u)) < 0)
1601                             goto fail;
1602                     }
1603
1604                     if (n_written == 0)
1605                         pa_log("Broken kernel: we got EAGAIN on write() after POLLOUT!");
1606
1607                     do_write -= n_written;
1608                     writable = FALSE;
1609                 }
1610
1611                 if ((!u->source || !PA_SOURCE_IS_LINKED(u->source->thread_info.state)) && do_write <= 0 && writable) {
1612                     pa_usec_t time_passed, next_write_at, sleep_for;
1613
1614                     /* Hmm, there is no input stream we could synchronize
1615                      * to. So let's estimate when we need to wake up the latest */
1616
1617                     time_passed = pa_rtclock_now() - u->started_at;
1618                     next_write_at = pa_bytes_to_usec(u->write_index, &u->sample_spec);
1619                     sleep_for = time_passed < next_write_at ? next_write_at - time_passed : 0;
1620
1621 /*                 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); */
1622
1623                     pa_rtpoll_set_timer_relative(u->rtpoll, sleep_for);
1624                     disable_timer = FALSE;
1625                 }
1626             }
1627         }
1628
1629         if (disable_timer)
1630             pa_rtpoll_set_timer_disabled(u->rtpoll);
1631
1632         /* Hmm, nothing to do. Let's sleep */
1633         if (pollfd)
1634             pollfd->events = (short) (((u->sink && PA_SINK_IS_LINKED(u->sink->thread_info.state) && !writable) ? POLLOUT : 0) |
1635                                       (u->source && PA_SOURCE_IS_LINKED(u->source->thread_info.state) ? POLLIN : 0));
1636
1637         if ((ret = pa_rtpoll_run(u->rtpoll, TRUE)) < 0)
1638             goto fail;
1639
1640         if (ret == 0)
1641             goto finish;
1642
1643         pollfd = u->rtpoll_item ? pa_rtpoll_item_get_pollfd(u->rtpoll_item, NULL) : NULL;
1644
1645         if (pollfd && (pollfd->revents & ~(POLLOUT|POLLIN))) {
1646             pa_log_info("FD error: %s%s%s%s",
1647                         pollfd->revents & POLLERR ? "POLLERR " :"",
1648                         pollfd->revents & POLLHUP ? "POLLHUP " :"",
1649                         pollfd->revents & POLLPRI ? "POLLPRI " :"",
1650                         pollfd->revents & POLLNVAL ? "POLLNVAL " :"");
1651             goto fail;
1652         }
1653     }
1654
1655 fail:
1656     /* If this was no regular exit from the loop we have to continue processing messages until we receive PA_MESSAGE_SHUTDOWN */
1657     pa_log_debug("IO thread failed");
1658     pa_asyncmsgq_post(u->thread_mq.outq, PA_MSGOBJECT(u->core), PA_CORE_MESSAGE_UNLOAD_MODULE, u->module, 0, NULL, NULL);
1659     pa_asyncmsgq_wait_for(u->thread_mq.inq, PA_MESSAGE_SHUTDOWN);
1660
1661 finish:
1662     pa_log_debug("IO thread shutting down");
1663 }
1664
1665 /* Run from main thread */
1666 static DBusHandlerResult filter_cb(DBusConnection *bus, DBusMessage *m, void *userdata) {
1667     DBusError err;
1668     struct userdata *u;
1669
1670     pa_assert(bus);
1671     pa_assert(m);
1672     pa_assert_se(u = userdata);
1673
1674     dbus_error_init(&err);
1675
1676     pa_log_debug("dbus: interface=%s, path=%s, member=%s\n",
1677                  dbus_message_get_interface(m),
1678                  dbus_message_get_path(m),
1679                  dbus_message_get_member(m));
1680
1681     if (!dbus_message_has_path(m, u->path))
1682         goto fail;
1683
1684     if (dbus_message_is_signal(m, "org.bluez.Headset", "SpeakerGainChanged") ||
1685         dbus_message_is_signal(m, "org.bluez.Headset", "MicrophoneGainChanged")) {
1686
1687         dbus_uint16_t gain;
1688         pa_cvolume v;
1689
1690         if (!dbus_message_get_args(m, &err, DBUS_TYPE_UINT16, &gain, DBUS_TYPE_INVALID) || gain > 15) {
1691             pa_log("Failed to parse org.bluez.Headset.{Speaker|Microphone}GainChanged: %s", err.message);
1692             goto fail;
1693         }
1694
1695         if (u->profile == PROFILE_HSP) {
1696             if (u->sink && dbus_message_is_signal(m, "org.bluez.Headset", "SpeakerGainChanged")) {
1697
1698                 pa_cvolume_set(&v, u->sample_spec.channels, (pa_volume_t) (gain * PA_VOLUME_NORM / 15));
1699                 pa_sink_volume_changed(u->sink, &v);
1700
1701             } else if (u->source && dbus_message_is_signal(m, "org.bluez.Headset", "MicrophoneGainChanged")) {
1702
1703                 pa_cvolume_set(&v, u->sample_spec.channels, (pa_volume_t) (gain * PA_VOLUME_NORM / 15));
1704                 pa_source_volume_changed(u->source, &v);
1705             }
1706         }
1707     }
1708
1709 fail:
1710     dbus_error_free(&err);
1711
1712     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1713 }
1714
1715 /* Run from main thread */
1716 static void sink_set_volume_cb(pa_sink *s) {
1717     struct userdata *u = s->userdata;
1718     DBusMessage *m;
1719     dbus_uint16_t gain;
1720
1721     pa_assert(u);
1722
1723     if (u->profile != PROFILE_HSP)
1724         return;
1725
1726     gain = (pa_cvolume_max(&s->real_volume) * 15) / PA_VOLUME_NORM;
1727
1728     if (gain > 15)
1729         gain = 15;
1730
1731     pa_cvolume_set(&s->real_volume, u->sample_spec.channels, (pa_volume_t) (gain * PA_VOLUME_NORM / 15));
1732
1733     pa_assert_se(m = dbus_message_new_method_call("org.bluez", u->path, "org.bluez.Headset", "SetSpeakerGain"));
1734     pa_assert_se(dbus_message_append_args(m, DBUS_TYPE_UINT16, &gain, DBUS_TYPE_INVALID));
1735     pa_assert_se(dbus_connection_send(pa_dbus_connection_get(u->connection), m, NULL));
1736     dbus_message_unref(m);
1737 }
1738
1739 /* Run from main thread */
1740 static void source_set_volume_cb(pa_source *s) {
1741     struct userdata *u = s->userdata;
1742     DBusMessage *m;
1743     dbus_uint16_t gain;
1744
1745     pa_assert(u);
1746
1747     if (u->profile != PROFILE_HSP)
1748         return;
1749
1750     gain = (pa_cvolume_max(&s->volume) * 15) / PA_VOLUME_NORM;
1751
1752     if (gain > 15)
1753         gain = 15;
1754
1755     pa_cvolume_set(&s->volume, u->sample_spec.channels, (pa_volume_t) (gain * PA_VOLUME_NORM / 15));
1756
1757     pa_assert_se(m = dbus_message_new_method_call("org.bluez", u->path, "org.bluez.Headset", "SetMicrophoneGain"));
1758     pa_assert_se(dbus_message_append_args(m, DBUS_TYPE_UINT16, &gain, DBUS_TYPE_INVALID));
1759     pa_assert_se(dbus_connection_send(pa_dbus_connection_get(u->connection), m, NULL));
1760     dbus_message_unref(m);
1761 }
1762
1763 /* Run from main thread */
1764 static char *get_name(const char *type, pa_modargs *ma, const char *device_id, pa_bool_t *namereg_fail) {
1765     char *t;
1766     const char *n;
1767
1768     pa_assert(type);
1769     pa_assert(ma);
1770     pa_assert(device_id);
1771     pa_assert(namereg_fail);
1772
1773     t = pa_sprintf_malloc("%s_name", type);
1774     n = pa_modargs_get_value(ma, t, NULL);
1775     pa_xfree(t);
1776
1777     if (n) {
1778         *namereg_fail = TRUE;
1779         return pa_xstrdup(n);
1780     }
1781
1782     if ((n = pa_modargs_get_value(ma, "name", NULL)))
1783         *namereg_fail = TRUE;
1784     else {
1785         n = device_id;
1786         *namereg_fail = FALSE;
1787     }
1788
1789     return pa_sprintf_malloc("bluez_%s.%s", type, n);
1790 }
1791
1792 #ifdef NOKIA
1793
1794 static void sco_over_pcm_state_update(struct userdata *u) {
1795     pa_assert(u);
1796     pa_assert(USE_SCO_OVER_PCM(u));
1797
1798     if (PA_SINK_IS_OPENED(pa_sink_get_state(u->hsp.sco_sink)) ||
1799         PA_SOURCE_IS_OPENED(pa_source_get_state(u->hsp.sco_source))) {
1800
1801         if (u->service_fd >= 0)
1802             return;
1803
1804         init_bt(u);
1805
1806         pa_log_debug("Resuming SCO over PCM");
1807         if (init_profile(u) < 0)
1808             pa_log("Can't resume SCO over PCM");
1809
1810         if (u->transport)
1811             bt_transport_acquire(u, TRUE);
1812         else
1813             start_stream_fd(u);
1814     } else {
1815
1816         if (u->service_fd < 0)
1817             return;
1818
1819         if (u->transport)
1820             bt_transport_release(u);
1821         else
1822             stop_stream_fd(u);
1823
1824         pa_log_debug("Closing SCO over PCM");
1825         pa_close(u->service_fd);
1826         u->service_fd = -1;
1827     }
1828 }
1829
1830 static pa_hook_result_t sink_state_changed_cb(pa_core *c, pa_sink *s, struct userdata *u) {
1831     pa_assert(c);
1832     pa_sink_assert_ref(s);
1833     pa_assert(u);
1834
1835     if (s != u->hsp.sco_sink)
1836         return PA_HOOK_OK;
1837
1838     sco_over_pcm_state_update(u);
1839
1840     return PA_HOOK_OK;
1841 }
1842
1843 static pa_hook_result_t source_state_changed_cb(pa_core *c, pa_source *s, struct userdata *u) {
1844     pa_assert(c);
1845     pa_source_assert_ref(s);
1846     pa_assert(u);
1847
1848     if (s != u->hsp.sco_source)
1849         return PA_HOOK_OK;
1850
1851     sco_over_pcm_state_update(u);
1852
1853     return PA_HOOK_OK;
1854 }
1855
1856 #endif
1857
1858 /* Run from main thread */
1859 static int add_sink(struct userdata *u) {
1860
1861 #ifdef NOKIA
1862     if (USE_SCO_OVER_PCM(u)) {
1863         pa_proplist *p;
1864
1865         u->sink = u->hsp.sco_sink;
1866         p = pa_proplist_new();
1867         pa_proplist_sets(p, "bluetooth.protocol", "sco");
1868         pa_proplist_update(u->sink->proplist, PA_UPDATE_MERGE, p);
1869         pa_proplist_free(p);
1870
1871         if (!u->hsp.sink_state_changed_slot)
1872             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);
1873
1874     } else
1875 #endif
1876
1877     {
1878         pa_sink_new_data data;
1879         pa_bool_t b;
1880
1881         pa_sink_new_data_init(&data);
1882         data.driver = __FILE__;
1883         data.module = u->module;
1884         pa_sink_new_data_set_sample_spec(&data, &u->sample_spec);
1885         pa_proplist_sets(data.proplist, "bluetooth.protocol", u->profile == PROFILE_A2DP ? "a2dp" : "sco");
1886         if (u->profile == PROFILE_HSP)
1887             pa_proplist_sets(data.proplist, PA_PROP_DEVICE_INTENDED_ROLES, "phone");
1888         data.card = u->card;
1889         data.name = get_name("sink", u->modargs, u->address, &b);
1890         data.namereg_fail = b;
1891
1892         if (pa_modargs_get_proplist(u->modargs, "sink_properties", data.proplist, PA_UPDATE_REPLACE) < 0) {
1893             pa_log("Invalid properties");
1894             pa_sink_new_data_done(&data);
1895             return -1;
1896         }
1897
1898         u->sink = pa_sink_new(u->core, &data, PA_SINK_HARDWARE|PA_SINK_LATENCY | (u->profile == PROFILE_HSP ? PA_SINK_HW_VOLUME_CTRL : 0));
1899         pa_sink_new_data_done(&data);
1900
1901         if (!u->sink) {
1902             pa_log_error("Failed to create sink");
1903             return -1;
1904         }
1905
1906         u->sink->userdata = u;
1907         u->sink->parent.process_msg = sink_process_msg;
1908
1909         pa_sink_set_max_request(u->sink, u->block_size);
1910         pa_sink_set_fixed_latency(u->sink,
1911                                   (u->profile == PROFILE_A2DP ? FIXED_LATENCY_PLAYBACK_A2DP : FIXED_LATENCY_PLAYBACK_HSP) +
1912                                   pa_bytes_to_usec(u->block_size, &u->sample_spec));
1913     }
1914
1915     if (u->profile == PROFILE_HSP) {
1916         u->sink->set_volume = sink_set_volume_cb;
1917         u->sink->n_volume_steps = 16;
1918     }
1919
1920     return 0;
1921 }
1922
1923 /* Run from main thread */
1924 static int add_source(struct userdata *u) {
1925
1926 #ifdef NOKIA
1927     if (USE_SCO_OVER_PCM(u)) {
1928         u->source = u->hsp.sco_source;
1929         pa_proplist_sets(u->source->proplist, "bluetooth.protocol", "hsp");
1930
1931         if (!u->hsp.source_state_changed_slot)
1932             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);
1933
1934     } else
1935 #endif
1936
1937     {
1938         pa_source_new_data data;
1939         pa_bool_t b;
1940
1941         pa_source_new_data_init(&data);
1942         data.driver = __FILE__;
1943         data.module = u->module;
1944         pa_source_new_data_set_sample_spec(&data, &u->sample_spec);
1945         pa_proplist_sets(data.proplist, "bluetooth.protocol", u->profile == PROFILE_A2DP_SOURCE ? "a2dp_source" : "hsp");
1946         if ((u->profile == PROFILE_HSP) || (u->profile == PROFILE_HFGW))
1947             pa_proplist_sets(data.proplist, PA_PROP_DEVICE_INTENDED_ROLES, "phone");
1948         data.card = u->card;
1949         data.name = get_name("source", u->modargs, u->address, &b);
1950         data.namereg_fail = b;
1951
1952         if (pa_modargs_get_proplist(u->modargs, "source_properties", data.proplist, PA_UPDATE_REPLACE) < 0) {
1953             pa_log("Invalid properties");
1954             pa_source_new_data_done(&data);
1955             return -1;
1956         }
1957
1958         u->source = pa_source_new(u->core, &data, PA_SOURCE_HARDWARE|PA_SOURCE_LATENCY | (u->profile == PROFILE_HSP ? PA_SOURCE_HW_VOLUME_CTRL : 0));
1959         pa_source_new_data_done(&data);
1960
1961         if (!u->source) {
1962             pa_log_error("Failed to create source");
1963             return -1;
1964         }
1965
1966         u->source->userdata = u;
1967         u->source->parent.process_msg = source_process_msg;
1968
1969         pa_source_set_fixed_latency(u->source,
1970                                     (u->profile == PROFILE_A2DP_SOURCE ? FIXED_LATENCY_RECORD_A2DP : FIXED_LATENCY_RECORD_HSP) +
1971                                     pa_bytes_to_usec(u->block_size, &u->sample_spec));
1972     }
1973
1974     if (u->profile == PROFILE_HSP || u->profile == PROFILE_HFGW)
1975         pa_proplist_sets(u->source->proplist, "bluetooth.nrec", (u->hsp.pcm_capabilities.flags & BT_PCM_FLAG_NREC) ? "1" : "0");
1976
1977     if (u->profile == PROFILE_HSP) {
1978         u->source->set_volume = source_set_volume_cb;
1979         u->source->n_volume_steps = 16;
1980     }
1981
1982     return 0;
1983 }
1984
1985 /* Run from main thread */
1986 static void shutdown_bt(struct userdata *u) {
1987     pa_assert(u);
1988
1989     if (u->stream_fd >= 0) {
1990         pa_close(u->stream_fd);
1991         u->stream_fd = -1;
1992
1993         u->stream_write_type = 0;
1994     }
1995
1996     if (u->service_fd >= 0) {
1997         pa_close(u->service_fd);
1998         u->service_fd = -1;
1999         u->service_write_type = 0;
2000         u->service_read_type = 0;
2001     }
2002
2003     if (u->write_memchunk.memblock) {
2004         pa_memblock_unref(u->write_memchunk.memblock);
2005         pa_memchunk_reset(&u->write_memchunk);
2006     }
2007 }
2008
2009 static int bt_transport_config_a2dp(struct userdata *u) {
2010     const pa_bluetooth_transport *t;
2011     struct a2dp_info *a2dp = &u->a2dp;
2012     sbc_capabilities_raw_t *config;
2013
2014     t = pa_bluetooth_discovery_get_transport(u->discovery, u->transport);
2015     pa_assert(t);
2016
2017     config = (sbc_capabilities_raw_t *) t->config;
2018
2019     if (a2dp->sbc_initialized)
2020         sbc_reinit(&a2dp->sbc, 0);
2021     else
2022         sbc_init(&a2dp->sbc, 0);
2023     a2dp->sbc_initialized = TRUE;
2024
2025     switch (config->frequency) {
2026         case BT_SBC_SAMPLING_FREQ_16000:
2027             a2dp->sbc.frequency = SBC_FREQ_16000;
2028             break;
2029         case BT_SBC_SAMPLING_FREQ_32000:
2030             a2dp->sbc.frequency = SBC_FREQ_32000;
2031             break;
2032         case BT_SBC_SAMPLING_FREQ_44100:
2033             a2dp->sbc.frequency = SBC_FREQ_44100;
2034             break;
2035         case BT_SBC_SAMPLING_FREQ_48000:
2036             a2dp->sbc.frequency = SBC_FREQ_48000;
2037             break;
2038         default:
2039             pa_assert_not_reached();
2040     }
2041
2042     switch (config->channel_mode) {
2043         case BT_A2DP_CHANNEL_MODE_MONO:
2044             a2dp->sbc.mode = SBC_MODE_MONO;
2045             break;
2046         case BT_A2DP_CHANNEL_MODE_DUAL_CHANNEL:
2047             a2dp->sbc.mode = SBC_MODE_DUAL_CHANNEL;
2048             break;
2049         case BT_A2DP_CHANNEL_MODE_STEREO:
2050             a2dp->sbc.mode = SBC_MODE_STEREO;
2051             break;
2052         case BT_A2DP_CHANNEL_MODE_JOINT_STEREO:
2053             a2dp->sbc.mode = SBC_MODE_JOINT_STEREO;
2054             break;
2055         default:
2056             pa_assert_not_reached();
2057     }
2058
2059     switch (config->allocation_method) {
2060         case BT_A2DP_ALLOCATION_SNR:
2061             a2dp->sbc.allocation = SBC_AM_SNR;
2062             break;
2063         case BT_A2DP_ALLOCATION_LOUDNESS:
2064             a2dp->sbc.allocation = SBC_AM_LOUDNESS;
2065             break;
2066         default:
2067             pa_assert_not_reached();
2068     }
2069
2070     switch (config->subbands) {
2071         case BT_A2DP_SUBBANDS_4:
2072             a2dp->sbc.subbands = SBC_SB_4;
2073             break;
2074         case BT_A2DP_SUBBANDS_8:
2075             a2dp->sbc.subbands = SBC_SB_8;
2076             break;
2077         default:
2078             pa_assert_not_reached();
2079     }
2080
2081     switch (config->block_length) {
2082         case BT_A2DP_BLOCK_LENGTH_4:
2083             a2dp->sbc.blocks = SBC_BLK_4;
2084             break;
2085         case BT_A2DP_BLOCK_LENGTH_8:
2086             a2dp->sbc.blocks = SBC_BLK_8;
2087             break;
2088         case BT_A2DP_BLOCK_LENGTH_12:
2089             a2dp->sbc.blocks = SBC_BLK_12;
2090             break;
2091         case BT_A2DP_BLOCK_LENGTH_16:
2092             a2dp->sbc.blocks = SBC_BLK_16;
2093             break;
2094         default:
2095             pa_assert_not_reached();
2096     }
2097
2098     a2dp->sbc.bitpool = config->max_bitpool;
2099     a2dp->codesize = sbc_get_codesize(&a2dp->sbc);
2100     a2dp->frame_length = sbc_get_frame_length(&a2dp->sbc);
2101
2102     u->block_size =
2103         ((u->link_mtu - sizeof(struct rtp_header) - sizeof(struct rtp_payload))
2104         / a2dp->frame_length
2105         * a2dp->codesize);
2106
2107     pa_log_info("SBC parameters:\n\tallocation=%u\n\tsubbands=%u\n\tblocks=%u\n\tbitpool=%u\n",
2108                 a2dp->sbc.allocation, a2dp->sbc.subbands, a2dp->sbc.blocks, a2dp->sbc.bitpool);
2109
2110     return 0;
2111 }
2112
2113 static int bt_transport_config(struct userdata *u) {
2114     if (u->profile == PROFILE_HSP || u->profile == PROFILE_HFGW) {
2115         u->block_size = u->link_mtu;
2116         return 0;
2117     }
2118
2119     return bt_transport_config_a2dp(u);
2120 }
2121
2122 static int parse_transport_property(struct userdata *u, DBusMessageIter *i) {
2123     const char *key;
2124     DBusMessageIter variant_i;
2125
2126     pa_assert(u);
2127     pa_assert(i);
2128
2129     if (dbus_message_iter_get_arg_type(i) != DBUS_TYPE_STRING) {
2130         pa_log("Property name not a string.");
2131         return -1;
2132     }
2133
2134     dbus_message_iter_get_basic(i, &key);
2135
2136     if (!dbus_message_iter_next(i))  {
2137         pa_log("Property value missing");
2138         return -1;
2139     }
2140
2141     if (dbus_message_iter_get_arg_type(i) != DBUS_TYPE_VARIANT) {
2142         pa_log("Property value not a variant.");
2143         return -1;
2144     }
2145
2146     dbus_message_iter_recurse(i, &variant_i);
2147
2148     switch (dbus_message_iter_get_arg_type(&variant_i)) {
2149
2150         case DBUS_TYPE_UINT16: {
2151
2152             uint16_t value;
2153             dbus_message_iter_get_basic(&variant_i, &value);
2154
2155             if (pa_streq(key, "OMTU"))
2156                 u->link_mtu = value;
2157
2158             break;
2159         }
2160
2161     }
2162
2163     return 0;
2164 }
2165
2166 /* Run from main thread */
2167 static int bt_transport_open(struct userdata *u) {
2168     if (bt_transport_acquire(u, FALSE) < 0)
2169         return -1;
2170
2171     return bt_transport_config(u);
2172 }
2173
2174 /* Run from main thread */
2175 static int init_bt(struct userdata *u) {
2176     pa_assert(u);
2177
2178     shutdown_bt(u);
2179
2180     u->stream_write_type = 0;
2181     u->service_write_type = 0;
2182     u->service_read_type = 0;
2183
2184     if ((u->service_fd = bt_audio_service_open()) < 0) {
2185         pa_log_warn("Bluetooth audio service not available");
2186         return -1;
2187     }
2188
2189     pa_log_debug("Connected to the bluetooth audio service");
2190
2191     return 0;
2192 }
2193
2194 /* Run from main thread */
2195 static int setup_bt(struct userdata *u) {
2196     const pa_bluetooth_device *d;
2197     const pa_bluetooth_transport *t;
2198
2199     pa_assert(u);
2200
2201     if (!(d = pa_bluetooth_discovery_get_by_path(u->discovery, u->path))) {
2202         pa_log_error("Failed to get device object.");
2203         return -1;
2204     }
2205
2206     /* release transport if exist */
2207     if (u->transport) {
2208         bt_transport_release(u);
2209         pa_xfree(u->transport);
2210         u->transport = NULL;
2211     }
2212
2213     /* check if profile has a transport */
2214     t = pa_bluetooth_device_get_transport(d, u->profile);
2215     if (t) {
2216         u->transport = pa_xstrdup(t->path);
2217         return bt_transport_open(u);
2218     }
2219
2220     if (get_caps(u, 0) < 0)
2221         return -1;
2222
2223     pa_log_debug("Got device capabilities");
2224
2225     if (set_conf(u) < 0)
2226         return -1;
2227
2228     pa_log_debug("Connection to the device configured");
2229
2230 #ifdef NOKIA
2231     if (USE_SCO_OVER_PCM(u)) {
2232         pa_log_debug("Configured to use SCO over PCM");
2233         return 0;
2234     }
2235 #endif
2236
2237     pa_log_debug("Got the stream socket");
2238
2239     return 0;
2240 }
2241
2242 /* Run from main thread */
2243 static int init_profile(struct userdata *u) {
2244     int r = 0;
2245     pa_assert(u);
2246     pa_assert(u->profile != PROFILE_OFF);
2247
2248     if (setup_bt(u) < 0)
2249         return -1;
2250
2251     if (u->profile == PROFILE_A2DP ||
2252         u->profile == PROFILE_HSP ||
2253         u->profile == PROFILE_HFGW)
2254         if (add_sink(u) < 0)
2255             r = -1;
2256
2257     if (u->profile == PROFILE_HSP ||
2258         u->profile == PROFILE_A2DP_SOURCE ||
2259         u->profile == PROFILE_HFGW)
2260         if (add_source(u) < 0)
2261             r = -1;
2262
2263     return r;
2264 }
2265
2266 /* Run from main thread */
2267 static void stop_thread(struct userdata *u) {
2268     pa_assert(u);
2269
2270     if (u->thread) {
2271         pa_asyncmsgq_send(u->thread_mq.inq, NULL, PA_MESSAGE_SHUTDOWN, NULL, 0, NULL);
2272         pa_thread_free(u->thread);
2273         u->thread = NULL;
2274     }
2275
2276     if (u->rtpoll_item) {
2277         pa_rtpoll_item_free(u->rtpoll_item);
2278         u->rtpoll_item = NULL;
2279     }
2280
2281     if (u->hsp.sink_state_changed_slot) {
2282         pa_hook_slot_free(u->hsp.sink_state_changed_slot);
2283         u->hsp.sink_state_changed_slot = NULL;
2284     }
2285
2286     if (u->hsp.source_state_changed_slot) {
2287         pa_hook_slot_free(u->hsp.source_state_changed_slot);
2288         u->hsp.source_state_changed_slot = NULL;
2289     }
2290
2291     if (u->sink) {
2292         pa_sink_unref(u->sink);
2293         u->sink = NULL;
2294     }
2295
2296     if (u->source) {
2297         pa_source_unref(u->source);
2298         u->source = NULL;
2299     }
2300
2301     if (u->rtpoll) {
2302         pa_thread_mq_done(&u->thread_mq);
2303
2304         pa_rtpoll_free(u->rtpoll);
2305         u->rtpoll = NULL;
2306     }
2307
2308     if (u->read_smoother) {
2309         pa_smoother_free(u->read_smoother);
2310         u->read_smoother = NULL;
2311     }
2312 }
2313
2314 /* Run from main thread */
2315 static int start_thread(struct userdata *u) {
2316     pa_assert(u);
2317     pa_assert(!u->thread);
2318     pa_assert(!u->rtpoll);
2319     pa_assert(!u->rtpoll_item);
2320
2321     u->rtpoll = pa_rtpoll_new();
2322     pa_thread_mq_init(&u->thread_mq, u->core->mainloop, u->rtpoll);
2323
2324 #ifdef NOKIA
2325     if (USE_SCO_OVER_PCM(u)) {
2326         if (u->transport) {
2327             if (bt_transport_acquire(u, TRUE) < 0)
2328                 return -1;
2329         } else if (start_stream_fd(u) < 0)
2330             return -1;
2331
2332         pa_sink_ref(u->sink);
2333         pa_source_ref(u->source);
2334         /* FIXME: monitor stream_fd error */
2335         return 0;
2336     }
2337 #endif
2338
2339     if (!(u->thread = pa_thread_new("bluetooth", thread_func, u))) {
2340         pa_log_error("Failed to create IO thread");
2341         stop_thread(u);
2342         return -1;
2343     }
2344
2345     if (u->sink) {
2346         pa_sink_set_asyncmsgq(u->sink, u->thread_mq.inq);
2347         pa_sink_set_rtpoll(u->sink, u->rtpoll);
2348         pa_sink_put(u->sink);
2349
2350         if (u->sink->set_volume)
2351             u->sink->set_volume(u->sink);
2352     }
2353
2354     if (u->source) {
2355         pa_source_set_asyncmsgq(u->source, u->thread_mq.inq);
2356         pa_source_set_rtpoll(u->source, u->rtpoll);
2357         pa_source_put(u->source);
2358
2359         if (u->source->set_volume)
2360             u->source->set_volume(u->source);
2361     }
2362
2363     return 0;
2364 }
2365
2366 /* Run from main thread */
2367 static int card_set_profile(pa_card *c, pa_card_profile *new_profile) {
2368     struct userdata *u;
2369     enum profile *d;
2370     pa_queue *inputs = NULL, *outputs = NULL;
2371     const pa_bluetooth_device *device;
2372
2373     pa_assert(c);
2374     pa_assert(new_profile);
2375     pa_assert_se(u = c->userdata);
2376
2377     d = PA_CARD_PROFILE_DATA(new_profile);
2378
2379     if (!(device = pa_bluetooth_discovery_get_by_path(u->discovery, u->path))) {
2380         pa_log_error("Failed to get device object.");
2381         return -PA_ERR_IO;
2382     }
2383
2384     /* The state signal is sent by bluez, so it is racy to check
2385        strictly for CONNECTED, we should also accept STREAMING state
2386        as being good enough. However, if the profile is used
2387        concurrently (which is unlikely), ipc will fail later on, and
2388        module will be unloaded. */
2389     if (device->headset_state < PA_BT_AUDIO_STATE_CONNECTED && *d == PROFILE_HSP) {
2390         pa_log_warn("HSP is not connected, refused to switch profile");
2391         return -PA_ERR_IO;
2392     }
2393     else if (device->audio_sink_state < PA_BT_AUDIO_STATE_CONNECTED && *d == PROFILE_A2DP) {
2394         pa_log_warn("A2DP is not connected, refused to switch profile");
2395         return -PA_ERR_IO;
2396     }
2397     else if (device->hfgw_state <= PA_BT_AUDIO_STATE_CONNECTED && *d == PROFILE_HFGW) {
2398         pa_log_warn("HandsfreeGateway is not connected, refused to switch profile");
2399         return -PA_ERR_IO;
2400     }
2401
2402     if (u->sink) {
2403         inputs = pa_sink_move_all_start(u->sink, NULL);
2404 #ifdef NOKIA
2405         if (!USE_SCO_OVER_PCM(u))
2406 #endif
2407             pa_sink_unlink(u->sink);
2408     }
2409
2410     if (u->source) {
2411         outputs = pa_source_move_all_start(u->source, NULL);
2412 #ifdef NOKIA
2413         if (!USE_SCO_OVER_PCM(u))
2414 #endif
2415             pa_source_unlink(u->source);
2416     }
2417
2418     stop_thread(u);
2419     shutdown_bt(u);
2420
2421     u->profile = *d;
2422     u->sample_spec = u->requested_sample_spec;
2423
2424     init_bt(u);
2425
2426     if (u->profile != PROFILE_OFF)
2427         init_profile(u);
2428
2429     if (u->sink || u->source)
2430         start_thread(u);
2431
2432     if (inputs) {
2433         if (u->sink)
2434             pa_sink_move_all_finish(u->sink, inputs, FALSE);
2435         else
2436             pa_sink_move_all_fail(inputs);
2437     }
2438
2439     if (outputs) {
2440         if (u->source)
2441             pa_source_move_all_finish(u->source, outputs, FALSE);
2442         else
2443             pa_source_move_all_fail(outputs);
2444     }
2445
2446     return 0;
2447 }
2448
2449 /* Run from main thread */
2450 static int add_card(struct userdata *u, const pa_bluetooth_device *device) {
2451     pa_card_new_data data;
2452     pa_bool_t b;
2453     pa_card_profile *p;
2454     enum profile *d;
2455     const char *ff;
2456     char *n;
2457     const char *default_profile;
2458
2459     pa_assert(u);
2460     pa_assert(device);
2461
2462     pa_card_new_data_init(&data);
2463     data.driver = __FILE__;
2464     data.module = u->module;
2465
2466     n = pa_bluetooth_cleanup_name(device->name);
2467     pa_proplist_sets(data.proplist, PA_PROP_DEVICE_DESCRIPTION, n);
2468     pa_xfree(n);
2469     pa_proplist_sets(data.proplist, PA_PROP_DEVICE_STRING, device->address);
2470     pa_proplist_sets(data.proplist, PA_PROP_DEVICE_API, "bluez");
2471     pa_proplist_sets(data.proplist, PA_PROP_DEVICE_CLASS, "sound");
2472     pa_proplist_sets(data.proplist, PA_PROP_DEVICE_BUS, "bluetooth");
2473     if ((ff = pa_bluetooth_get_form_factor(device->class)))
2474         pa_proplist_sets(data.proplist, PA_PROP_DEVICE_FORM_FACTOR, ff);
2475     pa_proplist_sets(data.proplist, "bluez.path", device->path);
2476     pa_proplist_setf(data.proplist, "bluez.class", "0x%06x", (unsigned) device->class);
2477     pa_proplist_sets(data.proplist, "bluez.name", device->name);
2478     data.name = get_name("card", u->modargs, device->address, &b);
2479     data.namereg_fail = b;
2480
2481     if (pa_modargs_get_proplist(u->modargs, "card_properties", data.proplist, PA_UPDATE_REPLACE) < 0) {
2482         pa_log("Invalid properties");
2483         pa_card_new_data_done(&data);
2484         return -1;
2485     }
2486
2487     data.profiles = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
2488
2489     /* we base hsp/a2dp availability on UUIDs.
2490        Ideally, it would be based on "Connected" state, but
2491        we can't afford to wait for this information when
2492        we are loaded with profile="hsp", for instance */
2493     if (pa_bluetooth_uuid_has(device->uuids, A2DP_SINK_UUID)) {
2494         p = pa_card_profile_new("a2dp", _("High Fidelity Playback (A2DP)"), sizeof(enum profile));
2495         p->priority = 10;
2496         p->n_sinks = 1;
2497         p->n_sources = 0;
2498         p->max_sink_channels = 2;
2499         p->max_source_channels = 0;
2500
2501         d = PA_CARD_PROFILE_DATA(p);
2502         *d = PROFILE_A2DP;
2503
2504         pa_hashmap_put(data.profiles, p->name, p);
2505     }
2506
2507     if (pa_bluetooth_uuid_has(device->uuids, A2DP_SOURCE_UUID)) {
2508         p = pa_card_profile_new("a2dp_source", _("High Fidelity Capture (A2DP)"), sizeof(enum profile));
2509         p->priority = 10;
2510         p->n_sinks = 0;
2511         p->n_sources = 1;
2512         p->max_sink_channels = 0;
2513         p->max_source_channels = 2;
2514
2515         d = PA_CARD_PROFILE_DATA(p);
2516         *d = PROFILE_A2DP_SOURCE;
2517
2518         pa_hashmap_put(data.profiles, p->name, p);
2519     }
2520
2521     if (pa_bluetooth_uuid_has(device->uuids, HSP_HS_UUID) ||
2522         pa_bluetooth_uuid_has(device->uuids, HFP_HS_UUID)) {
2523         p = pa_card_profile_new("hsp", _("Telephony Duplex (HSP/HFP)"), sizeof(enum profile));
2524         p->priority = 20;
2525         p->n_sinks = 1;
2526         p->n_sources = 1;
2527         p->max_sink_channels = 1;
2528         p->max_source_channels = 1;
2529
2530         d = PA_CARD_PROFILE_DATA(p);
2531         *d = PROFILE_HSP;
2532
2533         pa_hashmap_put(data.profiles, p->name, p);
2534     }
2535
2536     if (pa_bluetooth_uuid_has(device->uuids, HFP_AG_UUID)) {
2537         p = pa_card_profile_new("hfgw", _("Handsfree Gateway"), sizeof(enum profile));
2538         p->priority = 20;
2539         p->n_sinks = 1;
2540         p->n_sources = 1;
2541         p->max_sink_channels = 1;
2542         p->max_source_channels = 1;
2543
2544         d = PA_CARD_PROFILE_DATA(p);
2545         *d = PROFILE_HFGW;
2546
2547         pa_hashmap_put(data.profiles, p->name, p);
2548     }
2549
2550     pa_assert(!pa_hashmap_isempty(data.profiles));
2551
2552     p = pa_card_profile_new("off", _("Off"), sizeof(enum profile));
2553     d = PA_CARD_PROFILE_DATA(p);
2554     *d = PROFILE_OFF;
2555     pa_hashmap_put(data.profiles, p->name, p);
2556
2557     if ((default_profile = pa_modargs_get_value(u->modargs, "profile", NULL))) {
2558         if (pa_hashmap_get(data.profiles, default_profile))
2559             pa_card_new_data_set_profile(&data, default_profile);
2560         else
2561             pa_log_warn("Profile '%s' not valid or not supported by device.", default_profile);
2562     }
2563
2564     u->card = pa_card_new(u->core, &data);
2565     pa_card_new_data_done(&data);
2566
2567     if (!u->card) {
2568         pa_log("Failed to allocate card.");
2569         return -1;
2570     }
2571
2572     u->card->userdata = u;
2573     u->card->set_profile = card_set_profile;
2574
2575     d = PA_CARD_PROFILE_DATA(u->card->active_profile);
2576
2577     if ((device->headset_state < PA_BT_AUDIO_STATE_CONNECTED && *d == PROFILE_HSP) ||
2578         (device->audio_sink_state < PA_BT_AUDIO_STATE_CONNECTED && *d == PROFILE_A2DP) ||
2579         (device->hfgw_state < PA_BT_AUDIO_STATE_CONNECTED && *d == PROFILE_HFGW)) {
2580         pa_log_warn("Default profile not connected, selecting off profile");
2581         u->card->active_profile = pa_hashmap_get(u->card->profiles, "off");
2582         u->card->save_profile = FALSE;
2583     }
2584
2585     d = PA_CARD_PROFILE_DATA(u->card->active_profile);
2586     u->profile = *d;
2587
2588     return 0;
2589 }
2590
2591 /* Run from main thread */
2592 static const pa_bluetooth_device* find_device(struct userdata *u, const char *address, const char *path) {
2593     const pa_bluetooth_device *d = NULL;
2594
2595     pa_assert(u);
2596
2597     if (!address && !path) {
2598         pa_log_error("Failed to get device address/path from module arguments.");
2599         return NULL;
2600     }
2601
2602     if (path) {
2603         if (!(d = pa_bluetooth_discovery_get_by_path(u->discovery, path))) {
2604             pa_log_error("%s is not a valid BlueZ audio device.", path);
2605             return NULL;
2606         }
2607
2608         if (address && !(pa_streq(d->address, address))) {
2609             pa_log_error("Passed path %s address %s != %s don't match.", path, d->address, address);
2610             return NULL;
2611         }
2612
2613     } else {
2614         if (!(d = pa_bluetooth_discovery_get_by_address(u->discovery, address))) {
2615             pa_log_error("%s is not known.", address);
2616             return NULL;
2617         }
2618     }
2619
2620     if (d) {
2621         u->address = pa_xstrdup(d->address);
2622         u->path = pa_xstrdup(d->path);
2623     }
2624
2625     return d;
2626 }
2627
2628 /* Run from main thread */
2629 static int setup_dbus(struct userdata *u) {
2630     DBusError err;
2631
2632     dbus_error_init(&err);
2633
2634     u->connection = pa_dbus_bus_get(u->core, DBUS_BUS_SYSTEM, &err);
2635
2636     if (dbus_error_is_set(&err) || !u->connection) {
2637         pa_log("Failed to get D-Bus connection: %s", err.message);
2638         dbus_error_free(&err);
2639         return -1;
2640     }
2641
2642     return 0;
2643 }
2644
2645 int pa__init(pa_module* m) {
2646     pa_modargs *ma;
2647     uint32_t channels;
2648     struct userdata *u;
2649     const char *address, *path;
2650     DBusError err;
2651     char *mike, *speaker;
2652     const pa_bluetooth_device *device;
2653
2654     pa_assert(m);
2655
2656     dbus_error_init(&err);
2657
2658     if (!(ma = pa_modargs_new(m->argument, valid_modargs))) {
2659         pa_log_error("Failed to parse module arguments");
2660         goto fail;
2661     }
2662
2663     m->userdata = u = pa_xnew0(struct userdata, 1);
2664     u->module = m;
2665     u->core = m->core;
2666     u->service_fd = -1;
2667     u->stream_fd = -1;
2668     u->sample_spec = m->core->default_sample_spec;
2669     u->modargs = ma;
2670
2671 #ifdef NOKIA
2672     if (pa_modargs_get_value(ma, "sco_sink", NULL) &&
2673         !(u->hsp.sco_sink = pa_namereg_get(m->core, pa_modargs_get_value(ma, "sco_sink", NULL), PA_NAMEREG_SINK))) {
2674         pa_log("SCO sink not found");
2675         goto fail;
2676     }
2677
2678     if (pa_modargs_get_value(ma, "sco_source", NULL) &&
2679         !(u->hsp.sco_source = pa_namereg_get(m->core, pa_modargs_get_value(ma, "sco_source", NULL), PA_NAMEREG_SOURCE))) {
2680         pa_log("SCO source not found");
2681         goto fail;
2682     }
2683 #endif
2684
2685     if (pa_modargs_get_value_u32(ma, "rate", &u->sample_spec.rate) < 0 ||
2686         u->sample_spec.rate <= 0 || u->sample_spec.rate > PA_RATE_MAX) {
2687         pa_log_error("Failed to get rate from module arguments");
2688         goto fail;
2689     }
2690
2691     u->auto_connect = TRUE;
2692     if (pa_modargs_get_value_boolean(ma, "auto_connect", &u->auto_connect)) {
2693         pa_log("Failed to parse auto_connect= argument");
2694         goto fail;
2695     }
2696
2697     channels = u->sample_spec.channels;
2698     if (pa_modargs_get_value_u32(ma, "channels", &channels) < 0 ||
2699         channels <= 0 || channels > PA_CHANNELS_MAX) {
2700         pa_log_error("Failed to get channels from module arguments");
2701         goto fail;
2702     }
2703     u->sample_spec.channels = (uint8_t) channels;
2704     u->requested_sample_spec = u->sample_spec;
2705
2706     address = pa_modargs_get_value(ma, "address", NULL);
2707     path = pa_modargs_get_value(ma, "path", NULL);
2708
2709     if (setup_dbus(u) < 0)
2710         goto fail;
2711
2712     if (!(u->discovery = pa_bluetooth_discovery_get(m->core)))
2713         goto fail;
2714
2715     if (!(device = find_device(u, address, path)))
2716         goto fail;
2717
2718     /* Add the card structure. This will also initialize the default profile */
2719     if (add_card(u, device) < 0)
2720         goto fail;
2721
2722     if (!dbus_connection_add_filter(pa_dbus_connection_get(u->connection), filter_cb, u, NULL)) {
2723         pa_log_error("Failed to add filter function");
2724         goto fail;
2725     }
2726     u->filter_added = TRUE;
2727
2728     speaker = pa_sprintf_malloc("type='signal',sender='org.bluez',interface='org.bluez.Headset',member='SpeakerGainChanged',path='%s'", u->path);
2729     mike = pa_sprintf_malloc("type='signal',sender='org.bluez',interface='org.bluez.Headset',member='MicrophoneGainChanged',path='%s'", u->path);
2730
2731     if (pa_dbus_add_matches(
2732                 pa_dbus_connection_get(u->connection), &err,
2733                 speaker,
2734                 mike,
2735                 NULL) < 0) {
2736
2737         pa_xfree(speaker);
2738         pa_xfree(mike);
2739
2740         pa_log("Failed to add D-Bus matches: %s", err.message);
2741         goto fail;
2742     }
2743
2744     pa_xfree(speaker);
2745     pa_xfree(mike);
2746
2747     /* Connect to the BT service */
2748     init_bt(u);
2749
2750     if (u->profile != PROFILE_OFF)
2751         if (init_profile(u) < 0)
2752             goto fail;
2753
2754     if (u->sink || u->source)
2755         if (start_thread(u) < 0)
2756             goto fail;
2757
2758     return 0;
2759
2760 fail:
2761
2762     pa__done(m);
2763
2764     dbus_error_free(&err);
2765
2766     return -1;
2767 }
2768
2769 int pa__get_n_used(pa_module *m) {
2770     struct userdata *u;
2771
2772     pa_assert(m);
2773     pa_assert_se(u = m->userdata);
2774
2775     return
2776         (u->sink ? pa_sink_linked_by(u->sink) : 0) +
2777         (u->source ? pa_source_linked_by(u->source) : 0);
2778 }
2779
2780 void pa__done(pa_module *m) {
2781     struct userdata *u;
2782     pa_assert(m);
2783
2784     if (!(u = m->userdata))
2785         return;
2786
2787     if (u->sink
2788 #ifdef NOKIA
2789         && !USE_SCO_OVER_PCM(u)
2790 #endif
2791     )
2792         pa_sink_unlink(u->sink);
2793
2794     if (u->source
2795 #ifdef NOKIA
2796         && !USE_SCO_OVER_PCM(u)
2797 #endif
2798     )
2799         pa_source_unlink(u->source);
2800
2801     stop_thread(u);
2802
2803     if (u->connection) {
2804
2805         if (u->path) {
2806             char *speaker, *mike;
2807             speaker = pa_sprintf_malloc("type='signal',sender='org.bluez',interface='org.bluez.Headset',member='SpeakerGainChanged',path='%s'", u->path);
2808             mike = pa_sprintf_malloc("type='signal',sender='org.bluez',interface='org.bluez.Headset',member='MicrophoneGainChanged',path='%s'", u->path);
2809
2810             pa_dbus_remove_matches(pa_dbus_connection_get(u->connection), speaker, mike, NULL);
2811
2812             pa_xfree(speaker);
2813             pa_xfree(mike);
2814         }
2815
2816         if (u->filter_added)
2817             dbus_connection_remove_filter(pa_dbus_connection_get(u->connection), filter_cb, u);
2818
2819         pa_dbus_connection_unref(u->connection);
2820     }
2821
2822     if (u->card)
2823         pa_card_free(u->card);
2824
2825     if (u->read_smoother)
2826         pa_smoother_free(u->read_smoother);
2827
2828     shutdown_bt(u);
2829
2830     if (u->a2dp.buffer)
2831         pa_xfree(u->a2dp.buffer);
2832
2833     sbc_finish(&u->a2dp.sbc);
2834
2835     if (u->modargs)
2836         pa_modargs_free(u->modargs);
2837
2838     pa_xfree(u->address);
2839     pa_xfree(u->path);
2840
2841     if (u->transport) {
2842         bt_transport_release(u);
2843         pa_xfree(u->transport);
2844     }
2845
2846     if (u->discovery)
2847         pa_bluetooth_discovery_unref(u->discovery);
2848
2849     pa_xfree(u);
2850 }