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