android/hal-audio.c

   1 /*
   2  * Copyright (C) 2013 Intel Corporation
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 #include <errno.h>
  19 #include <pthread.h>
  20 #include <poll.h>
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <sys/socket.h>
  25 #include <sys/un.h>
  26 #include <unistd.h>
  27 #include <arpa/inet.h>
  28 #include <fcntl.h>
  29
  30 #include <hardware/audio.h>
  31 #include <hardware/hardware.h>
  32
  33 #include <sbc/sbc.h>
  34
  35 #include "audio-msg.h"
  36 #include "ipc-common.h"
  37 #include "hal-log.h"
  38 #include "hal-msg.h"
  39 #include "../profiles/audio/a2dp-codecs.h"
  40 #include "../src/shared/util.h"
  41
  42 #define FIXED_A2DP_PLAYBACK_LATENCY_MS 25
  43
  44 #define FIXED_BUFFER_SIZE (20 * 512)
  45
  46 #define MAX_FRAMES_IN_PAYLOAD 15
  47
  48 static const uint8_t a2dp_src_uuid[] = {
  49                 0x00, 0x00, 0x11, 0x0a, 0x00, 0x00, 0x10, 0x00,
  50                 0x80, 0x00, 0x00, 0x80, 0x5f, 0x9b, 0x34, 0xfb };
  51
  52 static int listen_sk = -1;
  53 static int audio_sk = -1;
  54
  55 static pthread_t ipc_th = 0;
  56 static pthread_mutex_t sk_mutex = PTHREAD_MUTEX_INITIALIZER;
  57
  58 #if __BYTE_ORDER == __LITTLE_ENDIAN
  59
  60 struct rtp_header {
  61         unsigned cc:4;
  62         unsigned x:1;
  63         unsigned p:1;
  64         unsigned v:2;
  65
  66         unsigned pt:7;
  67         unsigned m:1;
  68
  69         uint16_t sequence_number;
  70         uint32_t timestamp;
  71         uint32_t ssrc;
  72         uint32_t csrc[0];
  73 } __attribute__ ((packed));
  74
  75 struct rtp_payload {
  76         unsigned frame_count:4;
  77         unsigned rfa0:1;
  78         unsigned is_last_fragment:1;
  79         unsigned is_first_fragment:1;
  80         unsigned is_fragmented:1;
  81 } __attribute__ ((packed));
  82
  83 #elif __BYTE_ORDER == __BIG_ENDIAN
  84
  85 struct rtp_header {
  86         unsigned v:2;
  87         unsigned p:1;
  88         unsigned x:1;
  89         unsigned cc:4;
  90
  91         unsigned m:1;
  92         unsigned pt:7;
  93
  94         uint16_t sequence_number;
  95         uint32_t timestamp;
  96         uint32_t ssrc;
  97         uint32_t csrc[0];
  98 } __attribute__ ((packed));
  99
 100 struct rtp_payload {
 101         unsigned is_fragmented:1;
 102         unsigned is_first_fragment:1;
 103         unsigned is_last_fragment:1;
 104         unsigned rfa0:1;
 105         unsigned frame_count:4;
 106 } __attribute__ ((packed));
 107
 108 #else
 109 #error "Unknown byte order"
 110 #endif
 111
 112 struct media_packet {
 113         struct rtp_header hdr;
 114         struct rtp_payload payload;
 115         uint8_t data[0];
 116 };
 117
 118 struct audio_input_config {
 119         uint32_t rate;
 120         uint32_t channels;
 121         audio_format_t format;
 122 };
 123
 124 struct sbc_data {
 125         a2dp_sbc_t sbc;
 126
 127         sbc_t enc;
 128
 129         size_t in_frame_len;
 130         size_t in_buf_size;
 131
 132         size_t out_frame_len;
 133         size_t out_buf_size;
 134         uint8_t *out_buf;
 135
 136         unsigned frame_duration;
 137         unsigned frames_per_packet;
 138
 139         struct timespec start;
 140         unsigned frames_sent;
 141         uint32_t timestamp;
 142
 143         uint16_t seq;
 144 };
 145
 146 static inline void timespec_diff(struct timespec *a, struct timespec *b,
 147                                                         struct timespec *res)
 148 {
 149         res->tv_sec = a->tv_sec - b->tv_sec;
 150         res->tv_nsec = a->tv_nsec - b->tv_nsec;
 151
 152         if (res->tv_nsec < 0) {
 153                 res->tv_sec--;
 154                 res->tv_nsec += 1000000000; /* 1sec */
 155         }
 156 }
 157
 158 static int sbc_get_presets(struct audio_preset *preset, size_t *len);
 159 static int sbc_codec_init(struct audio_preset *preset, uint16_t mtu,
 160                                                         void **codec_data);
 161 static int sbc_cleanup(void *codec_data);
 162 static int sbc_get_config(void *codec_data, struct audio_input_config *config);
 163 static size_t sbc_get_buffer_size(void *codec_data);
 164 static size_t sbc_get_mediapacket_duration(void *codec_data);
 165 static void sbc_resume(void *codec_data);
 166 static ssize_t sbc_write_data(void *codec_data, const void *buffer,
 167                                                         size_t bytes, int fd);
 168
 169 struct audio_codec {
 170         uint8_t type;
 171
 172         int (*get_presets) (struct audio_preset *preset, size_t *len);
 173
 174         int (*init) (struct audio_preset *preset, uint16_t mtu,
 175                                 void **codec_data);
 176         int (*cleanup) (void *codec_data);
 177         int (*get_config) (void *codec_data,
 178                                         struct audio_input_config *config);
 179         size_t (*get_buffer_size) (void *codec_data);
 180         size_t (*get_mediapacket_duration) (void *codec_data);
 181         void (*resume) (void *codec_data);
 182         ssize_t (*write_data) (void *codec_data, const void *buffer,
 183                                                         size_t bytes, int fd);
 184 };
 185
 186 static const struct audio_codec audio_codecs[] = {
 187         {
 188                 .type = A2DP_CODEC_SBC,
 189
 190                 .get_presets = sbc_get_presets,
 191
 192                 .init = sbc_codec_init,
 193                 .cleanup = sbc_cleanup,
 194                 .get_config = sbc_get_config,
 195                 .get_buffer_size = sbc_get_buffer_size,
 196                 .get_mediapacket_duration = sbc_get_mediapacket_duration,
 197                 .resume = sbc_resume,
 198                 .write_data = sbc_write_data,
 199         }
 200 };
 201
 202 #define NUM_CODECS (sizeof(audio_codecs) / sizeof(audio_codecs[0]))
 203
 204 #define MAX_AUDIO_ENDPOINTS NUM_CODECS
 205
 206 struct audio_endpoint {
 207         uint8_t id;
 208         const struct audio_codec *codec;
 209         void *codec_data;
 210         int fd;
 211 };
 212
 213 static struct audio_endpoint audio_endpoints[MAX_AUDIO_ENDPOINTS];
 214
 215 enum a2dp_state_t {
 216         AUDIO_A2DP_STATE_NONE,
 217         AUDIO_A2DP_STATE_STANDBY,
 218         AUDIO_A2DP_STATE_SUSPENDED,
 219         AUDIO_A2DP_STATE_STARTED
 220 };
 221
 222 struct a2dp_stream_out {
 223         struct audio_stream_out stream;
 224
 225         struct audio_endpoint *ep;
 226         enum a2dp_state_t audio_state;
 227         struct audio_input_config cfg;
 228
 229         uint8_t *downmix_buf;
 230 };
 231
 232 struct a2dp_audio_dev {
 233         struct audio_hw_device dev;
 234         struct a2dp_stream_out *out;
 235 };
 236
 237 static const a2dp_sbc_t sbc_presets[] = {
 238         {
 239                 .frequency = SBC_SAMPLING_FREQ_44100 | SBC_SAMPLING_FREQ_48000,
 240                 .channel_mode = SBC_CHANNEL_MODE_MONO |
 241                                 SBC_CHANNEL_MODE_DUAL_CHANNEL |
 242                                 SBC_CHANNEL_MODE_STEREO |
 243                                 SBC_CHANNEL_MODE_JOINT_STEREO,
 244                 .subbands = SBC_SUBBANDS_4 | SBC_SUBBANDS_8,
 245                 .allocation_method = SBC_ALLOCATION_SNR |
 246                                         SBC_ALLOCATION_LOUDNESS,
 247                 .block_length = SBC_BLOCK_LENGTH_4 | SBC_BLOCK_LENGTH_8 |
 248                                 SBC_BLOCK_LENGTH_12 | SBC_BLOCK_LENGTH_16,
 249                 .min_bitpool = MIN_BITPOOL,
 250                 .max_bitpool = MAX_BITPOOL
 251         },
 252         {
 253                 .frequency = SBC_SAMPLING_FREQ_44100,
 254                 .channel_mode = SBC_CHANNEL_MODE_JOINT_STEREO,
 255                 .subbands = SBC_SUBBANDS_8,
 256                 .allocation_method = SBC_ALLOCATION_LOUDNESS,
 257                 .block_length = SBC_BLOCK_LENGTH_16,
 258                 .min_bitpool = MIN_BITPOOL,
 259                 .max_bitpool = MAX_BITPOOL
 260         },
 261         {
 262                 .frequency = SBC_SAMPLING_FREQ_48000,
 263                 .channel_mode = SBC_CHANNEL_MODE_JOINT_STEREO,
 264                 .subbands = SBC_SUBBANDS_8,
 265                 .allocation_method = SBC_ALLOCATION_LOUDNESS,
 266                 .block_length = SBC_BLOCK_LENGTH_16,
 267                 .min_bitpool = MIN_BITPOOL,
 268                 .max_bitpool = MAX_BITPOOL
 269         },
 270 };
 271
 272 static int sbc_get_presets(struct audio_preset *preset, size_t *len)
 273 {
 274         int i;
 275         int count;
 276         size_t new_len = 0;
 277         uint8_t *ptr = (uint8_t *) preset;
 278         size_t preset_size = sizeof(*preset) + sizeof(a2dp_sbc_t);
 279
 280         count = sizeof(sbc_presets) / sizeof(sbc_presets[0]);
 281
 282         for (i = 0; i < count; i++) {
 283                 preset = (struct audio_preset *) ptr;
 284
 285                 if (new_len + preset_size > *len)
 286                         break;
 287
 288                 preset->len = sizeof(a2dp_sbc_t);
 289                 memcpy(preset->data, &sbc_presets[i], preset->len);
 290
 291                 new_len += preset_size;
 292                 ptr += preset_size;
 293         }
 294
 295         *len = new_len;
 296
 297         return i;
 298 }
 299
 300 static int sbc_freq2int(uint8_t freq)
 301 {
 302         switch (freq) {
 303         case SBC_SAMPLING_FREQ_16000:
 304                 return 16000;
 305         case SBC_SAMPLING_FREQ_32000:
 306                 return 32000;
 307         case SBC_SAMPLING_FREQ_44100:
 308                 return 44100;
 309         case SBC_SAMPLING_FREQ_48000:
 310                 return 48000;
 311         default:
 312                 return 0;
 313         }
 314 }
 315
 316 static const char *sbc_mode2str(uint8_t mode)
 317 {
 318         switch (mode) {
 319         case SBC_CHANNEL_MODE_MONO:
 320                 return "Mono";
 321         case SBC_CHANNEL_MODE_DUAL_CHANNEL:
 322                 return "DualChannel";
 323         case SBC_CHANNEL_MODE_STEREO:
 324                 return "Stereo";
 325         case SBC_CHANNEL_MODE_JOINT_STEREO:
 326                 return "JointStereo";
 327         default:
 328                 return "(unknown)";
 329         }
 330 }
 331
 332 static int sbc_blocks2int(uint8_t blocks)
 333 {
 334         switch (blocks) {
 335         case SBC_BLOCK_LENGTH_4:
 336                 return 4;
 337         case SBC_BLOCK_LENGTH_8:
 338                 return 8;
 339         case SBC_BLOCK_LENGTH_12:
 340                 return 12;
 341         case SBC_BLOCK_LENGTH_16:
 342                 return 16;
 343         default:
 344                 return 0;
 345         }
 346 }
 347
 348 static int sbc_subbands2int(uint8_t subbands)
 349 {
 350         switch (subbands) {
 351         case SBC_SUBBANDS_4:
 352                 return 4;
 353         case SBC_SUBBANDS_8:
 354                 return 8;
 355         default:
 356                 return 0;
 357         }
 358 }
 359
 360 static const char *sbc_allocation2str(uint8_t allocation)
 361 {
 362         switch (allocation) {
 363         case SBC_ALLOCATION_SNR:
 364                 return "SNR";
 365         case SBC_ALLOCATION_LOUDNESS:
 366                 return "Loudness";
 367         default:
 368                 return "(unknown)";
 369         }
 370 }
 371
 372 static void sbc_init_encoder(struct sbc_data *sbc_data)
 373 {
 374         a2dp_sbc_t *in = &sbc_data->sbc;
 375         sbc_t *out = &sbc_data->enc;
 376
 377         sbc_init_a2dp(out, 0L, in, sizeof(*in));
 378
 379         out->endian = SBC_LE;
 380         out->bitpool = in->max_bitpool;
 381
 382         DBG("frequency=%d channel_mode=%s block_length=%d subbands=%d "
 383                         "allocation=%s bitpool=%d-%d",
 384                         sbc_freq2int(in->frequency),
 385                         sbc_mode2str(in->channel_mode),
 386                         sbc_blocks2int(in->block_length),
 387                         sbc_subbands2int(in->subbands),
 388                         sbc_allocation2str(in->allocation_method),
 389                         in->min_bitpool, in->max_bitpool);
 390 }
 391
 392 static int sbc_codec_init(struct audio_preset *preset, uint16_t mtu,
 393                                                         void **codec_data)
 394 {
 395         struct sbc_data *sbc_data;
 396         size_t hdr_len = sizeof(struct media_packet);
 397         size_t in_frame_len;
 398         size_t out_frame_len;
 399         size_t num_frames;
 400
 401         if (preset->len != sizeof(a2dp_sbc_t)) {
 402                 error("SBC: preset size mismatch");
 403                 return AUDIO_STATUS_FAILED;
 404         }
 405
 406         sbc_data = calloc(sizeof(struct sbc_data), 1);
 407         if (!sbc_data)
 408                 return AUDIO_STATUS_FAILED;
 409
 410         memcpy(&sbc_data->sbc, preset->data, preset->len);
 411
 412         sbc_init_encoder(sbc_data);
 413
 414         in_frame_len = sbc_get_codesize(&sbc_data->enc);
 415         out_frame_len = sbc_get_frame_length(&sbc_data->enc);
 416         num_frames = (mtu - hdr_len) / out_frame_len;
 417
 418         sbc_data->in_frame_len = in_frame_len;
 419         sbc_data->in_buf_size = num_frames * in_frame_len;
 420
 421         sbc_data->out_frame_len = out_frame_len;
 422         sbc_data->out_buf_size = hdr_len + num_frames * out_frame_len;
 423         sbc_data->out_buf = calloc(1, sbc_data->out_buf_size);
 424
 425         sbc_data->frame_duration = sbc_get_frame_duration(&sbc_data->enc);
 426         sbc_data->frames_per_packet = num_frames;
 427
 428         DBG("mtu=%u in_frame_len=%zu out_frame_len=%zu frames_per_packet=%zu",
 429                         mtu, in_frame_len, out_frame_len, num_frames);
 430
 431         *codec_data = sbc_data;
 432
 433         return AUDIO_STATUS_SUCCESS;
 434 }
 435
 436 static int sbc_cleanup(void *codec_data)
 437 {
 438         struct sbc_data *sbc_data = (struct sbc_data *) codec_data;
 439
 440         sbc_finish(&sbc_data->enc);
 441         free(sbc_data->out_buf);
 442         free(codec_data);
 443
 444         return AUDIO_STATUS_SUCCESS;
 445 }
 446
 447 static int sbc_get_config(void *codec_data, struct audio_input_config *config)
 448 {
 449         struct sbc_data *sbc_data = (struct sbc_data *) codec_data;
 450
 451         switch (sbc_data->sbc.frequency) {
 452         case SBC_SAMPLING_FREQ_16000:
 453                 config->rate = 16000;
 454                 break;
 455         case SBC_SAMPLING_FREQ_32000:
 456                 config->rate = 32000;
 457                 break;
 458         case SBC_SAMPLING_FREQ_44100:
 459                 config->rate = 44100;
 460                 break;
 461         case SBC_SAMPLING_FREQ_48000:
 462                 config->rate = 48000;
 463                 break;
 464         default:
 465                 return AUDIO_STATUS_FAILED;
 466         }
 467         config->channels = sbc_data->sbc.channel_mode == SBC_CHANNEL_MODE_MONO ?
 468                                 AUDIO_CHANNEL_OUT_MONO :
 469                                 AUDIO_CHANNEL_OUT_STEREO;
 470         config->format = AUDIO_FORMAT_PCM_16_BIT;
 471
 472         return AUDIO_STATUS_SUCCESS;
 473 }
 474
 475 static size_t sbc_get_buffer_size(void *codec_data)
 476 {
 477         struct sbc_data *sbc_data = (struct sbc_data *) codec_data;
 478
 479         return sbc_data->in_buf_size;
 480 }
 481
 482 static size_t sbc_get_mediapacket_duration(void *codec_data)
 483 {
 484         struct sbc_data *sbc_data = (struct sbc_data *) codec_data;
 485
 486         return sbc_data->frame_duration * sbc_data->frames_per_packet;
 487 }
 488
 489 static void sbc_resume(void *codec_data)
 490 {
 491         struct sbc_data *sbc_data = (struct sbc_data *) codec_data;
 492
 493         DBG("");
 494
 495         clock_gettime(CLOCK_MONOTONIC, &sbc_data->start);
 496
 497         sbc_data->frames_sent = 0;
 498         sbc_data->timestamp = 0;
 499 }
 500
 501 static int write_media_packet(int fd, struct sbc_data *sbc_data,
 502                                 struct media_packet *mp, size_t data_len)
 503 {
 504         struct timespec cur;
 505         struct timespec diff;
 506         unsigned expected_frames;
 507         int ret;
 508
 509         while (true) {
 510                 ret = write(fd, mp, sizeof(*mp) + data_len);
 511                 if (ret >= 0)
 512                         break;
 513
 514                 if (errno != EINTR)
 515                         return -errno;
 516         }
 517
 518         sbc_data->frames_sent += mp->payload.frame_count;
 519
 520         clock_gettime(CLOCK_MONOTONIC, &cur);
 521         timespec_diff(&cur, &sbc_data->start, &diff);
 522         expected_frames = (diff.tv_sec * 1000000 + diff.tv_nsec / 1000) /
 523                                                 sbc_data->frame_duration;
 524
 525         /* AudioFlinger does not seem to provide any *working*
 526          * API to provide data in some interval and will just
 527          * send another buffer as soon as we process current
 528          * one. To prevent overflowing L2CAP socket, we need to
 529          * introduce some artificial delay here base on how many
 530          * audio frames were sent so far, i.e. if we're not
 531          * lagging behind audio stream, we can sleep for
 532          * duration of single media packet.
 533          */
 534         if (sbc_data->frames_sent >= expected_frames)
 535                 usleep(sbc_data->frame_duration *
 536                                 mp->payload.frame_count);
 537
 538         return ret;
 539 }
 540
 541 static ssize_t sbc_encode_mediapacket(void *codec_data, const uint8_t *buffer,
 542                                         size_t len, struct media_packet *mp,
 543                                         size_t mp_data_len, size_t *written)
 544 {
 545         struct sbc_data *sbc_data = (struct sbc_data *) codec_data;
 546         size_t consumed = 0;
 547         size_t encoded = 0;
 548         uint8_t frame_count = 0;
 549
 550         while (len - consumed >= sbc_data->in_frame_len &&
 551                         mp_data_len - encoded >= sbc_data->out_frame_len &&
 552                         frame_count < MAX_FRAMES_IN_PAYLOAD) {
 553                 ssize_t read;
 554                 ssize_t written = 0;
 555
 556                 read = sbc_encode(&sbc_data->enc, buffer + consumed,
 557                                 sbc_data->in_frame_len, mp->data + encoded,
 558                                 mp_data_len - encoded, &written);
 559
 560                 if (read < 0) {
 561                         error("SBC: failed to encode block at frame %d (%zd)",
 562                                                         frame_count, read);
 563                         break;
 564                 }
 565
 566                 frame_count++;
 567                 consumed += read;
 568                 encoded += written;
 569         }
 570
 571         *written = encoded;
 572         mp->payload.frame_count = frame_count;
 573
 574         return consumed;
 575 }
 576
 577 static ssize_t sbc_write_data(void *codec_data, const void *buffer,
 578                                                         size_t bytes, int fd)
 579 {
 580         struct sbc_data *sbc_data = (struct sbc_data *) codec_data;
 581         size_t consumed = 0;
 582         struct media_packet *mp = (struct media_packet *) sbc_data->out_buf;
 583         size_t free_space = sbc_data->out_buf_size - sizeof(*mp);
 584
 585         mp->hdr.v = 2;
 586         mp->hdr.pt = 1;
 587         mp->hdr.ssrc = htonl(1);
 588
 589         while (consumed < bytes) {
 590                 size_t written = 0;
 591                 ssize_t read;
 592                 int ret;
 593
 594                 read = sbc_encode_mediapacket(codec_data, buffer + consumed,
 595                                                 bytes - consumed, mp,
 596                                                 free_space,
 597                                                 &written);
 598
 599                 if (read <= 0) {
 600                         error("sbc_encode_mediapacket failed (%zd)", read);
 601                         goto done;
 602                 }
 603
 604                 consumed += read;
 605
 606                 mp->hdr.sequence_number = htons(sbc_data->seq++);
 607                 mp->hdr.timestamp = htonl(sbc_data->timestamp);
 608
 609                 /* AudioFlinger provides PCM 16bit stereo only, thus sample size
 610                  * is always 4 bytes
 611                  */
 612                 sbc_data->timestamp += (read / 4);
 613
 614                 ret = write_media_packet(fd, sbc_data, mp, written);
 615                 if (ret < 0)
 616                         return ret;
 617         }
 618
 619 done:
 620         /* we always assume that all data was processed and sent */
 621         return bytes;
 622 }
 623
 624 static int audio_ipc_cmd(uint8_t service_id, uint8_t opcode, uint16_t len,
 625                         void *param, size_t *rsp_len, void *rsp, int *fd)
 626 {
 627         ssize_t ret;
 628         struct msghdr msg;
 629         struct iovec iv[2];
 630         struct ipc_hdr cmd;
 631         char cmsgbuf[CMSG_SPACE(sizeof(int))];
 632         struct ipc_status s;
 633         size_t s_len = sizeof(s);
 634
 635         pthread_mutex_lock(&sk_mutex);
 636
 637         if (audio_sk < 0) {
 638                 error("audio: Invalid cmd socket passed to audio_ipc_cmd");
 639                 goto failed;
 640         }
 641
 642         if (!rsp || !rsp_len) {
 643                 memset(&s, 0, s_len);
 644                 rsp_len = &s_len;
 645                 rsp = &s;
 646         }
 647
 648         memset(&msg, 0, sizeof(msg));
 649         memset(&cmd, 0, sizeof(cmd));
 650
 651         cmd.service_id = service_id;
 652         cmd.opcode = opcode;
 653         cmd.len = len;
 654
 655         iv[0].iov_base = &cmd;
 656         iv[0].iov_len = sizeof(cmd);
 657
 658         iv[1].iov_base = param;
 659         iv[1].iov_len = len;
 660
 661         msg.msg_iov = iv;
 662         msg.msg_iovlen = 2;
 663
 664         ret = sendmsg(audio_sk, &msg, 0);
 665         if (ret < 0) {
 666                 error("audio: Sending command failed:%s", strerror(errno));
 667                 goto failed;
 668         }
 669
 670         /* socket was shutdown */
 671         if (ret == 0) {
 672                 error("audio: Command socket closed");
 673                 goto failed;
 674         }
 675
 676         memset(&msg, 0, sizeof(msg));
 677         memset(&cmd, 0, sizeof(cmd));
 678
 679         iv[0].iov_base = &cmd;
 680         iv[0].iov_len = sizeof(cmd);
 681
 682         iv[1].iov_base = rsp;
 683         iv[1].iov_len = *rsp_len;
 684
 685         msg.msg_iov = iv;
 686         msg.msg_iovlen = 2;
 687
 688         if (fd) {
 689                 memset(cmsgbuf, 0, sizeof(cmsgbuf));
 690                 msg.msg_control = cmsgbuf;
 691                 msg.msg_controllen = sizeof(cmsgbuf);
 692         }
 693
 694         ret = recvmsg(audio_sk, &msg, 0);
 695         if (ret < 0) {
 696                 error("audio: Receiving command response failed:%s",
 697                                                         strerror(errno));
 698                 goto failed;
 699         }
 700
 701         if (ret < (ssize_t) sizeof(cmd)) {
 702                 error("audio: Too small response received(%zd bytes)", ret);
 703                 goto failed;
 704         }
 705
 706         if (cmd.service_id != service_id) {
 707                 error("audio: Invalid service id (%u vs %u)", cmd.service_id,
 708                                                                 service_id);
 709                 goto failed;
 710         }
 711
 712         if (ret != (ssize_t) (sizeof(cmd) + cmd.len)) {
 713                 error("audio: Malformed response received(%zd bytes)", ret);
 714                 goto failed;
 715         }
 716
 717         if (cmd.opcode != opcode && cmd.opcode != AUDIO_OP_STATUS) {
 718                 error("audio: Invalid opcode received (%u vs %u)",
 719                                                 cmd.opcode, opcode);
 720                 goto failed;
 721         }
 722
 723         if (cmd.opcode == AUDIO_OP_STATUS) {
 724                 struct ipc_status *s = rsp;
 725
 726                 if (sizeof(*s) != cmd.len) {
 727                         error("audio: Invalid status length");
 728                         goto failed;
 729                 }
 730
 731                 if (s->code == AUDIO_STATUS_SUCCESS) {
 732                         error("audio: Invalid success status response");
 733                         goto failed;
 734                 }
 735
 736                 pthread_mutex_unlock(&sk_mutex);
 737
 738                 return s->code;
 739         }
 740
 741         pthread_mutex_unlock(&sk_mutex);
 742
 743         /* Receive auxiliary data in msg */
 744         if (fd) {
 745                 struct cmsghdr *cmsg;
 746
 747                 *fd = -1;
 748
 749                 for (cmsg = CMSG_FIRSTHDR(&msg); cmsg;
 750                                         cmsg = CMSG_NXTHDR(&msg, cmsg)) {
 751                         if (cmsg->cmsg_level == SOL_SOCKET
 752                                         && cmsg->cmsg_type == SCM_RIGHTS) {
 753                                 memcpy(fd, CMSG_DATA(cmsg), sizeof(int));
 754                                 break;
 755                         }
 756                 }
 757
 758                 if (*fd < 0)
 759                         goto failed;
 760         }
 761
 762         if (rsp_len)
 763                 *rsp_len = cmd.len;
 764
 765         return AUDIO_STATUS_SUCCESS;
 766
 767 failed:
 768         /* Some serious issue happen on IPC - recover */
 769         shutdown(audio_sk, SHUT_RDWR);
 770         pthread_mutex_unlock(&sk_mutex);
 771
 772         return AUDIO_STATUS_FAILED;
 773 }
 774
 775 static int ipc_open_cmd(const struct audio_codec *codec)
 776 {
 777         uint8_t buf[BLUEZ_AUDIO_MTU];
 778         struct audio_cmd_open *cmd = (struct audio_cmd_open *) buf;
 779         struct audio_rsp_open rsp;
 780         size_t cmd_len = sizeof(buf) - sizeof(*cmd);
 781         size_t rsp_len = sizeof(rsp);
 782         int result;
 783
 784         DBG("");
 785
 786         memcpy(cmd->uuid, a2dp_src_uuid, sizeof(a2dp_src_uuid));
 787
 788         cmd->codec = codec->type;
 789         cmd->presets = codec->get_presets(cmd->preset, &cmd_len);
 790
 791         cmd_len += sizeof(*cmd);
 792
 793         result = audio_ipc_cmd(AUDIO_SERVICE_ID, AUDIO_OP_OPEN, cmd_len, cmd,
 794                                 &rsp_len, &rsp, NULL);
 795
 796         if (result != AUDIO_STATUS_SUCCESS)
 797                 return 0;
 798
 799         return rsp.id;
 800 }
 801
 802 static int ipc_close_cmd(uint8_t endpoint_id)
 803 {
 804         struct audio_cmd_close cmd;
 805         int result;
 806
 807         DBG("");
 808
 809         cmd.id = endpoint_id;
 810
 811         result = audio_ipc_cmd(AUDIO_SERVICE_ID, AUDIO_OP_CLOSE,
 812                                 sizeof(cmd), &cmd, NULL, NULL, NULL);
 813
 814         return result;
 815 }
 816
 817 static int ipc_open_stream_cmd(uint8_t endpoint_id, uint16_t *mtu, int *fd,
 818                                                 struct audio_preset **caps)
 819 {
 820         char buf[BLUEZ_AUDIO_MTU];
 821         struct audio_cmd_open_stream cmd;
 822         struct audio_rsp_open_stream *rsp =
 823                                         (struct audio_rsp_open_stream *) &buf;
 824         size_t rsp_len = sizeof(buf);
 825         int result;
 826
 827         DBG("");
 828
 829         if (!caps)
 830                 return AUDIO_STATUS_FAILED;
 831
 832         cmd.id = endpoint_id;
 833
 834         result = audio_ipc_cmd(AUDIO_SERVICE_ID, AUDIO_OP_OPEN_STREAM,
 835                                 sizeof(cmd), &cmd, &rsp_len, rsp, fd);
 836         if (result == AUDIO_STATUS_SUCCESS) {
 837                 size_t buf_len = sizeof(struct audio_preset) +
 838                                         rsp->preset[0].len;
 839                 *mtu = rsp->mtu;
 840                 *caps = malloc(buf_len);
 841                 memcpy(*caps, &rsp->preset, buf_len);
 842         } else {
 843                 *caps = NULL;
 844         }
 845
 846         return result;
 847 }
 848
 849 static int ipc_close_stream_cmd(uint8_t endpoint_id)
 850 {
 851         struct audio_cmd_close_stream cmd;
 852         int result;
 853
 854         DBG("");
 855
 856         cmd.id = endpoint_id;
 857
 858         result = audio_ipc_cmd(AUDIO_SERVICE_ID, AUDIO_OP_CLOSE_STREAM,
 859                                         sizeof(cmd), &cmd, NULL, NULL, NULL);
 860
 861         return result;
 862 }
 863
 864 static int ipc_resume_stream_cmd(uint8_t endpoint_id)
 865 {
 866         struct audio_cmd_resume_stream cmd;
 867         int result;
 868
 869         DBG("");
 870
 871         cmd.id = endpoint_id;
 872
 873         result = audio_ipc_cmd(AUDIO_SERVICE_ID, AUDIO_OP_RESUME_STREAM,
 874                                         sizeof(cmd), &cmd, NULL, NULL, NULL);
 875
 876         return result;
 877 }
 878
 879 static int ipc_suspend_stream_cmd(uint8_t endpoint_id)
 880 {
 881         struct audio_cmd_suspend_stream cmd;
 882         int result;
 883
 884         DBG("");
 885
 886         cmd.id = endpoint_id;
 887
 888         result = audio_ipc_cmd(AUDIO_SERVICE_ID, AUDIO_OP_SUSPEND_STREAM,
 889                                         sizeof(cmd), &cmd, NULL, NULL, NULL);
 890
 891         return result;
 892 }
 893
 894 static int register_endpoints(void)
 895 {
 896         struct audio_endpoint *ep = &audio_endpoints[0];
 897         size_t i;
 898
 899         for (i = 0; i < NUM_CODECS; i++, ep++) {
 900                 const struct audio_codec *codec = &audio_codecs[i];
 901
 902                 ep->id = ipc_open_cmd(codec);
 903
 904                 if (!ep->id)
 905                         return AUDIO_STATUS_FAILED;
 906
 907                 ep->codec = codec;
 908                 ep->codec_data = NULL;
 909                 ep->fd = -1;
 910         }
 911
 912         return AUDIO_STATUS_SUCCESS;
 913 }
 914
 915 static void unregister_endpoints(void)
 916 {
 917         size_t i;
 918
 919         for (i = 0; i < MAX_AUDIO_ENDPOINTS; i++) {
 920                 struct audio_endpoint *ep = &audio_endpoints[i];
 921
 922                 if (ep->id) {
 923                         ipc_close_cmd(ep->id);
 924                         memset(ep, 0, sizeof(*ep));
 925                 }
 926         }
 927 }
 928
 929 static int set_blocking(int fd)
 930 {
 931         int flags;
 932
 933         flags = fcntl(fd, F_GETFL, 0);
 934         if (flags < 0) {
 935                 int err = -errno;
 936                 error("fcntl(F_GETFL): %s (%d)", strerror(-err), -err);
 937                 return err;
 938         }
 939
 940         if (fcntl(fd, F_SETFL, flags & ~O_NONBLOCK) < 0) {
 941                 int err = -errno;
 942                 error("fcntl(F_SETFL): %s (%d)", strerror(-err), -err);
 943                 return err;
 944         }
 945
 946         return 0;
 947 }
 948
 949 static bool open_endpoint(struct audio_endpoint *ep,
 950                                                 struct audio_input_config *cfg)
 951 {
 952         struct audio_preset *preset;
 953         const struct audio_codec *codec;
 954         uint16_t mtu;
 955         int fd;
 956
 957         if (ipc_open_stream_cmd(ep->id, &mtu, &fd, &preset) !=
 958                                                         AUDIO_STATUS_SUCCESS)
 959                 return false;
 960
 961         if (set_blocking(fd) < 0)
 962                 goto failed;
 963
 964         ep->fd = fd;
 965
 966         codec = ep->codec;
 967         codec->init(preset, mtu, &ep->codec_data);
 968         codec->get_config(ep->codec_data, cfg);
 969
 970         free(preset);
 971
 972         return true;
 973
 974 failed:
 975         close(fd);
 976         free(preset);
 977
 978         return false;
 979 }
 980
 981 static void close_endpoint(struct audio_endpoint *ep)
 982 {
 983         ipc_close_stream_cmd(ep->id);
 984         if (ep->fd >= 0) {
 985                 close(ep->fd);
 986                 ep->fd = -1;
 987         }
 988
 989         ep->codec->cleanup(ep->codec_data);
 990         ep->codec_data = NULL;
 991 }
 992
 993 static void downmix_to_mono(struct a2dp_stream_out *out, const uint8_t *buffer,
 994                                                                 size_t bytes)
 995 {
 996         const int16_t *input = (const void *) buffer;
 997         int16_t *output = (void *) out->downmix_buf;
 998         size_t i;
 999
1000         for (i = 0; i < bytes / 2; i++) {
1001                 int16_t l = le16_to_cpu(get_unaligned(&input[i * 2]));
1002                 int16_t r = le16_to_cpu(get_unaligned(&input[i * 2 + 1]));
1003
1004                 put_unaligned(cpu_to_le16((l + r) / 2), &output[i]);
1005         }
1006 }
1007
1008 static ssize_t out_write(struct audio_stream_out *stream, const void *buffer,
1009                                                                 size_t bytes)
1010 {
1011         struct a2dp_stream_out *out = (struct a2dp_stream_out *) stream;
1012
1013         /* just return in case we're closing */
1014         if (out->audio_state == AUDIO_A2DP_STATE_NONE)
1015                 return -1;
1016
1017         /* We can auto-start only from standby */
1018         if (out->audio_state == AUDIO_A2DP_STATE_STANDBY) {
1019                 DBG("stream in standby, auto-start");
1020
1021                 if (ipc_resume_stream_cmd(out->ep->id) != AUDIO_STATUS_SUCCESS)
1022                         return -1;
1023
1024                 out->ep->codec->resume(out->ep->codec_data);
1025
1026                 out->audio_state = AUDIO_A2DP_STATE_STARTED;
1027         }
1028
1029         if (out->audio_state != AUDIO_A2DP_STATE_STARTED) {
1030                 error("audio: stream not started");
1031                 return -1;
1032         }
1033
1034         if (out->ep->fd < 0) {
1035                 error("audio: no transport socket");
1036                 return -1;
1037         }
1038
1039         /* currently Android audioflinger is not able to provide mono stream on
1040          * A2DP output so down mixing needs to be done in hal-audio plugin.
1041          *
1042          * for reference see
1043          * AudioFlinger::PlaybackThread::readOutputParameters()
1044          * frameworks/av/services/audioflinger/Threads.cpp:1631
1045          */
1046         if (out->cfg.channels == AUDIO_CHANNEL_OUT_MONO) {
1047                 if (!out->downmix_buf) {
1048                         error("audio: downmix buffer not initialized");
1049                         return -1;
1050                 }
1051
1052                 downmix_to_mono(out, buffer, bytes);
1053
1054                 return out->ep->codec->write_data(out->ep->codec_data,
1055                                                         out->downmix_buf,
1056                                                         bytes / 2,
1057                                                         out->ep->fd) * 2;
1058         }
1059
1060         return out->ep->codec->write_data(out->ep->codec_data, buffer,
1061                                                         bytes, out->ep->fd);
1062 }
1063
1064 static uint32_t out_get_sample_rate(const struct audio_stream *stream)
1065 {
1066         struct a2dp_stream_out *out = (struct a2dp_stream_out *) stream;
1067
1068         DBG("");
1069
1070         return out->cfg.rate;
1071 }
1072
1073 static int out_set_sample_rate(struct audio_stream *stream, uint32_t rate)
1074 {
1075         struct a2dp_stream_out *out = (struct a2dp_stream_out *) stream;
1076
1077         DBG("");
1078
1079         if (rate != out->cfg.rate) {
1080                 warn("audio: cannot set sample rate to %d", rate);
1081                 return -1;
1082         }
1083
1084         return 0;
1085 }
1086
1087 static size_t out_get_buffer_size(const struct audio_stream *stream)
1088 {
1089         DBG("");
1090
1091         /* We should return proper buffer size calculated by codec (so each
1092          * input buffer is encoded into single media packed) but this does not
1093          * work well with AudioFlinger and causes problems. For this reason we
1094          * use magic value here and out_write code takes care of splitting
1095          * input buffer into multiple media packets.
1096          */
1097         return FIXED_BUFFER_SIZE;
1098 }
1099
1100 static uint32_t out_get_channels(const struct audio_stream *stream)
1101 {
1102         DBG("");
1103
1104         /* AudioFlinger can only provide stereo stream, so we return it here and
1105          * later we'll downmix this to mono in case codec requires it
1106          */
1107
1108         return AUDIO_CHANNEL_OUT_STEREO;
1109 }
1110
1111 static audio_format_t out_get_format(const struct audio_stream *stream)
1112 {
1113         struct a2dp_stream_out *out = (struct a2dp_stream_out *) stream;
1114
1115         DBG("");
1116
1117         return out->cfg.format;
1118 }
1119
1120 static int out_set_format(struct audio_stream *stream, audio_format_t format)
1121 {
1122         DBG("");
1123         return -ENOSYS;
1124 }
1125
1126 static int out_standby(struct audio_stream *stream)
1127 {
1128         struct a2dp_stream_out *out = (struct a2dp_stream_out *) stream;
1129
1130         DBG("");
1131
1132         if (out->audio_state == AUDIO_A2DP_STATE_STARTED) {
1133                 if (ipc_suspend_stream_cmd(out->ep->id) != AUDIO_STATUS_SUCCESS)
1134                         return -1;
1135                 out->audio_state = AUDIO_A2DP_STATE_STANDBY;
1136         }
1137
1138         return 0;
1139 }
1140
1141 static int out_dump(const struct audio_stream *stream, int fd)
1142 {
1143         DBG("");
1144         return -ENOSYS;
1145 }
1146
1147 static int out_set_parameters(struct audio_stream *stream, const char *kvpairs)
1148 {
1149         struct a2dp_stream_out *out = (struct a2dp_stream_out *) stream;
1150         char *kvpair;
1151         char *str;
1152         char *saveptr;
1153         bool enter_suspend = false;
1154         bool exit_suspend = false;
1155
1156         DBG("%s", kvpairs);
1157
1158         str = strdup(kvpairs);
1159         kvpair = strtok_r(str, ";", &saveptr);
1160
1161         for (; kvpair && *kvpair; kvpair = strtok_r(NULL, ";", &saveptr)) {
1162                 char *keyval;
1163
1164                 keyval = strchr(kvpair, '=');
1165                 if (!keyval)
1166                         continue;
1167
1168                 *keyval = '\0';
1169                 keyval++;
1170
1171                 if (!strcmp(kvpair, "closing")) {
1172                         if (!strcmp(keyval, "true"))
1173                                 out->audio_state = AUDIO_A2DP_STATE_NONE;
1174                 } else if (!strcmp(kvpair, "A2dpSuspended")) {
1175                         if (!strcmp(keyval, "true"))
1176                                 enter_suspend = true;
1177                         else
1178                                 exit_suspend = true;
1179                 }
1180         }
1181
1182         free(str);
1183
1184         if (enter_suspend && out->audio_state == AUDIO_A2DP_STATE_STARTED) {
1185                 if (ipc_suspend_stream_cmd(out->ep->id) != AUDIO_STATUS_SUCCESS)
1186                         return -1;
1187                 out->audio_state = AUDIO_A2DP_STATE_SUSPENDED;
1188         }
1189
1190         if (exit_suspend && out->audio_state == AUDIO_A2DP_STATE_SUSPENDED)
1191                 out->audio_state = AUDIO_A2DP_STATE_STANDBY;
1192
1193         return 0;
1194 }
1195
1196 static char *out_get_parameters(const struct audio_stream *stream,
1197                                                         const char *keys)
1198 {
1199         DBG("");
1200         return strdup("");
1201 }
1202
1203 static uint32_t out_get_latency(const struct audio_stream_out *stream)
1204 {
1205         struct a2dp_stream_out *out = (struct a2dp_stream_out *) stream;
1206         struct audio_endpoint *ep = out->ep;
1207         size_t pkt_duration;
1208
1209         DBG("");
1210
1211         pkt_duration = ep->codec->get_mediapacket_duration(ep->codec_data);
1212
1213         return FIXED_A2DP_PLAYBACK_LATENCY_MS + pkt_duration / 1000;
1214 }
1215
1216 static int out_set_volume(struct audio_stream_out *stream, float left,
1217                                                                 float right)
1218 {
1219         DBG("");
1220         /* volume controlled in audioflinger mixer (digital) */
1221         return -ENOSYS;
1222 }
1223
1224 static int out_get_render_position(const struct audio_stream_out *stream,
1225                                                         uint32_t *dsp_frames)
1226 {
1227         DBG("");
1228         return -ENOSYS;
1229 }
1230
1231 static int out_add_audio_effect(const struct audio_stream *stream,
1232                                                         effect_handle_t effect)
1233 {
1234         DBG("");
1235         return -ENOSYS;
1236 }
1237
1238 static int out_remove_audio_effect(const struct audio_stream *stream,
1239                                                         effect_handle_t effect)
1240 {
1241         DBG("");
1242         return -ENOSYS;
1243 }
1244
1245 static uint32_t in_get_sample_rate(const struct audio_stream *stream)
1246 {
1247         DBG("");
1248         return -ENOSYS;
1249 }
1250
1251 static int in_set_sample_rate(struct audio_stream *stream, uint32_t rate)
1252 {
1253         DBG("");
1254         return -ENOSYS;
1255 }
1256
1257 static size_t in_get_buffer_size(const struct audio_stream *stream)
1258 {
1259         DBG("");
1260         return -ENOSYS;
1261 }
1262
1263 static uint32_t in_get_channels(const struct audio_stream *stream)
1264 {
1265         DBG("");
1266         return -ENOSYS;
1267 }
1268
1269 static audio_format_t in_get_format(const struct audio_stream *stream)
1270 {
1271         DBG("");
1272         return -ENOSYS;
1273 }
1274
1275 static int in_set_format(struct audio_stream *stream, audio_format_t format)
1276 {
1277         DBG("");
1278         return -ENOSYS;
1279 }
1280
1281 static int in_standby(struct audio_stream *stream)
1282 {
1283         DBG("");
1284         return -ENOSYS;
1285 }
1286
1287 static int in_dump(const struct audio_stream *stream, int fd)
1288 {
1289         DBG("");
1290         return -ENOSYS;
1291 }
1292
1293 static int in_set_parameters(struct audio_stream *stream, const char *kvpairs)
1294 {
1295         DBG("");
1296         return -ENOSYS;
1297 }
1298
1299 static char *in_get_parameters(const struct audio_stream *stream,
1300                                                         const char *keys)
1301 {
1302         DBG("");
1303         return strdup("");
1304 }
1305
1306 static int in_set_gain(struct audio_stream_in *stream, float gain)
1307 {
1308         DBG("");
1309         return -ENOSYS;
1310 }
1311
1312 static ssize_t in_read(struct audio_stream_in *stream, void *buffer,
1313                                                                 size_t bytes)
1314 {
1315         DBG("");
1316         return -ENOSYS;
1317 }
1318
1319 static uint32_t in_get_input_frames_lost(struct audio_stream_in *stream)
1320 {
1321         DBG("");
1322         return -ENOSYS;
1323 }
1324
1325 static int in_add_audio_effect(const struct audio_stream *stream,
1326                                                         effect_handle_t effect)
1327 {
1328         DBG("");
1329         return -ENOSYS;
1330 }
1331
1332 static int in_remove_audio_effect(const struct audio_stream *stream,
1333                                                         effect_handle_t effect)
1334 {
1335         DBG("");
1336         return -ENOSYS;
1337 }
1338
1339 static int audio_open_output_stream(struct audio_hw_device *dev,
1340                                         audio_io_handle_t handle,
1341                                         audio_devices_t devices,
1342                                         audio_output_flags_t flags,
1343                                         struct audio_config *config,
1344                                         struct audio_stream_out **stream_out)
1345
1346 {
1347         struct a2dp_audio_dev *a2dp_dev = (struct a2dp_audio_dev *) dev;
1348         struct a2dp_stream_out *out;
1349
1350         out = calloc(1, sizeof(struct a2dp_stream_out));
1351         if (!out)
1352                 return -ENOMEM;
1353
1354         DBG("");
1355
1356         out->stream.common.get_sample_rate = out_get_sample_rate;
1357         out->stream.common.set_sample_rate = out_set_sample_rate;
1358         out->stream.common.get_buffer_size = out_get_buffer_size;
1359         out->stream.common.get_channels = out_get_channels;
1360         out->stream.common.get_format = out_get_format;
1361         out->stream.common.set_format = out_set_format;
1362         out->stream.common.standby = out_standby;
1363         out->stream.common.dump = out_dump;
1364         out->stream.common.set_parameters = out_set_parameters;
1365         out->stream.common.get_parameters = out_get_parameters;
1366         out->stream.common.add_audio_effect = out_add_audio_effect;
1367         out->stream.common.remove_audio_effect = out_remove_audio_effect;
1368         out->stream.get_latency = out_get_latency;
1369         out->stream.set_volume = out_set_volume;
1370         out->stream.write = out_write;
1371         out->stream.get_render_position = out_get_render_position;
1372
1373         /* TODO: for now we always use endpoint 0 */
1374         out->ep = &audio_endpoints[0];
1375
1376         if (!open_endpoint(out->ep, &out->cfg))
1377                 goto fail;
1378
1379         DBG("rate=%d channels=%d format=%d", out->cfg.rate,
1380                                         out->cfg.channels, out->cfg.format);
1381
1382         if (out->cfg.channels == AUDIO_CHANNEL_OUT_MONO) {
1383                 out->downmix_buf = malloc(FIXED_BUFFER_SIZE / 2);
1384                 if (!out->downmix_buf)
1385                         goto fail;
1386         }
1387
1388         *stream_out = &out->stream;
1389         a2dp_dev->out = out;
1390
1391         out->audio_state = AUDIO_A2DP_STATE_STANDBY;
1392
1393         return 0;
1394
1395 fail:
1396         error("audio: cannot open output stream");
1397         free(out);
1398         *stream_out = NULL;
1399         return -EIO;
1400 }
1401
1402 static void audio_close_output_stream(struct audio_hw_device *dev,
1403                                         struct audio_stream_out *stream)
1404 {
1405         struct a2dp_audio_dev *a2dp_dev = (struct a2dp_audio_dev *) dev;
1406         struct a2dp_stream_out *out = (struct a2dp_stream_out *) stream;
1407
1408         DBG("");
1409
1410         close_endpoint(a2dp_dev->out->ep);
1411
1412         free(out->downmix_buf);
1413
1414         free(stream);
1415         a2dp_dev->out = NULL;
1416 }
1417
1418 static int audio_set_parameters(struct audio_hw_device *dev,
1419                                                         const char *kvpairs)
1420 {
1421         struct a2dp_audio_dev *a2dp_dev = (struct a2dp_audio_dev *) dev;
1422         struct a2dp_stream_out *out = a2dp_dev->out;
1423
1424         DBG("");
1425
1426         if (!out)
1427                 return 0;
1428
1429         return out->stream.common.set_parameters((struct audio_stream *) out,
1430                                                                 kvpairs);
1431 }
1432
1433 static char *audio_get_parameters(const struct audio_hw_device *dev,
1434                                                         const char *keys)
1435 {
1436         DBG("");
1437         return strdup("");
1438 }
1439
1440 static int audio_init_check(const struct audio_hw_device *dev)
1441 {
1442         DBG("");
1443         return 0;
1444 }
1445
1446 static int audio_set_voice_volume(struct audio_hw_device *dev, float volume)
1447 {
1448         DBG("");
1449         return -ENOSYS;
1450 }
1451
1452 static int audio_set_master_volume(struct audio_hw_device *dev, float volume)
1453 {
1454         DBG("");
1455         return -ENOSYS;
1456 }
1457
1458 static int audio_set_mode(struct audio_hw_device *dev, int mode)
1459 {
1460         DBG("");
1461         return -ENOSYS;
1462 }
1463
1464 static int audio_set_mic_mute(struct audio_hw_device *dev, bool state)
1465 {
1466         DBG("");
1467         return -ENOSYS;
1468 }
1469
1470 static int audio_get_mic_mute(const struct audio_hw_device *dev, bool *state)
1471 {
1472         DBG("");
1473         return -ENOSYS;
1474 }
1475
1476 static size_t audio_get_input_buffer_size(const struct audio_hw_device *dev,
1477                                         const struct audio_config *config)
1478 {
1479         DBG("");
1480         return -ENOSYS;
1481 }
1482
1483 static int audio_open_input_stream(struct audio_hw_device *dev,
1484                                         audio_io_handle_t handle,
1485                                         audio_devices_t devices,
1486                                         struct audio_config *config,
1487                                         struct audio_stream_in **stream_in)
1488 {
1489         struct audio_stream_in *in;
1490
1491         DBG("");
1492
1493         in = calloc(1, sizeof(struct audio_stream_in));
1494         if (!in)
1495                 return -ENOMEM;
1496
1497         in->common.get_sample_rate = in_get_sample_rate;
1498         in->common.set_sample_rate = in_set_sample_rate;
1499         in->common.get_buffer_size = in_get_buffer_size;
1500         in->common.get_channels = in_get_channels;
1501         in->common.get_format = in_get_format;
1502         in->common.set_format = in_set_format;
1503         in->common.standby = in_standby;
1504         in->common.dump = in_dump;
1505         in->common.set_parameters = in_set_parameters;
1506         in->common.get_parameters = in_get_parameters;
1507         in->common.add_audio_effect = in_add_audio_effect;
1508         in->common.remove_audio_effect = in_remove_audio_effect;
1509         in->set_gain = in_set_gain;
1510         in->read = in_read;
1511         in->get_input_frames_lost = in_get_input_frames_lost;
1512
1513         *stream_in = in;
1514
1515         return 0;
1516 }
1517
1518 static void audio_close_input_stream(struct audio_hw_device *dev,
1519                                         struct audio_stream_in *stream_in)
1520 {
1521         DBG("");
1522         free(stream_in);
1523 }
1524
1525 static int audio_dump(const audio_hw_device_t *device, int fd)
1526 {
1527         DBG("");
1528         return -ENOSYS;
1529 }
1530
1531 static int audio_close(hw_device_t *device)
1532 {
1533         struct a2dp_audio_dev *a2dp_dev = (struct a2dp_audio_dev *)device;
1534
1535         DBG("");
1536
1537         unregister_endpoints();
1538
1539         shutdown(listen_sk, SHUT_RDWR);
1540         shutdown(audio_sk, SHUT_RDWR);
1541
1542         pthread_join(ipc_th, NULL);
1543
1544         close(listen_sk);
1545         listen_sk = -1;
1546
1547         free(a2dp_dev);
1548         return 0;
1549 }
1550
1551 static void *ipc_handler(void *data)
1552 {
1553         bool done = false;
1554         struct pollfd pfd;
1555         int sk;
1556
1557         DBG("");
1558
1559         while (!done) {
1560                 DBG("Waiting for connection ...");
1561
1562                 sk = accept(listen_sk, NULL, NULL);
1563                 if (sk < 0) {
1564                         int err = errno;
1565
1566                         if (err == EINTR)
1567                                 continue;
1568
1569                         if (err != ECONNABORTED && err != EINVAL)
1570                                 error("audio: Failed to accept socket: %d (%s)",
1571                                                         err, strerror(err));
1572
1573                         break;
1574                 }
1575
1576                 pthread_mutex_lock(&sk_mutex);
1577                 audio_sk = sk;
1578                 pthread_mutex_unlock(&sk_mutex);
1579
1580                 DBG("Audio IPC: Connected");
1581
1582                 if (register_endpoints() != AUDIO_STATUS_SUCCESS) {
1583                         error("audio: Failed to register endpoints");
1584
1585                         unregister_endpoints();
1586
1587                         pthread_mutex_lock(&sk_mutex);
1588                         shutdown(audio_sk, SHUT_RDWR);
1589                         close(audio_sk);
1590                         audio_sk = -1;
1591                         pthread_mutex_unlock(&sk_mutex);
1592
1593                         continue;
1594                 }
1595
1596                 memset(&pfd, 0, sizeof(pfd));
1597                 pfd.fd = audio_sk;
1598                 pfd.events = POLLHUP | POLLERR | POLLNVAL;
1599
1600                 /* Check if socket is still alive. Empty while loop.*/
1601                 while (poll(&pfd, 1, -1) < 0 && errno == EINTR);
1602
1603                 if (pfd.revents & (POLLHUP | POLLERR | POLLNVAL)) {
1604                         info("Audio HAL: Socket closed");
1605
1606                         pthread_mutex_lock(&sk_mutex);
1607                         close(audio_sk);
1608                         audio_sk = -1;
1609                         pthread_mutex_unlock(&sk_mutex);
1610                 }
1611         }
1612
1613         /* audio_sk is closed at this point, just cleanup endpoints states */
1614         memset(audio_endpoints, 0, sizeof(audio_endpoints));
1615
1616         info("Closing Audio IPC thread");
1617         return NULL;
1618 }
1619
1620 static int audio_ipc_init(void)
1621 {
1622         struct sockaddr_un addr;
1623         int err;
1624         int sk;
1625
1626         DBG("");
1627
1628         sk = socket(PF_LOCAL, SOCK_SEQPACKET, 0);
1629         if (sk < 0) {
1630                 err = -errno;
1631                 error("audio: Failed to create socket: %d (%s)", -err,
1632                                                                 strerror(-err));
1633                 return err;
1634         }
1635
1636         memset(&addr, 0, sizeof(addr));
1637         addr.sun_family = AF_UNIX;
1638
1639         memcpy(addr.sun_path, BLUEZ_AUDIO_SK_PATH,
1640                                         sizeof(BLUEZ_AUDIO_SK_PATH));
1641
1642         if (bind(sk, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
1643                 err = -errno;
1644                 error("audio: Failed to bind socket: %d (%s)", -err,
1645                                                                 strerror(-err));
1646                 goto failed;
1647         }
1648
1649         if (listen(sk, 1) < 0) {
1650                 err = -errno;
1651                 error("audio: Failed to listen on the socket: %d (%s)", -err,
1652                                                                 strerror(-err));
1653                 goto failed;
1654         }
1655
1656         listen_sk = sk;
1657
1658         err = pthread_create(&ipc_th, NULL, ipc_handler, NULL);
1659         if (err) {
1660                 err = -err;
1661                 ipc_th = 0;
1662                 error("audio: Failed to start Audio IPC thread: %d (%s)",
1663                                                         -err, strerror(-err));
1664                 goto failed;
1665         }
1666
1667         return 0;
1668
1669 failed:
1670         close(sk);
1671         return err;
1672 }
1673
1674 static int audio_open(const hw_module_t *module, const char *name,
1675                                                         hw_device_t **device)
1676 {
1677         struct a2dp_audio_dev *a2dp_dev;
1678         int err;
1679
1680         DBG("");
1681
1682         if (strcmp(name, AUDIO_HARDWARE_INTERFACE)) {
1683                 error("audio: interface %s not matching [%s]", name,
1684                                                 AUDIO_HARDWARE_INTERFACE);
1685                 return -EINVAL;
1686         }
1687
1688         err = audio_ipc_init();
1689         if (err < 0)
1690                 return err;
1691
1692         a2dp_dev = calloc(1, sizeof(struct a2dp_audio_dev));
1693         if (!a2dp_dev)
1694                 return -ENOMEM;
1695
1696         a2dp_dev->dev.common.tag = HARDWARE_DEVICE_TAG;
1697         a2dp_dev->dev.common.version = AUDIO_DEVICE_API_VERSION_CURRENT;
1698         a2dp_dev->dev.common.module = (struct hw_module_t *) module;
1699         a2dp_dev->dev.common.close = audio_close;
1700
1701         a2dp_dev->dev.init_check = audio_init_check;
1702         a2dp_dev->dev.set_voice_volume = audio_set_voice_volume;
1703         a2dp_dev->dev.set_master_volume = audio_set_master_volume;
1704         a2dp_dev->dev.set_mode = audio_set_mode;
1705         a2dp_dev->dev.set_mic_mute = audio_set_mic_mute;
1706         a2dp_dev->dev.get_mic_mute = audio_get_mic_mute;
1707         a2dp_dev->dev.set_parameters = audio_set_parameters;
1708         a2dp_dev->dev.get_parameters = audio_get_parameters;
1709         a2dp_dev->dev.get_input_buffer_size = audio_get_input_buffer_size;
1710         a2dp_dev->dev.open_output_stream = audio_open_output_stream;
1711         a2dp_dev->dev.close_output_stream = audio_close_output_stream;
1712         a2dp_dev->dev.open_input_stream = audio_open_input_stream;
1713         a2dp_dev->dev.close_input_stream = audio_close_input_stream;
1714         a2dp_dev->dev.dump = audio_dump;
1715
1716         /* Note that &a2dp_dev->dev.common is the same pointer as a2dp_dev.
1717          * This results from the structure of following structs:a2dp_audio_dev,
1718          * audio_hw_device. We will rely on this later in the code.*/
1719         *device = &a2dp_dev->dev.common;
1720
1721         return 0;
1722 }
1723
1724 static struct hw_module_methods_t hal_module_methods = {
1725         .open = audio_open,
1726 };
1727
1728 struct audio_module HAL_MODULE_INFO_SYM = {
1729         .common = {
1730         .tag = HARDWARE_MODULE_TAG,
1731         .version_major = 1,
1732         .version_minor = 0,
1733         .id = AUDIO_HARDWARE_MODULE_ID,
1734         .name = "A2DP Bluez HW HAL",
1735         .author = "Intel Corporation",
1736         .methods = &hal_module_methods,
1737         },
1738 };