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