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