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