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