audio_a2dp_hw/audio_a2dp_hw.c

   1 /******************************************************************************
   2  *
   3  *  Copyright (C) 2009-2012 Broadcom Corporation
   4  *
   5  *  Licensed under the Apache License, Version 2.0 (the "License");
   6  *  you may not use this file except in compliance with the License.
   7  *  You may obtain a copy of the License at:
   8  *
   9  *  http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  *  Unless required by applicable law or agreed to in writing, software
  12  *  distributed under the License is distributed on an "AS IS" BASIS,
  13  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  *  See the License for the specific language governing permissions and
  15  *  limitations under the License.
  16  *
  17  ******************************************************************************/
  18
  19 /*****************************************************************************
  20  *
  21  *  Filename:      audio_a2dp_hw.c
  22  *
  23  *  Description:   Implements hal for bluedroid a2dp audio device
  24  *
  25  *****************************************************************************/
  26
  27 #define LOG_TAG "bt_a2dp_hw"
  28
  29 #include <errno.h>
  30 #include <fcntl.h>
  31 #include <inttypes.h>
  32 #include <pthread.h>
  33 #include <stdint.h>
  34 #include <sys/errno.h>
  35 #include <sys/socket.h>
  36 #include <sys/stat.h>
  37 #include <sys/time.h>
  38 #include <sys/un.h>
  39 #include <unistd.h>
  40
  41 #include <hardware/audio.h>
  42 #include <hardware/hardware.h>
  43 #include <system/audio.h>
  44
  45 #include "audio_a2dp_hw.h"
  46 #include "bt_utils.h"
  47 #include "osi/include/hash_map.h"
  48 #include "osi/include/hash_map_utils.h"
  49 #include "osi/include/log.h"
  50 #include "osi/include/osi.h"
  51 #include "osi/include/socket_utils/sockets.h"
  52
  53 /*****************************************************************************
  54 **  Constants & Macros
  55 ******************************************************************************/
  56
  57 #define CTRL_CHAN_RETRY_COUNT 3
  58 #define USEC_PER_SEC 1000000L
  59 #define SOCK_SEND_TIMEOUT_MS 2000  /* Timeout for sending */
  60 #define SOCK_RECV_TIMEOUT_MS 5000  /* Timeout for receiving */
  61
  62 // set WRITE_POLL_MS to 0 for blocking sockets, nonzero for polled non-blocking sockets
  63 #define WRITE_POLL_MS 20
  64
  65 #define CASE_RETURN_STR(const) case const: return #const;
  66
  67 #define FNLOG()             LOG_VERBOSE(LOG_TAG, "%s", __FUNCTION__);
  68 #define DEBUG(fmt, ...)     LOG_VERBOSE(LOG_TAG, "%s: " fmt,__FUNCTION__, ## __VA_ARGS__)
  69 #define INFO(fmt, ...)      LOG_INFO(LOG_TAG, "%s: " fmt,__FUNCTION__, ## __VA_ARGS__)
  70 #define WARN(fmt, ...)      LOG_WARN(LOG_TAG, "%s: " fmt,__FUNCTION__, ## __VA_ARGS__)
  71 #define ERROR(fmt, ...)     LOG_ERROR(LOG_TAG, "%s: " fmt,__FUNCTION__, ## __VA_ARGS__)
  72
  73 #define ASSERTC(cond, msg, val) if (!(cond)) {ERROR("### ASSERT : %s line %d %s (%d) ###", __FILE__, __LINE__, msg, val);}
  74
  75 /*****************************************************************************
  76 **  Local type definitions
  77 ******************************************************************************/
  78
  79 typedef enum {
  80     AUDIO_A2DP_STATE_STARTING,
  81     AUDIO_A2DP_STATE_STARTED,
  82     AUDIO_A2DP_STATE_STOPPING,
  83     AUDIO_A2DP_STATE_STOPPED,
  84     AUDIO_A2DP_STATE_SUSPENDED, /* need explicit set param call to resume (suspend=false) */
  85     AUDIO_A2DP_STATE_STANDBY    /* allows write to autoresume */
  86 } a2dp_state_t;
  87
  88 struct a2dp_stream_in;
  89 struct a2dp_stream_out;
  90
  91 struct a2dp_audio_device {
  92     struct audio_hw_device device;
  93     struct a2dp_stream_in  *input;
  94     struct a2dp_stream_out *output;
  95 };
  96
  97 struct a2dp_config {
  98     uint32_t                rate;
  99     uint32_t                channel_flags;
 100     int                     format;
 101 };
 102
 103 /* move ctrl_fd outside output stream and keep open until HAL unloaded ? */
 104
 105 struct a2dp_stream_common {
 106     pthread_mutex_t         lock;
 107     int                     ctrl_fd;
 108     int                     audio_fd;
 109     size_t                  buffer_sz;
 110     struct a2dp_config      cfg;
 111     a2dp_state_t            state;
 112 };
 113
 114 struct a2dp_stream_out {
 115     struct audio_stream_out stream;
 116     struct a2dp_stream_common common;
 117     uint64_t frames_presented; // frames written, never reset
 118     uint64_t frames_rendered;  // frames written, reset on standby
 119 };
 120
 121 struct a2dp_stream_in {
 122     struct audio_stream_in  stream;
 123     struct a2dp_stream_common common;
 124 };
 125
 126 /*****************************************************************************
 127 **  Static variables
 128 ******************************************************************************/
 129
 130 /*****************************************************************************
 131 **  Static functions
 132 ******************************************************************************/
 133
 134 static size_t out_get_buffer_size(const struct audio_stream *stream);
 135
 136 /*****************************************************************************
 137 **  Externs
 138 ******************************************************************************/
 139
 140 /*****************************************************************************
 141 **  Functions
 142 ******************************************************************************/
 143 /* Function used only in debug mode */
 144 static const char* dump_a2dp_ctrl_event(char event) __attribute__ ((unused));
 145 static void a2dp_open_ctrl_path(struct a2dp_stream_common *common);
 146
 147 /*****************************************************************************
 148 **   Miscellaneous helper functions
 149 ******************************************************************************/
 150
 151 static const char* dump_a2dp_ctrl_event(char event)
 152 {
 153     switch(event)
 154     {
 155         CASE_RETURN_STR(A2DP_CTRL_CMD_NONE)
 156         CASE_RETURN_STR(A2DP_CTRL_CMD_CHECK_READY)
 157         CASE_RETURN_STR(A2DP_CTRL_CMD_START)
 158         CASE_RETURN_STR(A2DP_CTRL_CMD_STOP)
 159         CASE_RETURN_STR(A2DP_CTRL_CMD_SUSPEND)
 160         default:
 161             return "UNKNOWN MSG ID";
 162     }
 163 }
 164
 165 /* logs timestamp with microsec precision
 166    pprev is optional in case a dedicated diff is required */
 167 static void ts_log(char *tag, int val, struct timespec *pprev_opt)
 168 {
 169     struct timespec now;
 170     static struct timespec prev = {0,0};
 171     unsigned long long now_us;
 172     unsigned long long diff_us;
 173     UNUSED(tag);
 174     UNUSED(val);
 175
 176     clock_gettime(CLOCK_MONOTONIC, &now);
 177
 178     now_us = now.tv_sec*USEC_PER_SEC + now.tv_nsec/1000;
 179
 180     if (pprev_opt)
 181     {
 182         diff_us = (now.tv_sec - prev.tv_sec) * USEC_PER_SEC + (now.tv_nsec - prev.tv_nsec)/1000;
 183         *pprev_opt = now;
 184         DEBUG("[%s] ts %08lld, *diff %08lld, val %d", tag, now_us, diff_us, val);
 185     }
 186     else
 187     {
 188         diff_us = (now.tv_sec - prev.tv_sec) * USEC_PER_SEC + (now.tv_nsec - prev.tv_nsec)/1000;
 189         prev = now;
 190         DEBUG("[%s] ts %08lld, diff %08lld, val %d", tag, now_us, diff_us, val);
 191     }
 192 }
 193
 194 static int calc_audiotime(struct a2dp_config cfg, int bytes)
 195 {
 196     int chan_count = popcount(cfg.channel_flags);
 197
 198     ASSERTC(cfg.format == AUDIO_FORMAT_PCM_16_BIT,
 199             "unsupported sample sz", cfg.format);
 200
 201     return (int)(((int64_t)bytes * (1000000 / (chan_count * 2))) / cfg.rate);
 202 }
 203
 204 /*****************************************************************************
 205 **
 206 **   bluedroid stack adaptation
 207 **
 208 *****************************************************************************/
 209
 210 static int skt_connect(char *path, size_t buffer_sz)
 211 {
 212     int ret;
 213     int skt_fd;
 214     int len;
 215
 216     INFO("connect to %s (sz %zu)", path, buffer_sz);
 217
 218     skt_fd = socket(AF_LOCAL, SOCK_STREAM, 0);
 219
 220     if(osi_socket_local_client_connect(skt_fd, path,
 221             ANDROID_SOCKET_NAMESPACE_ABSTRACT, SOCK_STREAM) < 0)
 222     {
 223         ERROR("failed to connect (%s)", strerror(errno));
 224         close(skt_fd);
 225         return -1;
 226     }
 227
 228     len = buffer_sz;
 229     ret = setsockopt(skt_fd, SOL_SOCKET, SO_SNDBUF, (char*)&len, (int)sizeof(len));
 230     if (ret < 0)
 231         ERROR("setsockopt failed (%s)", strerror(errno));
 232
 233     ret = setsockopt(skt_fd, SOL_SOCKET, SO_RCVBUF, (char*)&len, (int)sizeof(len));
 234     if (ret < 0)
 235         ERROR("setsockopt failed (%s)", strerror(errno));
 236
 237     /* Socket send/receive timeout value */
 238     struct timeval tv;
 239     tv.tv_sec = SOCK_SEND_TIMEOUT_MS / 1000;
 240     tv.tv_usec = (SOCK_SEND_TIMEOUT_MS % 1000) * 1000;
 241
 242     ret = setsockopt(skt_fd, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(tv));
 243     if (ret < 0)
 244         ERROR("setsockopt failed (%s)", strerror(errno));
 245
 246     tv.tv_sec = SOCK_RECV_TIMEOUT_MS / 1000;
 247     tv.tv_usec = (SOCK_RECV_TIMEOUT_MS % 1000) * 1000;
 248
 249     ret = setsockopt(skt_fd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
 250     if (ret < 0)
 251         ERROR("setsockopt failed (%s)", strerror(errno));
 252
 253     INFO("connected to stack fd = %d", skt_fd);
 254
 255     return skt_fd;
 256 }
 257
 258 static int skt_read(int fd, void *p, size_t len)
 259 {
 260     ssize_t read;
 261
 262     FNLOG();
 263
 264     ts_log("skt_read recv", len, NULL);
 265
 266     OSI_NO_INTR(read = recv(fd, p, len, MSG_NOSIGNAL));
 267     if (read == -1)
 268         ERROR("read failed with errno=%d\n", errno);
 269
 270     return (int)read;
 271 }
 272
 273 static int skt_write(int fd, const void *p, size_t len)
 274 {
 275     ssize_t sent;
 276     FNLOG();
 277
 278     ts_log("skt_write", len, NULL);
 279
 280     if (WRITE_POLL_MS == 0) {
 281         // do not poll, use blocking send
 282         OSI_NO_INTR(sent = send(fd, p, len, MSG_NOSIGNAL));
 283         if (sent == -1)
 284             ERROR("write failed with error(%s)", strerror(errno));
 285
 286         return (int)sent;
 287     }
 288
 289     // use non-blocking send, poll
 290     int ms_timeout = SOCK_SEND_TIMEOUT_MS;
 291     size_t count = 0;
 292     while (count < len) {
 293         OSI_NO_INTR(sent = send(fd, p, len - count, MSG_NOSIGNAL | MSG_DONTWAIT));
 294         if (sent == -1) {
 295             if (errno != EAGAIN && errno != EWOULDBLOCK) {
 296                 ERROR("write failed with error(%s)", strerror(errno));
 297                 return -1;
 298             }
 299             if (ms_timeout >= WRITE_POLL_MS) {
 300                 usleep(WRITE_POLL_MS * 1000);
 301                 ms_timeout -= WRITE_POLL_MS;
 302                 continue;
 303             }
 304             WARN("write timeout exceeded, sent %zu bytes", count);
 305             return -1;
 306         }
 307         count += sent;
 308         p = (const uint8_t *)p + sent;
 309     }
 310     return (int)count;
 311 }
 312
 313 static int skt_disconnect(int fd)
 314 {
 315     INFO("fd %d", fd);
 316
 317     if (fd != AUDIO_SKT_DISCONNECTED)
 318     {
 319         shutdown(fd, SHUT_RDWR);
 320         close(fd);
 321     }
 322     return 0;
 323 }
 324
 325
 326
 327 /*****************************************************************************
 328 **
 329 **  AUDIO CONTROL PATH
 330 **
 331 *****************************************************************************/
 332
 333 static int a2dp_ctrl_receive(struct a2dp_stream_common *common, void* buffer, int length)
 334 {
 335     ssize_t ret;
 336     int i;
 337
 338     for (i = 0;; i++) {
 339         OSI_NO_INTR(ret = recv(common->ctrl_fd, buffer, length, MSG_NOSIGNAL));
 340         if (ret > 0) {
 341             break;
 342         }
 343         if (ret == 0) {
 344             ERROR("ack failed: peer closed");
 345             break;
 346         }
 347         if (errno != EWOULDBLOCK && errno != EAGAIN) {
 348             ERROR("ack failed: error(%s)", strerror(errno));
 349             break;
 350         }
 351         if (i == (CTRL_CHAN_RETRY_COUNT - 1)) {
 352             ERROR("ack failed: max retry count");
 353             break;
 354         }
 355         INFO("ack failed (%s), retrying", strerror(errno));
 356     }
 357     if (ret <= 0) {
 358         skt_disconnect(common->ctrl_fd);
 359         common->ctrl_fd = AUDIO_SKT_DISCONNECTED;
 360     }
 361     return ret;
 362 }
 363
 364 static int a2dp_command(struct a2dp_stream_common *common, char cmd)
 365 {
 366     char ack;
 367
 368     DEBUG("A2DP COMMAND %s", dump_a2dp_ctrl_event(cmd));
 369
 370     if (common->ctrl_fd == AUDIO_SKT_DISCONNECTED) {
 371         INFO("recovering from previous error");
 372         a2dp_open_ctrl_path(common);
 373         if (common->ctrl_fd == AUDIO_SKT_DISCONNECTED) {
 374             ERROR("failure to open ctrl path");
 375             return -1;
 376         }
 377     }
 378
 379     /* send command */
 380     ssize_t sent;
 381     OSI_NO_INTR(sent = send(common->ctrl_fd, &cmd, 1, MSG_NOSIGNAL));
 382     if (sent == -1)
 383     {
 384         ERROR("cmd failed (%s)", strerror(errno));
 385         skt_disconnect(common->ctrl_fd);
 386         common->ctrl_fd = AUDIO_SKT_DISCONNECTED;
 387         return -1;
 388     }
 389
 390     /* wait for ack byte */
 391     if (a2dp_ctrl_receive(common, &ack, 1) < 0) {
 392         ERROR("A2DP COMMAND %s: no ACK", dump_a2dp_ctrl_event(cmd));
 393         return -1;
 394     }
 395
 396     DEBUG("A2DP COMMAND %s DONE STATUS %d", dump_a2dp_ctrl_event(cmd), ack);
 397
 398     if (ack == A2DP_CTRL_ACK_INCALL_FAILURE)
 399         return ack;
 400     if (ack != A2DP_CTRL_ACK_SUCCESS) {
 401         ERROR("A2DP COMMAND %s error %d", dump_a2dp_ctrl_event(cmd), ack);
 402         return -1;
 403     }
 404
 405     return 0;
 406 }
 407
 408 static int check_a2dp_ready(struct a2dp_stream_common *common)
 409 {
 410     if (a2dp_command(common, A2DP_CTRL_CMD_CHECK_READY) < 0)
 411     {
 412         ERROR("check a2dp ready failed");
 413         return -1;
 414     }
 415     return 0;
 416 }
 417
 418 static int a2dp_read_audio_config(struct a2dp_stream_common *common)
 419 {
 420     uint32_t sample_rate;
 421     uint8_t channel_count;
 422
 423     if (a2dp_command(common, A2DP_CTRL_GET_AUDIO_CONFIG) < 0)
 424     {
 425         ERROR("check a2dp ready failed");
 426         return -1;
 427     }
 428
 429     if (a2dp_ctrl_receive(common, &sample_rate, 4) < 0)
 430         return -1;
 431     if (a2dp_ctrl_receive(common, &channel_count, 1) < 0)
 432         return -1;
 433
 434     common->cfg.channel_flags = (channel_count == 1 ? AUDIO_CHANNEL_IN_MONO : AUDIO_CHANNEL_IN_STEREO);
 435     common->cfg.format = AUDIO_STREAM_DEFAULT_FORMAT;
 436     common->cfg.rate = sample_rate;
 437
 438     INFO("got config %d %d", common->cfg.format, common->cfg.rate);
 439
 440     return 0;
 441 }
 442
 443 static void a2dp_open_ctrl_path(struct a2dp_stream_common *common)
 444 {
 445     int i;
 446
 447     /* retry logic to catch any timing variations on control channel */
 448     for (i = 0; i < CTRL_CHAN_RETRY_COUNT; i++)
 449     {
 450         /* connect control channel if not already connected */
 451         if ((common->ctrl_fd = skt_connect(A2DP_CTRL_PATH, common->buffer_sz)) > 0)
 452         {
 453             /* success, now check if stack is ready */
 454             if (check_a2dp_ready(common) == 0)
 455                 break;
 456
 457             ERROR("error : a2dp not ready, wait 250 ms and retry");
 458             usleep(250000);
 459             skt_disconnect(common->ctrl_fd);
 460             common->ctrl_fd = AUDIO_SKT_DISCONNECTED;
 461         }
 462
 463         /* ctrl channel not ready, wait a bit */
 464         usleep(250000);
 465     }
 466 }
 467
 468 /*****************************************************************************
 469 **
 470 ** AUDIO DATA PATH
 471 **
 472 *****************************************************************************/
 473
 474 static void a2dp_stream_common_init(struct a2dp_stream_common *common)
 475 {
 476     pthread_mutexattr_t lock_attr;
 477
 478     FNLOG();
 479
 480     pthread_mutexattr_init(&lock_attr);
 481     pthread_mutexattr_settype(&lock_attr, PTHREAD_MUTEX_RECURSIVE);
 482     pthread_mutex_init(&common->lock, &lock_attr);
 483
 484     common->ctrl_fd = AUDIO_SKT_DISCONNECTED;
 485     common->audio_fd = AUDIO_SKT_DISCONNECTED;
 486     common->state = AUDIO_A2DP_STATE_STOPPED;
 487
 488     /* manages max capacity of socket pipe */
 489     common->buffer_sz = AUDIO_STREAM_OUTPUT_BUFFER_SZ;
 490 }
 491
 492 static int start_audio_datapath(struct a2dp_stream_common *common)
 493 {
 494     INFO("state %d", common->state);
 495
 496     int oldstate = common->state;
 497     common->state = AUDIO_A2DP_STATE_STARTING;
 498
 499     int a2dp_status = a2dp_command(common, A2DP_CTRL_CMD_START);
 500     if (a2dp_status < 0)
 501     {
 502         ERROR("Audiopath start failed (status %d)", a2dp_status);
 503         goto error;
 504     }
 505     else if (a2dp_status == A2DP_CTRL_ACK_INCALL_FAILURE)
 506     {
 507         ERROR("Audiopath start failed - in call, move to suspended");
 508         goto error;
 509     }
 510
 511     /* connect socket if not yet connected */
 512     if (common->audio_fd == AUDIO_SKT_DISCONNECTED)
 513     {
 514         common->audio_fd = skt_connect(A2DP_DATA_PATH, common->buffer_sz);
 515         if (common->audio_fd < 0)
 516         {
 517             ERROR("Audiopath start failed - error opening data socket");
 518             goto error;
 519         }
 520     }
 521     common->state = AUDIO_A2DP_STATE_STARTED;
 522     return 0;
 523
 524 error:
 525     common->state = oldstate;
 526     return -1;
 527 }
 528
 529 static int stop_audio_datapath(struct a2dp_stream_common *common)
 530 {
 531     int oldstate = common->state;
 532
 533     INFO("state %d", common->state);
 534
 535     /* prevent any stray output writes from autostarting the stream
 536        while stopping audiopath */
 537     common->state = AUDIO_A2DP_STATE_STOPPING;
 538
 539     if (a2dp_command(common, A2DP_CTRL_CMD_STOP) < 0)
 540     {
 541         ERROR("audiopath stop failed");
 542         common->state = oldstate;
 543         return -1;
 544     }
 545
 546     common->state = AUDIO_A2DP_STATE_STOPPED;
 547
 548     /* disconnect audio path */
 549     skt_disconnect(common->audio_fd);
 550     common->audio_fd = AUDIO_SKT_DISCONNECTED;
 551
 552     return 0;
 553 }
 554
 555 static int suspend_audio_datapath(struct a2dp_stream_common *common, bool standby)
 556 {
 557     INFO("state %d", common->state);
 558
 559     if (common->state == AUDIO_A2DP_STATE_STOPPING)
 560         return -1;
 561
 562     if (a2dp_command(common, A2DP_CTRL_CMD_SUSPEND) < 0)
 563         return -1;
 564
 565     if (standby)
 566         common->state = AUDIO_A2DP_STATE_STANDBY;
 567     else
 568         common->state = AUDIO_A2DP_STATE_SUSPENDED;
 569
 570     /* disconnect audio path */
 571     skt_disconnect(common->audio_fd);
 572
 573     common->audio_fd = AUDIO_SKT_DISCONNECTED;
 574
 575     return 0;
 576 }
 577
 578
 579 /*****************************************************************************
 580 **
 581 **  audio output callbacks
 582 **
 583 *****************************************************************************/
 584
 585 static ssize_t out_write(struct audio_stream_out *stream, const void* buffer,
 586                          size_t bytes)
 587 {
 588     struct a2dp_stream_out *out = (struct a2dp_stream_out *)stream;
 589     int sent = -1;
 590
 591     DEBUG("write %zu bytes (fd %d)", bytes, out->common.audio_fd);
 592
 593     pthread_mutex_lock(&out->common.lock);
 594     if (out->common.state == AUDIO_A2DP_STATE_SUSPENDED ||
 595             out->common.state == AUDIO_A2DP_STATE_STOPPING) {
 596         DEBUG("stream suspended or closing");
 597         goto finish;
 598     }
 599
 600     /* only allow autostarting if we are in stopped or standby */
 601     if ((out->common.state == AUDIO_A2DP_STATE_STOPPED) ||
 602         (out->common.state == AUDIO_A2DP_STATE_STANDBY))
 603     {
 604         if (start_audio_datapath(&out->common) < 0)
 605         {
 606             goto finish;
 607         }
 608     }
 609     else if (out->common.state != AUDIO_A2DP_STATE_STARTED)
 610     {
 611         ERROR("stream not in stopped or standby");
 612         goto finish;
 613     }
 614
 615     pthread_mutex_unlock(&out->common.lock);
 616     sent = skt_write(out->common.audio_fd, buffer,  bytes);
 617     pthread_mutex_lock(&out->common.lock);
 618
 619     if (sent == -1) {
 620         skt_disconnect(out->common.audio_fd);
 621         out->common.audio_fd = AUDIO_SKT_DISCONNECTED;
 622         if ((out->common.state != AUDIO_A2DP_STATE_SUSPENDED) &&
 623                 (out->common.state != AUDIO_A2DP_STATE_STOPPING)) {
 624             out->common.state = AUDIO_A2DP_STATE_STOPPED;
 625         } else {
 626             ERROR("write failed : stream suspended, avoid resetting state");
 627         }
 628         goto finish;
 629     }
 630
 631 finish: ;
 632     const size_t frames = bytes / audio_stream_out_frame_size(stream);
 633     out->frames_rendered += frames;
 634     out->frames_presented += frames;
 635     pthread_mutex_unlock(&out->common.lock);
 636
 637     // If send didn't work out, sleep to emulate write delay.
 638     if (sent == -1) {
 639         const int us_delay = calc_audiotime(out->common.cfg, bytes);
 640         DEBUG("emulate a2dp write delay (%d us)", us_delay);
 641         usleep(us_delay);
 642     }
 643     return bytes;
 644 }
 645
 646 static uint32_t out_get_sample_rate(const struct audio_stream *stream)
 647 {
 648     struct a2dp_stream_out *out = (struct a2dp_stream_out *)stream;
 649
 650     DEBUG("rate %" PRIu32,out->common.cfg.rate);
 651
 652     return out->common.cfg.rate;
 653 }
 654
 655 static int out_set_sample_rate(struct audio_stream *stream, uint32_t rate)
 656 {
 657     struct a2dp_stream_out *out = (struct a2dp_stream_out *)stream;
 658
 659     DEBUG("out_set_sample_rate : %" PRIu32, rate);
 660
 661     if (rate != AUDIO_STREAM_DEFAULT_RATE)
 662     {
 663         ERROR("only rate %d supported", AUDIO_STREAM_DEFAULT_RATE);
 664         return -1;
 665     }
 666
 667     out->common.cfg.rate = rate;
 668
 669     return 0;
 670 }
 671
 672 static size_t out_get_buffer_size(const struct audio_stream *stream)
 673 {
 674     struct a2dp_stream_out *out = (struct a2dp_stream_out *)stream;
 675     // period_size is the AudioFlinger mixer buffer size.
 676     const size_t period_size = out->common.buffer_sz / AUDIO_STREAM_OUTPUT_BUFFER_PERIODS;
 677     const size_t mixer_unit_size = 16 /* frames */ * 4 /* framesize */;
 678
 679     DEBUG("socket buffer size: %zu  period size: %zu", out->common.buffer_sz, period_size);
 680     if (period_size % mixer_unit_size != 0) {
 681         ERROR("period size %zu not a multiple of %zu", period_size, mixer_unit_size);
 682     }
 683
 684     return period_size;
 685 }
 686
 687 static uint32_t out_get_channels(const struct audio_stream *stream)
 688 {
 689     struct a2dp_stream_out *out = (struct a2dp_stream_out *)stream;
 690
 691     DEBUG("channels 0x%" PRIx32, out->common.cfg.channel_flags);
 692
 693     return out->common.cfg.channel_flags;
 694 }
 695
 696 static audio_format_t out_get_format(const struct audio_stream *stream)
 697 {
 698     struct a2dp_stream_out *out = (struct a2dp_stream_out *)stream;
 699     DEBUG("format 0x%x", out->common.cfg.format);
 700     return out->common.cfg.format;
 701 }
 702
 703 static int out_set_format(struct audio_stream *stream, audio_format_t format)
 704 {
 705     UNUSED(stream);
 706     UNUSED(format);
 707     DEBUG("setting format not yet supported (0x%x)", format);
 708     return -ENOSYS;
 709 }
 710
 711 static int out_standby(struct audio_stream *stream)
 712 {
 713     struct a2dp_stream_out *out = (struct a2dp_stream_out *)stream;
 714     int retVal = 0;
 715
 716     FNLOG();
 717
 718     pthread_mutex_lock(&out->common.lock);
 719     // Do nothing in SUSPENDED state.
 720     if (out->common.state != AUDIO_A2DP_STATE_SUSPENDED)
 721         retVal = suspend_audio_datapath(&out->common, true);
 722     out->frames_rendered = 0; // rendered is reset, presented is not
 723     pthread_mutex_unlock (&out->common.lock);
 724
 725     return retVal;
 726 }
 727
 728 static int out_dump(const struct audio_stream *stream, int fd)
 729 {
 730     UNUSED(stream);
 731     UNUSED(fd);
 732     FNLOG();
 733     return 0;
 734 }
 735
 736 static int out_set_parameters(struct audio_stream *stream, const char *kvpairs)
 737 {
 738     struct a2dp_stream_out *out = (struct a2dp_stream_out *)stream;
 739
 740     INFO("state %d", out->common.state);
 741
 742     hash_map_t *params = hash_map_utils_new_from_string_params(kvpairs);
 743     int status = 0;
 744
 745     if (!params)
 746       return status;
 747
 748     pthread_mutex_lock(&out->common.lock);
 749
 750     /* dump params */
 751     hash_map_utils_dump_string_keys_string_values(params);
 752
 753     char *keyval = (char *)hash_map_get(params, "closing");
 754
 755     if (keyval && strcmp(keyval, "true") == 0)
 756     {
 757         DEBUG("stream closing, disallow any writes");
 758         out->common.state = AUDIO_A2DP_STATE_STOPPING;
 759     }
 760
 761     keyval = (char *)hash_map_get(params, "A2dpSuspended");
 762
 763     if (keyval && strcmp(keyval, "true") == 0)
 764     {
 765         if (out->common.state == AUDIO_A2DP_STATE_STARTED)
 766             status = suspend_audio_datapath(&out->common, false);
 767     }
 768     else
 769     {
 770         /* Do not start the streaming automatically. If the phone was streaming
 771          * prior to being suspended, the next out_write shall trigger the
 772          * AVDTP start procedure */
 773         if (out->common.state == AUDIO_A2DP_STATE_SUSPENDED)
 774             out->common.state = AUDIO_A2DP_STATE_STANDBY;
 775         /* Irrespective of the state, return 0 */
 776     }
 777
 778     pthread_mutex_unlock(&out->common.lock);
 779     hash_map_free(params);
 780
 781     return status;
 782 }
 783
 784 static char * out_get_parameters(const struct audio_stream *stream, const char *keys)
 785 {
 786     UNUSED(stream);
 787     UNUSED(keys);
 788     FNLOG();
 789
 790     /* add populating param here */
 791
 792     return strdup("");
 793 }
 794
 795 static uint32_t out_get_latency(const struct audio_stream_out *stream)
 796 {
 797     int latency_us;
 798
 799     struct a2dp_stream_out *out = (struct a2dp_stream_out *)stream;
 800
 801     FNLOG();
 802
 803     latency_us = ((out->common.buffer_sz * 1000 ) /
 804                     audio_stream_out_frame_size(&out->stream) /
 805                     out->common.cfg.rate) * 1000;
 806
 807
 808     return (latency_us / 1000) + 200;
 809 }
 810
 811 static int out_set_volume(struct audio_stream_out *stream, float left,
 812                           float right)
 813 {
 814     UNUSED(stream);
 815     UNUSED(left);
 816     UNUSED(right);
 817
 818     FNLOG();
 819
 820     /* volume controlled in audioflinger mixer (digital) */
 821
 822     return -ENOSYS;
 823 }
 824
 825 static int out_get_presentation_position(const struct audio_stream_out *stream,
 826                                          uint64_t *frames, struct timespec *timestamp)
 827 {
 828     struct a2dp_stream_out *out = (struct a2dp_stream_out *)stream;
 829
 830     FNLOG();
 831     if (stream == NULL || frames == NULL || timestamp == NULL)
 832         return -EINVAL;
 833
 834     int ret = -EWOULDBLOCK;
 835     pthread_mutex_lock(&out->common.lock);
 836     uint64_t latency_frames = (uint64_t)out_get_latency(stream) * out->common.cfg.rate / 1000;
 837     if (out->frames_presented >= latency_frames) {
 838         *frames = out->frames_presented - latency_frames;
 839         clock_gettime(CLOCK_MONOTONIC, timestamp); // could also be associated with out_write().
 840         ret = 0;
 841     }
 842     pthread_mutex_unlock(&out->common.lock);
 843     return ret;
 844 }
 845
 846 static int out_get_render_position(const struct audio_stream_out *stream,
 847                                    uint32_t *dsp_frames)
 848 {
 849     struct a2dp_stream_out *out = (struct a2dp_stream_out *)stream;
 850
 851     FNLOG();
 852     if (stream == NULL || dsp_frames == NULL)
 853         return -EINVAL;
 854
 855     pthread_mutex_lock(&out->common.lock);
 856     uint64_t latency_frames = (uint64_t)out_get_latency(stream) * out->common.cfg.rate / 1000;
 857     if (out->frames_rendered >= latency_frames) {
 858         *dsp_frames = (uint32_t)(out->frames_rendered - latency_frames);
 859     } else {
 860         *dsp_frames = 0;
 861     }
 862     pthread_mutex_unlock(&out->common.lock);
 863     return 0;
 864 }
 865
 866 static int out_add_audio_effect(const struct audio_stream *stream, effect_handle_t effect)
 867 {
 868     UNUSED(stream);
 869     UNUSED(effect);
 870
 871     FNLOG();
 872     return 0;
 873 }
 874
 875 static int out_remove_audio_effect(const struct audio_stream *stream, effect_handle_t effect)
 876 {
 877     UNUSED(stream);
 878     UNUSED(effect);
 879
 880     FNLOG();
 881     return 0;
 882 }
 883
 884 /*
 885  * AUDIO INPUT STREAM
 886  */
 887
 888 static uint32_t in_get_sample_rate(const struct audio_stream *stream)
 889 {
 890     struct a2dp_stream_in *in = (struct a2dp_stream_in *)stream;
 891
 892     FNLOG();
 893     return in->common.cfg.rate;
 894 }
 895
 896 static int in_set_sample_rate(struct audio_stream *stream, uint32_t rate)
 897 {
 898     struct a2dp_stream_in *in = (struct a2dp_stream_in *)stream;
 899
 900     FNLOG();
 901
 902     if (in->common.cfg.rate > 0 && in->common.cfg.rate == rate)
 903         return 0;
 904     else
 905         return -1;
 906 }
 907
 908 static size_t in_get_buffer_size(const struct audio_stream *stream)
 909 {
 910     UNUSED(stream);
 911
 912     FNLOG();
 913     return 320;
 914 }
 915
 916 static uint32_t in_get_channels(const struct audio_stream *stream)
 917 {
 918     struct a2dp_stream_in *in = (struct a2dp_stream_in *)stream;
 919
 920     FNLOG();
 921     return in->common.cfg.channel_flags;
 922 }
 923
 924 static audio_format_t in_get_format(const struct audio_stream *stream)
 925 {
 926     UNUSED(stream);
 927
 928     FNLOG();
 929     return AUDIO_FORMAT_PCM_16_BIT;
 930 }
 931
 932 static int in_set_format(struct audio_stream *stream, audio_format_t format)
 933 {
 934     UNUSED(stream);
 935     UNUSED(format);
 936
 937     FNLOG();
 938     if (format == AUDIO_FORMAT_PCM_16_BIT)
 939         return 0;
 940     else
 941         return -1;
 942 }
 943
 944 static int in_standby(struct audio_stream *stream)
 945 {
 946     UNUSED(stream);
 947
 948     FNLOG();
 949     return 0;
 950 }
 951
 952 static int in_dump(const struct audio_stream *stream, int fd)
 953 {
 954     UNUSED(stream);
 955     UNUSED(fd);
 956
 957     FNLOG();
 958     return 0;
 959 }
 960
 961 static int in_set_parameters(struct audio_stream *stream, const char *kvpairs)
 962 {
 963     UNUSED(stream);
 964     UNUSED(kvpairs);
 965
 966     FNLOG();
 967     return 0;
 968 }
 969
 970 static char * in_get_parameters(const struct audio_stream *stream,
 971                                 const char *keys)
 972 {
 973     UNUSED(stream);
 974     UNUSED(keys);
 975
 976     FNLOG();
 977     return strdup("");
 978 }
 979
 980 static int in_set_gain(struct audio_stream_in *stream, float gain)
 981 {
 982     UNUSED(stream);
 983     UNUSED(gain);
 984
 985     FNLOG();
 986     return 0;
 987 }
 988
 989 static ssize_t in_read(struct audio_stream_in *stream, void* buffer,
 990                        size_t bytes)
 991 {
 992     struct a2dp_stream_in *in = (struct a2dp_stream_in *)stream;
 993     int read;
 994     int us_delay;
 995
 996     DEBUG("read %zu bytes, state: %d", bytes, in->common.state);
 997
 998     pthread_mutex_lock(&in->common.lock);
 999     if (in->common.state == AUDIO_A2DP_STATE_SUSPENDED ||
1000             in->common.state == AUDIO_A2DP_STATE_STOPPING)
1001     {
1002         DEBUG("stream suspended");
1003         goto error;
1004     }
1005
1006     /* only allow autostarting if we are in stopped or standby */
1007     if ((in->common.state == AUDIO_A2DP_STATE_STOPPED) ||
1008         (in->common.state == AUDIO_A2DP_STATE_STANDBY))
1009     {
1010         if (start_audio_datapath(&in->common) < 0)
1011         {
1012             goto error;
1013         }
1014     }
1015     else if (in->common.state != AUDIO_A2DP_STATE_STARTED)
1016     {
1017         ERROR("stream not in stopped or standby");
1018         goto error;
1019     }
1020
1021     pthread_mutex_unlock(&in->common.lock);
1022     read = skt_read(in->common.audio_fd, buffer, bytes);
1023     pthread_mutex_lock(&in->common.lock);
1024     if (read == -1)
1025     {
1026         skt_disconnect(in->common.audio_fd);
1027         in->common.audio_fd = AUDIO_SKT_DISCONNECTED;
1028         if ((in->common.state != AUDIO_A2DP_STATE_SUSPENDED) &&
1029                 (in->common.state != AUDIO_A2DP_STATE_STOPPING)) {
1030             in->common.state = AUDIO_A2DP_STATE_STOPPED;
1031         } else {
1032             ERROR("read failed : stream suspended, avoid resetting state");
1033         }
1034         goto error;
1035     } else if (read == 0) {
1036         DEBUG("read time out - return zeros");
1037         memset(buffer, 0, bytes);
1038         read = bytes;
1039     }
1040     pthread_mutex_unlock(&in->common.lock);
1041
1042     DEBUG("read %d bytes out of %zu bytes", read, bytes);
1043     return read;
1044
1045 error:
1046     pthread_mutex_unlock(&in->common.lock);
1047     memset(buffer, 0, bytes);
1048     us_delay = calc_audiotime(in->common.cfg, bytes);
1049     DEBUG("emulate a2dp read delay (%d us)", us_delay);
1050
1051     usleep(us_delay);
1052     return bytes;
1053 }
1054
1055 static uint32_t in_get_input_frames_lost(struct audio_stream_in *stream)
1056 {
1057     UNUSED(stream);
1058
1059     FNLOG();
1060     return 0;
1061 }
1062
1063 static int in_add_audio_effect(const struct audio_stream *stream, effect_handle_t effect)
1064 {
1065     UNUSED(stream);
1066     UNUSED(effect);
1067
1068     FNLOG();
1069     return 0;
1070 }
1071
1072 static int in_remove_audio_effect(const struct audio_stream *stream, effect_handle_t effect)
1073 {
1074     UNUSED(stream);
1075     UNUSED(effect);
1076
1077     FNLOG();
1078
1079     return 0;
1080 }
1081
1082 static int adev_open_output_stream(struct audio_hw_device *dev,
1083                                    audio_io_handle_t handle,
1084                                    audio_devices_t devices,
1085                                    audio_output_flags_t flags,
1086                                    struct audio_config *config,
1087                                    struct audio_stream_out **stream_out,
1088                                    const char *address)
1089
1090 {
1091     struct a2dp_audio_device *a2dp_dev = (struct a2dp_audio_device *)dev;
1092     struct a2dp_stream_out *out;
1093     int ret = 0;
1094     UNUSED(address);
1095     UNUSED(handle);
1096     UNUSED(devices);
1097     UNUSED(flags);
1098
1099     INFO("opening output");
1100
1101     out = (struct a2dp_stream_out *)calloc(1, sizeof(struct a2dp_stream_out));
1102
1103     if (!out)
1104         return -ENOMEM;
1105
1106     out->stream.common.get_sample_rate = out_get_sample_rate;
1107     out->stream.common.set_sample_rate = out_set_sample_rate;
1108     out->stream.common.get_buffer_size = out_get_buffer_size;
1109     out->stream.common.get_channels = out_get_channels;
1110     out->stream.common.get_format = out_get_format;
1111     out->stream.common.set_format = out_set_format;
1112     out->stream.common.standby = out_standby;
1113     out->stream.common.dump = out_dump;
1114     out->stream.common.set_parameters = out_set_parameters;
1115     out->stream.common.get_parameters = out_get_parameters;
1116     out->stream.common.add_audio_effect = out_add_audio_effect;
1117     out->stream.common.remove_audio_effect = out_remove_audio_effect;
1118     out->stream.get_latency = out_get_latency;
1119     out->stream.set_volume = out_set_volume;
1120     out->stream.write = out_write;
1121     out->stream.get_render_position = out_get_render_position;
1122     out->stream.get_presentation_position = out_get_presentation_position;
1123
1124
1125     /* initialize a2dp specifics */
1126     a2dp_stream_common_init(&out->common);
1127
1128     out->common.cfg.channel_flags = AUDIO_STREAM_DEFAULT_CHANNEL_FLAG;
1129     out->common.cfg.format = AUDIO_STREAM_DEFAULT_FORMAT;
1130     out->common.cfg.rate = AUDIO_STREAM_DEFAULT_RATE;
1131
1132    /* set output config values */
1133    if (config)
1134    {
1135       config->format = out_get_format((const struct audio_stream *)&out->stream);
1136       config->sample_rate = out_get_sample_rate((const struct audio_stream *)&out->stream);
1137       config->channel_mask = out_get_channels((const struct audio_stream *)&out->stream);
1138    }
1139     *stream_out = &out->stream;
1140     a2dp_dev->output = out;
1141
1142     a2dp_open_ctrl_path(&out->common);
1143     if (out->common.ctrl_fd == AUDIO_SKT_DISCONNECTED)
1144     {
1145         ERROR("ctrl socket failed to connect (%s)", strerror(errno));
1146         ret = -1;
1147         goto err_open;
1148     }
1149
1150     DEBUG("success");
1151     /* Delay to ensure Headset is in proper state when START is initiated
1152        from DUT immediately after the connection due to ongoing music playback. */
1153     usleep(250000);
1154     return 0;
1155
1156 err_open:
1157     free(out);
1158     *stream_out = NULL;
1159     a2dp_dev->output = NULL;
1160     ERROR("failed");
1161     return ret;
1162 }
1163
1164 static void adev_close_output_stream(struct audio_hw_device *dev,
1165                                      struct audio_stream_out *stream)
1166 {
1167     struct a2dp_audio_device *a2dp_dev = (struct a2dp_audio_device *)dev;
1168     struct a2dp_stream_out *out = (struct a2dp_stream_out *)stream;
1169
1170     INFO("closing output (state %d)", out->common.state);
1171
1172     pthread_mutex_lock(&out->common.lock);
1173     if ((out->common.state == AUDIO_A2DP_STATE_STARTED) ||
1174             (out->common.state == AUDIO_A2DP_STATE_STOPPING)) {
1175         stop_audio_datapath(&out->common);
1176     }
1177
1178     skt_disconnect(out->common.ctrl_fd);
1179     out->common.ctrl_fd = AUDIO_SKT_DISCONNECTED;
1180     free(stream);
1181     a2dp_dev->output = NULL;
1182     pthread_mutex_unlock(&out->common.lock);
1183
1184     DEBUG("done");
1185 }
1186
1187 static int adev_set_parameters(struct audio_hw_device *dev, const char *kvpairs)
1188 {
1189     struct a2dp_audio_device *a2dp_dev = (struct a2dp_audio_device *)dev;
1190     struct a2dp_stream_out *out = a2dp_dev->output;
1191     int retval = 0;
1192
1193     if (out == NULL)
1194         return retval;
1195
1196     INFO("state %d", out->common.state);
1197
1198     retval = out->stream.common.set_parameters((struct audio_stream *)out, kvpairs);
1199
1200     return retval;
1201 }
1202
1203 static char * adev_get_parameters(const struct audio_hw_device *dev,
1204                                   const char *keys)
1205 {
1206     UNUSED(dev);
1207
1208     FNLOG();
1209
1210     hash_map_t *params = hash_map_utils_new_from_string_params(keys);
1211     hash_map_utils_dump_string_keys_string_values(params);
1212     hash_map_free(params);
1213
1214     return strdup("");
1215 }
1216
1217 static int adev_init_check(const struct audio_hw_device *dev)
1218 {
1219     UNUSED(dev);
1220     FNLOG();
1221
1222     return 0;
1223 }
1224
1225 static int adev_set_voice_volume(struct audio_hw_device *dev, float volume)
1226 {
1227     UNUSED(dev);
1228     UNUSED(volume);
1229
1230     FNLOG();
1231
1232     return -ENOSYS;
1233 }
1234
1235 static int adev_set_master_volume(struct audio_hw_device *dev, float volume)
1236 {
1237     UNUSED(dev);
1238     UNUSED(volume);
1239
1240     FNLOG();
1241
1242     return -ENOSYS;
1243 }
1244
1245 static int adev_set_mode(struct audio_hw_device *dev, int mode)
1246 {
1247     UNUSED(dev);
1248     UNUSED(mode);
1249
1250     FNLOG();
1251
1252     return 0;
1253 }
1254
1255 static int adev_set_mic_mute(struct audio_hw_device *dev, bool state)
1256 {
1257     UNUSED(dev);
1258     UNUSED(state);
1259
1260     FNLOG();
1261
1262     return -ENOSYS;
1263 }
1264
1265 static int adev_get_mic_mute(const struct audio_hw_device *dev, bool *state)
1266 {
1267     UNUSED(dev);
1268     UNUSED(state);
1269
1270     FNLOG();
1271
1272     return -ENOSYS;
1273 }
1274
1275 static size_t adev_get_input_buffer_size(const struct audio_hw_device *dev,
1276                                          const struct audio_config *config)
1277 {
1278     UNUSED(dev);
1279     UNUSED(config);
1280
1281     FNLOG();
1282
1283     return 320;
1284 }
1285
1286 static int adev_open_input_stream(struct audio_hw_device *dev,
1287                                   audio_io_handle_t handle,
1288                                   audio_devices_t devices,
1289                                   struct audio_config *config,
1290                                   struct audio_stream_in **stream_in,
1291                                   audio_input_flags_t flags,
1292                                   const char *address,
1293                                   audio_source_t source)
1294 {
1295     struct a2dp_audio_device *a2dp_dev = (struct a2dp_audio_device *)dev;
1296     struct a2dp_stream_in *in;
1297     int ret;
1298     UNUSED(address);
1299     UNUSED(config);
1300     UNUSED(devices);
1301     UNUSED(flags);
1302     UNUSED(handle);
1303     UNUSED(source);
1304
1305     FNLOG();
1306
1307     in = (struct a2dp_stream_in *)calloc(1, sizeof(struct a2dp_stream_in));
1308
1309     if (!in)
1310         return -ENOMEM;
1311
1312     in->stream.common.get_sample_rate = in_get_sample_rate;
1313     in->stream.common.set_sample_rate = in_set_sample_rate;
1314     in->stream.common.get_buffer_size = in_get_buffer_size;
1315     in->stream.common.get_channels = in_get_channels;
1316     in->stream.common.get_format = in_get_format;
1317     in->stream.common.set_format = in_set_format;
1318     in->stream.common.standby = in_standby;
1319     in->stream.common.dump = in_dump;
1320     in->stream.common.set_parameters = in_set_parameters;
1321     in->stream.common.get_parameters = in_get_parameters;
1322     in->stream.common.add_audio_effect = in_add_audio_effect;
1323     in->stream.common.remove_audio_effect = in_remove_audio_effect;
1324     in->stream.set_gain = in_set_gain;
1325     in->stream.read = in_read;
1326     in->stream.get_input_frames_lost = in_get_input_frames_lost;
1327
1328     /* initialize a2dp specifics */
1329     a2dp_stream_common_init(&in->common);
1330
1331     *stream_in = &in->stream;
1332     a2dp_dev->input = in;
1333
1334     a2dp_open_ctrl_path(&in->common);
1335     if (in->common.ctrl_fd == AUDIO_SKT_DISCONNECTED)
1336     {
1337         ERROR("ctrl socket failed to connect (%s)", strerror(errno));
1338         ret = -1;
1339         goto err_open;
1340     }
1341
1342     if (a2dp_read_audio_config(&in->common) < 0) {
1343         ERROR("a2dp_read_audio_config failed (%s)", strerror(errno));
1344         ret = -1;
1345         goto err_open;
1346     }
1347
1348     DEBUG("success");
1349     return 0;
1350
1351 err_open:
1352     free(in);
1353     *stream_in = NULL;
1354     a2dp_dev->input = NULL;
1355     ERROR("failed");
1356     return ret;
1357 }
1358
1359 static void adev_close_input_stream(struct audio_hw_device *dev,
1360                                    struct audio_stream_in *stream)
1361 {
1362     struct a2dp_audio_device *a2dp_dev = (struct a2dp_audio_device *)dev;
1363     struct a2dp_stream_in* in = (struct a2dp_stream_in *)stream;
1364     a2dp_state_t state = in->common.state;
1365
1366     INFO("closing input (state %d)", state);
1367
1368     if ((state == AUDIO_A2DP_STATE_STARTED) || (state == AUDIO_A2DP_STATE_STOPPING))
1369         stop_audio_datapath(&in->common);
1370
1371     skt_disconnect(in->common.ctrl_fd);
1372     in->common.ctrl_fd = AUDIO_SKT_DISCONNECTED;
1373     free(stream);
1374     a2dp_dev->input = NULL;
1375
1376     DEBUG("done");
1377 }
1378
1379 static int adev_dump(const audio_hw_device_t *device, int fd)
1380 {
1381     UNUSED(device);
1382     UNUSED(fd);
1383
1384     FNLOG();
1385
1386     return 0;
1387 }
1388
1389 static int adev_close(hw_device_t *device)
1390 {
1391     FNLOG();
1392
1393     free(device);
1394     return 0;
1395 }
1396
1397 static int adev_open(const hw_module_t* module, const char* name,
1398                      hw_device_t** device)
1399 {
1400     struct a2dp_audio_device *adev;
1401
1402     INFO(" adev_open in A2dp_hw module");
1403     FNLOG();
1404
1405     if (strcmp(name, AUDIO_HARDWARE_INTERFACE) != 0)
1406     {
1407         ERROR("interface %s not matching [%s]", name, AUDIO_HARDWARE_INTERFACE);
1408         return -EINVAL;
1409     }
1410
1411     adev = calloc(1, sizeof(struct a2dp_audio_device));
1412
1413     if (!adev)
1414         return -ENOMEM;
1415
1416     adev->device.common.tag = HARDWARE_DEVICE_TAG;
1417     adev->device.common.version = AUDIO_DEVICE_API_VERSION_2_0;
1418     adev->device.common.module = (struct hw_module_t *) module;
1419     adev->device.common.close = adev_close;
1420
1421     adev->device.init_check = adev_init_check;
1422     adev->device.set_voice_volume = adev_set_voice_volume;
1423     adev->device.set_master_volume = adev_set_master_volume;
1424     adev->device.set_mode = adev_set_mode;
1425     adev->device.set_mic_mute = adev_set_mic_mute;
1426     adev->device.get_mic_mute = adev_get_mic_mute;
1427     adev->device.set_parameters = adev_set_parameters;
1428     adev->device.get_parameters = adev_get_parameters;
1429     adev->device.get_input_buffer_size = adev_get_input_buffer_size;
1430     adev->device.open_output_stream = adev_open_output_stream;
1431     adev->device.close_output_stream = adev_close_output_stream;
1432     adev->device.open_input_stream = adev_open_input_stream;
1433     adev->device.close_input_stream = adev_close_input_stream;
1434     adev->device.dump = adev_dump;
1435
1436     adev->output = NULL;
1437
1438
1439     *device = &adev->device.common;
1440
1441     return 0;
1442 }
1443
1444 static struct hw_module_methods_t hal_module_methods = {
1445     .open = adev_open,
1446 };
1447
1448 __attribute__ ((visibility ("default")))
1449 struct audio_module HAL_MODULE_INFO_SYM = {
1450     .common = {
1451         .tag = HARDWARE_MODULE_TAG,
1452         .version_major = 1,
1453         .version_minor = 0,
1454         .id = AUDIO_HARDWARE_MODULE_ID,
1455         .name = "A2DP Audio HW HAL",
1456         .author = "The Android Open Source Project",
1457         .methods = &hal_module_methods,
1458     },
1459 };