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