Home | History | Annotate | Download | only in src 
      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 <stdint.h>
     33 #include <sys/errno.h>
     34 #include <sys/socket.h>
     35 #include <sys/stat.h>
     36 #include <sys/time.h>
     37 #include <sys/un.h>
     38 #include <unistd.h>
     39 
     40 #include <mutex>
     41 
     42 #include <hardware/audio.h>
     43 #include <hardware/hardware.h>
     44 #include <system/audio.h>
     45 
     46 #include "osi/include/hash_map_utils.h"
     47 #include "osi/include/log.h"
     48 #include "osi/include/osi.h"
     49 #include "osi/include/socket_utils/sockets.h"
     50 
     51 #include "audio_a2dp_hw.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
     63 // sockets
     64 #define WRITE_POLL_MS 20
     65 
     66 #define FNLOG() LOG_VERBOSE(LOG_TAG, "%s", __func__);
     67 #define DEBUG(fmt, ...) \
     68   LOG_VERBOSE(LOG_TAG, "%s: " fmt, __func__, ##__VA_ARGS__)
     69 #define INFO(fmt, ...) LOG_INFO(LOG_TAG, "%s: " fmt, __func__, ##__VA_ARGS__)
     70 #define WARN(fmt, ...) LOG_WARN(LOG_TAG, "%s: " fmt, __func__, ##__VA_ARGS__)
     71 #define ERROR(fmt, ...) LOG_ERROR(LOG_TAG, "%s: " fmt, __func__, ##__VA_ARGS__)
     72 
     73 #define ASSERTC(cond, msg, val)                                           \
     74   if (!(cond)) {                                                          \
     75     ERROR("### ASSERT : %s line %d %s (%d) ###", __FILE__, __LINE__, msg, \
     76           val);                                                           \
     77   }
     78 
     79 /*****************************************************************************
     80  *  Local type definitions
     81  *****************************************************************************/
     82 
     83 typedef enum {
     84   AUDIO_A2DP_STATE_STARTING,
     85   AUDIO_A2DP_STATE_STARTED,
     86   AUDIO_A2DP_STATE_STOPPING,
     87   AUDIO_A2DP_STATE_STOPPED,
     88   /* need explicit set param call to resume (suspend=false) */
     89   AUDIO_A2DP_STATE_SUSPENDED,
     90   AUDIO_A2DP_STATE_STANDBY /* allows write to autoresume */
     91 } a2dp_state_t;
     92 
     93 struct a2dp_stream_in;
     94 struct a2dp_stream_out;
     95 
     96 struct a2dp_audio_device {
     97   // Important: device must be first as an audio_hw_device* may be cast to
     98   // a2dp_audio_device* when the type is implicitly known.
     99   struct audio_hw_device device;
    100   std::recursive_mutex* mutex;  // See note below on mutex acquisition order.
    101   struct a2dp_stream_in* input;
    102   struct a2dp_stream_out* output;
    103 };
    104 
    105 struct a2dp_config {
    106   uint32_t rate;
    107   uint32_t channel_mask;
    108   int format;
    109 };
    110 
    111 /* move ctrl_fd outside output stream and keep open until HAL unloaded ? */
    112 
    113 struct a2dp_stream_common {
    114   std::recursive_mutex* mutex;  // See note below on mutex acquisition order.
    115   int ctrl_fd;
    116   int audio_fd;
    117   size_t buffer_sz;
    118   struct a2dp_config cfg;
    119   a2dp_state_t state;
    120 };
    121 
    122 struct a2dp_stream_out {
    123   struct audio_stream_out stream;
    124   struct a2dp_stream_common common;
    125   uint64_t frames_presented;  // frames written, never reset
    126   uint64_t frames_rendered;   // frames written, reset on standby
    127 };
    128 
    129 struct a2dp_stream_in {
    130   struct audio_stream_in stream;
    131   struct a2dp_stream_common common;
    132 };
    133 
    134 /*
    135  * Mutex acquisition order:
    136  *
    137  * The a2dp_audio_device (adev) mutex must be acquired before
    138  * the a2dp_stream_common (out or in) mutex.
    139  *
    140  * This may differ from other audio HALs.
    141  */
    142 
    143 /*****************************************************************************
    144  *  Static variables
    145  *****************************************************************************/
    146 
    147 /*****************************************************************************
    148  *  Static functions
    149  *****************************************************************************/
    150 
    151 static size_t out_get_buffer_size(const struct audio_stream* stream);
    152 
    153 /*****************************************************************************
    154  *  Externs
    155  *****************************************************************************/
    156 
    157 /*****************************************************************************
    158  *  Functions
    159  *****************************************************************************/
    160 static void a2dp_open_ctrl_path(struct a2dp_stream_common* common);
    161 
    162 /*****************************************************************************
    163  *   Miscellaneous helper functions
    164  *****************************************************************************/
    165 
    166 /* logs timestamp with microsec precision
    167    pprev is optional in case a dedicated diff is required */
    168 static void ts_log(UNUSED_ATTR const char* tag, UNUSED_ATTR int val,
    169                    struct timespec* pprev_opt) {
    170   struct timespec now;
    171   static struct timespec prev = {0, 0};
    172   unsigned long long now_us;
    173   unsigned long long diff_us;
    174 
    175   clock_gettime(CLOCK_MONOTONIC, &now);
    176 
    177   now_us = now.tv_sec * USEC_PER_SEC + now.tv_nsec / 1000;
    178 
    179   if (pprev_opt) {
    180     diff_us = (now.tv_sec - prev.tv_sec) * USEC_PER_SEC +
    181               (now.tv_nsec - prev.tv_nsec) / 1000;
    182     *pprev_opt = now;
    183     DEBUG("[%s] ts %08lld, *diff %08lld, val %d", tag, now_us, diff_us, val);
    184   } else {
    185     diff_us = (now.tv_sec - prev.tv_sec) * USEC_PER_SEC +
    186               (now.tv_nsec - prev.tv_nsec) / 1000;
    187     prev = now;
    188     DEBUG("[%s] ts %08lld, diff %08lld, val %d", tag, now_us, diff_us, val);
    189   }
    190 }
    191 
    192 static int calc_audiotime_usec(struct a2dp_config cfg, int bytes) {
    193   int chan_count = audio_channel_count_from_out_mask(cfg.channel_mask);
    194   int bytes_per_sample;
    195 
    196   switch (cfg.format) {
    197     case AUDIO_FORMAT_PCM_8_BIT:
    198       bytes_per_sample = 1;
    199       break;
    200     case AUDIO_FORMAT_PCM_16_BIT:
    201       bytes_per_sample = 2;
    202       break;
    203     case AUDIO_FORMAT_PCM_24_BIT_PACKED:
    204       bytes_per_sample = 3;
    205       break;
    206     case AUDIO_FORMAT_PCM_8_24_BIT:
    207       bytes_per_sample = 4;
    208       break;
    209     case AUDIO_FORMAT_PCM_32_BIT:
    210       bytes_per_sample = 4;
    211       break;
    212     default:
    213       ASSERTC(false, "unsupported sample format", cfg.format);
    214       bytes_per_sample = 2;
    215       break;
    216   }
    217 
    218   return (
    219       int)(((int64_t)bytes * (USEC_PER_SEC / (chan_count * bytes_per_sample))) /
    220            cfg.rate);
    221 }
    222 
    223 /*****************************************************************************
    224  *
    225  *   bluedroid stack adaptation
    226  *
    227  ****************************************************************************/
    228 
    229 static int skt_connect(const char* path, size_t buffer_sz) {
    230   int ret;
    231   int skt_fd;
    232   int len;
    233 
    234   INFO("connect to %s (sz %zu)", path, buffer_sz);
    235 
    236   skt_fd = socket(AF_LOCAL, SOCK_STREAM, 0);
    237 
    238   if (osi_socket_local_client_connect(
    239           skt_fd, path, ANDROID_SOCKET_NAMESPACE_ABSTRACT, SOCK_STREAM) < 0) {
    240     ERROR("failed to connect (%s)", strerror(errno));
    241     close(skt_fd);
    242     return -1;
    243   }
    244 
    245   len = buffer_sz;
    246   ret =
    247       setsockopt(skt_fd, SOL_SOCKET, SO_SNDBUF, (char*)&len, (int)sizeof(len));
    248   if (ret < 0) ERROR("setsockopt failed (%s)", strerror(errno));
    249 
    250   ret =
    251       setsockopt(skt_fd, SOL_SOCKET, SO_RCVBUF, (char*)&len, (int)sizeof(len));
    252   if (ret < 0) ERROR("setsockopt failed (%s)", strerror(errno));
    253 
    254   /* Socket send/receive timeout value */
    255   struct timeval tv;
    256   tv.tv_sec = SOCK_SEND_TIMEOUT_MS / 1000;
    257   tv.tv_usec = (SOCK_SEND_TIMEOUT_MS % 1000) * 1000;
    258 
    259   ret = setsockopt(skt_fd, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(tv));
    260   if (ret < 0) ERROR("setsockopt failed (%s)", strerror(errno));
    261 
    262   tv.tv_sec = SOCK_RECV_TIMEOUT_MS / 1000;
    263   tv.tv_usec = (SOCK_RECV_TIMEOUT_MS % 1000) * 1000;
    264 
    265   ret = setsockopt(skt_fd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
    266   if (ret < 0) ERROR("setsockopt failed (%s)", strerror(errno));
    267 
    268   INFO("connected to stack fd = %d", skt_fd);
    269 
    270   return skt_fd;
    271 }
    272 
    273 static int skt_read(int fd, void* p, size_t len) {
    274   ssize_t read;
    275 
    276   FNLOG();
    277 
    278   ts_log("skt_read recv", len, NULL);
    279 
    280   OSI_NO_INTR(read = recv(fd, p, len, MSG_NOSIGNAL));
    281   if (read == -1) ERROR("read failed with errno=%d\n", errno);
    282 
    283   return (int)read;
    284 }
    285 
    286 static int skt_write(int fd, const void* p, size_t len) {
    287   ssize_t sent;
    288   FNLOG();
    289 
    290   ts_log("skt_write", len, NULL);
    291 
    292   if (WRITE_POLL_MS == 0) {
    293     // do not poll, use blocking send
    294     OSI_NO_INTR(sent = send(fd, p, len, MSG_NOSIGNAL));
    295     if (sent == -1) ERROR("write failed with error(%s)", strerror(errno));
    296 
    297     return (int)sent;
    298   }
    299 
    300   // use non-blocking send, poll
    301   int ms_timeout = SOCK_SEND_TIMEOUT_MS;
    302   size_t count = 0;
    303   while (count < len) {
    304     OSI_NO_INTR(sent = send(fd, p, len - count, MSG_NOSIGNAL | MSG_DONTWAIT));
    305     if (sent == -1) {
    306       if (errno != EAGAIN && errno != EWOULDBLOCK) {
    307         ERROR("write failed with error(%s)", strerror(errno));
    308         return -1;
    309       }
    310       if (ms_timeout >= WRITE_POLL_MS) {
    311         usleep(WRITE_POLL_MS * 1000);
    312         ms_timeout -= WRITE_POLL_MS;
    313         continue;
    314       }
    315       WARN("write timeout exceeded, sent %zu bytes", count);
    316       return -1;
    317     }
    318     count += sent;
    319     p = (const uint8_t*)p + sent;
    320   }
    321   return (int)count;
    322 }
    323 
    324 static int skt_disconnect(int fd) {
    325   INFO("fd %d", fd);
    326 
    327   if (fd != AUDIO_SKT_DISCONNECTED) {
    328     shutdown(fd, SHUT_RDWR);
    329     close(fd);
    330   }
    331   return 0;
    332 }
    333 
    334 /*****************************************************************************
    335  *
    336  *  AUDIO CONTROL PATH
    337  *
    338  ****************************************************************************/
    339 
    340 static int a2dp_ctrl_receive(struct a2dp_stream_common* common, void* buffer,
    341                              size_t length) {
    342   ssize_t ret;
    343   int i;
    344 
    345   for (i = 0;; i++) {
    346     OSI_NO_INTR(ret = recv(common->ctrl_fd, buffer, length, MSG_NOSIGNAL));
    347     if (ret > 0) {
    348       break;
    349     }
    350     if (ret == 0) {
    351       ERROR("receive control data failed: peer closed");
    352       break;
    353     }
    354     if (errno != EWOULDBLOCK && errno != EAGAIN) {
    355       ERROR("receive control data failed: error(%s)", strerror(errno));
    356       break;
    357     }
    358     if (i == (CTRL_CHAN_RETRY_COUNT - 1)) {
    359       ERROR("receive control data failed: max retry count");
    360       break;
    361     }
    362     INFO("receive control data failed (%s), retrying", strerror(errno));
    363   }
    364   if (ret <= 0) {
    365     skt_disconnect(common->ctrl_fd);
    366     common->ctrl_fd = AUDIO_SKT_DISCONNECTED;
    367   }
    368   return ret;
    369 }
    370 
    371 // Sends control info for stream |common|. The data to send is stored in
    372 // |buffer| and has size |length|.
    373 // On success, returns the number of octets sent, otherwise -1.
    374 static int a2dp_ctrl_send(struct a2dp_stream_common* common, const void* buffer,
    375                           size_t length) {
    376   ssize_t sent;
    377   size_t remaining = length;
    378   int i;
    379 
    380   if (length == 0) return 0;  // Nothing to do
    381 
    382   for (i = 0;; i++) {
    383     OSI_NO_INTR(sent = send(common->ctrl_fd, buffer, remaining, MSG_NOSIGNAL));
    384     if (sent == static_cast<ssize_t>(remaining)) {
    385       remaining = 0;
    386       break;
    387     }
    388     if (sent > 0) {
    389       buffer = (static_cast<const char*>(buffer) + sent);
    390       remaining -= sent;
    391       continue;
    392     }
    393     if (sent < 0) {
    394       if (errno != EWOULDBLOCK && errno != EAGAIN) {
    395         ERROR("send control data failed: error(%s)", strerror(errno));
    396         break;
    397       }
    398       INFO("send control data failed (%s), retrying", strerror(errno));
    399     }
    400     if (i >= (CTRL_CHAN_RETRY_COUNT - 1)) {
    401       ERROR("send control data failed: max retry count");
    402       break;
    403     }
    404   }
    405   if (remaining > 0) {
    406     skt_disconnect(common->ctrl_fd);
    407     common->ctrl_fd = AUDIO_SKT_DISCONNECTED;
    408     return -1;
    409   }
    410   return length;
    411 }
    412 
    413 static int a2dp_command(struct a2dp_stream_common* common, tA2DP_CTRL_CMD cmd) {
    414   char ack;
    415 
    416   DEBUG("A2DP COMMAND %s", audio_a2dp_hw_dump_ctrl_event(cmd));
    417 
    418   if (common->ctrl_fd == AUDIO_SKT_DISCONNECTED) {
    419     INFO("starting up or recovering from previous error");
    420     a2dp_open_ctrl_path(common);
    421     if (common->ctrl_fd == AUDIO_SKT_DISCONNECTED) {
    422       ERROR("failure to open ctrl path");
    423       return -1;
    424     }
    425   }
    426 
    427   /* send command */
    428   ssize_t sent;
    429   OSI_NO_INTR(sent = send(common->ctrl_fd, &cmd, 1, MSG_NOSIGNAL));
    430   if (sent == -1) {
    431     ERROR("cmd failed (%s)", strerror(errno));
    432     skt_disconnect(common->ctrl_fd);
    433     common->ctrl_fd = AUDIO_SKT_DISCONNECTED;
    434     return -1;
    435   }
    436 
    437   /* wait for ack byte */
    438   if (a2dp_ctrl_receive(common, &ack, 1) < 0) {
    439     ERROR("A2DP COMMAND %s: no ACK", audio_a2dp_hw_dump_ctrl_event(cmd));
    440     return -1;
    441   }
    442 
    443   DEBUG("A2DP COMMAND %s DONE STATUS %d", audio_a2dp_hw_dump_ctrl_event(cmd),
    444         ack);
    445 
    446   if (ack == A2DP_CTRL_ACK_INCALL_FAILURE) return ack;
    447   if (ack != A2DP_CTRL_ACK_SUCCESS) {
    448     ERROR("A2DP COMMAND %s error %d", audio_a2dp_hw_dump_ctrl_event(cmd), ack);
    449     return -1;
    450   }
    451 
    452   return 0;
    453 }
    454 
    455 static int check_a2dp_ready(struct a2dp_stream_common* common) {
    456   if (a2dp_command(common, A2DP_CTRL_CMD_CHECK_READY) < 0) {
    457     ERROR("check a2dp ready failed");
    458     return -1;
    459   }
    460   return 0;
    461 }
    462 
    463 static int a2dp_read_input_audio_config(struct a2dp_stream_common* common) {
    464   tA2DP_SAMPLE_RATE sample_rate;
    465   tA2DP_CHANNEL_COUNT channel_count;
    466 
    467   if (a2dp_command(common, A2DP_CTRL_GET_INPUT_AUDIO_CONFIG) < 0) {
    468     ERROR("get a2dp input audio config failed");
    469     return -1;
    470   }
    471 
    472   if (a2dp_ctrl_receive(common, &sample_rate, sizeof(tA2DP_SAMPLE_RATE)) < 0)
    473     return -1;
    474   if (a2dp_ctrl_receive(common, &channel_count, sizeof(tA2DP_CHANNEL_COUNT)) <
    475       0) {
    476     return -1;
    477   }
    478 
    479   switch (sample_rate) {
    480     case 44100:
    481     case 48000:
    482       common->cfg.rate = sample_rate;
    483       break;
    484     default:
    485       ERROR("Invalid sample rate: %" PRIu32, sample_rate);
    486       return -1;
    487   }
    488 
    489   switch (channel_count) {
    490     case 1:
    491       common->cfg.channel_mask = AUDIO_CHANNEL_IN_MONO;
    492       break;
    493     case 2:
    494       common->cfg.channel_mask = AUDIO_CHANNEL_IN_STEREO;
    495       break;
    496     default:
    497       ERROR("Invalid channel count: %" PRIu32, channel_count);
    498       return -1;
    499   }
    500 
    501   // TODO: For now input audio format is always hard-coded as PCM 16-bit
    502   common->cfg.format = AUDIO_FORMAT_PCM_16_BIT;
    503 
    504   INFO("got input audio config %d %d", common->cfg.format, common->cfg.rate);
    505 
    506   return 0;
    507 }
    508 
    509 static int a2dp_read_output_audio_config(
    510     struct a2dp_stream_common* common, btav_a2dp_codec_config_t* codec_config,
    511     btav_a2dp_codec_config_t* codec_capability, bool update_stream_config) {
    512   struct a2dp_config stream_config;
    513 
    514   if (a2dp_command(common, A2DP_CTRL_GET_OUTPUT_AUDIO_CONFIG) < 0) {
    515     ERROR("get a2dp output audio config failed");
    516     return -1;
    517   }
    518 
    519   // Receive the current codec config
    520   if (a2dp_ctrl_receive(common, &codec_config->sample_rate,
    521                         sizeof(btav_a2dp_codec_sample_rate_t)) < 0) {
    522     return -1;
    523   }
    524   if (a2dp_ctrl_receive(common, &codec_config->bits_per_sample,
    525                         sizeof(btav_a2dp_codec_bits_per_sample_t)) < 0) {
    526     return -1;
    527   }
    528   if (a2dp_ctrl_receive(common, &codec_config->channel_mode,
    529                         sizeof(btav_a2dp_codec_channel_mode_t)) < 0) {
    530     return -1;
    531   }
    532 
    533   // Receive the current codec capability
    534   if (a2dp_ctrl_receive(common, &codec_capability->sample_rate,
    535                         sizeof(btav_a2dp_codec_sample_rate_t)) < 0) {
    536     return -1;
    537   }
    538   if (a2dp_ctrl_receive(common, &codec_capability->bits_per_sample,
    539                         sizeof(btav_a2dp_codec_bits_per_sample_t)) < 0) {
    540     return -1;
    541   }
    542   if (a2dp_ctrl_receive(common, &codec_capability->channel_mode,
    543                         sizeof(btav_a2dp_codec_channel_mode_t)) < 0) {
    544     return -1;
    545   }
    546 
    547   // Check the codec config sample rate
    548   switch (codec_config->sample_rate) {
    549     case BTAV_A2DP_CODEC_SAMPLE_RATE_44100:
    550       stream_config.rate = 44100;
    551       break;
    552     case BTAV_A2DP_CODEC_SAMPLE_RATE_48000:
    553       stream_config.rate = 48000;
    554       break;
    555     case BTAV_A2DP_CODEC_SAMPLE_RATE_88200:
    556       stream_config.rate = 88200;
    557       break;
    558     case BTAV_A2DP_CODEC_SAMPLE_RATE_96000:
    559       stream_config.rate = 96000;
    560       break;
    561     case BTAV_A2DP_CODEC_SAMPLE_RATE_176400:
    562       stream_config.rate = 176400;
    563       break;
    564     case BTAV_A2DP_CODEC_SAMPLE_RATE_192000:
    565       stream_config.rate = 192000;
    566       break;
    567     case BTAV_A2DP_CODEC_SAMPLE_RATE_NONE:
    568     default:
    569       ERROR("Invalid sample rate: 0x%x", codec_config->sample_rate);
    570       return -1;
    571   }
    572 
    573   // Check the codec config bits per sample
    574   switch (codec_config->bits_per_sample) {
    575     case BTAV_A2DP_CODEC_BITS_PER_SAMPLE_16:
    576       stream_config.format = AUDIO_FORMAT_PCM_16_BIT;
    577       break;
    578     case BTAV_A2DP_CODEC_BITS_PER_SAMPLE_24:
    579       stream_config.format = AUDIO_FORMAT_PCM_24_BIT_PACKED;
    580       break;
    581     case BTAV_A2DP_CODEC_BITS_PER_SAMPLE_32:
    582       stream_config.format = AUDIO_FORMAT_PCM_32_BIT;
    583       break;
    584     case BTAV_A2DP_CODEC_BITS_PER_SAMPLE_NONE:
    585     default:
    586       ERROR("Invalid bits per sample: 0x%x", codec_config->bits_per_sample);
    587       return -1;
    588   }
    589 
    590   // Check the codec config channel mode
    591   switch (codec_config->channel_mode) {
    592     case BTAV_A2DP_CODEC_CHANNEL_MODE_MONO:
    593       stream_config.channel_mask = AUDIO_CHANNEL_OUT_MONO;
    594       break;
    595     case BTAV_A2DP_CODEC_CHANNEL_MODE_STEREO:
    596       stream_config.channel_mask = AUDIO_CHANNEL_OUT_STEREO;
    597       break;
    598     case BTAV_A2DP_CODEC_CHANNEL_MODE_NONE:
    599     default:
    600       ERROR("Invalid channel mode: 0x%x", codec_config->channel_mode);
    601       return -1;
    602   }
    603 
    604   // Update the output stream configuration
    605   if (update_stream_config) {
    606     common->cfg.rate = stream_config.rate;
    607     common->cfg.channel_mask = stream_config.channel_mask;
    608     common->cfg.format = stream_config.format;
    609     common->buffer_sz = audio_a2dp_hw_stream_compute_buffer_size(
    610         codec_config->sample_rate, codec_config->bits_per_sample,
    611         codec_config->channel_mode);
    612   }
    613 
    614   INFO(
    615       "got output codec capability: sample_rate=0x%x bits_per_sample=0x%x "
    616       "channel_mode=0x%x",
    617       codec_capability->sample_rate, codec_capability->bits_per_sample,
    618       codec_capability->channel_mode);
    619 
    620   return 0;
    621 }
    622 
    623 static int a2dp_write_output_audio_config(struct a2dp_stream_common* common) {
    624   btav_a2dp_codec_config_t codec_config;
    625 
    626   if (a2dp_command(common, A2DP_CTRL_SET_OUTPUT_AUDIO_CONFIG) < 0) {
    627     ERROR("set a2dp output audio config failed");
    628     return -1;
    629   }
    630 
    631   codec_config.sample_rate = BTAV_A2DP_CODEC_SAMPLE_RATE_NONE;
    632   codec_config.bits_per_sample = BTAV_A2DP_CODEC_BITS_PER_SAMPLE_NONE;
    633   codec_config.channel_mode = BTAV_A2DP_CODEC_CHANNEL_MODE_NONE;
    634 
    635   switch (common->cfg.rate) {
    636     case 44100:
    637       codec_config.sample_rate = BTAV_A2DP_CODEC_SAMPLE_RATE_44100;
    638       break;
    639     case 48000:
    640       codec_config.sample_rate = BTAV_A2DP_CODEC_SAMPLE_RATE_48000;
    641       break;
    642     case 88200:
    643       codec_config.sample_rate = BTAV_A2DP_CODEC_SAMPLE_RATE_88200;
    644       break;
    645     case 96000:
    646       codec_config.sample_rate = BTAV_A2DP_CODEC_SAMPLE_RATE_96000;
    647       break;
    648     case 176400:
    649       codec_config.sample_rate = BTAV_A2DP_CODEC_SAMPLE_RATE_176400;
    650       break;
    651     case 192000:
    652       codec_config.sample_rate = BTAV_A2DP_CODEC_SAMPLE_RATE_192000;
    653       break;
    654     default:
    655       ERROR("Invalid sample rate: %" PRIu32, common->cfg.rate);
    656       return -1;
    657   }
    658 
    659   switch (common->cfg.format) {
    660     case AUDIO_FORMAT_PCM_16_BIT:
    661       codec_config.bits_per_sample = BTAV_A2DP_CODEC_BITS_PER_SAMPLE_16;
    662       break;
    663     case AUDIO_FORMAT_PCM_24_BIT_PACKED:
    664       codec_config.bits_per_sample = BTAV_A2DP_CODEC_BITS_PER_SAMPLE_24;
    665       break;
    666     case AUDIO_FORMAT_PCM_32_BIT:
    667       codec_config.bits_per_sample = BTAV_A2DP_CODEC_BITS_PER_SAMPLE_32;
    668       break;
    669     case AUDIO_FORMAT_PCM_8_24_BIT:
    670     // FALLTHROUGH
    671     // All 24-bit audio is expected in AUDIO_FORMAT_PCM_24_BIT_PACKED format
    672     default:
    673       ERROR("Invalid audio format: 0x%x", common->cfg.format);
    674       return -1;
    675   }
    676 
    677   switch (common->cfg.channel_mask) {
    678     case AUDIO_CHANNEL_OUT_MONO:
    679       codec_config.channel_mode = BTAV_A2DP_CODEC_CHANNEL_MODE_MONO;
    680       break;
    681     case AUDIO_CHANNEL_OUT_STEREO:
    682       codec_config.channel_mode = BTAV_A2DP_CODEC_CHANNEL_MODE_STEREO;
    683       break;
    684     default:
    685       ERROR("Invalid channel mask: 0x%x", common->cfg.channel_mask);
    686       return -1;
    687   }
    688 
    689   // Send the current codec config that has been selected by us
    690   if (a2dp_ctrl_send(common, &codec_config.sample_rate,
    691                      sizeof(btav_a2dp_codec_sample_rate_t)) < 0)
    692     return -1;
    693   if (a2dp_ctrl_send(common, &codec_config.bits_per_sample,
    694                      sizeof(btav_a2dp_codec_bits_per_sample_t)) < 0) {
    695     return -1;
    696   }
    697   if (a2dp_ctrl_send(common, &codec_config.channel_mode,
    698                      sizeof(btav_a2dp_codec_channel_mode_t)) < 0) {
    699     return -1;
    700   }
    701 
    702   INFO(
    703       "sent output codec config: sample_rate=0x%x bits_per_sample=0x%x "
    704       "channel_mode=0x%x",
    705       codec_config.sample_rate, codec_config.bits_per_sample,
    706       codec_config.channel_mode);
    707 
    708   return 0;
    709 }
    710 
    711 static void a2dp_open_ctrl_path(struct a2dp_stream_common* common) {
    712   int i;
    713 
    714   if (common->ctrl_fd != AUDIO_SKT_DISCONNECTED) return;  // already connected
    715 
    716   /* retry logic to catch any timing variations on control channel */
    717   for (i = 0; i < CTRL_CHAN_RETRY_COUNT; i++) {
    718     /* connect control channel if not already connected */
    719     if ((common->ctrl_fd = skt_connect(
    720              A2DP_CTRL_PATH, AUDIO_STREAM_CONTROL_OUTPUT_BUFFER_SZ)) >= 0) {
    721       /* success, now check if stack is ready */
    722       if (check_a2dp_ready(common) == 0) break;
    723 
    724       ERROR("error : a2dp not ready, wait 250 ms and retry");
    725       usleep(250000);
    726       skt_disconnect(common->ctrl_fd);
    727       common->ctrl_fd = AUDIO_SKT_DISCONNECTED;
    728     }
    729 
    730     /* ctrl channel not ready, wait a bit */
    731     usleep(250000);
    732   }
    733 }
    734 
    735 /*****************************************************************************
    736  *
    737  * AUDIO DATA PATH
    738  *
    739  ****************************************************************************/
    740 
    741 static void a2dp_stream_common_init(struct a2dp_stream_common* common) {
    742   FNLOG();
    743 
    744   common->mutex = new std::recursive_mutex;
    745 
    746   common->ctrl_fd = AUDIO_SKT_DISCONNECTED;
    747   common->audio_fd = AUDIO_SKT_DISCONNECTED;
    748   common->state = AUDIO_A2DP_STATE_STOPPED;
    749 
    750   /* manages max capacity of socket pipe */
    751   common->buffer_sz = AUDIO_STREAM_OUTPUT_BUFFER_SZ;
    752 }
    753 
    754 static void a2dp_stream_common_destroy(struct a2dp_stream_common* common) {
    755   FNLOG();
    756 
    757   delete common->mutex;
    758   common->mutex = NULL;
    759 }
    760 
    761 static int start_audio_datapath(struct a2dp_stream_common* common) {
    762   INFO("state %d", common->state);
    763 
    764   int oldstate = common->state;
    765   common->state = AUDIO_A2DP_STATE_STARTING;
    766 
    767   int a2dp_status = a2dp_command(common, A2DP_CTRL_CMD_START);
    768   if (a2dp_status < 0) {
    769     ERROR("Audiopath start failed (status %d)", a2dp_status);
    770     goto error;
    771   } else if (a2dp_status == A2DP_CTRL_ACK_INCALL_FAILURE) {
    772     ERROR("Audiopath start failed - in call, move to suspended");
    773     goto error;
    774   }
    775 
    776   /* connect socket if not yet connected */
    777   if (common->audio_fd == AUDIO_SKT_DISCONNECTED) {
    778     common->audio_fd = skt_connect(A2DP_DATA_PATH, common->buffer_sz);
    779     if (common->audio_fd < 0) {
    780       ERROR("Audiopath start failed - error opening data socket");
    781       goto error;
    782     }
    783   }
    784   common->state = (a2dp_state_t)AUDIO_A2DP_STATE_STARTED;
    785   return 0;
    786 
    787 error:
    788   common->state = (a2dp_state_t)oldstate;
    789   return -1;
    790 }
    791 
    792 static int stop_audio_datapath(struct a2dp_stream_common* common) {
    793   int oldstate = common->state;
    794 
    795   INFO("state %d", common->state);
    796 
    797   /* prevent any stray output writes from autostarting the stream
    798      while stopping audiopath */
    799   common->state = AUDIO_A2DP_STATE_STOPPING;
    800 
    801   if (a2dp_command(common, A2DP_CTRL_CMD_STOP) < 0) {
    802     ERROR("audiopath stop failed");
    803     common->state = (a2dp_state_t)oldstate;
    804     return -1;
    805   }
    806 
    807   common->state = (a2dp_state_t)AUDIO_A2DP_STATE_STOPPED;
    808 
    809   /* disconnect audio path */
    810   skt_disconnect(common->audio_fd);
    811   common->audio_fd = AUDIO_SKT_DISCONNECTED;
    812 
    813   return 0;
    814 }
    815 
    816 static int suspend_audio_datapath(struct a2dp_stream_common* common,
    817                                   bool standby) {
    818   INFO("state %d", common->state);
    819 
    820   if (common->state == AUDIO_A2DP_STATE_STOPPING) return -1;
    821 
    822   if (a2dp_command(common, A2DP_CTRL_CMD_SUSPEND) < 0) return -1;
    823 
    824   if (standby)
    825     common->state = AUDIO_A2DP_STATE_STANDBY;
    826   else
    827     common->state = AUDIO_A2DP_STATE_SUSPENDED;
    828 
    829   /* disconnect audio path */
    830   skt_disconnect(common->audio_fd);
    831 
    832   common->audio_fd = AUDIO_SKT_DISCONNECTED;
    833 
    834   return 0;
    835 }
    836 
    837 /*****************************************************************************
    838  *
    839  *  audio output callbacks
    840  *
    841  ****************************************************************************/
    842 
    843 static ssize_t out_write(struct audio_stream_out* stream, const void* buffer,
    844                          size_t bytes) {
    845   struct a2dp_stream_out* out = (struct a2dp_stream_out*)stream;
    846   int sent = -1;
    847 
    848   DEBUG("write %zu bytes (fd %d)", bytes, out->common.audio_fd);
    849 
    850   std::unique_lock<std::recursive_mutex> lock(*out->common.mutex);
    851   if (out->common.state == AUDIO_A2DP_STATE_SUSPENDED ||
    852       out->common.state == AUDIO_A2DP_STATE_STOPPING) {
    853     DEBUG("stream suspended or closing");
    854     goto finish;
    855   }
    856 
    857   /* only allow autostarting if we are in stopped or standby */
    858   if ((out->common.state == AUDIO_A2DP_STATE_STOPPED) ||
    859       (out->common.state == AUDIO_A2DP_STATE_STANDBY)) {
    860     if (start_audio_datapath(&out->common) < 0) {
    861       goto finish;
    862     }
    863   } else if (out->common.state != AUDIO_A2DP_STATE_STARTED) {
    864     ERROR("stream not in stopped or standby");
    865     goto finish;
    866   }
    867 
    868   lock.unlock();
    869   sent = skt_write(out->common.audio_fd, buffer, bytes);
    870   lock.lock();
    871 
    872   if (sent == -1) {
    873     skt_disconnect(out->common.audio_fd);
    874     out->common.audio_fd = AUDIO_SKT_DISCONNECTED;
    875     if ((out->common.state != AUDIO_A2DP_STATE_SUSPENDED) &&
    876         (out->common.state != AUDIO_A2DP_STATE_STOPPING)) {
    877       out->common.state = AUDIO_A2DP_STATE_STOPPED;
    878     } else {
    879       ERROR("write failed : stream suspended, avoid resetting state");
    880     }
    881     goto finish;
    882   }
    883 
    884 finish:;
    885   const size_t frames = bytes / audio_stream_out_frame_size(stream);
    886   out->frames_rendered += frames;
    887   out->frames_presented += frames;
    888   lock.unlock();
    889 
    890   // If send didn't work out, sleep to emulate write delay.
    891   if (sent == -1) {
    892     const int us_delay = calc_audiotime_usec(out->common.cfg, bytes);
    893     DEBUG("emulate a2dp write delay (%d us)", us_delay);
    894     usleep(us_delay);
    895   }
    896   return bytes;
    897 }
    898 
    899 static uint32_t out_get_sample_rate(const struct audio_stream* stream) {
    900   struct a2dp_stream_out* out = (struct a2dp_stream_out*)stream;
    901 
    902   DEBUG("rate %" PRIu32, out->common.cfg.rate);
    903 
    904   return out->common.cfg.rate;
    905 }
    906 
    907 static int out_set_sample_rate(struct audio_stream* stream, uint32_t rate) {
    908   struct a2dp_stream_out* out = (struct a2dp_stream_out*)stream;
    909 
    910   DEBUG("out_set_sample_rate : %" PRIu32, rate);
    911 
    912   out->common.cfg.rate = rate;
    913 
    914   return 0;
    915 }
    916 
    917 static size_t out_get_buffer_size(const struct audio_stream* stream) {
    918   struct a2dp_stream_out* out = (struct a2dp_stream_out*)stream;
    919   // period_size is the AudioFlinger mixer buffer size.
    920   const size_t period_size =
    921       out->common.buffer_sz / AUDIO_STREAM_OUTPUT_BUFFER_PERIODS;
    922 
    923   DEBUG("socket buffer size: %zu  period size: %zu", out->common.buffer_sz,
    924         period_size);
    925 
    926   return period_size;
    927 }
    928 
    929 size_t audio_a2dp_hw_stream_compute_buffer_size(
    930     btav_a2dp_codec_sample_rate_t codec_sample_rate,
    931     btav_a2dp_codec_bits_per_sample_t codec_bits_per_sample,
    932     btav_a2dp_codec_channel_mode_t codec_channel_mode) {
    933   size_t buffer_sz = AUDIO_STREAM_OUTPUT_BUFFER_SZ;  // Default value
    934   const uint64_t time_period_ms = 20;                // Conservative 20ms
    935   uint32_t sample_rate;
    936   uint32_t bits_per_sample;
    937   uint32_t number_of_channels;
    938 
    939   // Check the codec config sample rate
    940   switch (codec_sample_rate) {
    941     case BTAV_A2DP_CODEC_SAMPLE_RATE_44100:
    942       sample_rate = 44100;
    943       break;
    944     case BTAV_A2DP_CODEC_SAMPLE_RATE_48000:
    945       sample_rate = 48000;
    946       break;
    947     case BTAV_A2DP_CODEC_SAMPLE_RATE_88200:
    948       sample_rate = 88200;
    949       break;
    950     case BTAV_A2DP_CODEC_SAMPLE_RATE_96000:
    951       sample_rate = 96000;
    952       break;
    953     case BTAV_A2DP_CODEC_SAMPLE_RATE_176400:
    954       sample_rate = 176400;
    955       break;
    956     case BTAV_A2DP_CODEC_SAMPLE_RATE_192000:
    957       sample_rate = 192000;
    958       break;
    959     case BTAV_A2DP_CODEC_SAMPLE_RATE_NONE:
    960     default:
    961       ERROR("Invalid sample rate: 0x%x", codec_sample_rate);
    962       return buffer_sz;
    963   }
    964 
    965   // Check the codec config bits per sample
    966   switch (codec_bits_per_sample) {
    967     case BTAV_A2DP_CODEC_BITS_PER_SAMPLE_16:
    968       bits_per_sample = 16;
    969       break;
    970     case BTAV_A2DP_CODEC_BITS_PER_SAMPLE_24:
    971       bits_per_sample = 24;
    972       break;
    973     case BTAV_A2DP_CODEC_BITS_PER_SAMPLE_32:
    974       bits_per_sample = 32;
    975       break;
    976     case BTAV_A2DP_CODEC_BITS_PER_SAMPLE_NONE:
    977     default:
    978       ERROR("Invalid bits per sample: 0x%x", codec_bits_per_sample);
    979       return buffer_sz;
    980   }
    981 
    982   // Check the codec config channel mode
    983   switch (codec_channel_mode) {
    984     case BTAV_A2DP_CODEC_CHANNEL_MODE_MONO:
    985       number_of_channels = 1;
    986       break;
    987     case BTAV_A2DP_CODEC_CHANNEL_MODE_STEREO:
    988       number_of_channels = 2;
    989       break;
    990     case BTAV_A2DP_CODEC_CHANNEL_MODE_NONE:
    991     default:
    992       ERROR("Invalid channel mode: 0x%x", codec_channel_mode);
    993       return buffer_sz;
    994   }
    995 
    996   //
    997   // The buffer size is computed by using the following formula:
    998   //
    999   // AUDIO_STREAM_OUTPUT_BUFFER_SIZE =
   1000   //    (TIME_PERIOD_MS * AUDIO_STREAM_OUTPUT_BUFFER_PERIODS *
   1001   //     SAMPLE_RATE_HZ * NUMBER_OF_CHANNELS * (BITS_PER_SAMPLE / 8)) / 1000
   1002   //
   1003   // AUDIO_STREAM_OUTPUT_BUFFER_PERIODS controls how the socket buffer is
   1004   // divided for AudioFlinger data delivery. The AudioFlinger mixer delivers
   1005   // data in chunks of
   1006   // (AUDIO_STREAM_OUTPUT_BUFFER_SIZE / AUDIO_STREAM_OUTPUT_BUFFER_PERIODS) .
   1007   // If the number of periods is 2, the socket buffer represents "double
   1008   // buffering" of the AudioFlinger mixer buffer.
   1009   //
   1010   // Furthermore, the AudioFlinger expects the buffer size to be a multiple
   1011   // of 16 frames.
   1012   const size_t divisor = (AUDIO_STREAM_OUTPUT_BUFFER_PERIODS * 16 *
   1013                           number_of_channels * bits_per_sample) /
   1014                          8;
   1015 
   1016   buffer_sz = (time_period_ms * AUDIO_STREAM_OUTPUT_BUFFER_PERIODS *
   1017                sample_rate * number_of_channels * (bits_per_sample / 8)) /
   1018               1000;
   1019 
   1020   // Adjust the buffer size so it can be divided by the divisor
   1021   const size_t remainder = buffer_sz % divisor;
   1022   if (remainder != 0) {
   1023     buffer_sz += divisor - remainder;
   1024   }
   1025 
   1026   return buffer_sz;
   1027 }
   1028 
   1029 static uint32_t out_get_channels(const struct audio_stream* stream) {
   1030   struct a2dp_stream_out* out = (struct a2dp_stream_out*)stream;
   1031 
   1032   DEBUG("channels 0x%" PRIx32, out->common.cfg.channel_mask);
   1033 
   1034   return out->common.cfg.channel_mask;
   1035 }
   1036 
   1037 static audio_format_t out_get_format(const struct audio_stream* stream) {
   1038   struct a2dp_stream_out* out = (struct a2dp_stream_out*)stream;
   1039   DEBUG("format 0x%x", out->common.cfg.format);
   1040   return (audio_format_t)out->common.cfg.format;
   1041 }
   1042 
   1043 static int out_set_format(UNUSED_ATTR struct audio_stream* stream,
   1044                           UNUSED_ATTR audio_format_t format) {
   1045   DEBUG("setting format not yet supported (0x%x)", format);
   1046   return -ENOSYS;
   1047 }
   1048 
   1049 static int out_standby(struct audio_stream* stream) {
   1050   struct a2dp_stream_out* out = (struct a2dp_stream_out*)stream;
   1051   int retVal = 0;
   1052 
   1053   FNLOG();
   1054 
   1055   std::lock_guard<std::recursive_mutex> lock(*out->common.mutex);
   1056   // Do nothing in SUSPENDED state.
   1057   if (out->common.state != AUDIO_A2DP_STATE_SUSPENDED)
   1058     retVal = suspend_audio_datapath(&out->common, true);
   1059   out->frames_rendered = 0;  // rendered is reset, presented is not
   1060 
   1061   return retVal;
   1062 }
   1063 
   1064 static int out_dump(UNUSED_ATTR const struct audio_stream* stream,
   1065                     UNUSED_ATTR int fd) {
   1066   FNLOG();
   1067   return 0;
   1068 }
   1069 
   1070 static int out_set_parameters(struct audio_stream* stream,
   1071                               const char* kvpairs) {
   1072   struct a2dp_stream_out* out = (struct a2dp_stream_out*)stream;
   1073 
   1074   INFO("state %d kvpairs %s", out->common.state, kvpairs);
   1075 
   1076   std::unordered_map<std::string, std::string> params =
   1077       hash_map_utils_new_from_string_params(kvpairs);
   1078   int status = 0;
   1079 
   1080   if (params.empty()) return status;
   1081 
   1082   std::lock_guard<std::recursive_mutex> lock(*out->common.mutex);
   1083 
   1084   /* dump params */
   1085   hash_map_utils_dump_string_keys_string_values(params);
   1086 
   1087   if (params["closing"].compare("true") == 0) {
   1088     DEBUG("stream closing, disallow any writes");
   1089     out->common.state = AUDIO_A2DP_STATE_STOPPING;
   1090   }
   1091 
   1092   if (params["A2dpSuspended"].compare("true") == 0) {
   1093     if (out->common.state == AUDIO_A2DP_STATE_STARTED)
   1094       status = suspend_audio_datapath(&out->common, false);
   1095   } else {
   1096     /* Do not start the streaming automatically. If the phone was streaming
   1097      * prior to being suspended, the next out_write shall trigger the
   1098      * AVDTP start procedure */
   1099     if (out->common.state == AUDIO_A2DP_STATE_SUSPENDED)
   1100       out->common.state = AUDIO_A2DP_STATE_STANDBY;
   1101     /* Irrespective of the state, return 0 */
   1102   }
   1103 
   1104   return status;
   1105 }
   1106 
   1107 static char* out_get_parameters(const struct audio_stream* stream,
   1108                                 const char* keys) {
   1109   FNLOG();
   1110 
   1111   btav_a2dp_codec_config_t codec_config;
   1112   btav_a2dp_codec_config_t codec_capability;
   1113 
   1114   struct a2dp_stream_out* out = (struct a2dp_stream_out*)stream;
   1115 
   1116   std::unordered_map<std::string, std::string> params =
   1117       hash_map_utils_new_from_string_params(keys);
   1118   std::unordered_map<std::string, std::string> return_params;
   1119 
   1120   if (params.empty()) return strdup("");
   1121 
   1122   std::lock_guard<std::recursive_mutex> lock(*out->common.mutex);
   1123 
   1124   if (a2dp_read_output_audio_config(&out->common, &codec_config,
   1125                                     &codec_capability,
   1126                                     false /* update_stream_config */) < 0) {
   1127     ERROR("a2dp_read_output_audio_config failed");
   1128     goto done;
   1129   }
   1130 
   1131   // Add the format
   1132   if (params.find(AUDIO_PARAMETER_STREAM_SUP_FORMATS) != params.end()) {
   1133     std::string param;
   1134     if (codec_capability.bits_per_sample & BTAV_A2DP_CODEC_BITS_PER_SAMPLE_16) {
   1135       if (!param.empty()) param += "|";
   1136       param += "AUDIO_FORMAT_PCM_16_BIT";
   1137     }
   1138     if (codec_capability.bits_per_sample & BTAV_A2DP_CODEC_BITS_PER_SAMPLE_24) {
   1139       if (!param.empty()) param += "|";
   1140       param += "AUDIO_FORMAT_PCM_24_BIT_PACKED";
   1141     }
   1142     if (codec_capability.bits_per_sample & BTAV_A2DP_CODEC_BITS_PER_SAMPLE_32) {
   1143       if (!param.empty()) param += "|";
   1144       param += "AUDIO_FORMAT_PCM_32_BIT";
   1145     }
   1146     if (param.empty()) {
   1147       ERROR("Invalid codec capability bits_per_sample=0x%x",
   1148             codec_capability.bits_per_sample);
   1149       goto done;
   1150     } else {
   1151       return_params[AUDIO_PARAMETER_STREAM_SUP_FORMATS] = param;
   1152     }
   1153   }
   1154 
   1155   // Add the sample rate
   1156   if (params.find(AUDIO_PARAMETER_STREAM_SUP_SAMPLING_RATES) != params.end()) {
   1157     std::string param;
   1158     if (codec_capability.sample_rate & BTAV_A2DP_CODEC_SAMPLE_RATE_44100) {
   1159       if (!param.empty()) param += "|";
   1160       param += "44100";
   1161     }
   1162     if (codec_capability.sample_rate & BTAV_A2DP_CODEC_SAMPLE_RATE_48000) {
   1163       if (!param.empty()) param += "|";
   1164       param += "48000";
   1165     }
   1166     if (codec_capability.sample_rate & BTAV_A2DP_CODEC_SAMPLE_RATE_88200) {
   1167       if (!param.empty()) param += "|";
   1168       param += "88200";
   1169     }
   1170     if (codec_capability.sample_rate & BTAV_A2DP_CODEC_SAMPLE_RATE_96000) {
   1171       if (!param.empty()) param += "|";
   1172       param += "96000";
   1173     }
   1174     if (codec_capability.sample_rate & BTAV_A2DP_CODEC_SAMPLE_RATE_176400) {
   1175       if (!param.empty()) param += "|";
   1176       param += "176400";
   1177     }
   1178     if (codec_capability.sample_rate & BTAV_A2DP_CODEC_SAMPLE_RATE_192000) {
   1179       if (!param.empty()) param += "|";
   1180       param += "192000";
   1181     }
   1182     if (param.empty()) {
   1183       ERROR("Invalid codec capability sample_rate=0x%x",
   1184             codec_capability.sample_rate);
   1185       goto done;
   1186     } else {
   1187       return_params[AUDIO_PARAMETER_STREAM_SUP_SAMPLING_RATES] = param;
   1188     }
   1189   }
   1190 
   1191   // Add the channel mask
   1192   if (params.find(AUDIO_PARAMETER_STREAM_SUP_CHANNELS) != params.end()) {
   1193     std::string param;
   1194     if (codec_capability.channel_mode & BTAV_A2DP_CODEC_CHANNEL_MODE_MONO) {
   1195       if (!param.empty()) param += "|";
   1196       param += "AUDIO_CHANNEL_OUT_MONO";
   1197     }
   1198     if (codec_capability.channel_mode & BTAV_A2DP_CODEC_CHANNEL_MODE_STEREO) {
   1199       if (!param.empty()) param += "|";
   1200       param += "AUDIO_CHANNEL_OUT_STEREO";
   1201     }
   1202     if (param.empty()) {
   1203       ERROR("Invalid codec capability channel_mode=0x%x",
   1204             codec_capability.channel_mode);
   1205       goto done;
   1206     } else {
   1207       return_params[AUDIO_PARAMETER_STREAM_SUP_CHANNELS] = param;
   1208     }
   1209   }
   1210 
   1211 done:
   1212   std::string result;
   1213   for (const auto& ptr : return_params) {
   1214     result += ptr.first + "=" + ptr.second + ";";
   1215   }
   1216 
   1217   INFO("get parameters result = %s", result.c_str());
   1218 
   1219   return strdup(result.c_str());
   1220 }
   1221 
   1222 static uint32_t out_get_latency(const struct audio_stream_out* stream) {
   1223   int latency_us;
   1224 
   1225   struct a2dp_stream_out* out = (struct a2dp_stream_out*)stream;
   1226 
   1227   FNLOG();
   1228 
   1229   latency_us =
   1230       ((out->common.buffer_sz * 1000) /
   1231        audio_stream_out_frame_size(&out->stream) / out->common.cfg.rate) *
   1232       1000;
   1233 
   1234   return (latency_us / 1000) + 200;
   1235 }
   1236 
   1237 static int out_set_volume(UNUSED_ATTR struct audio_stream_out* stream,
   1238                           UNUSED_ATTR float left, UNUSED_ATTR float right) {
   1239   FNLOG();
   1240 
   1241   /* volume controlled in audioflinger mixer (digital) */
   1242 
   1243   return -ENOSYS;
   1244 }
   1245 
   1246 static int out_get_presentation_position(const struct audio_stream_out* stream,
   1247                                          uint64_t* frames,
   1248                                          struct timespec* timestamp) {
   1249   struct a2dp_stream_out* out = (struct a2dp_stream_out*)stream;
   1250 
   1251   FNLOG();
   1252   if (stream == NULL || frames == NULL || timestamp == NULL) return -EINVAL;
   1253 
   1254   int ret = -EWOULDBLOCK;
   1255   std::lock_guard<std::recursive_mutex> lock(*out->common.mutex);
   1256   uint64_t latency_frames =
   1257       (uint64_t)out_get_latency(stream) * out->common.cfg.rate / 1000;
   1258   if (out->frames_presented >= latency_frames) {
   1259     *frames = out->frames_presented - latency_frames;
   1260     clock_gettime(CLOCK_MONOTONIC,
   1261                   timestamp);  // could also be associated with out_write().
   1262     ret = 0;
   1263   }
   1264   return ret;
   1265 }
   1266 
   1267 static int out_get_render_position(const struct audio_stream_out* stream,
   1268                                    uint32_t* dsp_frames) {
   1269   struct a2dp_stream_out* out = (struct a2dp_stream_out*)stream;
   1270 
   1271   FNLOG();
   1272   if (stream == NULL || dsp_frames == NULL) return -EINVAL;
   1273 
   1274   std::lock_guard<std::recursive_mutex> lock(*out->common.mutex);
   1275   uint64_t latency_frames =
   1276       (uint64_t)out_get_latency(stream) * out->common.cfg.rate / 1000;
   1277   if (out->frames_rendered >= latency_frames) {
   1278     *dsp_frames = (uint32_t)(out->frames_rendered - latency_frames);
   1279   } else {
   1280     *dsp_frames = 0;
   1281   }
   1282   return 0;
   1283 }
   1284 
   1285 static int out_add_audio_effect(UNUSED_ATTR const struct audio_stream* stream,
   1286                                 UNUSED_ATTR effect_handle_t effect) {
   1287   FNLOG();
   1288   return 0;
   1289 }
   1290 
   1291 static int out_remove_audio_effect(
   1292     UNUSED_ATTR const struct audio_stream* stream,
   1293     UNUSED_ATTR effect_handle_t effect) {
   1294   FNLOG();
   1295   return 0;
   1296 }
   1297 
   1298 /*
   1299  * AUDIO INPUT STREAM
   1300  */
   1301 
   1302 static uint32_t in_get_sample_rate(const struct audio_stream* stream) {
   1303   struct a2dp_stream_in* in = (struct a2dp_stream_in*)stream;
   1304 
   1305   FNLOG();
   1306   return in->common.cfg.rate;
   1307 }
   1308 
   1309 static int in_set_sample_rate(struct audio_stream* stream, uint32_t rate) {
   1310   struct a2dp_stream_in* in = (struct a2dp_stream_in*)stream;
   1311 
   1312   FNLOG();
   1313 
   1314   if (in->common.cfg.rate > 0 && in->common.cfg.rate == rate)
   1315     return 0;
   1316   else
   1317     return -1;
   1318 }
   1319 
   1320 static size_t in_get_buffer_size(
   1321     UNUSED_ATTR const struct audio_stream* stream) {
   1322   FNLOG();
   1323   return 320;
   1324 }
   1325 
   1326 static uint32_t in_get_channels(const struct audio_stream* stream) {
   1327   struct a2dp_stream_in* in = (struct a2dp_stream_in*)stream;
   1328 
   1329   FNLOG();
   1330   return in->common.cfg.channel_mask;
   1331 }
   1332 
   1333 static audio_format_t in_get_format(
   1334     UNUSED_ATTR const struct audio_stream* stream) {
   1335   FNLOG();
   1336   return AUDIO_FORMAT_PCM_16_BIT;
   1337 }
   1338 
   1339 static int in_set_format(UNUSED_ATTR struct audio_stream* stream,
   1340                          UNUSED_ATTR audio_format_t format) {
   1341   FNLOG();
   1342   if (format == AUDIO_FORMAT_PCM_16_BIT)
   1343     return 0;
   1344   else
   1345     return -1;
   1346 }
   1347 
   1348 static int in_standby(UNUSED_ATTR struct audio_stream* stream) {
   1349   FNLOG();
   1350   return 0;
   1351 }
   1352 
   1353 static int in_dump(UNUSED_ATTR const struct audio_stream* stream,
   1354                    UNUSED_ATTR int fd) {
   1355   FNLOG();
   1356   return 0;
   1357 }
   1358 
   1359 static int in_set_parameters(UNUSED_ATTR struct audio_stream* stream,
   1360                              UNUSED_ATTR const char* kvpairs) {
   1361   FNLOG();
   1362   return 0;
   1363 }
   1364 
   1365 static char* in_get_parameters(UNUSED_ATTR const struct audio_stream* stream,
   1366                                UNUSED_ATTR const char* keys) {
   1367   FNLOG();
   1368   return strdup("");
   1369 }
   1370 
   1371 static int in_set_gain(UNUSED_ATTR struct audio_stream_in* stream,
   1372                        UNUSED_ATTR float gain) {
   1373   FNLOG();
   1374   return 0;
   1375 }
   1376 
   1377 static ssize_t in_read(struct audio_stream_in* stream, void* buffer,
   1378                        size_t bytes) {
   1379   struct a2dp_stream_in* in = (struct a2dp_stream_in*)stream;
   1380   int read;
   1381   int us_delay;
   1382 
   1383   DEBUG("read %zu bytes, state: %d", bytes, in->common.state);
   1384 
   1385   std::unique_lock<std::recursive_mutex> lock(*in->common.mutex);
   1386   if (in->common.state == AUDIO_A2DP_STATE_SUSPENDED ||
   1387       in->common.state == AUDIO_A2DP_STATE_STOPPING) {
   1388     DEBUG("stream suspended");
   1389     goto error;
   1390   }
   1391 
   1392   /* only allow autostarting if we are in stopped or standby */
   1393   if ((in->common.state == AUDIO_A2DP_STATE_STOPPED) ||
   1394       (in->common.state == AUDIO_A2DP_STATE_STANDBY)) {
   1395     if (start_audio_datapath(&in->common) < 0) {
   1396       goto error;
   1397     }
   1398   } else if (in->common.state != AUDIO_A2DP_STATE_STARTED) {
   1399     ERROR("stream not in stopped or standby");
   1400     goto error;
   1401   }
   1402 
   1403   lock.unlock();
   1404   read = skt_read(in->common.audio_fd, buffer, bytes);
   1405   lock.lock();
   1406   if (read == -1) {
   1407     skt_disconnect(in->common.audio_fd);
   1408     in->common.audio_fd = AUDIO_SKT_DISCONNECTED;
   1409     if ((in->common.state != AUDIO_A2DP_STATE_SUSPENDED) &&
   1410         (in->common.state != AUDIO_A2DP_STATE_STOPPING)) {
   1411       in->common.state = AUDIO_A2DP_STATE_STOPPED;
   1412     } else {
   1413       ERROR("read failed : stream suspended, avoid resetting state");
   1414     }
   1415     goto error;
   1416   } else if (read == 0) {
   1417     DEBUG("read time out - return zeros");
   1418     memset(buffer, 0, bytes);
   1419     read = bytes;
   1420   }
   1421   lock.unlock();
   1422 
   1423   DEBUG("read %d bytes out of %zu bytes", read, bytes);
   1424   return read;
   1425 
   1426 error:
   1427   memset(buffer, 0, bytes);
   1428   us_delay = calc_audiotime_usec(in->common.cfg, bytes);
   1429   DEBUG("emulate a2dp read delay (%d us)", us_delay);
   1430 
   1431   usleep(us_delay);
   1432   return bytes;
   1433 }
   1434 
   1435 static uint32_t in_get_input_frames_lost(
   1436     UNUSED_ATTR struct audio_stream_in* stream) {
   1437   FNLOG();
   1438   return 0;
   1439 }
   1440 
   1441 static int in_add_audio_effect(UNUSED_ATTR const struct audio_stream* stream,
   1442                                UNUSED_ATTR effect_handle_t effect) {
   1443   FNLOG();
   1444   return 0;
   1445 }
   1446 
   1447 static int in_remove_audio_effect(UNUSED_ATTR const struct audio_stream* stream,
   1448                                   UNUSED_ATTR effect_handle_t effect) {
   1449   FNLOG();
   1450 
   1451   return 0;
   1452 }
   1453 
   1454 static int adev_open_output_stream(struct audio_hw_device* dev,
   1455                                    UNUSED_ATTR audio_io_handle_t handle,
   1456                                    UNUSED_ATTR audio_devices_t devices,
   1457                                    UNUSED_ATTR audio_output_flags_t flags,
   1458                                    struct audio_config* config,
   1459                                    struct audio_stream_out** stream_out,
   1460                                    UNUSED_ATTR const char* address)
   1461 
   1462 {
   1463   struct a2dp_audio_device* a2dp_dev = (struct a2dp_audio_device*)dev;
   1464   struct a2dp_stream_out* out;
   1465   int ret = 0;
   1466 
   1467   INFO("opening output");
   1468   // protect against adev->output and stream_out from being inconsistent
   1469   std::lock_guard<std::recursive_mutex> lock(*a2dp_dev->mutex);
   1470   out = (struct a2dp_stream_out*)calloc(1, sizeof(struct a2dp_stream_out));
   1471 
   1472   if (!out) return -ENOMEM;
   1473 
   1474   out->stream.common.get_sample_rate = out_get_sample_rate;
   1475   out->stream.common.set_sample_rate = out_set_sample_rate;
   1476   out->stream.common.get_buffer_size = out_get_buffer_size;
   1477   out->stream.common.get_channels = out_get_channels;
   1478   out->stream.common.get_format = out_get_format;
   1479   out->stream.common.set_format = out_set_format;
   1480   out->stream.common.standby = out_standby;
   1481   out->stream.common.dump = out_dump;
   1482   out->stream.common.set_parameters = out_set_parameters;
   1483   out->stream.common.get_parameters = out_get_parameters;
   1484   out->stream.common.add_audio_effect = out_add_audio_effect;
   1485   out->stream.common.remove_audio_effect = out_remove_audio_effect;
   1486   out->stream.get_latency = out_get_latency;
   1487   out->stream.set_volume = out_set_volume;
   1488   out->stream.write = out_write;
   1489   out->stream.get_render_position = out_get_render_position;
   1490   out->stream.get_presentation_position = out_get_presentation_position;
   1491 
   1492   /* initialize a2dp specifics */
   1493   a2dp_stream_common_init(&out->common);
   1494 
   1495   // Make sure we always have the feeding parameters configured
   1496   btav_a2dp_codec_config_t codec_config;
   1497   btav_a2dp_codec_config_t codec_capability;
   1498   if (a2dp_read_output_audio_config(&out->common, &codec_config,
   1499                                     &codec_capability,
   1500                                     true /* update_stream_config */) < 0) {
   1501     ERROR("a2dp_read_output_audio_config failed");
   1502     ret = -1;
   1503     goto err_open;
   1504   }
   1505   // a2dp_read_output_audio_config() opens the socket control path (or fails)
   1506 
   1507   /* set output config values */
   1508   if (config != nullptr) {
   1509     // Try to use the config parameters and send it to the remote side
   1510     // TODO: Shall we use out_set_format() and similar?
   1511     if (config->format != 0) out->common.cfg.format = config->format;
   1512     if (config->sample_rate != 0) out->common.cfg.rate = config->sample_rate;
   1513     if (config->channel_mask != 0)
   1514       out->common.cfg.channel_mask = config->channel_mask;
   1515     if ((out->common.cfg.format != 0) || (out->common.cfg.rate != 0) ||
   1516         (out->common.cfg.channel_mask != 0)) {
   1517       if (a2dp_write_output_audio_config(&out->common) < 0) {
   1518         ERROR("a2dp_write_output_audio_config failed");
   1519         ret = -1;
   1520         goto err_open;
   1521       }
   1522       // Read again and make sure we use the same parameters as the remote side
   1523       if (a2dp_read_output_audio_config(&out->common, &codec_config,
   1524                                         &codec_capability,
   1525                                         true /* update_stream_config */) < 0) {
   1526         ERROR("a2dp_read_output_audio_config failed");
   1527         ret = -1;
   1528         goto err_open;
   1529       }
   1530     }
   1531     config->format = out_get_format((const struct audio_stream*)&out->stream);
   1532     config->sample_rate =
   1533         out_get_sample_rate((const struct audio_stream*)&out->stream);
   1534     config->channel_mask =
   1535         out_get_channels((const struct audio_stream*)&out->stream);
   1536 
   1537     INFO(
   1538         "Output stream config: format=0x%x sample_rate=%d channel_mask=0x%x "
   1539         "buffer_sz=%zu",
   1540         config->format, config->sample_rate, config->channel_mask,
   1541         out->common.buffer_sz);
   1542   }
   1543   *stream_out = &out->stream;
   1544   a2dp_dev->output = out;
   1545 
   1546   DEBUG("success");
   1547   /* Delay to ensure Headset is in proper state when START is initiated from
   1548    * DUT immediately after the connection due to ongoing music playback. */
   1549   usleep(250000);
   1550   return 0;
   1551 
   1552 err_open:
   1553   a2dp_stream_common_destroy(&out->common);
   1554   free(out);
   1555   *stream_out = NULL;
   1556   a2dp_dev->output = NULL;
   1557   ERROR("failed");
   1558   return ret;
   1559 }
   1560 
   1561 static void adev_close_output_stream(struct audio_hw_device* dev,
   1562                                      struct audio_stream_out* stream) {
   1563   struct a2dp_audio_device* a2dp_dev = (struct a2dp_audio_device*)dev;
   1564   struct a2dp_stream_out* out = (struct a2dp_stream_out*)stream;
   1565 
   1566   // prevent interference with adev_set_parameters.
   1567   std::lock_guard<std::recursive_mutex> lock(*a2dp_dev->mutex);
   1568   {
   1569     std::lock_guard<std::recursive_mutex> lock(*out->common.mutex);
   1570     const a2dp_state_t state = out->common.state;
   1571     INFO("closing output (state %d)", (int)state);
   1572     if ((state == AUDIO_A2DP_STATE_STARTED) ||
   1573         (state == AUDIO_A2DP_STATE_STOPPING)) {
   1574       stop_audio_datapath(&out->common);
   1575     }
   1576 
   1577     skt_disconnect(out->common.ctrl_fd);
   1578     out->common.ctrl_fd = AUDIO_SKT_DISCONNECTED;
   1579   }
   1580 
   1581   a2dp_stream_common_destroy(&out->common);
   1582   free(stream);
   1583   a2dp_dev->output = NULL;
   1584 
   1585   DEBUG("done");
   1586 }
   1587 
   1588 static int adev_set_parameters(struct audio_hw_device* dev,
   1589                                const char* kvpairs) {
   1590   struct a2dp_audio_device* a2dp_dev = (struct a2dp_audio_device*)dev;
   1591   int retval = 0;
   1592 
   1593   // prevent interference with adev_close_output_stream
   1594   std::lock_guard<std::recursive_mutex> lock(*a2dp_dev->mutex);
   1595   struct a2dp_stream_out* out = a2dp_dev->output;
   1596 
   1597   if (out == NULL) return retval;
   1598 
   1599   INFO("state %d", out->common.state);
   1600 
   1601   retval =
   1602       out->stream.common.set_parameters((struct audio_stream*)out, kvpairs);
   1603 
   1604   return retval;
   1605 }
   1606 
   1607 static char* adev_get_parameters(UNUSED_ATTR const struct audio_hw_device* dev,
   1608                                  const char* keys) {
   1609   FNLOG();
   1610 
   1611   std::unordered_map<std::string, std::string> params =
   1612       hash_map_utils_new_from_string_params(keys);
   1613   hash_map_utils_dump_string_keys_string_values(params);
   1614 
   1615   return strdup("");
   1616 }
   1617 
   1618 static int adev_init_check(UNUSED_ATTR const struct audio_hw_device* dev) {
   1619   FNLOG();
   1620 
   1621   return 0;
   1622 }
   1623 
   1624 static int adev_set_voice_volume(UNUSED_ATTR struct audio_hw_device* dev,
   1625                                  UNUSED_ATTR float volume) {
   1626   FNLOG();
   1627 
   1628   return -ENOSYS;
   1629 }
   1630 
   1631 static int adev_set_master_volume(UNUSED_ATTR struct audio_hw_device* dev,
   1632                                   UNUSED_ATTR float volume) {
   1633   FNLOG();
   1634 
   1635   return -ENOSYS;
   1636 }
   1637 
   1638 static int adev_set_mode(UNUSED_ATTR struct audio_hw_device* dev,
   1639                          UNUSED_ATTR audio_mode_t mode) {
   1640   FNLOG();
   1641 
   1642   return 0;
   1643 }
   1644 
   1645 static int adev_set_mic_mute(UNUSED_ATTR struct audio_hw_device* dev,
   1646                              UNUSED_ATTR bool state) {
   1647   FNLOG();
   1648 
   1649   return -ENOSYS;
   1650 }
   1651 
   1652 static int adev_get_mic_mute(UNUSED_ATTR const struct audio_hw_device* dev,
   1653                              UNUSED_ATTR bool* state) {
   1654   FNLOG();
   1655 
   1656   return -ENOSYS;
   1657 }
   1658 
   1659 static size_t adev_get_input_buffer_size(
   1660     UNUSED_ATTR const struct audio_hw_device* dev,
   1661     UNUSED_ATTR const struct audio_config* config) {
   1662   FNLOG();
   1663 
   1664   return 320;
   1665 }
   1666 
   1667 static int adev_open_input_stream(struct audio_hw_device* dev,
   1668                                   UNUSED_ATTR audio_io_handle_t handle,
   1669                                   UNUSED_ATTR audio_devices_t devices,
   1670                                   UNUSED_ATTR struct audio_config* config,
   1671                                   struct audio_stream_in** stream_in,
   1672                                   UNUSED_ATTR audio_input_flags_t flags,
   1673                                   UNUSED_ATTR const char* address,
   1674                                   UNUSED_ATTR audio_source_t source) {
   1675   struct a2dp_audio_device* a2dp_dev = (struct a2dp_audio_device*)dev;
   1676   struct a2dp_stream_in* in;
   1677   int ret;
   1678 
   1679   FNLOG();
   1680 
   1681   // protect against adev->input and stream_in from being inconsistent
   1682   std::lock_guard<std::recursive_mutex> lock(*a2dp_dev->mutex);
   1683   in = (struct a2dp_stream_in*)calloc(1, sizeof(struct a2dp_stream_in));
   1684 
   1685   if (!in) return -ENOMEM;
   1686 
   1687   in->stream.common.get_sample_rate = in_get_sample_rate;
   1688   in->stream.common.set_sample_rate = in_set_sample_rate;
   1689   in->stream.common.get_buffer_size = in_get_buffer_size;
   1690   in->stream.common.get_channels = in_get_channels;
   1691   in->stream.common.get_format = in_get_format;
   1692   in->stream.common.set_format = in_set_format;
   1693   in->stream.common.standby = in_standby;
   1694   in->stream.common.dump = in_dump;
   1695   in->stream.common.set_parameters = in_set_parameters;
   1696   in->stream.common.get_parameters = in_get_parameters;
   1697   in->stream.common.add_audio_effect = in_add_audio_effect;
   1698   in->stream.common.remove_audio_effect = in_remove_audio_effect;
   1699   in->stream.set_gain = in_set_gain;
   1700   in->stream.read = in_read;
   1701   in->stream.get_input_frames_lost = in_get_input_frames_lost;
   1702 
   1703   /* initialize a2dp specifics */
   1704   a2dp_stream_common_init(&in->common);
   1705 
   1706   *stream_in = &in->stream;
   1707   a2dp_dev->input = in;
   1708 
   1709   if (a2dp_read_input_audio_config(&in->common) < 0) {
   1710     ERROR("a2dp_read_input_audio_config failed (%s)", strerror(errno));
   1711     ret = -1;
   1712     goto err_open;
   1713   }
   1714   // a2dp_read_input_audio_config() opens socket control path (or fails)
   1715 
   1716   DEBUG("success");
   1717   return 0;
   1718 
   1719 err_open:
   1720   a2dp_stream_common_destroy(&in->common);
   1721   free(in);
   1722   *stream_in = NULL;
   1723   a2dp_dev->input = NULL;
   1724   ERROR("failed");
   1725   return ret;
   1726 }
   1727 
   1728 static void adev_close_input_stream(struct audio_hw_device* dev,
   1729                                     struct audio_stream_in* stream) {
   1730   struct a2dp_audio_device* a2dp_dev = (struct a2dp_audio_device*)dev;
   1731   struct a2dp_stream_in* in = (struct a2dp_stream_in*)stream;
   1732 
   1733   std::lock_guard<std::recursive_mutex> lock(*a2dp_dev->mutex);
   1734   {
   1735     std::lock_guard<std::recursive_mutex> lock(*in->common.mutex);
   1736     const a2dp_state_t state = in->common.state;
   1737     INFO("closing input (state %d)", (int)state);
   1738 
   1739     if ((state == AUDIO_A2DP_STATE_STARTED) ||
   1740         (state == AUDIO_A2DP_STATE_STOPPING))
   1741       stop_audio_datapath(&in->common);
   1742 
   1743     skt_disconnect(in->common.ctrl_fd);
   1744     in->common.ctrl_fd = AUDIO_SKT_DISCONNECTED;
   1745   }
   1746   a2dp_stream_common_destroy(&in->common);
   1747   free(stream);
   1748   a2dp_dev->input = NULL;
   1749 
   1750   DEBUG("done");
   1751 }
   1752 
   1753 static int adev_dump(UNUSED_ATTR const audio_hw_device_t* device,
   1754                      UNUSED_ATTR int fd) {
   1755   FNLOG();
   1756 
   1757   return 0;
   1758 }
   1759 
   1760 static int adev_close(hw_device_t* device) {
   1761   struct a2dp_audio_device* a2dp_dev = (struct a2dp_audio_device*)device;
   1762   FNLOG();
   1763 
   1764   delete a2dp_dev->mutex;
   1765   a2dp_dev->mutex = nullptr;
   1766   free(device);
   1767   return 0;
   1768 }
   1769 
   1770 static int adev_open(const hw_module_t* module, const char* name,
   1771                      hw_device_t** device) {
   1772   struct a2dp_audio_device* adev;
   1773 
   1774   INFO(" adev_open in A2dp_hw module");
   1775   FNLOG();
   1776 
   1777   if (strcmp(name, AUDIO_HARDWARE_INTERFACE) != 0) {
   1778     ERROR("interface %s not matching [%s]", name, AUDIO_HARDWARE_INTERFACE);
   1779     return -EINVAL;
   1780   }
   1781 
   1782   adev = (struct a2dp_audio_device*)calloc(1, sizeof(struct a2dp_audio_device));
   1783 
   1784   if (!adev) return -ENOMEM;
   1785 
   1786   adev->mutex = new std::recursive_mutex;
   1787 
   1788   adev->device.common.tag = HARDWARE_DEVICE_TAG;
   1789   adev->device.common.version = AUDIO_DEVICE_API_VERSION_2_0;
   1790   adev->device.common.module = (struct hw_module_t*)module;
   1791   adev->device.common.close = adev_close;
   1792 
   1793   adev->device.init_check = adev_init_check;
   1794   adev->device.set_voice_volume = adev_set_voice_volume;
   1795   adev->device.set_master_volume = adev_set_master_volume;
   1796   adev->device.set_mode = adev_set_mode;
   1797   adev->device.set_mic_mute = adev_set_mic_mute;
   1798   adev->device.get_mic_mute = adev_get_mic_mute;
   1799   adev->device.set_parameters = adev_set_parameters;
   1800   adev->device.get_parameters = adev_get_parameters;
   1801   adev->device.get_input_buffer_size = adev_get_input_buffer_size;
   1802   adev->device.open_output_stream = adev_open_output_stream;
   1803   adev->device.close_output_stream = adev_close_output_stream;
   1804   adev->device.open_input_stream = adev_open_input_stream;
   1805   adev->device.close_input_stream = adev_close_input_stream;
   1806   adev->device.dump = adev_dump;
   1807 
   1808   adev->output = NULL;
   1809 
   1810   *device = &adev->device.common;
   1811 
   1812   return 0;
   1813 }
   1814 
   1815 static struct hw_module_methods_t hal_module_methods = {
   1816     .open = adev_open,
   1817 };
   1818 
   1819 __attribute__((
   1820     visibility("default"))) struct audio_module HAL_MODULE_INFO_SYM = {
   1821     .common =
   1822         {
   1823             .tag = HARDWARE_MODULE_TAG,
   1824             .version_major = 1,
   1825             .version_minor = 0,
   1826             .id = AUDIO_HARDWARE_MODULE_ID,
   1827             .name = "A2DP Audio HW HAL",
   1828             .author = "The Android Open Source Project",
   1829             .methods = &hal_module_methods,
   1830         },
   1831 };
   1832