| /* |
| * 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. |
| */ |
| |
| #if TARGET_AUDIO_PRIMARY |
| #define LOG_TAG "modules.audio.audio_hal.primary" |
| #else |
| #define LOG_TAG "modules.audio.audio_hal.usb" |
| #endif |
| #define LOG_NDEBUG 0 |
| |
| #include <errno.h> |
| #include <inttypes.h> |
| #include <math.h> |
| #include <pthread.h> |
| #include <stdint.h> |
| #include <stdlib.h> |
| #include <sys/time.h> |
| |
| #include <log/log.h> |
| #include <cutils/str_parms.h> |
| #include <cutils/properties.h> |
| |
| #include <hardware/audio.h> |
| #include <hardware/audio_alsaops.h> |
| #include <hardware/hardware.h> |
| |
| #include <system/audio.h> |
| |
| #include <tinyalsa/asoundlib.h> |
| |
| #include <audio_utils/channels.h> |
| |
| #include <dirent.h> |
| #include <sys/ioctl.h> |
| #include <fcntl.h> |
| #include <sound/asound.h> |
| |
| |
| #define PCM_DEV_STR "pcm" |
| #if TARGET_AUDIO_PRIMARY |
| #define AUDIO_STR "rt5616" |
| #else |
| #define AUDIO_STR "USB Audio" |
| #endif |
| #define MAX_PATH_LEN 30 |
| |
| #define NBR_RETRIES 5 |
| #define RETRY_WAIT_USEC 20000 |
| |
| /* FOR TESTING: |
| * Set k_force_channels to force the number of channels to present to AudioFlinger. |
| * 0 disables (this is default: present the device channels to AudioFlinger). |
| * 2 forces to legacy stereo mode. |
| * |
| * Others values can be tried (up to 8). |
| * TODO: AudioFlinger cannot support more than 8 active output channels |
| * at this time, so limiting logic needs to be put here or communicated from above. |
| */ |
| static const unsigned k_force_channels = 0; |
| |
| #include "alsa_device_profile.h" |
| #include "alsa_device_proxy.h" |
| #include "alsa_logging.h" |
| |
| #define DEFAULT_INPUT_BUFFER_SIZE_MS 20 |
| |
| // stereo channel count |
| #define FCC_2 2 |
| // fixed channel count of 8 limitation (for data processing in AudioFlinger) |
| #define FCC_8 8 |
| |
| struct audio_device { |
| struct audio_hw_device hw_device; |
| |
| pthread_mutex_t lock; /* see note below on mutex acquisition order */ |
| |
| /* output */ |
| alsa_device_profile out_profile; |
| |
| /* input */ |
| alsa_device_profile in_profile; |
| |
| bool mic_muted; |
| |
| bool standby; |
| #if TARGET_AUDIO_PRIMARY |
| unsigned int master_volume; |
| #endif |
| }; |
| |
| struct stream_out { |
| struct audio_stream_out stream; |
| |
| pthread_mutex_t lock; /* see note below on mutex acquisition order */ |
| pthread_mutex_t pre_lock; /* acquire before lock to avoid DOS by playback thread */ |
| bool standby; |
| |
| struct audio_device *dev; /* hardware information - only using this for the lock */ |
| |
| alsa_device_profile * profile; /* Points to the alsa_device_profile in the audio_device */ |
| alsa_device_proxy proxy; /* state of the stream */ |
| |
| unsigned hal_channel_count; /* channel count exposed to AudioFlinger. |
| * This may differ from the device channel count when |
| * the device is not compatible with AudioFlinger |
| * capabilities, e.g. exposes too many channels or |
| * too few channels. */ |
| audio_channel_mask_t hal_channel_mask; /* channel mask exposed to AudioFlinger. */ |
| |
| void * conversion_buffer; /* any conversions are put into here |
| * they could come from here too if |
| * there was a previous conversion */ |
| size_t conversion_buffer_size; /* in bytes */ |
| }; |
| |
| struct stream_in { |
| struct audio_stream_in stream; |
| |
| pthread_mutex_t lock; /* see note below on mutex acquisition order */ |
| pthread_mutex_t pre_lock; /* acquire before lock to avoid DOS by capture thread */ |
| bool standby; |
| |
| struct audio_device *dev; /* hardware information - only using this for the lock */ |
| |
| alsa_device_profile * profile; /* Points to the alsa_device_profile in the audio_device */ |
| alsa_device_proxy proxy; /* state of the stream */ |
| |
| unsigned hal_channel_count; /* channel count exposed to AudioFlinger. |
| * This may differ from the device channel count when |
| * the device is not compatible with AudioFlinger |
| * capabilities, e.g. exposes too many channels or |
| * too few channels. */ |
| audio_channel_mask_t hal_channel_mask; /* channel mask exposed to AudioFlinger. */ |
| |
| /* We may need to read more data from the device in order to data reduce to 16bit, 4chan */ |
| void * conversion_buffer; /* any conversions are put into here |
| * they could come from here too if |
| * there was a previous conversion */ |
| size_t conversion_buffer_size; /* in bytes */ |
| }; |
| |
| /* |
| * NOTE: when multiple mutexes have to be acquired, always take the |
| * stream_in or stream_out mutex first, followed by the audio_device mutex. |
| * stream pre_lock is always acquired before stream lock to prevent starvation of control thread by |
| * higher priority playback or capture thread. |
| */ |
| |
| |
| static int in_stream_card_number = -1, out_stream_card_number = -1; |
| |
| |
| /* |
| * Examines a pcm-device file to see if its a Audio device and |
| * returns its card-number. If no match, returns -1. |
| */ |
| static int first_valid_sound_card(char *pcm_name, bool is_out_stream) |
| { |
| int fd; |
| char pcm_dev_path[MAX_PATH_LEN]; |
| struct snd_pcm_info info; |
| char type; |
| int pcm_name_length; |
| |
| ALOGV("%s enter",__func__); |
| |
| pcm_name_length = strlen(pcm_name); |
| if (pcm_name_length < 2) { |
| return -1; |
| } |
| type = is_out_stream ? 'p' : 'c'; |
| /* If pcm out then filename must end with 0p/0c */ |
| if ((pcm_name[pcm_name_length -2] != '0') && (pcm_name[pcm_name_length - 1] != type)) { |
| ALOGV("%s exit",__func__); |
| return -1; |
| } |
| |
| snprintf(pcm_dev_path, sizeof(pcm_dev_path), "/dev/snd/%s", pcm_name); |
| fd = open(pcm_dev_path, O_RDONLY); |
| |
| if (fd != -1) { |
| if (!(ioctl(fd, SNDRV_PCM_IOCTL_INFO, &info))) { |
| if (strstr(info.id, AUDIO_STR)) { |
| close(fd); |
| ALOGV("%s exit",__func__); |
| return info.card; |
| } |
| } else { |
| ALOGE("ioctl failed for file: %s", pcm_dev_path); |
| } |
| |
| close(fd); |
| } |
| |
| ALOGV("%s exit",__func__); |
| return -1; |
| } |
| |
| /* |
| * Returns the number of the first valid Audio card |
| * If none is found, returns -1. |
| */ |
| static int get_first_sound_card(bool is_out_stream) |
| { |
| DIR *dir; |
| struct dirent *de = NULL; |
| int card_nr; |
| |
| ALOGV("%s enter",__func__); |
| |
| dir = opendir("/dev/snd"); |
| if (dir == NULL) { |
| ALOGE("Could not open directory /dev/snd"); |
| ALOGV("%s exit",__func__); |
| return -1; |
| } |
| |
| while ((de = readdir(dir))) { |
| if (strncmp(de->d_name, PCM_DEV_STR, sizeof(PCM_DEV_STR) - 1) == 0) { |
| if ((card_nr = first_valid_sound_card(de->d_name, is_out_stream)) != -1) { |
| closedir(dir); |
| ALOGV("%s exit",__func__); |
| return card_nr; |
| } |
| } |
| } |
| |
| closedir(dir); |
| ALOGW("No card found in /dev/snd"); |
| ALOGV("%s exit",__func__); |
| return -1; |
| } |
| |
| static bool parse_card_device_params(bool is_out_stream, int *card, int *device) |
| { |
| int try_time; |
| int found_card = -1; |
| |
| if (is_out_stream) { |
| if (out_stream_card_number != -1) { |
| *card = out_stream_card_number; |
| *device = 0; |
| return true; |
| } |
| } else { |
| if (in_stream_card_number != -1) { |
| *card = in_stream_card_number; |
| *device = 0; |
| return true; |
| } |
| } |
| |
| for (try_time = 0; try_time < NBR_RETRIES; try_time++) { |
| found_card = get_first_sound_card(is_out_stream); |
| if (found_card == -1) |
| usleep(RETRY_WAIT_USEC); |
| else |
| break; |
| } |
| |
| if (found_card == -1) { |
| *card = -1; |
| *device = -1; |
| return false; |
| } |
| |
| if (is_out_stream) { |
| out_stream_card_number = found_card; |
| } else { |
| in_stream_card_number = found_card; |
| } |
| |
| *card = found_card; |
| *device = 0; |
| |
| return true; |
| } |
| |
| static char * device_get_parameters(alsa_device_profile * profile, const char * keys) |
| { |
| if (profile->card < 0 || profile->device < 0) { |
| return strdup(""); |
| } |
| |
| struct str_parms *query = str_parms_create_str(keys); |
| struct str_parms *result = str_parms_create(); |
| |
| /* These keys are from hardware/libhardware/include/audio.h */ |
| /* supported sample rates */ |
| if (str_parms_has_key(query, AUDIO_PARAMETER_STREAM_SUP_SAMPLING_RATES)) { |
| char* rates_list = profile_get_sample_rate_strs(profile); |
| str_parms_add_str(result, AUDIO_PARAMETER_STREAM_SUP_SAMPLING_RATES, |
| rates_list); |
| free(rates_list); |
| } |
| |
| /* supported channel counts */ |
| if (str_parms_has_key(query, AUDIO_PARAMETER_STREAM_SUP_CHANNELS)) { |
| char* channels_list = profile_get_channel_count_strs(profile); |
| str_parms_add_str(result, AUDIO_PARAMETER_STREAM_SUP_CHANNELS, |
| channels_list); |
| free(channels_list); |
| } |
| |
| /* supported sample formats */ |
| if (str_parms_has_key(query, AUDIO_PARAMETER_STREAM_SUP_FORMATS)) { |
| char * format_params = profile_get_format_strs(profile); |
| str_parms_add_str(result, AUDIO_PARAMETER_STREAM_SUP_FORMATS, |
| format_params); |
| free(format_params); |
| } |
| str_parms_destroy(query); |
| |
| char* result_str = str_parms_to_str(result); |
| str_parms_destroy(result); |
| |
| ALOGV("device_get_parameters = %s", result_str); |
| |
| return result_str; |
| } |
| |
| void lock_input_stream(struct stream_in *in) |
| { |
| pthread_mutex_lock(&in->pre_lock); |
| pthread_mutex_lock(&in->lock); |
| pthread_mutex_unlock(&in->pre_lock); |
| } |
| |
| void lock_output_stream(struct stream_out *out) |
| { |
| pthread_mutex_lock(&out->pre_lock); |
| pthread_mutex_lock(&out->lock); |
| pthread_mutex_unlock(&out->pre_lock); |
| } |
| |
| /* |
| * HAl Functions |
| */ |
| /** |
| * NOTE: when multiple mutexes have to be acquired, always respect the |
| * following order: hw device > out stream |
| */ |
| |
| /* |
| * OUT functions |
| */ |
| |
| static uint32_t adjust_volume(const uint32_t volume) |
| { |
| /* |
| * map [0, 100] to [0, 25] |
| */ |
| return (int)(sqrt(volume) * 2.5f); |
| } |
| |
| static uint32_t out_get_sample_rate(const struct audio_stream *stream) |
| { |
| uint32_t rate = proxy_get_sample_rate(&((struct stream_out*)stream)->proxy); |
| ALOGV("out_get_sample_rate() = %d", rate); |
| return rate; |
| } |
| |
| static int out_set_sample_rate(struct audio_stream *stream, uint32_t rate) |
| { |
| return 0; |
| } |
| |
| static size_t out_get_buffer_size(const struct audio_stream *stream) |
| { |
| const struct stream_out* out = (const struct stream_out*)stream; |
| size_t buffer_size = |
| proxy_get_period_size(&out->proxy) * audio_stream_out_frame_size(&(out->stream)); |
| return buffer_size; |
| } |
| |
| static uint32_t out_get_channels(const struct audio_stream *stream) |
| { |
| const struct stream_out *out = (const struct stream_out*)stream; |
| return out->hal_channel_mask; |
| } |
| |
| static audio_format_t out_get_format(const struct audio_stream *stream) |
| { |
| /* Note: The HAL doesn't do any FORMAT conversion at this time. It |
| * Relies on the framework to provide data in the specified format. |
| * This could change in the future. |
| */ |
| alsa_device_proxy * proxy = &((struct stream_out*)stream)->proxy; |
| audio_format_t format = audio_format_from_pcm_format(proxy_get_format(proxy)); |
| return format; |
| } |
| |
| static int out_set_format(struct audio_stream *stream, audio_format_t format) |
| { |
| return 0; |
| } |
| |
| static int out_standby(struct audio_stream *stream) |
| { |
| struct stream_out *out = (struct stream_out *)stream; |
| lock_output_stream(out); |
| if (!out->standby) { |
| pthread_mutex_lock(&out->dev->lock); |
| proxy_close(&out->proxy); |
| pthread_mutex_unlock(&out->dev->lock); |
| out->standby = true; |
| } |
| pthread_mutex_unlock(&out->lock); |
| |
| return 0; |
| } |
| |
| static int out_dump(const struct audio_stream *stream, int fd) |
| { |
| return 0; |
| } |
| |
| static int out_set_parameters(struct audio_stream *stream, const char *kvpairs) |
| { |
| ALOGV("out_set_parameters() keys:%s", kvpairs); |
| |
| struct stream_out *out = (struct stream_out *)stream; |
| |
| int routing = 0; |
| int ret_value = 0; |
| int card = -1; |
| int device = -1; |
| |
| if (!parse_card_device_params(true, &card, &device)) { |
| // nothing to do |
| return ret_value; |
| } |
| |
| lock_output_stream(out); |
| /* Lock the device because that is where the profile lives */ |
| pthread_mutex_lock(&out->dev->lock); |
| |
| if (!profile_is_cached_for(out->profile, card, device)) { |
| /* cannot read pcm device info if playback is active */ |
| if (!out->standby) |
| ret_value = -ENOSYS; |
| else { |
| int saved_card = out->profile->card; |
| int saved_device = out->profile->device; |
| out->profile->card = card; |
| out->profile->device = device; |
| ret_value = profile_read_device_info(out->profile) ? 0 : -EINVAL; |
| if (ret_value != 0) { |
| out->profile->card = saved_card; |
| out->profile->device = saved_device; |
| } |
| } |
| } |
| |
| pthread_mutex_unlock(&out->dev->lock); |
| pthread_mutex_unlock(&out->lock); |
| |
| return ret_value; |
| } |
| |
| static char * out_get_parameters(const struct audio_stream *stream, const char *keys) |
| { |
| struct stream_out *out = (struct stream_out *)stream; |
| lock_output_stream(out); |
| pthread_mutex_lock(&out->dev->lock); |
| |
| char * params_str = device_get_parameters(out->profile, keys); |
| |
| pthread_mutex_unlock(&out->lock); |
| pthread_mutex_unlock(&out->dev->lock); |
| |
| return params_str; |
| } |
| |
| static uint32_t out_get_latency(const struct audio_stream_out *stream) |
| { |
| alsa_device_proxy * proxy = &((struct stream_out*)stream)->proxy; |
| return proxy_get_latency(proxy); |
| } |
| |
| static int out_set_volume(struct audio_stream_out *stream, float left, float right) |
| { |
| return -ENOSYS; |
| } |
| |
| /* must be called with hw device and output stream mutexes locked */ |
| static int start_output_stream(struct stream_out *out) |
| { |
| ALOGV("start_output_stream(card:%d device:%d)", out->profile->card, out->profile->device); |
| |
| return proxy_open(&out->proxy); |
| } |
| |
| 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; |
| |
| lock_output_stream(out); |
| if (out->standby) { |
| pthread_mutex_lock(&out->dev->lock); |
| ret = start_output_stream(out); |
| pthread_mutex_unlock(&out->dev->lock); |
| if (ret != 0) { |
| goto err; |
| } |
| out->standby = false; |
| } |
| |
| 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; |
| } |
| |
| static int out_get_render_position(const struct audio_stream_out *stream, uint32_t *dsp_frames) |
| { |
| return -EINVAL; |
| } |
| |
| static int out_get_presentation_position(const struct audio_stream_out *stream, |
| uint64_t *frames, struct timespec *timestamp) |
| { |
| struct stream_out *out = (struct stream_out *)stream; // discard const qualifier |
| lock_output_stream(out); |
| |
| const alsa_device_proxy *proxy = &out->proxy; |
| const int ret = proxy_get_presentation_position(proxy, frames, timestamp); |
| |
| pthread_mutex_unlock(&out->lock); |
| ALOGV("out_get_presentation_position() status:%d frames:%llu", |
| ret, (unsigned long long)*frames); |
| return ret; |
| } |
| |
| 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 -EINVAL; |
| } |
| |
| 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() handle:0x%X, device:0x%X, flags:0x%X, addr:%s", |
| handle, devices, flags, address); |
| |
| struct audio_device *adev = (struct audio_device *)dev; |
| |
| struct stream_out *out; |
| out = (struct stream_out *)calloc(1, sizeof(struct stream_out)); |
| if (!out) |
| return -ENOMEM; |
| |
| /* setup function pointers */ |
| 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_presentation_position = out_get_presentation_position; |
| out->stream.get_next_write_timestamp = out_get_next_write_timestamp; |
| |
| pthread_mutex_init(&out->lock, (const pthread_mutexattr_t *) NULL); |
| pthread_mutex_init(&out->pre_lock, (const pthread_mutexattr_t *) NULL); |
| |
| out->dev = adev; |
| pthread_mutex_lock(&adev->lock); |
| out->profile = &adev->out_profile; |
| |
| // build this to hand to the alsa_device_proxy |
| struct pcm_config proxy_config; |
| memset(&proxy_config, 0, sizeof(proxy_config)); |
| |
| /* Pull out the card/device pair */ |
| parse_card_device_params(true, &(out->profile->card), &(out->profile->device)); |
| |
| profile_read_device_info(out->profile); |
| |
| pthread_mutex_unlock(&adev->lock); |
| |
| int ret = 0; |
| |
| /* Rate */ |
| if (config->sample_rate == 0) { |
| proxy_config.rate = config->sample_rate = profile_get_default_sample_rate(out->profile); |
| } else if (profile_is_sample_rate_valid(out->profile, config->sample_rate)) { |
| proxy_config.rate = config->sample_rate; |
| } else { |
| ALOGE("%s: The requested sample rate (%d) is not valid", __func__, config->sample_rate); |
| proxy_config.rate = config->sample_rate = profile_get_default_sample_rate(out->profile); |
| ret = -EINVAL; |
| } |
| |
| /* Format */ |
| if (config->format == AUDIO_FORMAT_DEFAULT) { |
| proxy_config.format = profile_get_default_format(out->profile); |
| config->format = audio_format_from_pcm_format(proxy_config.format); |
| } else { |
| enum pcm_format fmt = pcm_format_from_audio_format(config->format); |
| if (profile_is_format_valid(out->profile, fmt)) { |
| proxy_config.format = fmt; |
| } else { |
| ALOGE("%s: The requested format (0x%x) is not valid", __func__, config->format); |
| proxy_config.format = profile_get_default_format(out->profile); |
| config->format = audio_format_from_pcm_format(proxy_config.format); |
| ret = -EINVAL; |
| } |
| } |
| |
| /* Channels */ |
| unsigned proposed_channel_count = 0; |
| if (k_force_channels) { |
| proposed_channel_count = k_force_channels; |
| } else if (config->channel_mask == AUDIO_CHANNEL_NONE) { |
| proposed_channel_count = profile_get_default_channel_count(out->profile); |
| } |
| if (proposed_channel_count != 0) { |
| if (proposed_channel_count <= FCC_2) { |
| // use channel position mask for mono and stereo |
| config->channel_mask = audio_channel_out_mask_from_count(proposed_channel_count); |
| } else { |
| // use channel index mask for multichannel |
| config->channel_mask = |
| audio_channel_mask_for_index_assignment_from_count(proposed_channel_count); |
| } |
| out->hal_channel_count = proposed_channel_count; |
| } else { |
| out->hal_channel_count = audio_channel_count_from_out_mask(config->channel_mask); |
| } |
| /* we can expose any channel mask, and emulate internally based on channel count. */ |
| out->hal_channel_mask = config->channel_mask; |
| |
| /* no validity checks are needed as proxy_prepare() forces channel_count to be valid. |
| * and we emulate any channel count discrepancies in out_write(). */ |
| proxy_config.channels = proposed_channel_count; |
| |
| proxy_prepare(&out->proxy, out->profile, &proxy_config); |
| |
| /* TODO The retry mechanism isn't implemented in AudioPolicyManager/AudioFlinger. */ |
| ret = 0; |
| |
| out->conversion_buffer = NULL; |
| out->conversion_buffer_size = 0; |
| |
| out->standby = true; |
| |
| *stream_out = &out->stream; |
| |
| return ret; |
| |
| err_open: |
| free(out); |
| *stream_out = NULL; |
| return -ENOSYS; |
| } |
| |
| static void adev_close_output_stream(struct audio_hw_device *dev, |
| struct audio_stream_out *stream) |
| { |
| struct stream_out *out = (struct stream_out *)stream; |
| ALOGV("adev_close_output_stream(c:%d d:%d)", out->profile->card, out->profile->device); |
| /* Close the pcm device */ |
| out_standby(&stream->common); |
| |
| free(out->conversion_buffer); |
| |
| out->conversion_buffer = NULL; |
| out->conversion_buffer_size = 0; |
| |
| free(stream); |
| } |
| |
| static size_t adev_get_input_buffer_size(const struct audio_hw_device *dev, |
| const struct audio_config *config) |
| { |
| /* TODO This needs to be calculated based on format/channels/rate */ |
| return 320; |
| } |
| |
| /* |
| * IN functions |
| */ |
| static uint32_t in_get_sample_rate(const struct audio_stream *stream) |
| { |
| uint32_t rate = proxy_get_sample_rate(&((const struct stream_in *)stream)->proxy); |
| ALOGV("in_get_sample_rate() = %d", rate); |
| return rate; |
| } |
| |
| static int in_set_sample_rate(struct audio_stream *stream, uint32_t rate) |
| { |
| ALOGV("in_set_sample_rate(%d) - NOPE", rate); |
| return -ENOSYS; |
| } |
| |
| static size_t in_get_buffer_size(const struct audio_stream *stream) |
| { |
| const struct stream_in * in = ((const struct stream_in*)stream); |
| return proxy_get_period_size(&in->proxy) * audio_stream_in_frame_size(&(in->stream)); |
| } |
| |
| static uint32_t in_get_channels(const struct audio_stream *stream) |
| { |
| const struct stream_in *in = (const struct stream_in*)stream; |
| return in->hal_channel_mask; |
| } |
| |
| static audio_format_t in_get_format(const struct audio_stream *stream) |
| { |
| alsa_device_proxy *proxy = &((struct stream_in*)stream)->proxy; |
| audio_format_t format = audio_format_from_pcm_format(proxy_get_format(proxy)); |
| return format; |
| } |
| |
| static int in_set_format(struct audio_stream *stream, audio_format_t format) |
| { |
| ALOGV("in_set_format(%d) - NOPE", format); |
| |
| return -ENOSYS; |
| } |
| |
| static int in_standby(struct audio_stream *stream) |
| { |
| struct stream_in *in = (struct stream_in *)stream; |
| |
| lock_input_stream(in); |
| if (!in->standby) { |
| pthread_mutex_lock(&in->dev->lock); |
| proxy_close(&in->proxy); |
| pthread_mutex_unlock(&in->dev->lock); |
| in->standby = true; |
| } |
| |
| pthread_mutex_unlock(&in->lock); |
| |
| 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) |
| { |
| ALOGV("in_set_parameters() keys:%s", kvpairs); |
| |
| struct stream_in *in = (struct stream_in *)stream; |
| |
| char value[32]; |
| int param_val; |
| int routing = 0; |
| int ret_value = 0; |
| int card = -1; |
| int device = -1; |
| |
| if (!parse_card_device_params(false, &card, &device)) { |
| // nothing to do |
| return ret_value; |
| } |
| |
| lock_input_stream(in); |
| pthread_mutex_lock(&in->dev->lock); |
| |
| if (card >= 0 && device >= 0 && !profile_is_cached_for(in->profile, card, device)) { |
| /* cannot read pcm device info if playback is active */ |
| if (!in->standby) |
| ret_value = -ENOSYS; |
| else { |
| int saved_card = in->profile->card; |
| int saved_device = in->profile->device; |
| in->profile->card = card; |
| in->profile->device = device; |
| ret_value = profile_read_device_info(in->profile) ? 0 : -EINVAL; |
| if (ret_value != 0) { |
| in->profile->card = saved_card; |
| in->profile->device = saved_device; |
| } |
| } |
| } |
| |
| pthread_mutex_unlock(&in->dev->lock); |
| pthread_mutex_unlock(&in->lock); |
| |
| return ret_value; |
| } |
| |
| static char * in_get_parameters(const struct audio_stream *stream, const char *keys) |
| { |
| struct stream_in *in = (struct stream_in *)stream; |
| |
| lock_input_stream(in); |
| pthread_mutex_lock(&in->dev->lock); |
| |
| char * params_str = device_get_parameters(in->profile, keys); |
| |
| pthread_mutex_unlock(&in->dev->lock); |
| pthread_mutex_unlock(&in->lock); |
| |
| return params_str; |
| } |
| |
| 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 in_set_gain(struct audio_stream_in *stream, float gain) |
| { |
| return 0; |
| } |
| |
| /* must be called with hw device and output stream mutexes locked */ |
| static int start_input_stream(struct stream_in *in) |
| { |
| ALOGV("ustart_input_stream(card:%d device:%d)", in->profile->card, in->profile->device); |
| |
| return proxy_open(&in->proxy); |
| } |
| |
| /* 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; |
| } |
| |
| static uint32_t in_get_input_frames_lost(struct audio_stream_in *stream) |
| { |
| return 0; |
| } |
| |
| 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("in adev_open_input_stream() rate:%" PRIu32 ", chanMask:0x%" PRIX32 ", fmt:%" PRIu8, |
| config->sample_rate, config->channel_mask, config->format); |
| |
| struct stream_in *in = (struct stream_in *)calloc(1, sizeof(struct stream_in)); |
| int ret = 0; |
| |
| if (in == NULL) |
| return -ENOMEM; |
| |
| /* setup function pointers */ |
| 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; |
| |
| pthread_mutex_init(&in->lock, (const pthread_mutexattr_t *) NULL); |
| pthread_mutex_init(&in->pre_lock, (const pthread_mutexattr_t *) NULL); |
| |
| in->dev = (struct audio_device *)dev; |
| pthread_mutex_lock(&in->dev->lock); |
| |
| in->profile = &in->dev->in_profile; |
| |
| struct pcm_config proxy_config; |
| memset(&proxy_config, 0, sizeof(proxy_config)); |
| |
| /* Pull out the card/device pair */ |
| parse_card_device_params(false, &(in->profile->card), &(in->profile->device)); |
| |
| profile_read_device_info(in->profile); |
| pthread_mutex_unlock(&in->dev->lock); |
| |
| /* Rate */ |
| if (config->sample_rate == 0) { |
| proxy_config.rate = config->sample_rate = profile_get_default_sample_rate(in->profile); |
| } else if (profile_is_sample_rate_valid(in->profile, config->sample_rate)) { |
| proxy_config.rate = config->sample_rate; |
| } else { |
| ALOGE("%s: The requested sample rate (%d) is not valid", __func__, config->sample_rate); |
| proxy_config.rate = config->sample_rate = profile_get_default_sample_rate(in->profile); |
| ret = -EINVAL; |
| } |
| |
| /* Format */ |
| if (config->format == AUDIO_FORMAT_DEFAULT) { |
| proxy_config.format = profile_get_default_format(in->profile); |
| config->format = audio_format_from_pcm_format(proxy_config.format); |
| } else { |
| enum pcm_format fmt = pcm_format_from_audio_format(config->format); |
| if (profile_is_format_valid(in->profile, fmt)) { |
| proxy_config.format = fmt; |
| } else { |
| ALOGE("%s: The requested format (0x%x) is not valid", __func__, config->format); |
| proxy_config.format = profile_get_default_format(in->profile); |
| config->format = audio_format_from_pcm_format(proxy_config.format); |
| ret = -EINVAL; |
| } |
| } |
| |
| /* Channels */ |
| unsigned proposed_channel_count = 0; |
| if (k_force_channels) { |
| proposed_channel_count = k_force_channels; |
| } else if (config->channel_mask == AUDIO_CHANNEL_NONE) { |
| proposed_channel_count = profile_get_default_channel_count(in->profile); |
| } |
| if (proposed_channel_count != 0) { |
| config->channel_mask = audio_channel_in_mask_from_count(proposed_channel_count); |
| if (config->channel_mask == AUDIO_CHANNEL_INVALID) |
| config->channel_mask = |
| audio_channel_mask_for_index_assignment_from_count(proposed_channel_count); |
| in->hal_channel_count = proposed_channel_count; |
| } else { |
| in->hal_channel_count = audio_channel_count_from_in_mask(config->channel_mask); |
| } |
| /* we can expose any channel mask, and emulate internally based on channel count. */ |
| in->hal_channel_mask = config->channel_mask; |
| |
| proxy_config.channels = profile_get_default_channel_count(in->profile); |
| proxy_prepare(&in->proxy, in->profile, &proxy_config); |
| |
| in->standby = true; |
| |
| in->conversion_buffer = NULL; |
| in->conversion_buffer_size = 0; |
| |
| *stream_in = &in->stream; |
| |
| return ret; |
| } |
| |
| static void adev_close_input_stream(struct audio_hw_device *dev, struct audio_stream_in *stream) |
| { |
| struct stream_in *in = (struct stream_in *)stream; |
| |
| /* Close the pcm device */ |
| in_standby(&stream->common); |
| |
| free(in->conversion_buffer); |
| |
| free(stream); |
| } |
| |
| /* |
| * ADEV Functions |
| */ |
| 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 -ENOSYS; |
| } |
| |
| static int adev_set_master_volume(struct audio_hw_device *dev, float volume) |
| { |
| #if TARGET_AUDIO_PRIMARY |
| struct mixer *mixer; |
| struct mixer_ctl *ctl; |
| struct audio_device * adev = (struct audio_device *)dev; |
| |
| if ((0 > volume) || (1 < volume) || (NULL == adev)) |
| return -EINVAL; |
| |
| pthread_mutex_lock(&adev->lock); |
| adev->master_volume = (int)(volume*100); |
| |
| if (!(mixer = mixer_open(0))) { |
| pthread_mutex_unlock(&adev->lock); |
| return -ENOSYS; |
| } |
| |
| ctl = mixer_get_ctl_by_name(mixer, "HP Playback Volume"); |
| mixer_ctl_set_value(ctl,0,adjust_volume(adev->master_volume)); |
| mixer_ctl_set_value(ctl,1,adjust_volume(adev->master_volume)); |
| |
| mixer_close(mixer); |
| pthread_mutex_unlock(&adev->lock); |
| return 0; |
| #else |
| return -ENOSYS; |
| #endif |
| } |
| |
| 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 audio_device * adev = (struct audio_device *)dev; |
| pthread_mutex_lock(&adev->lock); |
| adev->mic_muted = state; |
| pthread_mutex_unlock(&adev->lock); |
| return -ENOSYS; |
| } |
| |
| static int adev_get_mic_mute(const struct audio_hw_device *dev, bool *state) |
| { |
| return -ENOSYS; |
| } |
| |
| static int adev_dump(const audio_hw_device_t *device, int fd) |
| { |
| return 0; |
| } |
| |
| static int adev_close(hw_device_t *device) |
| { |
| struct audio_device *adev = (struct audio_device *)device; |
| free(device); |
| |
| return 0; |
| } |
| |
| static int adev_open(const hw_module_t* module, const char* name, hw_device_t** device) |
| { |
| #if TARGET_AUDIO_PRIMARY |
| struct mixer *mixer; |
| struct mixer_ctl *ctl; |
| #endif |
| if (strcmp(name, AUDIO_HARDWARE_INTERFACE) != 0) |
| return -EINVAL; |
| |
| struct audio_device *adev = calloc(1, sizeof(struct audio_device)); |
| if (!adev) |
| return -ENOMEM; |
| |
| profile_init(&adev->out_profile, PCM_OUT); |
| profile_init(&adev->in_profile, PCM_IN); |
| |
| adev->hw_device.common.tag = HARDWARE_DEVICE_TAG; |
| adev->hw_device.common.version = AUDIO_DEVICE_API_VERSION_2_0; |
| adev->hw_device.common.module = (struct hw_module_t *)module; |
| adev->hw_device.common.close = adev_close; |
| |
| adev->hw_device.init_check = adev_init_check; |
| adev->hw_device.set_voice_volume = adev_set_voice_volume; |
| adev->hw_device.set_master_volume = adev_set_master_volume; |
| adev->hw_device.set_mode = adev_set_mode; |
| adev->hw_device.set_mic_mute = adev_set_mic_mute; |
| adev->hw_device.get_mic_mute = adev_get_mic_mute; |
| adev->hw_device.set_parameters = adev_set_parameters; |
| adev->hw_device.get_parameters = adev_get_parameters; |
| adev->hw_device.get_input_buffer_size = adev_get_input_buffer_size; |
| adev->hw_device.open_output_stream = adev_open_output_stream; |
| adev->hw_device.close_output_stream = adev_close_output_stream; |
| adev->hw_device.open_input_stream = adev_open_input_stream; |
| adev->hw_device.close_input_stream = adev_close_input_stream; |
| adev->hw_device.dump = adev_dump; |
| |
| *device = &adev->hw_device.common; |
| #if TARGET_AUDIO_PRIMARY |
| mixer = mixer_open(0); |
| |
| if (mixer) { |
| /* setting master volume to value 50 */ |
| adev->master_volume = 50; |
| |
| int ret = 0; |
| ctl = mixer_get_ctl_by_name(mixer, "HP Playback Switch"); |
| ret = mixer_ctl_set_value(ctl,0,1); |
| ret = mixer_ctl_set_value(ctl,1,1); |
| ctl = mixer_get_ctl_by_name(mixer, "HP Playback Volume"); |
| mixer_ctl_set_value(ctl,0,adjust_volume(adev->master_volume)); |
| mixer_ctl_set_value(ctl,1,adjust_volume(adev->master_volume)); |
| ctl = mixer_get_ctl_by_name(mixer, "HPO MIX DAC1 Switch"); |
| mixer_ctl_set_value(ctl,0,1); |
| ctl = mixer_get_ctl_by_name(mixer, "HPO MIX DAC1 Switch"); |
| mixer_ctl_set_value(ctl,0,1); |
| ctl = mixer_get_ctl_by_name(mixer, "OUT MIXR DAC R1 Switch"); |
| mixer_ctl_set_value(ctl,0,1); |
| ctl = mixer_get_ctl_by_name(mixer, "OUT MIXL DAC L1 Switch"); |
| mixer_ctl_set_value(ctl,0,1); |
| ctl = mixer_get_ctl_by_name(mixer, "Stereo DAC MIXR DAC R1 Switch"); |
| mixer_ctl_set_value(ctl,0,1); |
| ctl = mixer_get_ctl_by_name(mixer, "Stereo DAC MIXL DAC L1 Switch"); |
| mixer_ctl_set_value(ctl,0,1); |
| |
| mixer_close(mixer); |
| } |
| #endif |
| 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 = "audio HW HAL", |
| .author = "The Android Open Source Project", |
| .methods = &hal_module_methods, |
| }, |
| }; |