anbox/android/audio/audio_hw.cpp

/*
 * Copyright (C) 2012 The Android Open Source Project
 *
 * 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 LOG_TAG "audio_hw_generic"
#define LOG_NDEBUG 0

#include <errno.h>
#include <fcntl.h>
#include <pthread.h>
#include <stdint.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <sys/un.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>

#include <cutils/log.h>
#include <cutils/str_parms.h>

#include <hardware/audio.h>
#include <hardware/hardware.h>
#include <system/audio.h>

#include "anbox/audio/client_info.h"

#define AUDIO_DEVICE_NAME "/dev/anbox_audio"
#define OUT_SAMPLING_RATE 44100
#define OUT_BUFFER_SIZE 4096
#define OUT_LATENCY_MS 20
#define IN_SAMPLING_RATE 8000
#define IN_BUFFER_SIZE 320

struct generic_audio_device {
  struct audio_hw_device device;
  pthread_mutex_t lock;
  struct audio_stream_out *output;
  struct audio_stream_in *input;
  bool mic_mute;
};

struct generic_stream_out {
  struct audio_stream_out stream;
  struct generic_audio_device *dev;
  audio_devices_t device;
  int fd;
};

struct generic_stream_in {
  struct audio_stream_in stream;
  struct generic_audio_device *dev;
  audio_devices_t device;
  int fd;
};

static uint32_t out_get_sample_rate(const struct audio_stream *stream) {
  return OUT_SAMPLING_RATE;
}

static int out_set_sample_rate(struct audio_stream *stream, uint32_t rate) {
  return -ENOSYS;
}

static size_t out_get_buffer_size(const struct audio_stream *stream) {
  return OUT_BUFFER_SIZE;
}

static audio_channel_mask_t out_get_channels(const struct audio_stream *stream) {
  return AUDIO_CHANNEL_OUT_STEREO;
}

static audio_format_t out_get_format(const struct audio_stream *stream) {
  return AUDIO_FORMAT_PCM_16_BIT;
}

static int out_set_format(struct audio_stream *stream, audio_format_t format) {
  return -ENOSYS;
}

static int out_standby(struct audio_stream *stream) {
  return 0;
}

static int out_dump(const struct audio_stream *stream, int fd) {
  struct generic_stream_out *out = (struct generic_stream_out *)stream;

  dprintf(fd,
          "\tout_dump:\n"
          "\t\tsample rate: %u\n"
          "\t\tbuffer size: %u\n"
          "\t\tchannel mask: %08x\n"
          "\t\tformat: %d\n"
          "\t\tdevice: %08x\n"
          "\t\taudio dev: %p\n\n",
          out_get_sample_rate(stream),
          out_get_buffer_size(stream),
          out_get_channels(stream),
          out_get_format(stream),
          out->device,
          out->dev);

  return 0;
}

static int out_set_parameters(struct audio_stream *stream, const char *kvpairs) {
  struct generic_stream_out *out = (struct generic_stream_out *)stream;
  struct str_parms *parms;
  char value[32];
  int ret;
  long val;
  char *end;

  parms = str_parms_create_str(kvpairs);

  ret = str_parms_get_str(parms, AUDIO_PARAMETER_STREAM_ROUTING,
                          value, sizeof(value));
  if (ret >= 0) {
    errno = 0;
    val = strtol(value, &end, 10);
    if (errno == 0 && (end != NULL) && (*end == '\0') && ((int)val == val)) {
      out->device = (int)val;
    } else {
      ret = -EINVAL;
    }
  }

  str_parms_destroy(parms);
  return ret;
}

static char *out_get_parameters(const struct audio_stream *stream, const char *keys) {
  struct generic_stream_out *out = (struct generic_stream_out *)stream;
  struct str_parms *query = str_parms_create_str(keys);
  char *str;
  char value[256];
  struct str_parms *reply = str_parms_create();
  int ret;

  ret = str_parms_get_str(query, AUDIO_PARAMETER_STREAM_ROUTING, value, sizeof(value));
  if (ret >= 0) {
    str_parms_add_int(reply, AUDIO_PARAMETER_STREAM_ROUTING, out->device);
    str = strdup(str_parms_to_str(reply));
  } else {
    str = strdup(keys);
  }

  str_parms_destroy(query);
  str_parms_destroy(reply);
  return str;
}

static uint32_t out_get_latency(const struct audio_stream_out *stream) {
  return OUT_LATENCY_MS;
}

static int out_set_volume(struct audio_stream_out *stream, float left,
                          float right) {
  return -ENOSYS;
}

static ssize_t out_write(struct audio_stream_out *stream, const void *buffer,
                         size_t bytes) {
  struct generic_stream_out *out = (struct generic_stream_out *)stream;
  struct generic_audio_device *adev = out->dev;

  pthread_mutex_lock(&adev->lock);
  if (out->fd >= 0)
    bytes = write(out->fd, buffer, bytes);
  pthread_mutex_unlock(&adev->lock);
  return bytes;
}

static int out_get_render_position(const struct audio_stream_out *stream,
                                   uint32_t *dsp_frames) {
  return -ENOSYS;
}

static int out_add_audio_effect(const struct audio_stream *stream, effect_handle_t effect) {
  return 0;
}

static int out_remove_audio_effect(const struct audio_stream *stream, effect_handle_t effect) {
  return 0;
}

static int out_get_next_write_timestamp(const struct audio_stream_out *stream,
                                        int64_t *timestamp) {
  return -ENOSYS;
}

static uint32_t in_get_sample_rate(const struct audio_stream *stream) {
  return IN_SAMPLING_RATE;
}

static int in_set_sample_rate(struct audio_stream *stream, uint32_t rate) {
  return -ENOSYS;
}

static size_t in_get_buffer_size(const struct audio_stream *stream) {
  return IN_BUFFER_SIZE;
}

static audio_channel_mask_t in_get_channels(const struct audio_stream *stream) {
  return AUDIO_CHANNEL_IN_MONO;
}

static audio_format_t in_get_format(const struct audio_stream *stream) {
  return AUDIO_FORMAT_PCM_16_BIT;
}

static int in_set_format(struct audio_stream *stream, audio_format_t format) {
  return -ENOSYS;
}

static int in_standby(struct audio_stream *stream) {
  return 0;
}

static int in_dump(const struct audio_stream *stream, int fd) {
  struct generic_stream_in *in = (struct generic_stream_in *)stream;

  dprintf(fd,
          "\tin_dump:\n"
          "\t\tsample rate: %u\n"
          "\t\tbuffer size: %u\n"
          "\t\tchannel mask: %08x\n"
          "\t\tformat: %d\n"
          "\t\tdevice: %08x\n"
          "\t\taudio dev: %p\n\n",
          in_get_sample_rate(stream),
          in_get_buffer_size(stream),
          in_get_channels(stream),
          in_get_format(stream),
          in->device,
          in->dev);

  return 0;
}

static int in_set_parameters(struct audio_stream *stream, const char *kvpairs) {
  struct generic_stream_in *in = (struct generic_stream_in *)stream;
  struct str_parms *parms;
  char value[32];
  int ret;
  long val;
  char *end;

  parms = str_parms_create_str(kvpairs);

  ret = str_parms_get_str(parms, AUDIO_PARAMETER_STREAM_ROUTING,
                          value, sizeof(value));
  if (ret >= 0) {
    errno = 0;
    val = strtol(value, &end, 10);
    if ((errno == 0) && (end != NULL) && (*end == '\0') && ((int)val == val)) {
      in->device = (int)val;
    } else {
      ret = -EINVAL;
    }
  }

  str_parms_destroy(parms);
  return ret;
}

static char *in_get_parameters(const struct audio_stream *stream,
                               const char *keys) {
  struct generic_stream_in *in = (struct generic_stream_in *)stream;
  struct str_parms *query = str_parms_create_str(keys);
  char *str;
  char value[256];
  struct str_parms *reply = str_parms_create();
  int ret;

  ret = str_parms_get_str(query, AUDIO_PARAMETER_STREAM_ROUTING, value, sizeof(value));
  if (ret >= 0) {
    str_parms_add_int(reply, AUDIO_PARAMETER_STREAM_ROUTING, in->device);
    str = strdup(str_parms_to_str(reply));
  } else {
    str = strdup(keys);
  }

  str_parms_destroy(query);
  str_parms_destroy(reply);
  return str;
}

static int in_set_gain(struct audio_stream_in *stream, float gain) {
  return 0;
}

static ssize_t in_read(struct audio_stream_in *stream, void *buffer,
                       size_t bytes) {
  struct generic_stream_in *in = (struct generic_stream_in *)stream;
  struct generic_audio_device *adev = in->dev;

  pthread_mutex_lock(&adev->lock);
  if (in->fd >= 0)
    bytes = read(in->fd, buffer, bytes);
  if (adev->mic_mute && (bytes > 0)) {
    memset(buffer, 0, bytes);
  }
  pthread_mutex_unlock(&adev->lock);

  return bytes;
}

static uint32_t in_get_input_frames_lost(struct audio_stream_in *stream) {
  return 0;
}

static int in_add_audio_effect(const struct audio_stream *stream, effect_handle_t effect) {
  return 0;
}

static int in_remove_audio_effect(const struct audio_stream *stream, effect_handle_t effect) {
  return 0;
}

static int connect_audio_server(const anbox::audio::ClientInfo::Type &type) {
  int fd = socket(AF_LOCAL, SOCK_STREAM, 0);
  if (fd < 0)
    return -errno;

  struct sockaddr_un addr;
  memset(&addr, 0, sizeof(addr));
  addr.sun_family = AF_UNIX;
  strncpy(addr.sun_path, AUDIO_DEVICE_NAME, sizeof(addr.sun_path));

  if (connect(fd, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
    close(fd);
    return -errno;
  }

  // We will send out client type information to the server and the
  // server will either deny the request by closing the connection
  // or by sending us the approved client details back.
  anbox::audio::ClientInfo client_info{type};
  if (::write(fd, &client_info, sizeof(client_info)) < 0) {
    close(fd);
    return -EIO;
  }

  auto bytes_read = ::read(fd, &client_info, sizeof(client_info));
  if (bytes_read < 0) {
    close(fd);
    return -EIO;
  }

  // FIXME once we have real client details we need to check if we
  // got everything we need or if anything is missing.

  ALOGE("Successfully connected Anbox audio server");

  return fd;
}

static int adev_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 __unused) {
  struct generic_audio_device *adev = (struct generic_audio_device *)dev;
  struct generic_stream_out *out;
  int ret = 0, fd = 0;

  pthread_mutex_lock(&adev->lock);
  if (adev->output != NULL) {
    ret = -ENOSYS;
    goto error;
  }

  fd = connect_audio_server(anbox::audio::ClientInfo::Type::Playback);
  if (fd < 0) {
    ret = fd;
    ALOGE("Failed to connect with Anbox audio servers (err %d)", ret);
    goto error;
  }

  if ((config->format != AUDIO_FORMAT_PCM_16_BIT) ||
      (config->channel_mask != AUDIO_CHANNEL_OUT_STEREO) ||
      (config->sample_rate != OUT_SAMPLING_RATE)) {
    ALOGE("Error opening output stream format %d, channel_mask %04x, sample_rate %u",
          config->format, config->channel_mask, config->sample_rate);
    config->format = AUDIO_FORMAT_PCM_16_BIT;
    config->channel_mask = AUDIO_CHANNEL_OUT_STEREO;
    config->sample_rate = OUT_SAMPLING_RATE;
    ret = -EINVAL;
    goto error;
  }

  out = (struct generic_stream_out *)calloc(1, sizeof(struct generic_stream_out));
  out->fd = fd;

  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;
  out->stream.get_next_write_timestamp = out_get_next_write_timestamp;

  out->dev = adev;
  out->device = devices;
  adev->output = (struct audio_stream_out *)out;
  *stream_out = &out->stream;

error:
  pthread_mutex_unlock(&adev->lock);

  return ret;
}

static void adev_close_output_stream(struct audio_hw_device *dev,
                                     struct audio_stream_out *stream) {
  struct generic_audio_device *adev = (struct generic_audio_device *)dev;

  pthread_mutex_lock(&adev->lock);
  if (stream == adev->output) {
    free(stream);
    adev->output = NULL;
  }
  pthread_mutex_unlock(&adev->lock);
}

static int adev_set_parameters(struct audio_hw_device *dev, const char *kvpairs) {
  return 0;
}

static char *adev_get_parameters(const struct audio_hw_device *dev,
                                 const char *keys) {
  return strdup("");
}

static int adev_init_check(const struct audio_hw_device *dev) {
  return 0;
}

static int adev_set_voice_volume(struct audio_hw_device *dev, float volume) {
  return 0;
}

static int adev_set_master_volume(struct audio_hw_device *dev, float volume) {
  return -ENOSYS;
}

static int adev_get_master_volume(struct audio_hw_device *dev, float *volume) {
  return -ENOSYS;
}

static int adev_set_master_mute(struct audio_hw_device *dev, bool muted) {
  return -ENOSYS;
}

static int adev_get_master_mute(struct audio_hw_device *dev, bool *muted) {
  return -ENOSYS;
}

static int adev_set_mode(struct audio_hw_device *dev, audio_mode_t mode) {
  return 0;
}

static int adev_set_mic_mute(struct audio_hw_device *dev, bool state) {
  struct generic_audio_device *adev = (struct generic_audio_device *)dev;

  pthread_mutex_lock(&adev->lock);
  adev->mic_mute = state;
  pthread_mutex_unlock(&adev->lock);
  return 0;
}

static int adev_get_mic_mute(const struct audio_hw_device *dev, bool *state) {
  struct generic_audio_device *adev = (struct generic_audio_device *)dev;

  pthread_mutex_lock(&adev->lock);
  *state = adev->mic_mute;
  pthread_mutex_unlock(&adev->lock);

  return 0;
}

static size_t adev_get_input_buffer_size(const struct audio_hw_device *dev,
                                         const struct audio_config *config) {
  return IN_BUFFER_SIZE;
}

static int adev_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 __unused,
                                  const char *address __unused,
                                  audio_source_t source __unused) {
  struct generic_audio_device *adev = (struct generic_audio_device *)dev;
  struct generic_stream_in *in;
  int ret = 0, fd = 0;

  pthread_mutex_lock(&adev->lock);
  if (adev->input != NULL) {
    ret = -ENOSYS;
    goto error;
  }

  if ((config->format != AUDIO_FORMAT_PCM_16_BIT) ||
      (config->channel_mask != AUDIO_CHANNEL_IN_MONO) ||
      (config->sample_rate != IN_SAMPLING_RATE)) {
    ALOGE("Error opening input stream format %d, channel_mask %04x, sample_rate %u",
          config->format, config->channel_mask, config->sample_rate);
    config->format = AUDIO_FORMAT_PCM_16_BIT;
    config->channel_mask = AUDIO_CHANNEL_IN_MONO;
    config->sample_rate = IN_SAMPLING_RATE;
    ret = -EINVAL;
    goto error;
  }

  fd = connect_audio_server(anbox::audio::ClientInfo::Type::Recording);
  if (fd < 0) {
    ret = fd;
    ALOGE("Failed to connect with Anbox audio servers (err %d)", ret);
    goto error;
  }

  in = (struct generic_stream_in *)calloc(1, sizeof(struct generic_stream_in));
  in->fd = fd;

  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;

  in->dev = adev;
  in->device = devices;
  adev->input = (struct audio_stream_in *)in;
  *stream_in = &in->stream;

error:
  pthread_mutex_unlock(&adev->lock);

  return ret;
}

static void adev_close_input_stream(struct audio_hw_device *dev,
                                    struct audio_stream_in *stream) {
  struct generic_audio_device *adev = (struct generic_audio_device *)dev;

  pthread_mutex_lock(&adev->lock);
  if (stream == adev->input) {
    free(stream);
    adev->input = NULL;
  }
  pthread_mutex_unlock(&adev->lock);
}

static int adev_dump(const audio_hw_device_t *dev, int fd) {
  struct generic_audio_device *adev = (struct generic_audio_device *)dev;

  const size_t SIZE = 256;
  char buffer[SIZE];

  dprintf(fd,
          "\nadev_dump:\n"
          "\tmic_mute: %s\n"
          "\toutput: %p\n"
          "\tinput: %p\n\n",
          adev->mic_mute ? "true" : "false",
          adev->output,
          adev->input);

  if (adev->output != NULL)
    out_dump((const struct audio_stream *)adev->output, fd);
  if (adev->input != NULL)
    in_dump((const struct audio_stream *)adev->input, fd);

  return 0;
}

static int adev_close(hw_device_t *dev) {
  struct generic_audio_device *adev = (struct generic_audio_device *)dev;

  adev_close_output_stream((struct audio_hw_device *)dev, adev->output);
  adev_close_input_stream((struct audio_hw_device *)dev, adev->input);

  free(dev);
  return 0;
}

static int adev_open(const hw_module_t *module, const char *name,
                     hw_device_t **device) {
  struct generic_audio_device *adev;

  if (strcmp(name, AUDIO_HARDWARE_INTERFACE) != 0)
    return -EINVAL;

  adev = (struct generic_audio_device*) calloc(1, sizeof(struct generic_audio_device));

  adev->device.common.tag = HARDWARE_DEVICE_TAG;
  adev->device.common.version = AUDIO_DEVICE_API_VERSION_2_0;
  adev->device.common.module = (struct hw_module_t *)module;
  adev->device.common.close = adev_close;

  adev->device.init_check = adev_init_check;
  adev->device.set_voice_volume = adev_set_voice_volume;
  adev->device.set_master_volume = adev_set_master_volume;
  adev->device.get_master_volume = adev_get_master_volume;
  adev->device.set_master_mute = adev_set_master_mute;
  adev->device.get_master_mute = adev_get_master_mute;
  adev->device.set_mode = adev_set_mode;
  adev->device.set_mic_mute = adev_set_mic_mute;
  adev->device.get_mic_mute = adev_get_mic_mute;
  adev->device.set_parameters = adev_set_parameters;
  adev->device.get_parameters = adev_get_parameters;
  adev->device.get_input_buffer_size = adev_get_input_buffer_size;
  adev->device.open_output_stream = adev_open_output_stream;
  adev->device.close_output_stream = adev_close_output_stream;
  adev->device.open_input_stream = adev_open_input_stream;
  adev->device.close_input_stream = adev_close_input_stream;
  adev->device.dump = adev_dump;

  *device = &adev->device.common;

  return 0;
}

static struct hw_module_methods_t hal_module_methods = {
    .open = adev_open,
};

struct audio_module HAL_MODULE_INFO_SYM = {
    .common = {
        .tag = HARDWARE_MODULE_TAG,
        .module_api_version = AUDIO_MODULE_API_VERSION_0_1,
        .hal_api_version = HARDWARE_HAL_API_VERSION,
        .id = AUDIO_HARDWARE_MODULE_ID,
        .name = "Anbox audio HW HAL",
        .author = "The Android Open Source Project",
        .methods = &hal_module_methods,
    },
};