static ssize_t out_write(struct audio_stream_out *stream, const void* buffer, size_t bytes)
{
int ret;
struct stream_out *out = (struct stream_out *)stream;
pthread_mutex_lock(&out->dev->lock);
pthread_mutex_lock(&out->lock);
if (out->standby) {
ret = start_output_stream(out);
if (ret != 0) {
pthread_mutex_unlock(&out->dev->lock);
goto err;
}
out->standby = false;
}
pthread_mutex_unlock(&out->dev->lock);
alsa_device_proxy* proxy = &out->proxy;
const void * write_buff = buffer;
int num_write_buff_bytes = bytes;
const int num_device_channels = proxy_get_channel_count(proxy); /* what we told alsa */
const int num_req_channels = out->hal_channel_count; /* what we told AudioFlinger */
if (num_device_channels != num_req_channels) {
/* allocate buffer */
const size_t required_conversion_buffer_size =
bytes * num_device_channels / num_req_channels;
if (required_conversion_buffer_size > out->conversion_buffer_size) {
out->conversion_buffer_size = required_conversion_buffer_size;
out->conversion_buffer = realloc(out->conversion_buffer,
out->conversion_buffer_size);
}
/* convert data */
const audio_format_t audio_format = out_get_format(&(out->stream.common));
const unsigned sample_size_in_bytes = audio_bytes_per_sample(audio_format);
num_write_buff_bytes =
adjust_channels(write_buff, num_req_channels,
out->conversion_buffer, num_device_channels,
sample_size_in_bytes, num_write_buff_bytes);
write_buff = out->conversion_buffer;
}
if (write_buff != NULL && num_write_buff_bytes != 0) {
proxy_write(&out->proxy, write_buff, num_write_buff_bytes);
}
pthread_mutex_unlock(&out->lock);
return bytes;
err:
pthread_mutex_unlock(&out->lock);
if (ret != 0) {
usleep(bytes * 1000000 / audio_stream_out_frame_size(stream) /
out_get_sample_rate(&stream->common));
}
return bytes;
}
/* TODO mutex stuff here (see out_write) */
static ssize_t in_read(struct audio_stream_in *stream, void* buffer, size_t bytes)
{
size_t num_read_buff_bytes = 0;
void * read_buff = buffer;
void * out_buff = buffer;
int ret = 0;
struct stream_in * in = (struct stream_in *)stream;
lock_input_stream(in);
if (in->standby) {
pthread_mutex_lock(&in->dev->lock);
ret = start_input_stream(in);
pthread_mutex_unlock(&in->dev->lock);
if (ret != 0) {
goto err;
}
in->standby = false;
}
alsa_device_profile * profile = in->profile;
/*
* OK, we need to figure out how much data to read to be able to output the requested
* number of bytes in the HAL format (16-bit, stereo).
*/
num_read_buff_bytes = bytes;
int num_device_channels = proxy_get_channel_count(&in->proxy); /* what we told Alsa */
int num_req_channels = in->hal_channel_count; /* what we told AudioFlinger */
if (num_device_channels != num_req_channels) {
num_read_buff_bytes = (num_device_channels * num_read_buff_bytes) / num_req_channels;
}
/* Setup/Realloc the conversion buffer (if necessary). */
if (num_read_buff_bytes != bytes) {
if (num_read_buff_bytes > in->conversion_buffer_size) {
/*TODO Remove this when AudioPolicyManger/AudioFlinger support arbitrary formats
(and do these conversions themselves) */
in->conversion_buffer_size = num_read_buff_bytes;
in->conversion_buffer = realloc(in->conversion_buffer, in->conversion_buffer_size);
}
read_buff = in->conversion_buffer;
}
ret = proxy_read(&in->proxy, read_buff, num_read_buff_bytes);
if (ret == 0) {
if (num_device_channels != num_req_channels) {
// ALOGV("chans dev:%d req:%d", num_device_channels, num_req_channels);
out_buff = buffer;
/* Num Channels conversion */
if (num_device_channels != num_req_channels) {
audio_format_t audio_format = in_get_format(&(in->stream.common));
unsigned sample_size_in_bytes = audio_bytes_per_sample(audio_format);
num_read_buff_bytes =
adjust_channels(read_buff, num_device_channels,
out_buff, num_req_channels,
sample_size_in_bytes, num_read_buff_bytes);
}
}
/* no need to acquire in->dev->lock to read mic_muted here as we don't change its state */
if (num_read_buff_bytes > 0 && in->dev->mic_muted)
memset(buffer, 0, num_read_buff_bytes);
} else {
num_read_buff_bytes = 0; // reset the value after headset is unplugged
}
err:
pthread_mutex_unlock(&in->lock);
return num_read_buff_bytes;
}
