tequilaOS/platform_hardware_libhardware
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
platform_hardware_libhardware/modules/audio/audio_hw.c
John Muir 001e6f4650 audio: Update default audio implementation. 
Allow the default audio implementation to use the sample rate and
format provided by the application, but default to 16-bit stereo
for both input and output.

Also, default to 10ms output buffer and 20ms input buffer.

Bug: 70692394
Test: Audio device and output stream created successfully with
      the default frame_count.
      Audio device reports 20ms for input buffer size.
      Audio input stream created successfully with defaults.
      Setup device with audio_policy_configuration_stub.xml;
          no failures for GTS tests: GtsGmscoreHostTestCases
          -t 'com.google.android.gts.audio.AudioHostTest'
Change-Id: If496fc89f72f26266a7ed9b59acf88d1ca76e704
2018-01-30 12:05:24 -08:00

625 lines
20 KiB
C
Raw Blame History

/*
* Copyright (C) 2011 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_default"
//#define LOG_NDEBUG 0
#include <errno.h>
#include <malloc.h>
#include <pthread.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
#include <log/log.h>
#include <hardware/audio.h>
#include <hardware/hardware.h>
#include <system/audio.h>
#define STUB_DEFAULT_SAMPLE_RATE 48000
#define STUB_DEFAULT_AUDIO_FORMAT AUDIO_FORMAT_PCM_16_BIT
#define STUB_INPUT_BUFFER_MILLISECONDS 20
#define STUB_INPUT_DEFAULT_CHANNEL_MASK AUDIO_CHANNEL_IN_STEREO
#define STUB_OUTPUT_BUFFER_MILLISECONDS 10
#define STUB_OUTPUT_DEFAULT_CHANNEL_MASK AUDIO_CHANNEL_OUT_STEREO
struct stub_audio_device {
struct audio_hw_device device;
};
struct stub_stream_out {
struct audio_stream_out stream;
int64_t last_write_time_us;
uint32_t sample_rate;
audio_channel_mask_t channel_mask;
audio_format_t format;
size_t frame_count;
};
struct stub_stream_in {
struct audio_stream_in stream;
int64_t last_read_time_us;
uint32_t sample_rate;
audio_channel_mask_t channel_mask;
audio_format_t format;
size_t frame_count;
};
static uint32_t out_get_sample_rate(const struct audio_stream *stream)
{
const struct stub_stream_out *out = (const struct stub_stream_out *)stream;
ALOGV("out_get_sample_rate: %u", out->sample_rate);
return out->sample_rate;
}
static int out_set_sample_rate(struct audio_stream *stream, uint32_t rate)
{
struct stub_stream_out *out = (struct stub_stream_out *)stream;
ALOGV("out_set_sample_rate: %d", rate);
out->sample_rate = rate;
return 0;
}
static size_t out_get_buffer_size(const struct audio_stream *stream)
{
const struct stub_stream_out *out = (const struct stub_stream_out *)stream;
size_t buffer_size = out->frame_count *
audio_stream_out_frame_size(&out->stream);
ALOGV("out_get_buffer_size: %zu", buffer_size);
return buffer_size;
}
static audio_channel_mask_t out_get_channels(const struct audio_stream *stream)
{
const struct stub_stream_out *out = (const struct stub_stream_out *)stream;
ALOGV("out_get_channels: %x", out->channel_mask);
return out->channel_mask;
}
static audio_format_t out_get_format(const struct audio_stream *stream)
{
const struct stub_stream_out *out = (const struct stub_stream_out *)stream;
ALOGV("out_get_format: %d", out->format);
return out->format;
}
static int out_set_format(struct audio_stream *stream, audio_format_t format)
{
struct stub_stream_out *out = (struct stub_stream_out *)stream;
ALOGV("out_set_format: %d", format);
out->format = format;
return 0;
}
static int out_standby(struct audio_stream *stream)
{
ALOGV("out_standby");
// out->last_write_time_us = 0; unnecessary as a stale write time has same effect
return 0;
}
static int out_dump(const struct audio_stream *stream, int fd)
{
ALOGV("out_dump");
return 0;
}
static int out_set_parameters(struct audio_stream *stream, const char *kvpairs)
{
ALOGV("out_set_parameters");
return 0;
}
static char * out_get_parameters(const struct audio_stream *stream, const char *keys)
{
ALOGV("out_get_parameters");
return strdup("");
}
static uint32_t out_get_latency(const struct audio_stream_out *stream)
{
ALOGV("out_get_latency");
return STUB_OUTPUT_BUFFER_MILLISECONDS;
}
static int out_set_volume(struct audio_stream_out *stream, float left,
float right)
{
ALOGV("out_set_volume: Left:%f Right:%f", left, right);
return 0;
}
static ssize_t out_write(struct audio_stream_out *stream, const void* buffer,
size_t bytes)
{
ALOGV("out_write: bytes: %zu", bytes);
/* XXX: fake timing for audio output */
struct stub_stream_out *out = (struct stub_stream_out *)stream;
struct timespec t = { .tv_sec = 0, .tv_nsec = 0 };
clock_gettime(CLOCK_MONOTONIC, &t);
const int64_t now = (t.tv_sec * 1000000000LL + t.tv_nsec) / 1000;
const int64_t elapsed_time_since_last_write = now - out->last_write_time_us;
int64_t sleep_time = bytes * 1000000LL / audio_stream_out_frame_size(stream) /
out_get_sample_rate(&stream->common) - elapsed_time_since_last_write;
if (sleep_time > 0) {
usleep(sleep_time);
} else {
// we don't sleep when we exit standby (this is typical for a real alsa buffer).
sleep_time = 0;
}
out->last_write_time_us = now + sleep_time;
// last_write_time_us is an approximation of when the (simulated) alsa
// buffer is believed completely full. The usleep above waits for more space
// in the buffer, but by the end of the sleep the buffer is considered
// topped-off.
//
// On the subsequent out_write(), we measure the elapsed time spent in
// the mixer. This is subtracted from the sleep estimate based on frames,
// thereby accounting for drain in the alsa buffer during mixing.
// This is a crude approximation; we don't handle underruns precisely.
return bytes;
}
static int out_get_render_position(const struct audio_stream_out *stream,
uint32_t *dsp_frames)
{
*dsp_frames = 0;
ALOGV("out_get_render_position: dsp_frames: %p", dsp_frames);
return -EINVAL;
}
static int out_add_audio_effect(const struct audio_stream *stream, effect_handle_t effect)
{
ALOGV("out_add_audio_effect: %p", effect);
return 0;
}
static int out_remove_audio_effect(const struct audio_stream *stream, effect_handle_t effect)
{
ALOGV("out_remove_audio_effect: %p", effect);
return 0;
}
static int out_get_next_write_timestamp(const struct audio_stream_out *stream,
int64_t *timestamp)
{
*timestamp = 0;
ALOGV("out_get_next_write_timestamp: %ld", (long int)(*timestamp));
return -EINVAL;
}
/** audio_stream_in implementation **/
static uint32_t in_get_sample_rate(const struct audio_stream *stream)
{
const struct stub_stream_in *in = (const struct stub_stream_in *)stream;
ALOGV("in_get_sample_rate: %u", in->sample_rate);
return in->sample_rate;
}
static int in_set_sample_rate(struct audio_stream *stream, uint32_t rate)
{
struct stub_stream_in *in = (struct stub_stream_in *)stream;
ALOGV("in_set_sample_rate: %u", rate);
in->sample_rate = rate;
return 0;
}
static size_t in_get_buffer_size(const struct audio_stream *stream)
{
const struct stub_stream_in *in = (const struct stub_stream_in *)stream;
size_t buffer_size = in->frame_count *
audio_stream_in_frame_size(&in->stream);
ALOGV("in_get_buffer_size: %zu", buffer_size);
return buffer_size;
}
static audio_channel_mask_t in_get_channels(const struct audio_stream *stream)
{
const struct stub_stream_in *in = (const struct stub_stream_in *)stream;
ALOGV("in_get_channels: %x", in->channel_mask);
return in->channel_mask;
}
static audio_format_t in_get_format(const struct audio_stream *stream)
{
const struct stub_stream_in *in = (const struct stub_stream_in *)stream;
ALOGV("in_get_format: %d", in->format);
return in->format;
}
static int in_set_format(struct audio_stream *stream, audio_format_t format)
{
struct stub_stream_in *in = (struct stub_stream_in *)stream;
ALOGV("in_set_format: %d", format);
in->format = format;
return 0;
}
static int in_standby(struct audio_stream *stream)
{
struct stub_stream_in *in = (struct stub_stream_in *)stream;
in->last_read_time_us = 0;
return 0;
}
static int in_dump(const struct audio_stream *stream, int fd)
{
return 0;
}
static int in_set_parameters(struct audio_stream *stream, const char *kvpairs)
{
return 0;
}
static char * in_get_parameters(const struct audio_stream *stream,
const char *keys)
{
return strdup("");
}
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)
{
ALOGV("in_read: bytes %zu", bytes);
/* XXX: fake timing for audio input */
struct stub_stream_in *in = (struct stub_stream_in *)stream;
struct timespec t = { .tv_sec = 0, .tv_nsec = 0 };
clock_gettime(CLOCK_MONOTONIC, &t);
const int64_t now = (t.tv_sec * 1000000000LL + t.tv_nsec) / 1000;
// we do a full sleep when exiting standby.
const bool standby = in->last_read_time_us == 0;
const int64_t elapsed_time_since_last_read = standby ?
0 : now - in->last_read_time_us;
int64_t sleep_time = bytes * 1000000LL / audio_stream_in_frame_size(stream) /
in_get_sample_rate(&stream->common) - elapsed_time_since_last_read;
if (sleep_time > 0) {
usleep(sleep_time);
} else {
sleep_time = 0;
}
in->last_read_time_us = now + sleep_time;
// last_read_time_us is an approximation of when the (simulated) alsa
// buffer is drained by the read, and is empty.
//
// On the subsequent in_read(), we measure the elapsed time spent in
// the recording thread. This is subtracted from the sleep estimate based on frames,
// thereby accounting for fill in the alsa buffer during the interim.
memset(buffer, 0, bytes);
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 size_t samples_per_milliseconds(size_t milliseconds,
uint32_t sample_rate,
size_t channel_count)
{
return milliseconds * sample_rate * channel_count / 1000;
}
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)
{
ALOGV("adev_open_output_stream...");
*stream_out = NULL;
struct stub_stream_out *out =
(struct stub_stream_out *)calloc(1, sizeof(struct stub_stream_out));
if (!out)
return -ENOMEM;
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->sample_rate = config->sample_rate;
if (out->sample_rate == 0)
out->sample_rate = STUB_DEFAULT_SAMPLE_RATE;
out->channel_mask = config->channel_mask;
if (out->channel_mask == AUDIO_CHANNEL_NONE)
out->channel_mask = STUB_OUTPUT_DEFAULT_CHANNEL_MASK;
out->format = config->format;
if (out->format == AUDIO_FORMAT_DEFAULT)
out->format = STUB_DEFAULT_AUDIO_FORMAT;
out->frame_count = samples_per_milliseconds(
STUB_OUTPUT_BUFFER_MILLISECONDS,
out->sample_rate, 1);
ALOGV("adev_open_output_stream: sample_rate: %u, channels: %x, format: %d,"
" frames: %zu", out->sample_rate, out->channel_mask, out->format,
out->frame_count);
*stream_out = &out->stream;
return 0;
}
static void adev_close_output_stream(struct audio_hw_device *dev,
struct audio_stream_out *stream)
{
ALOGV("adev_close_output_stream...");
free(stream);
}
static int adev_set_parameters(struct audio_hw_device *dev, const char *kvpairs)
{
ALOGV("adev_set_parameters");
return -ENOSYS;
}
static char * adev_get_parameters(const struct audio_hw_device *dev,
const char *keys)
{
ALOGV("adev_get_parameters");
return strdup("");
}
static int adev_init_check(const struct audio_hw_device *dev)
{
ALOGV("adev_init_check");
return 0;
}
static int adev_set_voice_volume(struct audio_hw_device *dev, float volume)
{
ALOGV("adev_set_voice_volume: %f", volume);
return -ENOSYS;
}
static int adev_set_master_volume(struct audio_hw_device *dev, float volume)
{
ALOGV("adev_set_master_volume: %f", volume);
return -ENOSYS;
}
static int adev_get_master_volume(struct audio_hw_device *dev, float *volume)
{
ALOGV("adev_get_master_volume: %f", *volume);
return -ENOSYS;
}
static int adev_set_master_mute(struct audio_hw_device *dev, bool muted)
{
ALOGV("adev_set_master_mute: %d", muted);
return -ENOSYS;
}
static int adev_get_master_mute(struct audio_hw_device *dev, bool *muted)
{
ALOGV("adev_get_master_mute: %d", *muted);
return -ENOSYS;
}
static int adev_set_mode(struct audio_hw_device *dev, audio_mode_t mode)
{
ALOGV("adev_set_mode: %d", mode);
return 0;
}
static int adev_set_mic_mute(struct audio_hw_device *dev, bool state)
{
ALOGV("adev_set_mic_mute: %d",state);
return -ENOSYS;
}
static int adev_get_mic_mute(const struct audio_hw_device *dev, bool *state)
{
ALOGV("adev_get_mic_mute");
return -ENOSYS;
}
static size_t adev_get_input_buffer_size(const struct audio_hw_device *dev,
const struct audio_config *config)
{
size_t buffer_size = samples_per_milliseconds(
STUB_INPUT_BUFFER_MILLISECONDS,
config->sample_rate,
audio_channel_count_from_in_mask(
config->channel_mask));
if (!audio_has_proportional_frames(config->format)) {
// Since the audio data is not proportional choose an arbitrary size for
// the buffer.
buffer_size *= 4;
} else {
buffer_size *= audio_bytes_per_sample(config->format);
}
ALOGV("adev_get_input_buffer_size: %zu", buffer_size);
return 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)
{
ALOGV("adev_open_input_stream...");
*stream_in = NULL;
struct stub_stream_in *in = (struct stub_stream_in *)calloc(1, sizeof(struct stub_stream_in));
if (!in)
return -ENOMEM;
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->sample_rate = config->sample_rate;
if (in->sample_rate == 0)
in->sample_rate = STUB_DEFAULT_SAMPLE_RATE;
in->channel_mask = config->channel_mask;
if (in->channel_mask == AUDIO_CHANNEL_NONE)
in->channel_mask = STUB_INPUT_DEFAULT_CHANNEL_MASK;
in->format = config->format;
if (in->format == AUDIO_FORMAT_DEFAULT)
in->format = STUB_DEFAULT_AUDIO_FORMAT;
in->frame_count = samples_per_milliseconds(
STUB_INPUT_BUFFER_MILLISECONDS, in->sample_rate, 1);
ALOGV("adev_open_input_stream: sample_rate: %u, channels: %x, format: %d,"
"frames: %zu", in->sample_rate, in->channel_mask, in->format,
in->frame_count);
*stream_in = &in->stream;
return 0;
}
static void adev_close_input_stream(struct audio_hw_device *dev,
struct audio_stream_in *in)
{
ALOGV("adev_close_input_stream...");
return;
}
static int adev_dump(const audio_hw_device_t *device, int fd)
{
ALOGV("adev_dump");
return 0;
}
static int adev_close(hw_device_t *device)
{
ALOGV("adev_close");
free(device);
return 0;
}
static int adev_open(const hw_module_t* module, const char* name,
hw_device_t** device)
{
ALOGV("adev_open: %s", name);
struct stub_audio_device *adev;
if (strcmp(name, AUDIO_HARDWARE_INTERFACE) != 0)
return -EINVAL;
adev = calloc(1, sizeof(struct stub_audio_device));
if (!adev)
return -ENOMEM;
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 = "Default audio HW HAL",
.author = "The Android Open Source Project",
.methods = &hal_module_methods,
},
};
Reference in a new issue View git blame Copy permalink