android/hal-audio.c

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