/*
* Copyright (C) 2013 Intel Corporation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
#define _GNU_SOURCE
#include <errno.h>
#include <pthread.h>
#include <poll.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <unistd.h>
#include <hardware/audio.h>
#include <hardware/hardware.h>
#include <audio_utils/resampler.h>
#include "hal-utils.h"
#include "sco-msg.h"
#include "ipc-common.h"
#include "hal-log.h"
#include "hal.h"
#define AUDIO_STREAM_DEFAULT_RATE 44100
#define AUDIO_STREAM_SCO_RATE 8000
#define AUDIO_STREAM_DEFAULT_FORMAT AUDIO_FORMAT_PCM_16_BIT
#define OUT_BUFFER_SIZE 2560
#define OUT_STREAM_FRAMES 2560
#define IN_STREAM_FRAMES 5292
#define SOCKET_POLL_TIMEOUT_MS 500
static int listen_sk = -1;
static int ipc_sk = -1;
static int sco_fd = -1;
static uint16_t sco_mtu = 0;
static pthread_mutex_t sco_mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_t ipc_th = 0;
static pthread_mutex_t sk_mutex = PTHREAD_MUTEX_INITIALIZER;
static struct sco_stream_in *sco_stream_in = NULL;
static struct sco_stream_out *sco_stream_out = NULL;
struct sco_audio_config {
uint32_t rate;
uint32_t channels;
uint32_t frame_num;
audio_format_t format;
};
struct sco_stream_out {
struct audio_stream_out stream;
struct sco_audio_config cfg;
uint8_t *downmix_buf;
uint8_t *cache;
size_t cache_len;
size_t samples;
struct timespec start;
struct resampler_itfe *resampler;
int16_t *resample_buf;
uint32_t resample_frame_num;
bt_bdaddr_t bd_addr;
};
static void sco_close_socket(void)
{
DBG("sco fd %d", sco_fd);
if (sco_fd < 0)
return;
shutdown(sco_fd, SHUT_RDWR);
close(sco_fd);
sco_fd = -1;
}
struct sco_stream_in {
struct audio_stream_in stream;
struct sco_audio_config cfg;
struct resampler_itfe *resampler;
int16_t *resample_buf;
uint32_t resample_frame_num;
bt_bdaddr_t bd_addr;
};
struct sco_dev {
struct audio_hw_device dev;
struct sco_stream_out *out;
struct sco_stream_in *in;
};
/*
* return the minimum frame numbers from resampling between BT stack's rate
* and audio flinger's. For output stream, 'output' shall be true, otherwise
* false for input streams at audio flinger side.
*/
static size_t get_resample_frame_num(uint32_t sco_rate, uint32_t rate,
size_t frame_num, bool output)
{
size_t resample_frames_num = frame_num * sco_rate / rate + output;
DBG("resampler: sco_rate %d frame_num %zd rate %d resample frames %zd",
sco_rate, frame_num, rate, resample_frames_num);
return resample_frames_num;
}
/* SCO IPC functions */
static int sco_ipc_cmd(uint8_t service_id, uint8_t opcode, uint16_t len,
void *param, size_t *rsp_len, void *rsp, int *fd)
{
ssize_t ret;
struct msghdr msg;
struct iovec iv[2];
struct ipc_hdr cmd;
char cmsgbuf[CMSG_SPACE(sizeof(int))];
struct ipc_status s;
size_t s_len = sizeof(s);
pthread_mutex_lock(&sk_mutex);
if (ipc_sk < 0) {
error("sco: Invalid cmd socket passed to sco_ipc_cmd");
goto failed;
}
if (!rsp || !rsp_len) {
memset(&s, 0, s_len);
rsp_len = &s_len;
rsp = &s;
}
memset(&msg, 0, sizeof(msg));
memset(&cmd, 0, sizeof(cmd));
cmd.service_id = service_id;
cmd.opcode = opcode;
cmd.len = len;
iv[0].iov_base = &cmd;
iv[0].iov_len = sizeof(cmd);
iv[1].iov_base = param;
iv[1].iov_len = len;
msg.msg_iov = iv;
msg.msg_iovlen = 2;
ret = sendmsg(ipc_sk, &msg, 0);
if (ret < 0) {
error("sco: Sending command failed:%s", strerror(errno));
goto failed;
}
/* socket was shutdown */
if (ret == 0) {
error("sco: Command socket closed");
goto failed;
}
memset(&msg, 0, sizeof(msg));
memset(&cmd, 0, sizeof(cmd));
iv[0].iov_base = &cmd;
iv[0].iov_len = sizeof(cmd);
iv[1].iov_base = rsp;
iv[1].iov_len = *rsp_len;
msg.msg_iov = iv;
msg.msg_iovlen = 2;
if (fd) {
memset(cmsgbuf, 0, sizeof(cmsgbuf));
msg.msg_control = cmsgbuf;
msg.msg_controllen = sizeof(cmsgbuf);
}
ret = recvmsg(ipc_sk, &msg, 0);
if (ret < 0) {
error("sco: Receiving command response failed:%s",
strerror(errno));
goto failed;
}
if (ret < (ssize_t) sizeof(cmd)) {
error("sco: Too small response received(%zd bytes)", ret);
goto failed;
}
if (cmd.service_id != service_id) {
error("sco: Invalid service id (%u vs %u)", cmd.service_id,
service_id);
goto failed;
}
if (ret != (ssize_t) (sizeof(cmd) + cmd.len)) {
error("sco: Malformed response received(%zd bytes)", ret);
goto failed;
}
if (cmd.opcode != opcode && cmd.opcode != SCO_OP_STATUS) {
error("sco: Invalid opcode received (%u vs %u)",
cmd.opcode, opcode);
goto failed;
}
if (cmd.opcode == SCO_OP_STATUS) {
struct ipc_status *s = rsp;
if (sizeof(*s) != cmd.len) {
error("sco: Invalid status length");
goto failed;
}
if (s->code == SCO_STATUS_SUCCESS) {
error("sco: Invalid success status response");
goto failed;
}
pthread_mutex_unlock(&sk_mutex);
return s->code;
}
pthread_mutex_unlock(&sk_mutex);
/* Receive auxiliary data in msg */
if (fd) {
struct cmsghdr *cmsg;
*fd = -1;
for (cmsg = CMSG_FIRSTHDR(&msg); cmsg;
cmsg = CMSG_NXTHDR(&msg, cmsg)) {
if (cmsg->cmsg_level == SOL_SOCKET
&& cmsg->cmsg_type == SCM_RIGHTS) {
memcpy(fd, CMSG_DATA(cmsg), sizeof(int));
break;
}
}
if (*fd < 0)
goto failed;
}
*rsp_len = cmd.len;
return SCO_STATUS_SUCCESS;
failed:
/* Some serious issue happen on IPC - recover */
shutdown(ipc_sk, SHUT_RDWR);
pthread_mutex_unlock(&sk_mutex);
return SCO_STATUS_FAILED;
}
static int ipc_get_sco_fd(bt_bdaddr_t *bd_addr)
{
int ret = SCO_STATUS_SUCCESS;
pthread_mutex_lock(&sco_mutex);
if (sco_fd < 0) {
struct sco_cmd_get_fd cmd;
struct sco_rsp_get_fd rsp;
size_t rsp_len = sizeof(rsp);
DBG("Getting SCO fd");
memcpy(cmd.bdaddr, bd_addr, sizeof(cmd.bdaddr));
ret = sco_ipc_cmd(SCO_SERVICE_ID, SCO_OP_GET_FD, sizeof(cmd),
&cmd, &rsp_len, &rsp, &sco_fd);
/* Sometimes mtu returned is wrong */
sco_mtu = /* rsp.mtu */ 48;
}
pthread_mutex_unlock(&sco_mutex);
return ret;
}
/* Audio stream functions */
static void downmix_to_mono(struct sco_stream_out *out, const uint8_t *buffer,
size_t frame_num)
{
const int16_t *input = (const void *) buffer;
int16_t *output = (void *) out->downmix_buf;
size_t i;
for (i = 0; i < frame_num; i++) {
int16_t l = get_le16(&input[i * 2]);
int16_t r = get_le16(&input[i * 2 + 1]);
put_le16((l + r) / 2, &output[i]);
}
}
static uint64_t timespec_diff_us(struct timespec *a, struct timespec *b)
{
struct timespec res;
res.tv_sec = a->tv_sec - b->tv_sec;
res.tv_nsec = a->tv_nsec - b->tv_nsec;
if (res.tv_nsec < 0) {
res.tv_sec--;
res.tv_nsec += 1000000000ll; /* 1sec */
}
return res.tv_sec * 1000000ll + res.tv_nsec / 1000ll;
}
static bool write_data(struct sco_stream_out *out, const uint8_t *buffer,
size_t bytes)
{
struct pollfd pfd;
size_t len, written = 0;
int ret;
uint8_t *p;
uint64_t audio_sent_us, audio_passed_us;
pfd.fd = sco_fd;
pfd.events = POLLOUT | POLLHUP | POLLNVAL;
while (bytes > written) {
struct timespec now;
/* poll for sending */
if (poll(&pfd, 1, SOCKET_POLL_TIMEOUT_MS) == 0) {
DBG("timeout fd %d", sco_fd);
return false;
}
if (pfd.revents & (POLLHUP | POLLNVAL)) {
error("error fd %d, events 0x%x", sco_fd, pfd.revents);
return false;
}
len = bytes - written > sco_mtu ? sco_mtu : bytes - written;
clock_gettime(CLOCK_REALTIME, &now);
/* Mark start of the stream */
if (!out->samples)
memcpy(&out->start, &now, sizeof(out->start));
audio_sent_us = out->samples * 1000000ll / AUDIO_STREAM_SCO_RATE;
audio_passed_us = timespec_diff_us(&now, &out->start);
if ((int) (audio_sent_us - audio_passed_us) > 1500) {
struct timespec timeout = {0,
(audio_sent_us -
audio_passed_us) * 1000};
DBG("Sleeping for %d ms",
(int) (audio_sent_us - audio_passed_us));
nanosleep(&timeout, NULL);
} else if ((int)(audio_passed_us - audio_sent_us) > 50000) {
DBG("\n\nResync\n\n");
out->samples = 0;
memcpy(&out->start, &now, sizeof(out->start));
}
if (out->cache_len) {
DBG("First packet cache_len %zd", out->cache_len);
memcpy(out->cache + out->cache_len, buffer,
sco_mtu - out->cache_len);
p = out->cache;
} else {
if (bytes - written >= sco_mtu)
p = (void *) buffer + written;
else {
memcpy(out->cache, buffer + written,
bytes - written);
out->cache_len = bytes - written;
DBG("Last packet, cache %zd bytes",
bytes - written);
written += bytes - written;
continue;
}
}
ret = write(sco_fd, p, len);
if (ret > 0) {
if (out->cache_len) {
written = sco_mtu - out->cache_len;
out->cache_len = 0;
} else
written += ret;
out->samples += ret / 2;
DBG("written %d samples %zd total %zd bytes",
ret, out->samples, written);
continue;
}
if (errno == EAGAIN) {
ret = errno;
warn("write failed (%d)", ret);
continue;
}
if (errno != EINTR) {
ret = errno;
error("write failed (%d) fd %d bytes %zd", ret, sco_fd,
bytes);
return false;
}
}
DBG("written %zd bytes", bytes);
return true;
}
static ssize_t out_write(struct audio_stream_out *stream, const void *buffer,
size_t bytes)
{
struct sco_stream_out *out = (struct sco_stream_out *) stream;
#if ANDROID_VERSION >= PLATFORM_VER(5, 0, 0)
size_t frame_num = bytes / audio_stream_out_frame_size(stream);
#else
size_t frame_num = bytes / audio_stream_frame_size(&out->stream.common);
#endif
size_t output_frame_num = frame_num;
void *send_buf = out->downmix_buf;
size_t total;
DBG("write to fd %d bytes %zu", sco_fd, bytes);
if (ipc_get_sco_fd(&out->bd_addr) != SCO_STATUS_SUCCESS)
return -1;
if (!out->downmix_buf) {
error("sco: downmix buffer not initialized");
return -1;
}
downmix_to_mono(out, buffer, frame_num);
if (out->resampler) {
int ret;
/* limit resampler's output within what resample buf can hold */
output_frame_num = out->resample_frame_num;
ret = out->resampler->resample_from_input(out->resampler,
send_buf,
&frame_num,
out->resample_buf,
&output_frame_num);
if (ret) {
error("Failed to resample frames: %zd input %zd (%s)",
frame_num, output_frame_num, strerror(ret));
return -1;
}
send_buf = out->resample_buf;
DBG("Resampled: frame_num %zd, output_frame_num %zd",
frame_num, output_frame_num);
}
total = output_frame_num * sizeof(int16_t) * 1;
DBG("total %zd", total);
if (!write_data(out, send_buf, total))
return -1;
return bytes;
}
static uint32_t out_get_sample_rate(const struct audio_stream *stream)
{
struct sco_stream_out *out = (struct sco_stream_out *) stream;
DBG("rate %u", out->cfg.rate);
return out->cfg.rate;
}
static int out_set_sample_rate(struct audio_stream *stream, uint32_t rate)
{
DBG("rate %u", rate);
return 0;
}
static size_t out_get_buffer_size(const struct audio_stream *stream)
{
struct sco_stream_out *out = (struct sco_stream_out *) stream;
#if ANDROID_VERSION >= PLATFORM_VER(5, 0, 0)
size_t size = audio_stream_out_frame_size(&out->stream) *
out->cfg.frame_num;
#else
size_t size = audio_stream_frame_size(&out->stream.common) *
out->cfg.frame_num;
#endif
/* buffer size without resampling */
if (out->cfg.rate == AUDIO_STREAM_SCO_RATE)
size = 576 * 2;
DBG("buf size %zd", size);
return size;
}
static uint32_t out_get_channels(const struct audio_stream *stream)
{
struct sco_stream_out *out = (struct sco_stream_out *) stream;
DBG("channels num: %u", popcount(out->cfg.channels));
return out->cfg.channels;
}
static audio_format_t out_get_format(const struct audio_stream *stream)
{
struct sco_stream_out *out = (struct sco_stream_out *) stream;
DBG("format: %u", out->cfg.format);
return out->cfg.format;
}
static int out_set_format(struct audio_stream *stream, audio_format_t format)
{
DBG("");
return -ENOSYS;
}
static int out_standby(struct audio_stream *stream)
{
DBG("");
return 0;
}
static int out_dump(const struct audio_stream *stream, int fd)
{
DBG("");
return -ENOSYS;
}
static int out_set_parameters(struct audio_stream *stream, const char *kvpairs)
{
DBG("%s", kvpairs);
return 0;
}
static char *out_get_parameters(const struct audio_stream *stream,
const char *keys)
{
DBG("");
return strdup("");
}
static uint32_t out_get_latency(const struct audio_stream_out *stream)
{
DBG("");
return 0;
}
static int out_set_volume(struct audio_stream_out *stream, float left,
float right)
{
DBG("");
return -ENOSYS;
}
static int out_get_render_position(const struct audio_stream_out *stream,
uint32_t *dsp_frames)
{
DBG("");
return -ENOSYS;
}
static int out_add_audio_effect(const struct audio_stream *stream,
effect_handle_t effect)
{
DBG("");
return -ENOSYS;
}
static int out_remove_audio_effect(const struct audio_stream *stream,
effect_handle_t effect)
{
DBG("");
return -ENOSYS;
}
static int sco_open_output_stream_real(struct audio_hw_device *dev,
audio_io_handle_t handle,
audio_devices_t devices,
audio_output_flags_t flags,
struct audio_config *config,
struct audio_stream_out **stream_out,
const char *address)
{
struct sco_dev *adev = (struct sco_dev *) dev;
struct sco_stream_out *out;
int chan_num, ret;
size_t resample_size;
DBG("config %p device flags 0x%02x", config, devices);
if (sco_stream_out) {
DBG("stream_out already open");
return -EIO;
}
out = calloc(1, sizeof(struct sco_stream_out));
if (!out)
return -ENOMEM;
DBG("stream %p sco fd %d mtu %u", out, sco_fd, sco_mtu);
out->stream.common.get_sample_rate = out_get_sample_rate;
out->stream.common.set_sample_rate = out_set_sample_rate;
out->stream.common.get_buffer_size = out_get_buffer_size;
out->stream.common.get_channels = out_get_channels;
out->stream.common.get_format = out_get_format;
out->stream.common.set_format = out_set_format;
out->stream.common.standby = out_standby;
out->stream.common.dump = out_dump;
out->stream.common.set_parameters = out_set_parameters;
out->stream.common.get_parameters = out_get_parameters;
out->stream.common.add_audio_effect = out_add_audio_effect;
out->stream.common.remove_audio_effect = out_remove_audio_effect;
out->stream.get_latency = out_get_latency;
out->stream.set_volume = out_set_volume;
out->stream.write = out_write;
out->stream.get_render_position = out_get_render_position;
#if ANDROID_VERSION >= PLATFORM_VER(5, 0, 0)
if (address) {
DBG("address %s", address);
str2bt_bdaddr_t(address, &out->bd_addr);
}
#endif
if (ipc_get_sco_fd(&out->bd_addr) != SCO_STATUS_SUCCESS)
DBG("SCO is not connected yet; get fd on write()");
if (config) {
DBG("config: rate %u chan mask %x format %d offload %p",
config->sample_rate, config->channel_mask,
config->format, &config->offload_info);
out->cfg.format = config->format;
out->cfg.channels = config->channel_mask;
out->cfg.rate = config->sample_rate;
} else {
out->cfg.format = AUDIO_STREAM_DEFAULT_FORMAT;
out->cfg.channels = AUDIO_CHANNEL_OUT_STEREO;
out->cfg.rate = AUDIO_STREAM_DEFAULT_RATE;
}
out->cfg.frame_num = OUT_STREAM_FRAMES;
out->downmix_buf = malloc(out_get_buffer_size(&out->stream.common));
if (!out->downmix_buf) {
free(out);
return -ENOMEM;
}
out->cache = malloc(sco_mtu);
if (!out->cache) {
free(out->downmix_buf);
free(out);
return -ENOMEM;
}
if (out->cfg.rate == AUDIO_STREAM_SCO_RATE)
goto skip_resampler;
/* Channel numbers for resampler */
chan_num = 1;
ret = create_resampler(out->cfg.rate, AUDIO_STREAM_SCO_RATE, chan_num,
RESAMPLER_QUALITY_DEFAULT, NULL,
&out->resampler);
if (ret) {
error("Failed to create resampler (%s)", strerror(-ret));
goto failed;
}
out->resample_frame_num = get_resample_frame_num(AUDIO_STREAM_SCO_RATE,
out->cfg.rate,
out->cfg.frame_num, 1);
if (!out->resample_frame_num) {
error("frame num is too small to resample, discard it");
goto failed;
}
resample_size = sizeof(int16_t) * chan_num * out->resample_frame_num;
out->resample_buf = malloc(resample_size);
if (!out->resample_buf) {
error("failed to allocate resample buffer for %u frames",
out->resample_frame_num);
goto failed;
}
DBG("Resampler: input %d output %d chan %d frames %u size %zd",
out->cfg.rate, AUDIO_STREAM_SCO_RATE, chan_num,
out->resample_frame_num, resample_size);
skip_resampler:
*stream_out = &out->stream;
adev->out = out;
sco_stream_out = out;
return 0;
failed:
if (out->resampler)
release_resampler(out->resampler);
free(out->cache);
free(out->downmix_buf);
free(out);
*stream_out = NULL;
adev->out = NULL;
sco_stream_out = NULL;
return ret;
}
#if ANDROID_VERSION >= PLATFORM_VER(5, 0, 0)
static int sco_open_output_stream(struct audio_hw_device *dev,
audio_io_handle_t handle,
audio_devices_t devices,
audio_output_flags_t flags,
struct audio_config *config,
struct audio_stream_out **stream_out,
const char *address)
{
return sco_open_output_stream_real(dev, handle, devices, flags,
config, stream_out, address);
}
#else
static int sco_open_output_stream(struct audio_hw_device *dev,
audio_io_handle_t handle,
audio_devices_t devices,
audio_output_flags_t flags,
struct audio_config *config,
struct audio_stream_out **stream_out)
{
return sco_open_output_stream_real(dev, handle, devices, flags,
config, stream_out, NULL);
}
#endif
static void sco_close_output_stream(struct audio_hw_device *dev,
struct audio_stream_out *stream_out)
{
struct sco_dev *sco_dev = (struct sco_dev *) dev;
struct sco_stream_out *out = (struct sco_stream_out *) stream_out;
DBG("dev %p stream %p fd %d", dev, out, sco_fd);
if (out->resampler) {
release_resampler(out->resampler);
free(out->resample_buf);
}
free(out->cache);
free(out->downmix_buf);
free(out);
sco_dev->out = NULL;
pthread_mutex_lock(&sco_mutex);
sco_stream_out = NULL;
if (!sco_stream_in)
sco_close_socket();
pthread_mutex_unlock(&sco_mutex);
}
static int sco_set_parameters(struct audio_hw_device *dev,
const char *kvpairs)
{
DBG("%s", kvpairs);
return 0;
}
static char *sco_get_parameters(const struct audio_hw_device *dev,
const char *keys)
{
DBG("");
return strdup("");
}
static int sco_init_check(const struct audio_hw_device *dev)
{
DBG("");
return 0;
}
static int sco_set_voice_volume(struct audio_hw_device *dev, float volume)
{
DBG("%f", volume);
return 0;
}
static int sco_set_master_volume(struct audio_hw_device *dev, float volume)
{
DBG("%f", volume);
return 0;
}
static int sco_set_mode(struct audio_hw_device *dev, int mode)
{
DBG("");
return -ENOSYS;
}
static int sco_set_mic_mute(struct audio_hw_device *dev, bool state)
{
DBG("");
return -ENOSYS;
}
static int sco_get_mic_mute(const struct audio_hw_device *dev, bool *state)
{
DBG("");
return -ENOSYS;
}
static size_t sco_get_input_buffer_size(const struct audio_hw_device *dev,
const struct audio_config *config)
{
DBG("");
return -ENOSYS;
}
static uint32_t in_get_sample_rate(const struct audio_stream *stream)
{
struct sco_stream_in *in = (struct sco_stream_in *) stream;
DBG("rate %u", in->cfg.rate);
return in->cfg.rate;
}
static int in_set_sample_rate(struct audio_stream *stream, uint32_t rate)
{
DBG("rate %u", rate);
return 0;
}
static size_t in_get_buffer_size(const struct audio_stream *stream)
{
struct sco_stream_in *in = (struct sco_stream_in *) stream;
#if ANDROID_VERSION >= PLATFORM_VER(5, 0, 0)
size_t size = audio_stream_in_frame_size(&in->stream) *
in->cfg.frame_num;
#else
size_t size = audio_stream_frame_size(&in->stream.common) *
in->cfg.frame_num;
#endif
/* buffer size without resampling */
if (in->cfg.rate == AUDIO_STREAM_SCO_RATE)
size = 576;
DBG("buf size %zd", size);
return size;
}
static uint32_t in_get_channels(const struct audio_stream *stream)
{
struct sco_stream_in *in = (struct sco_stream_in *) stream;
DBG("channels num: %u", popcount(in->cfg.channels));
return in->cfg.channels;
}
static audio_format_t in_get_format(const struct audio_stream *stream)
{
struct sco_stream_in *in = (struct sco_stream_in *) stream;
DBG("format: %u", in->cfg.format);
return in->cfg.format;
}
static int in_set_format(struct audio_stream *stream, audio_format_t format)
{
DBG("");
return -ENOSYS;
}
static int in_standby(struct audio_stream *stream)
{
DBG("");
return 0;
}
static int in_dump(const struct audio_stream *stream, int fd)
{
DBG("");
return -ENOSYS;
}
static int in_set_parameters(struct audio_stream *stream, const char *kvpairs)
{
DBG("%s", kvpairs);
return 0;
}
static char *in_get_parameters(const struct audio_stream *stream,
const char *keys)
{
DBG("");
return strdup("");
}
static int in_add_audio_effect(const struct audio_stream *stream,
effect_handle_t effect)
{
DBG("");
return -ENOSYS;
}
static int in_remove_audio_effect(const struct audio_stream *stream,
effect_handle_t effect)
{
DBG("");
return -ENOSYS;
}
static int in_set_gain(struct audio_stream_in *stream, float gain)
{
DBG("");
return -ENOSYS;
}
static bool read_data(struct sco_stream_in *in, char *buffer, size_t bytes)
{
struct pollfd pfd;
size_t len, read_bytes = 0;
pfd.fd = sco_fd;
pfd.events = POLLIN | POLLHUP | POLLNVAL;
while (bytes > read_bytes) {
int ret;
/* poll for reading */
if (poll(&pfd, 1, SOCKET_POLL_TIMEOUT_MS) == 0) {
DBG("timeout fd %d", sco_fd);
return false;
}
if (pfd.revents & (POLLHUP | POLLNVAL)) {
error("error fd %d, events 0x%x", sco_fd, pfd.revents);
return false;
}
len = bytes - read_bytes > sco_mtu ? sco_mtu :
bytes - read_bytes;
ret = read(sco_fd, buffer + read_bytes, len);
if (ret > 0) {
read_bytes += ret;
DBG("read %d total %zd", ret, read_bytes);
continue;
}
if (errno == EAGAIN) {
ret = errno;
warn("read failed (%d)", ret);
continue;
}
if (errno != EINTR) {
ret = errno;
error("read failed (%d) fd %d bytes %zd", ret, sco_fd,
bytes);
return false;
}
}
DBG("read %zd bytes", read_bytes);
return true;
}
static ssize_t in_read(struct audio_stream_in *stream, void *buffer,
size_t bytes)
{
struct sco_stream_in *in = (struct sco_stream_in *) stream;
size_t frame_size, frame_num, input_frame_num;
void *read_buf = buffer;
size_t total = bytes;
int ret;
#if ANDROID_VERSION >= PLATFORM_VER(5, 0, 0)
frame_size = audio_stream_in_frame_size(&in->stream);
#else
frame_size = audio_stream_frame_size(&stream->common);
#endif
if (!frame_size)
return -1;
frame_num = bytes / frame_size;
input_frame_num = frame_num;
DBG("Read from fd %d bytes %zu", sco_fd, bytes);
if (ipc_get_sco_fd(&in->bd_addr) != SCO_STATUS_SUCCESS)
return -1;
if (!in->resampler && in->cfg.rate != AUDIO_STREAM_SCO_RATE) {
error("Cannot find resampler");
return -1;
}
if (in->resampler) {
input_frame_num = get_resample_frame_num(AUDIO_STREAM_SCO_RATE,
in->cfg.rate,
frame_num, 0);
if (input_frame_num > in->resample_frame_num) {
DBG("resize input frames from %zd to %d",
input_frame_num, in->resample_frame_num);
input_frame_num = in->resample_frame_num;
}
read_buf = in->resample_buf;
total = input_frame_num * sizeof(int16_t) * 1;
}
if(!read_data(in, read_buf, total))
return -1;
if (in->resampler) {
ret = in->resampler->resample_from_input(in->resampler,
in->resample_buf,
&input_frame_num,
(int16_t *) buffer,
&frame_num);
if (ret) {
error("Failed to resample frames: %zd input %zd (%s)",
frame_num, input_frame_num,
strerror(ret));
return -1;
}
DBG("resampler: remain %zd output %zd frames", input_frame_num,
frame_num);
}
return bytes;
}
static uint32_t in_get_input_frames_lost(struct audio_stream_in *stream)
{
DBG("");
return -ENOSYS;
}
static int sco_open_input_stream_real(struct audio_hw_device *dev,
audio_io_handle_t handle,
audio_devices_t devices,
struct audio_config *config,
struct audio_stream_in **stream_in,
audio_input_flags_t flags,
const char *address,
audio_source_t source)
{
struct sco_dev *sco_dev = (struct sco_dev *) dev;
struct sco_stream_in *in;
int chan_num, ret;
size_t resample_size;
DBG("config %p device flags 0x%02x", config, devices);
if (sco_stream_in) {
DBG("stream_in already open");
ret = -EIO;
goto failed2;
}
in = calloc(1, sizeof(struct sco_stream_in));
if (!in)
return -ENOMEM;
DBG("stream %p sco fd %d mtu %u", in, sco_fd, sco_mtu);
in->stream.common.get_sample_rate = in_get_sample_rate;
in->stream.common.set_sample_rate = in_set_sample_rate;
in->stream.common.get_buffer_size = in_get_buffer_size;
in->stream.common.get_channels = in_get_channels;
in->stream.common.get_format = in_get_format;
in->stream.common.set_format = in_set_format;
in->stream.common.standby = in_standby;
in->stream.common.dump = in_dump;
in->stream.common.set_parameters = in_set_parameters;
in->stream.common.get_parameters = in_get_parameters;
in->stream.common.add_audio_effect = in_add_audio_effect;
in->stream.common.remove_audio_effect = in_remove_audio_effect;
in->stream.set_gain = in_set_gain;
in->stream.read = in_read;
in->stream.get_input_frames_lost = in_get_input_frames_lost;
#if ANDROID_VERSION >= PLATFORM_VER(5, 0, 0)
if (address) {
DBG("address %s", address);
str2bt_bdaddr_t(address, &in->bd_addr);
}
#endif
if (config) {
DBG("config: rate %u chan mask %x format %d offload %p",
config->sample_rate, config->channel_mask,
config->format, &config->offload_info);
in->cfg.format = config->format;
in->cfg.channels = config->channel_mask;
in->cfg.rate = config->sample_rate;
} else {
in->cfg.format = AUDIO_STREAM_DEFAULT_FORMAT;
in->cfg.channels = AUDIO_CHANNEL_OUT_MONO;
in->cfg.rate = AUDIO_STREAM_DEFAULT_RATE;
}
in->cfg.frame_num = IN_STREAM_FRAMES;
if (in->cfg.rate == AUDIO_STREAM_SCO_RATE)
goto skip_resampler;
/* Channel numbers for resampler */
chan_num = 1;
ret = create_resampler(AUDIO_STREAM_SCO_RATE, in->cfg.rate, chan_num,
RESAMPLER_QUALITY_DEFAULT, NULL,
&in->resampler);
if (ret) {
error("Failed to create resampler (%s)", strerror(-ret));
goto failed;
}
in->resample_frame_num = get_resample_frame_num(AUDIO_STREAM_SCO_RATE,
in->cfg.rate,
in->cfg.frame_num, 0);
resample_size = sizeof(int16_t) * chan_num * in->resample_frame_num;
in->resample_buf = malloc(resample_size);
if (!in->resample_buf) {
error("failed to allocate resample buffer for %d frames",
in->resample_frame_num);
goto failed;
}
DBG("Resampler: input %d output %d chan %d frames %u size %zd",
AUDIO_STREAM_SCO_RATE, in->cfg.rate, chan_num,
in->resample_frame_num, resample_size);
skip_resampler:
*stream_in = &in->stream;
sco_dev->in = in;
sco_stream_in = in;
return 0;
failed:
if (in->resampler)
release_resampler(in->resampler);
free(in);
failed2:
*stream_in = NULL;
sco_dev->in = NULL;
sco_stream_in = NULL;
return ret;
}
#if ANDROID_VERSION >= PLATFORM_VER(5, 0, 0)
static int sco_open_input_stream(struct audio_hw_device *dev,
audio_io_handle_t handle,
audio_devices_t devices,
struct audio_config *config,
struct audio_stream_in **stream_in,
audio_input_flags_t flags,
const char *address,
audio_source_t source)
{
return sco_open_input_stream_real(dev, handle, devices, config,
stream_in, flags, address,
source);
}
#else
static int sco_open_input_stream(struct audio_hw_device *dev,
audio_io_handle_t handle,
audio_devices_t devices,
struct audio_config *config,
struct audio_stream_in **stream_in)
{
return sco_open_input_stream_real(dev, handle, devices, config,
stream_in, 0, NULL, 0);
}
#endif
static void sco_close_input_stream(struct audio_hw_device *dev,
struct audio_stream_in *stream_in)
{
struct sco_dev *sco_dev = (struct sco_dev *) dev;
struct sco_stream_in *in = (struct sco_stream_in *) stream_in;
DBG("dev %p stream %p fd %d", dev, in, sco_fd);
if (in->resampler) {
release_resampler(in->resampler);
free(in->resample_buf);
}
free(in);
sco_dev->in = NULL;
pthread_mutex_lock(&sco_mutex);
sco_stream_in = NULL;
if (!sco_stream_out)
sco_close_socket();
pthread_mutex_unlock(&sco_mutex);
}
static int sco_dump(const audio_hw_device_t *device, int fd)
{
DBG("");
return 0;
}
#if ANDROID_VERSION >= PLATFORM_VER(5, 0, 0)
static int set_master_mute(struct audio_hw_device *dev, bool mute)
{
DBG("");
return -ENOSYS;
}
static int get_master_mute(struct audio_hw_device *dev, bool *mute)
{
DBG("");
return -ENOSYS;
}
static int create_audio_patch(struct audio_hw_device *dev,
unsigned int num_sources,
const struct audio_port_config *sources,
unsigned int num_sinks,
const struct audio_port_config *sinks,
audio_patch_handle_t *handle)
{
DBG("");
return -ENOSYS;
}
static int release_audio_patch(struct audio_hw_device *dev,
audio_patch_handle_t handle)
{
DBG("");
return -ENOSYS;
}
static int get_audio_port(struct audio_hw_device *dev, struct audio_port *port)
{
DBG("");
return -ENOSYS;
}
static int set_audio_port_config(struct audio_hw_device *dev,
const struct audio_port_config *config)
{
DBG("");
return -ENOSYS;
}
#endif
static int sco_close(hw_device_t *device)
{
DBG("");
free(device);
return 0;
}
static void *ipc_handler(void *data)
{
bool done = false;
struct pollfd pfd;
int sk;
DBG("");
while (!done) {
DBG("Waiting for connection ...");
sk = accept(listen_sk, NULL, NULL);
if (sk < 0) {
int err = errno;
if (err == EINTR)
continue;
if (err != ECONNABORTED && err != EINVAL)
error("sco: Failed to accept socket: %d (%s)",
err, strerror(err));
break;
}
pthread_mutex_lock(&sk_mutex);
ipc_sk = sk;
pthread_mutex_unlock(&sk_mutex);
DBG("SCO IPC: Connected");
memset(&pfd, 0, sizeof(pfd));
pfd.fd = ipc_sk;
pfd.events = POLLHUP | POLLERR | POLLNVAL;
/* Check if socket is still alive. Empty while loop.*/
while (poll(&pfd, 1, -1) < 0 && errno == EINTR);
info("SCO HAL: Socket closed");
pthread_mutex_lock(&sk_mutex);
close(ipc_sk);
ipc_sk = -1;
pthread_mutex_unlock(&sk_mutex);
}
info("Closing SCO IPC thread");
return NULL;
}
static int sco_ipc_init(void)
{
struct sockaddr_un addr;
int err;
int sk;
DBG("");
sk = socket(PF_LOCAL, SOCK_SEQPACKET, 0);
if (sk < 0) {
err = -errno;
error("sco: Failed to create socket: %d (%s)", -err,
strerror(-err));
return err;
}
memset(&addr, 0, sizeof(addr));
addr.sun_family = AF_UNIX;
memcpy(addr.sun_path, BLUEZ_SCO_SK_PATH, sizeof(BLUEZ_SCO_SK_PATH));
if (bind(sk, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
err = -errno;
error("sco: Failed to bind socket: %d (%s)", -err,
strerror(-err));
goto failed;
}
if (listen(sk, 1) < 0) {
err = -errno;
error("sco: Failed to listen on the socket: %d (%s)", -err,
strerror(-err));
goto failed;
}
listen_sk = sk;
err = pthread_create(&ipc_th, NULL, ipc_handler, NULL);
if (err) {
err = -err;
ipc_th = 0;
error("sco: Failed to start IPC thread: %d (%s)",
-err, strerror(-err));
goto failed;
}
return 0;
failed:
close(sk);
return err;
}
static int sco_open(const hw_module_t *module, const char *name,
hw_device_t **device)
{
struct sco_dev *dev;
int err;
DBG("");
if (strcmp(name, AUDIO_HARDWARE_INTERFACE)) {
error("SCO: interface %s not matching [%s]", name,
AUDIO_HARDWARE_INTERFACE);
return -EINVAL;
}
err = sco_ipc_init();
if (err < 0)
return err;
dev = calloc(1, sizeof(struct sco_dev));
if (!dev)
return -ENOMEM;
dev->dev.common.tag = HARDWARE_DEVICE_TAG;
dev->dev.common.version = AUDIO_DEVICE_API_VERSION_CURRENT;
dev->dev.common.module = (struct hw_module_t *) module;
dev->dev.common.close = sco_close;
dev->dev.init_check = sco_init_check;
dev->dev.set_voice_volume = sco_set_voice_volume;
dev->dev.set_master_volume = sco_set_master_volume;
dev->dev.set_mode = sco_set_mode;
dev->dev.set_mic_mute = sco_set_mic_mute;
dev->dev.get_mic_mute = sco_get_mic_mute;
dev->dev.set_parameters = sco_set_parameters;
dev->dev.get_parameters = sco_get_parameters;
dev->dev.get_input_buffer_size = sco_get_input_buffer_size;
dev->dev.open_output_stream = sco_open_output_stream;
dev->dev.close_output_stream = sco_close_output_stream;
dev->dev.open_input_stream = sco_open_input_stream;
dev->dev.close_input_stream = sco_close_input_stream;
dev->dev.dump = sco_dump;
#if ANDROID_VERSION >= PLATFORM_VER(5, 0, 0)
dev->dev.set_master_mute = set_master_mute;
dev->dev.get_master_mute = get_master_mute;
dev->dev.create_audio_patch = create_audio_patch;
dev->dev.release_audio_patch = release_audio_patch;
dev->dev.get_audio_port = get_audio_port;
dev->dev.set_audio_port_config = set_audio_port_config;
#endif
*device = &dev->dev.common;
return 0;
}
static struct hw_module_methods_t hal_module_methods = {
.open = sco_open,
};
struct audio_module HAL_MODULE_INFO_SYM = {
.common = {
.tag = HARDWARE_MODULE_TAG,
.version_major = 1,
.version_minor = 0,
.id = AUDIO_HARDWARE_MODULE_ID,
.name = "SCO Audio HW HAL",
.author = "Intel Corporation",
.methods = &hal_module_methods,
},
};