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