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