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