diff options
author | Leo Wang <leozwang@google.com> | 2016-01-28 01:33:14 +0000 |
---|---|---|
committer | Android Partner Code Review <android-gerrit-partner@google.com> | 2016-01-28 01:33:14 +0000 |
commit | b80b61f426a33d459022904f783775a9b258de8a (patch) | |
tree | cbb6f41538e927eab1a1ed3f1ccc42754d54bff8 | |
parent | b95ee1d6757dfe98651687c8201e6aa4295564a3 (diff) | |
parent | 1b4e8fb06a88e9ffd4473a6923574bb20ba2bdb5 (diff) | |
download | rockchip-b80b61f426a33d459022904f783775a9b258de8a.tar.gz |
Merge "kylin: Add audio, base on intel's" into m-brillo-dev-kylin
-rw-r--r-- | peripheral/audio/generic/Android.mk | 49 | ||||
-rw-r--r-- | peripheral/audio/generic/audio_hal.c | 1272 | ||||
-rw-r--r-- | peripheral/audio/generic/audio_policy.conf | 69 | ||||
-rw-r--r-- | peripheral/audio/generic/media_codecs.xml | 82 | ||||
-rw-r--r-- | peripheral/audio/generic/peripheral.mk | 28 |
5 files changed, 1500 insertions, 0 deletions
diff --git a/peripheral/audio/generic/Android.mk b/peripheral/audio/generic/Android.mk new file mode 100644 index 0000000..f211787 --- /dev/null +++ b/peripheral/audio/generic/Android.mk @@ -0,0 +1,49 @@ +# 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. + +LOCAL_PATH := $(call my-dir) + +include $(CLEAR_VARS) +LOCAL_MODULE_RELATIVE_PATH := hw +LOCAL_SRC_FILES := \ + audio_hal.c +LOCAL_C_INCLUDES += \ + external/tinyalsa/include \ + $(call include-path-for, audio-utils) \ + $(call include-path-for, alsa-utils) +LOCAL_SHARED_LIBRARIES := liblog libcutils libtinyalsa libaudioutils libalsautils +LOCAL_MODULE_TAGS := optional +# setting to build for primary audio or usb audio +# set -DTARGET_AUDIO_PRIMARY to 1 for Primary (audio jack) +# set -DTARGET_AUDIO_PRIMARY to 0 for USB audio +LOCAL_CFLAGS := -Wno-unused-parameter -DTARGET_AUDIO_PRIMARY=1 +LOCAL_MODULE := audio.primary.$(TARGET_BOARD_PLATFORM) +include $(BUILD_SHARED_LIBRARY) + +include $(CLEAR_VARS) +LOCAL_MODULE_RELATIVE_PATH := hw +LOCAL_SRC_FILES := \ + audio_hal.c +LOCAL_C_INCLUDES += \ + external/tinyalsa/include \ + $(call include-path-for, audio-utils) \ + $(call include-path-for, alsa-utils) +LOCAL_SHARED_LIBRARIES := liblog libcutils libtinyalsa libaudioutils libalsautils +LOCAL_MODULE_TAGS := optional +# setting to build for primary audio or usb audio +# set -DTARGET_AUDIO_PRIMARY to 1 for Primary (audio jack) +# set -DTARGET_AUDIO_PRIMARY to 0 for USB audio +LOCAL_CFLAGS := -Wno-unused-parameter -DTARGET_AUDIO_PRIMARY=0 +LOCAL_MODULE := audio.usb.$(TARGET_BOARD_PLATFORM) +include $(BUILD_SHARED_LIBRARY) diff --git a/peripheral/audio/generic/audio_hal.c b/peripheral/audio/generic/audio_hal.c new file mode 100644 index 0000000..8cc1639 --- /dev/null +++ b/peripheral/audio/generic/audio_hal.c @@ -0,0 +1,1272 @@ +/* + * 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 "modules.audio.audio_hal" +/*#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, + }, +}; diff --git a/peripheral/audio/generic/audio_policy.conf b/peripheral/audio/generic/audio_policy.conf new file mode 100644 index 0000000..ec3624f --- /dev/null +++ b/peripheral/audio/generic/audio_policy.conf @@ -0,0 +1,69 @@ +# +# Copyright (C) 2015 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. +# + +# Global configuration section: lists input and output devices always present on the device +# as well as the output device selected by default. +# Devices are designated by a string that corresponds to the enum in audio.h + +global_configuration { + attached_output_devices AUDIO_DEVICE_OUT_SPEAKER + default_output_device AUDIO_DEVICE_OUT_SPEAKER + attached_input_devices AUDIO_DEVICE_IN_BUILTIN_MIC|AUDIO_DEVICE_IN_REMOTE_SUBMIX +} +audio_hw_modules { + primary { + outputs { + primary { + sampling_rates 8000|11025|12000|16000|22050|24000|32000|44100|48000|88200|96000|176400|192000| + channel_masks AUDIO_CHANNEL_OUT_STEREO + formats AUDIO_FORMAT_PCM_16_BIT + devices AUDIO_DEVICE_OUT_EARPIECE|AUDIO_DEVICE_OUT_SPEAKER|AUDIO_DEVICE_OUT_WIRED_HEADSET|AUDIO_DEVICE_OUT_WIRED_HEADPHONE|AUDIO_DEVICE_OUT_ALL_SCO|AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET|AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET|AUDIO_DEVICE_OUT_AUX_DIGITAL|AUDIO_DEVICE_OUT_USB_DEVICE + flags AUDIO_OUTPUT_FLAG_PRIMARY + } + } + inputs { + primary { + sampling_rates 8000|11025|16000|22050|32000|44100|48000 + channel_masks AUDIO_CHANNEL_IN_MONO|AUDIO_CHANNEL_IN_STEREO + formats AUDIO_FORMAT_PCM_16_BIT + devices AUDIO_DEVICE_IN_BUILTIN_MIC|AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET|AUDIO_DEVICE_IN_WIRED_HEADSET|AUDIO_DEVICE_IN_DGTL_DOCK_HEADSET|AUDIO_DEVICE_IN_USB_DEVICE + } + } + } + usb { + global_configuration { + attached_output_devices AUDIO_DEVICE_OUT_USB_DEVICE + attached_input_devices AUDIO_DEVICE_IN_USB_DEVICE + } + outputs { + usb_device { + sampling_rates dynamic + channel_masks dynamic + formats dynamic + devices AUDIO_DEVICE_OUT_USB_DEVICE + flags AUDIO_OUTPUT_FLAG_PRIMARY + } + } + inputs { + usb_device { + sampling_rates 8000|11025|12000|16000|22050|24000|32000|44100|48000 + channel_masks AUDIO_CHANNEL_IN_MONO|AUDIO_CHANNEL_IN_STEREO + formats AUDIO_FORMAT_PCM_16_BIT + devices AUDIO_DEVICE_IN_USB_DEVICE + } + } + } +} diff --git a/peripheral/audio/generic/media_codecs.xml b/peripheral/audio/generic/media_codecs.xml new file mode 100644 index 0000000..934619c --- /dev/null +++ b/peripheral/audio/generic/media_codecs.xml @@ -0,0 +1,82 @@ +<?xml version="1.0" encoding="utf-8" ?> +<!-- Copyright (C) 2015 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. +--> + +<!-- +<!DOCTYPE MediaCodecs [ +<!ELEMENT Include EMPTY> +<!ATTLIST Include href CDATA #REQUIRED> +<!ELEMENT MediaCodecs (Decoders|Encoders|Include)*> +<!ELEMENT Decoders (MediaCodec|Include)*> +<!ELEMENT Encoders (MediaCodec|Include)*> +<!ELEMENT MediaCodec (Type|Quirk|Include)*> +<!ATTLIST MediaCodec name CDATA #REQUIRED> +<!ATTLIST MediaCodec type CDATA> +<!ELEMENT Type EMPTY> +<!ATTLIST Type name CDATA #REQUIRED> +<!ELEMENT Quirk EMPTY> +<!ATTLIST Quirk name CDATA #REQUIRED> +]> + +There's a simple and a complex syntax to declare the availability of a +media codec: + +A codec that properly follows the OpenMax spec and therefore doesn't have any +quirks and that only supports a single content type can be declared like so: + + <MediaCodec name="OMX.foo.bar" type="something/interesting" /> + +If a codec has quirks OR supports multiple content types, the following syntax +can be used: + + <MediaCodec name="OMX.foo.bar" > + <Type name="something/interesting" /> + <Type name="something/else" /> + ... + <Quirk name="requires-allocate-on-input-ports" /> + <Quirk name="requires-allocate-on-output-ports" /> + <Quirk name="output-buffers-are-unreadable" /> + </MediaCodec> + +Only the three quirks included above are recognized at this point: + +"requires-allocate-on-input-ports" + must be advertised if the component does not properly support specification + of input buffers using the OMX_UseBuffer(...) API but instead requires + OMX_AllocateBuffer to be used. + +"requires-allocate-on-output-ports" + must be advertised if the component does not properly support specification + of output buffers using the OMX_UseBuffer(...) API but instead requires + OMX_AllocateBuffer to be used. + +"output-buffers-are-unreadable" + must be advertised if the emitted output buffers of a decoder component + are not readable, i.e. use a custom format even though abusing one of + the official OMX colorspace constants. + Clients of such decoders will not be able to access the decoded data, + naturally making the component much less useful. The only use for + a component with this quirk is to render the output to the screen. + Audio decoders MUST NOT advertise this quirk. + Video decoders that advertise this quirk must be accompanied by a + corresponding color space converter for thumbnail extraction, + matching surfaceflinger support that can render the custom format to + a texture and possibly other code, so just DON'T USE THIS QUIRK. + +--> + +<MediaCodecs> + <Include href="media_codecs_google_audio.xml" /> +</MediaCodecs> diff --git a/peripheral/audio/generic/peripheral.mk b/peripheral/audio/generic/peripheral.mk new file mode 100644 index 0000000..1d17efb --- /dev/null +++ b/peripheral/audio/generic/peripheral.mk @@ -0,0 +1,28 @@ +# +# Copyright 2015 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. +# + +# Audio configuration files +PRODUCT_COPY_FILES += \ + frameworks/av/media/libstagefright/data/media_codecs_google_audio.xml:system/etc/media_codecs_google_audio.xml + +PRODUCT_COPY_FILES += \ + hardware/bsp/rockchip/peripheral/audio/generic/media_codecs.xml:system/etc/media_codecs.xml \ + hardware/bsp/rockchip/peripheral/audio/generic/audio_policy.conf:system/etc/audio_policy.conf + +# Primary audio HAL +DEVICE_PACKAGES += \ + audio.primary.$(TARGET_BOARD_PLATFORM) \ + audio.usb.$(TARGET_BOARD_PLATFORM) |