android/hal-audio.c

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