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