/*
* 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.
*/
#define LOG_TAG "audio_hw_primary"
/*#define LOG_NDEBUG 0*/
/*#define VERY_VERY_VERBOSE_LOGGING*/
#ifdef VERY_VERY_VERBOSE_LOGGING
#define ALOGVV ALOGV
#else
#define ALOGVV(a...) do { } while(0)
#endif
#include <errno.h>
#include <pthread.h>
#include <stdint.h>
#include <sys/time.h>
#include <stdlib.h>
#include <math.h>
#include <dlfcn.h>
#include <sys/resource.h>
#include <sys/prctl.h>
#include <cutils/log.h>
#include <cutils/str_parms.h>
#include <cutils/properties.h>
#include <cutils/atomic.h>
#include <cutils/sched_policy.h>
#include <hardware/audio_effect.h>
#include <system/thread_defs.h>
#include <audio_effects/effect_aec.h>
#include <audio_effects/effect_ns.h>
#include <audio_utils/channels.h>
#include "audio_hw.h"
#include "cras_dsp.h"
/* TODO: the following PCM device profiles could be read from a config file */
struct pcm_device_profile pcm_device_playback_hs = {
.config = {
.channels = PLAYBACK_DEFAULT_CHANNEL_COUNT,
.rate = PLAYBACK_DEFAULT_SAMPLING_RATE,
.period_size = PLAYBACK_PERIOD_SIZE,
.period_count = PLAYBACK_PERIOD_COUNT,
.format = PCM_FORMAT_S16_LE,
.start_threshold = PLAYBACK_START_THRESHOLD,
.stop_threshold = PLAYBACK_STOP_THRESHOLD,
.silence_threshold = 0,
.avail_min = PLAYBACK_AVAILABLE_MIN,
},
.card = SOUND_CARD,
.id = 1,
.device = 0,
.type = PCM_PLAYBACK,
.devices = AUDIO_DEVICE_OUT_WIRED_HEADSET|AUDIO_DEVICE_OUT_WIRED_HEADPHONE,
.dsp_name = "invert_lr",
};
struct pcm_device_profile pcm_device_capture = {
.config = {
.channels = CAPTURE_DEFAULT_CHANNEL_COUNT,
.rate = CAPTURE_DEFAULT_SAMPLING_RATE,
.period_size = CAPTURE_PERIOD_SIZE,
.period_count = CAPTURE_PERIOD_COUNT,
.format = PCM_FORMAT_S16_LE,
.start_threshold = CAPTURE_START_THRESHOLD,
.stop_threshold = 0,
.silence_threshold = 0,
.avail_min = 0,
},
.card = SOUND_CARD,
.id = 2,
.device = 0,
.type = PCM_CAPTURE,
.devices = AUDIO_DEVICE_IN_BUILTIN_MIC|AUDIO_DEVICE_IN_WIRED_HEADSET|AUDIO_DEVICE_IN_BACK_MIC,
};
struct pcm_device_profile pcm_device_capture_loopback_aec = {
.config = {
.channels = CAPTURE_DEFAULT_CHANNEL_COUNT,
.rate = CAPTURE_DEFAULT_SAMPLING_RATE,
.period_size = CAPTURE_PERIOD_SIZE,
.period_count = CAPTURE_PERIOD_COUNT,
.format = PCM_FORMAT_S16_LE,
.start_threshold = CAPTURE_START_THRESHOLD,
.stop_threshold = 0,
.silence_threshold = 0,
.avail_min = 0,
},
.card = SOUND_CARD,
.id = 3,
.device = 1,
.type = PCM_CAPTURE,
.devices = SND_DEVICE_IN_LOOPBACK_AEC,
};
struct pcm_device_profile pcm_device_playback_spk_and_headset = {
.config = {
.channels = PLAYBACK_DEFAULT_CHANNEL_COUNT,
.rate = PLAYBACK_DEFAULT_SAMPLING_RATE,
.period_size = PLAYBACK_PERIOD_SIZE,
.period_count = PLAYBACK_PERIOD_COUNT,
.format = PCM_FORMAT_S16_LE,
.start_threshold = PLAYBACK_START_THRESHOLD,
.stop_threshold = PLAYBACK_STOP_THRESHOLD,
.silence_threshold = 0,
.avail_min = PLAYBACK_AVAILABLE_MIN,
},
.card = SOUND_CARD,
.id = 4,
.device = 0,
.type = PCM_PLAYBACK,
.devices = AUDIO_DEVICE_OUT_SPEAKER|AUDIO_DEVICE_OUT_WIRED_HEADSET|AUDIO_DEVICE_OUT_WIRED_HEADPHONE,
.dsp_name = "speaker_eq",
};
struct pcm_device_profile pcm_device_playback_spk = {
.config = {
.channels = PLAYBACK_DEFAULT_CHANNEL_COUNT,
.rate = PLAYBACK_DEFAULT_SAMPLING_RATE,
.period_size = PLAYBACK_PERIOD_SIZE,
.period_count = PLAYBACK_PERIOD_COUNT,
.format = PCM_FORMAT_S16_LE,
.start_threshold = PLAYBACK_START_THRESHOLD,
.stop_threshold = PLAYBACK_STOP_THRESHOLD,
.silence_threshold = 0,
.avail_min = PLAYBACK_AVAILABLE_MIN,
},
.card = SOUND_CARD,
.id = 5,
.device = 0,
.type = PCM_PLAYBACK,
.devices = AUDIO_DEVICE_OUT_SPEAKER,
.dsp_name = "speaker_eq",
};
static struct pcm_device_profile pcm_device_hotword_streaming = {
.config = {
.channels = 1,
.rate = 16000,
.period_size = CAPTURE_PERIOD_SIZE,
.period_count = CAPTURE_PERIOD_COUNT,
.format = PCM_FORMAT_S16_LE,
.start_threshold = CAPTURE_START_THRESHOLD,
.stop_threshold = 0,
.silence_threshold = 0,
.avail_min = 0,
},
.card = SOUND_CARD,
.id = 0,
.type = PCM_HOTWORD_STREAMING,
.devices = AUDIO_DEVICE_IN_BUILTIN_MIC |
AUDIO_DEVICE_IN_WIRED_HEADSET |
AUDIO_DEVICE_IN_BACK_MIC,
};
struct pcm_device_profile *pcm_devices[] = {
&pcm_device_playback_hs,
&pcm_device_capture,
&pcm_device_playback_spk,
&pcm_device_capture_loopback_aec,
&pcm_device_playback_spk_and_headset,
&pcm_device_hotword_streaming,
NULL,
};
static const char * const use_case_table[AUDIO_USECASE_MAX] = {
[USECASE_AUDIO_PLAYBACK] = "playback",
[USECASE_AUDIO_PLAYBACK_MULTI_CH] = "playback multi-channel",
[USECASE_AUDIO_CAPTURE] = "capture",
[USECASE_AUDIO_CAPTURE_HOTWORD] = "capture-hotword",
[USECASE_VOICE_CALL] = "voice-call",
};
#define STRING_TO_ENUM(string) { #string, string }
struct pcm_config pcm_config_deep_buffer = {
.channels = 2,
.rate = DEEP_BUFFER_OUTPUT_SAMPLING_RATE,
.period_size = DEEP_BUFFER_OUTPUT_PERIOD_SIZE,
.period_count = DEEP_BUFFER_OUTPUT_PERIOD_COUNT,
.format = PCM_FORMAT_S16_LE,
.start_threshold = DEEP_BUFFER_OUTPUT_PERIOD_SIZE / 4,
.stop_threshold = INT_MAX,
.avail_min = DEEP_BUFFER_OUTPUT_PERIOD_SIZE / 4,
};
struct string_to_enum {
const char *name;
uint32_t value;
};
static const struct string_to_enum out_channels_name_to_enum_table[] = {
STRING_TO_ENUM(AUDIO_CHANNEL_OUT_STEREO),
STRING_TO_ENUM(AUDIO_CHANNEL_OUT_5POINT1),
STRING_TO_ENUM(AUDIO_CHANNEL_OUT_7POINT1),
};
static bool is_supported_format(audio_format_t format)
{
if (format == AUDIO_FORMAT_MP3 ||
((format & AUDIO_FORMAT_MAIN_MASK) == AUDIO_FORMAT_AAC))
return true;
return false;
}
static int get_snd_codec_id(audio_format_t format)
{
int id = 0;
switch (format & AUDIO_FORMAT_MAIN_MASK) {
default:
ALOGE("%s: Unsupported audio format", __func__);
}
return id;
}
/* Array to store sound devices */
static const char * const device_table[SND_DEVICE_MAX] = {
[SND_DEVICE_NONE] = "none",
/* Playback sound devices */
[SND_DEVICE_OUT_HANDSET] = "handset",
[SND_DEVICE_OUT_SPEAKER] = "speaker",
[SND_DEVICE_OUT_HEADPHONES] = "headphones",
[SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES] = "speaker-and-headphones",
[SND_DEVICE_OUT_VOICE_HANDSET] = "voice-handset",
[SND_DEVICE_OUT_VOICE_SPEAKER] = "voice-speaker",
[SND_DEVICE_OUT_VOICE_HEADPHONES] = "voice-headphones",
[SND_DEVICE_OUT_HDMI] = "hdmi",
[SND_DEVICE_OUT_SPEAKER_AND_HDMI] = "speaker-and-hdmi",
[SND_DEVICE_OUT_VOICE_TTY_FULL_HEADPHONES] = "voice-tty-full-headphones",
[SND_DEVICE_OUT_VOICE_TTY_VCO_HEADPHONES] = "voice-tty-vco-headphones",
[SND_DEVICE_OUT_VOICE_TTY_HCO_HANDSET] = "voice-tty-hco-handset",
/* Capture sound devices */
[SND_DEVICE_IN_HANDSET_MIC] = "handset-mic",
[SND_DEVICE_IN_SPEAKER_MIC] = "speaker-mic",
[SND_DEVICE_IN_HEADSET_MIC] = "headset-mic",
[SND_DEVICE_IN_HANDSET_MIC_AEC] = "handset-mic",
[SND_DEVICE_IN_SPEAKER_MIC_AEC] = "voice-speaker-mic",
[SND_DEVICE_IN_HEADSET_MIC_AEC] = "headset-mic",
[SND_DEVICE_IN_VOICE_SPEAKER_MIC] = "voice-speaker-mic",
[SND_DEVICE_IN_VOICE_HEADSET_MIC] = "voice-headset-mic",
[SND_DEVICE_IN_HDMI_MIC] = "hdmi-mic",
[SND_DEVICE_IN_CAMCORDER_MIC] = "camcorder-mic",
[SND_DEVICE_IN_VOICE_DMIC_1] = "voice-dmic-1",
[SND_DEVICE_IN_VOICE_SPEAKER_DMIC_1] = "voice-speaker-dmic-1",
[SND_DEVICE_IN_VOICE_TTY_FULL_HEADSET_MIC] = "voice-tty-full-headset-mic",
[SND_DEVICE_IN_VOICE_TTY_VCO_HANDSET_MIC] = "voice-tty-vco-handset-mic",
[SND_DEVICE_IN_VOICE_TTY_HCO_HEADSET_MIC] = "voice-tty-hco-headset-mic",
[SND_DEVICE_IN_VOICE_REC_HEADSET_MIC] = "voice-rec-headset-mic",
[SND_DEVICE_IN_VOICE_REC_MIC] = "voice-rec-mic",
[SND_DEVICE_IN_VOICE_REC_DMIC_1] = "voice-rec-dmic-1",
[SND_DEVICE_IN_VOICE_REC_DMIC_NS_1] = "voice-rec-dmic-ns-1",
[SND_DEVICE_IN_LOOPBACK_AEC] = "loopback-aec",
};
struct mixer_card *adev_get_mixer_for_card(struct audio_device *adev, int card)
{
struct mixer_card *mixer_card;
struct listnode *node;
list_for_each(node, &adev->mixer_list) {
mixer_card = node_to_item(node, struct mixer_card, adev_list_node);
if (mixer_card->card == card)
return mixer_card;
}
return NULL;
}
struct mixer_card *uc_get_mixer_for_card(struct audio_usecase *usecase, int card)
{
struct mixer_card *mixer_card;
struct listnode *node;
list_for_each(node, &usecase->mixer_list) {
mixer_card = node_to_item(node, struct mixer_card, uc_list_node[usecase->id]);
if (mixer_card->card == card)
return mixer_card;
}
return NULL;
}
void free_mixer_list(struct audio_device *adev)
{
struct mixer_card *mixer_card;
struct listnode *node;
struct listnode *next;
list_for_each_safe(node, next, &adev->mixer_list) {
mixer_card = node_to_item(node, struct mixer_card, adev_list_node);
list_remove(node);
audio_route_free(mixer_card->audio_route);
free(mixer_card);
}
}
int mixer_init(struct audio_device *adev)
{
int i;
int card;
int retry_num;
struct mixer *mixer;
struct audio_route *audio_route;
char mixer_path[PATH_MAX];
struct mixer_card *mixer_card;
struct listnode *node;
list_init(&adev->mixer_list);
for (i = 0; pcm_devices[i] != NULL; i++) {
card = pcm_devices[i]->card;
if (adev_get_mixer_for_card(adev, card) == NULL) {
retry_num = 0;
do {
mixer = mixer_open(card);
if (mixer == NULL) {
if (++retry_num > RETRY_NUMBER) {
ALOGE("%s unable to open the mixer for--card %d, aborting.",
__func__, card);
goto error;
}
usleep(RETRY_US);
}
} while (mixer == NULL);
sprintf(mixer_path, "/system/etc/mixer_paths_%d.xml", card);
audio_route = audio_route_init(card, mixer_path);
if (!audio_route) {
ALOGE("%s: Failed to init audio route controls for card %d, aborting.",
__func__, card);
goto error;
}
mixer_card = calloc(1, sizeof(struct mixer_card));
mixer_card->card = card;
mixer_card->mixer = mixer;
mixer_card->audio_route = audio_route;
list_add_tail(&adev->mixer_list, &mixer_card->adev_list_node);
}
}
return 0;
error:
free_mixer_list(adev);
return -ENODEV;
}
const char *get_snd_device_name(snd_device_t snd_device)
{
const char *name = NULL;
if (snd_device >= SND_DEVICE_MIN && snd_device < SND_DEVICE_MAX)
name = device_table[snd_device];
ALOGE_IF(name == NULL, "%s: invalid snd device %d", __func__, snd_device);
return name;
}
const char *get_snd_device_display_name(snd_device_t snd_device)
{
const char *name = get_snd_device_name(snd_device);
if (name == NULL)
name = "SND DEVICE NOT FOUND";
return name;
}
struct pcm_device_profile *get_pcm_device(usecase_type_t uc_type, audio_devices_t devices)
{
int i;
devices &= ~AUDIO_DEVICE_BIT_IN;
if (!devices)
return NULL;
for (i = 0; pcm_devices[i] != NULL; i++) {
if ((pcm_devices[i]->type == uc_type) &&
(devices & pcm_devices[i]->devices) == devices)
return pcm_devices[i];
}
return NULL;
}
static struct audio_usecase *get_usecase_from_id(struct audio_device *adev,
audio_usecase_t uc_id)
{
struct audio_usecase *usecase;
struct listnode *node;
list_for_each(node, &adev->usecase_list) {
usecase = node_to_item(node, struct audio_usecase, adev_list_node);
if (usecase->id == uc_id)
return usecase;
}
return NULL;
}
static struct audio_usecase *get_usecase_from_type(struct audio_device *adev,
usecase_type_t type)
{
struct audio_usecase *usecase;
struct listnode *node;
list_for_each(node, &adev->usecase_list) {
usecase = node_to_item(node, struct audio_usecase, adev_list_node);
if (usecase->type & type)
return usecase;
}
return NULL;
}
/* always called with adev lock held */
static int set_voice_volume_l(struct audio_device *adev, float volume)
{
int err = 0;
(void)volume;
if (adev->mode == AUDIO_MODE_IN_CALL) {
/* TODO */
}
return err;
}
snd_device_t get_output_snd_device(struct audio_device *adev, audio_devices_t devices)
{
audio_mode_t mode = adev->mode;
snd_device_t snd_device = SND_DEVICE_NONE;
ALOGV("%s: enter: output devices(%#x), mode(%d)", __func__, devices, mode);
if (devices == AUDIO_DEVICE_NONE ||
devices & AUDIO_DEVICE_BIT_IN) {
ALOGV("%s: Invalid output devices (%#x)", __func__, devices);
goto exit;
}
if (mode == AUDIO_MODE_IN_CALL) {
if (devices & AUDIO_DEVICE_OUT_WIRED_HEADPHONE ||
devices & AUDIO_DEVICE_OUT_WIRED_HEADSET) {
if (adev->tty_mode == TTY_MODE_FULL)
snd_device = SND_DEVICE_OUT_VOICE_TTY_FULL_HEADPHONES;
else if (adev->tty_mode == TTY_MODE_VCO)
snd_device = SND_DEVICE_OUT_VOICE_TTY_VCO_HEADPHONES;
else if (adev->tty_mode == TTY_MODE_HCO)
snd_device = SND_DEVICE_OUT_VOICE_TTY_HCO_HANDSET;
else
snd_device = SND_DEVICE_OUT_VOICE_HEADPHONES;
} else if (devices & AUDIO_DEVICE_OUT_SPEAKER) {
snd_device = SND_DEVICE_OUT_VOICE_SPEAKER;
} else if (devices & AUDIO_DEVICE_OUT_EARPIECE) {
snd_device = SND_DEVICE_OUT_HANDSET;
}
if (snd_device != SND_DEVICE_NONE) {
goto exit;
}
}
if (popcount(devices) == 2) {
if (devices == (AUDIO_DEVICE_OUT_WIRED_HEADPHONE |
AUDIO_DEVICE_OUT_SPEAKER)) {
snd_device = SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES;
} else if (devices == (AUDIO_DEVICE_OUT_WIRED_HEADSET |
AUDIO_DEVICE_OUT_SPEAKER)) {
snd_device = SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES;
} else {
ALOGE("%s: Invalid combo device(%#x)", __func__, devices);
goto exit;
}
if (snd_device != SND_DEVICE_NONE) {
goto exit;
}
}
if (popcount(devices) != 1) {
ALOGE("%s: Invalid output devices(%#x)", __func__, devices);
goto exit;
}
if (devices & AUDIO_DEVICE_OUT_WIRED_HEADPHONE ||
devices & AUDIO_DEVICE_OUT_WIRED_HEADSET) {
snd_device = SND_DEVICE_OUT_HEADPHONES;
} else if (devices & AUDIO_DEVICE_OUT_SPEAKER) {
snd_device = SND_DEVICE_OUT_SPEAKER;
} else if (devices & AUDIO_DEVICE_OUT_EARPIECE) {
snd_device = SND_DEVICE_OUT_HANDSET;
} else {
ALOGE("%s: Unknown device(s) %#x", __func__, devices);
}
exit:
ALOGV("%s: exit: snd_device(%s)", __func__, device_table[snd_device]);
return snd_device;
}
snd_device_t get_input_snd_device(struct audio_device *adev, audio_devices_t out_device)
{
audio_source_t source;
audio_mode_t mode = adev->mode;
audio_devices_t in_device;
audio_channel_mask_t channel_mask;
snd_device_t snd_device = SND_DEVICE_NONE;
struct stream_in *active_input = NULL;
struct audio_usecase *usecase;
usecase = get_usecase_from_type(adev, PCM_CAPTURE|VOICE_CALL);
if (usecase != NULL) {
active_input = (struct stream_in *)usecase->stream;
}
source = (active_input == NULL) ?
AUDIO_SOURCE_DEFAULT : active_input->source;
in_device = ((active_input == NULL) ?
AUDIO_DEVICE_NONE : active_input->devices)
& ~AUDIO_DEVICE_BIT_IN;
channel_mask = (active_input == NULL) ?
AUDIO_CHANNEL_IN_MONO : active_input->main_channels;
ALOGV("%s: enter: out_device(%#x) in_device(%#x)",
__func__, out_device, in_device);
if (mode == AUDIO_MODE_IN_CALL) {
if (out_device == AUDIO_DEVICE_NONE) {
ALOGE("%s: No output device set for voice call", __func__);
goto exit;
}
if (adev->tty_mode != TTY_MODE_OFF) {
if (out_device & AUDIO_DEVICE_OUT_WIRED_HEADPHONE ||
out_device & AUDIO_DEVICE_OUT_WIRED_HEADSET) {
switch (adev->tty_mode) {
case TTY_MODE_FULL:
snd_device = SND_DEVICE_IN_VOICE_TTY_FULL_HEADSET_MIC;
break;
case TTY_MODE_VCO:
snd_device = SND_DEVICE_IN_VOICE_TTY_VCO_HANDSET_MIC;
break;
case TTY_MODE_HCO:
snd_device = SND_DEVICE_IN_VOICE_TTY_HCO_HEADSET_MIC;
break;
default:
ALOGE("%s: Invalid TTY mode (%#x)", __func__, adev->tty_mode);
}
goto exit;
}
}
if (out_device & AUDIO_DEVICE_OUT_EARPIECE ||
out_device & AUDIO_DEVICE_OUT_WIRED_HEADPHONE) {
snd_device = SND_DEVICE_IN_HANDSET_MIC;
} else if (out_device & AUDIO_DEVICE_OUT_WIRED_HEADSET) {
snd_device = SND_DEVICE_IN_VOICE_HEADSET_MIC;
} else if (out_device & AUDIO_DEVICE_OUT_SPEAKER) {
snd_device = SND_DEVICE_IN_VOICE_SPEAKER_MIC;
}
} else if (source == AUDIO_SOURCE_CAMCORDER) {
if (in_device & AUDIO_DEVICE_IN_BUILTIN_MIC ||
in_device & AUDIO_DEVICE_IN_BACK_MIC) {
snd_device = SND_DEVICE_IN_CAMCORDER_MIC;
}
} else if (source == AUDIO_SOURCE_VOICE_RECOGNITION) {
if (in_device & AUDIO_DEVICE_IN_BUILTIN_MIC) {
if (adev->dualmic_config == DUALMIC_CONFIG_1) {
if (channel_mask == AUDIO_CHANNEL_IN_FRONT_BACK)
snd_device = SND_DEVICE_IN_VOICE_REC_DMIC_1;
else if (adev->ns_in_voice_rec)
snd_device = SND_DEVICE_IN_VOICE_REC_DMIC_NS_1;
}
if (snd_device == SND_DEVICE_NONE) {
snd_device = SND_DEVICE_IN_VOICE_REC_MIC;
}
} else if (in_device & AUDIO_DEVICE_IN_WIRED_HEADSET) {
snd_device = SND_DEVICE_IN_VOICE_REC_HEADSET_MIC;
}
} else if (source == AUDIO_SOURCE_VOICE_COMMUNICATION || source == AUDIO_SOURCE_MIC) {
if (out_device & AUDIO_DEVICE_OUT_SPEAKER)
in_device = AUDIO_DEVICE_IN_BACK_MIC;
if (active_input) {
if (active_input->enable_aec) {
if (in_device & AUDIO_DEVICE_IN_BACK_MIC) {
snd_device = SND_DEVICE_IN_SPEAKER_MIC_AEC;
} else if (in_device & AUDIO_DEVICE_IN_BUILTIN_MIC) {
if (out_device & AUDIO_DEVICE_OUT_WIRED_HEADPHONE) {
snd_device = SND_DEVICE_IN_SPEAKER_MIC_AEC;
} else {
snd_device = SND_DEVICE_IN_HANDSET_MIC_AEC;
}
} else if (in_device & AUDIO_DEVICE_IN_WIRED_HEADSET) {
snd_device = SND_DEVICE_IN_HEADSET_MIC_AEC;
}
}
/* TODO: set echo reference */
}
} else if (source == AUDIO_SOURCE_DEFAULT) {
goto exit;
}
if (snd_device != SND_DEVICE_NONE) {
goto exit;
}
if (in_device != AUDIO_DEVICE_NONE &&
!(in_device & AUDIO_DEVICE_IN_VOICE_CALL) &&
!(in_device & AUDIO_DEVICE_IN_COMMUNICATION)) {
if (in_device & AUDIO_DEVICE_IN_BUILTIN_MIC) {
snd_device = SND_DEVICE_IN_HANDSET_MIC;
} else if (in_device & AUDIO_DEVICE_IN_BACK_MIC) {
snd_device = SND_DEVICE_IN_SPEAKER_MIC;
} else if (in_device & AUDIO_DEVICE_IN_WIRED_HEADSET) {
snd_device = SND_DEVICE_IN_HEADSET_MIC;
} else if (in_device & AUDIO_DEVICE_IN_AUX_DIGITAL) {
snd_device = SND_DEVICE_IN_HDMI_MIC;
} else {
ALOGE("%s: Unknown input device(s) %#x", __func__, in_device);
ALOGW("%s: Using default handset-mic", __func__);
snd_device = SND_DEVICE_IN_HANDSET_MIC;
}
} else {
if (out_device & AUDIO_DEVICE_OUT_EARPIECE) {
snd_device = SND_DEVICE_IN_HANDSET_MIC;
} else if (out_device & AUDIO_DEVICE_OUT_WIRED_HEADSET) {
snd_device = SND_DEVICE_IN_HEADSET_MIC;
} else if (out_device & AUDIO_DEVICE_OUT_SPEAKER) {
snd_device = SND_DEVICE_IN_SPEAKER_MIC;
} else if (out_device & AUDIO_DEVICE_OUT_WIRED_HEADPHONE) {
snd_device = SND_DEVICE_IN_HANDSET_MIC;
} else {
ALOGE("%s: Unknown output device(s) %#x", __func__, out_device);
ALOGW("%s: Using default handset-mic", __func__);
snd_device = SND_DEVICE_IN_HANDSET_MIC;
}
}
exit:
ALOGV("%s: exit: in_snd_device(%s)", __func__, device_table[snd_device]);
return snd_device;
}
int set_hdmi_channels(struct audio_device *adev, int channel_count)
{
struct mixer_ctl *ctl;
const char *mixer_ctl_name = "";
(void)adev;
(void)channel_count;
/* TODO */
return 0;
}
int edid_get_max_channels(struct audio_device *adev)
{
int max_channels = 2;
struct mixer_ctl *ctl;
(void)adev;
/* TODO */
return max_channels;
}
/* Delay in Us */
int64_t render_latency(audio_usecase_t usecase)
{
(void)usecase;
/* TODO */
return 0;
}
static int enable_snd_device(struct audio_device *adev,
struct audio_usecase *uc_info,
snd_device_t snd_device,
bool update_mixer)
{
struct mixer_card *mixer_card;
struct listnode *node;
const char *snd_device_name = get_snd_device_name(snd_device);
if (snd_device_name == NULL)
return -EINVAL;
adev->snd_dev_ref_cnt[snd_device]++;
if (adev->snd_dev_ref_cnt[snd_device] > 1) {
ALOGV("%s: snd_device(%d: %s) is already active",
__func__, snd_device, snd_device_name);
return 0;
}
ALOGV("%s: snd_device(%d: %s)", __func__,
snd_device, snd_device_name);
list_for_each(node, &uc_info->mixer_list) {
mixer_card = node_to_item(node, struct mixer_card, uc_list_node[uc_info->id]);
audio_route_apply_path(mixer_card->audio_route, snd_device_name);
if (update_mixer)
audio_route_update_mixer(mixer_card->audio_route);
}
return 0;
}
static int disable_snd_device(struct audio_device *adev,
struct audio_usecase *uc_info,
snd_device_t snd_device,
bool update_mixer)
{
struct mixer_card *mixer_card;
struct listnode *node;
const char *snd_device_name = get_snd_device_name(snd_device);
if (snd_device_name == NULL)
return -EINVAL;
if (adev->snd_dev_ref_cnt[snd_device] <= 0) {
ALOGE("%s: device ref cnt is already 0", __func__);
return -EINVAL;
}
adev->snd_dev_ref_cnt[snd_device]--;
if (adev->snd_dev_ref_cnt[snd_device] == 0) {
ALOGV("%s: snd_device(%d: %s)", __func__,
snd_device, snd_device_name);
list_for_each(node, &uc_info->mixer_list) {
mixer_card = node_to_item(node, struct mixer_card, uc_list_node[uc_info->id]);
audio_route_reset_path(mixer_card->audio_route, snd_device_name);
if (update_mixer)
audio_route_update_mixer(mixer_card->audio_route);
}
}
return 0;
}
static int select_devices(struct audio_device *adev,
audio_usecase_t uc_id)
{
snd_device_t out_snd_device = SND_DEVICE_NONE;
snd_device_t in_snd_device = SND_DEVICE_NONE;
struct audio_usecase *usecase = NULL;
struct audio_usecase *vc_usecase = NULL;
struct listnode *node;
struct stream_in *active_input = NULL;
struct stream_out *active_out;
struct mixer_card *mixer_card;
ALOGV("%s: usecase(%d)", __func__, uc_id);
if (uc_id == USECASE_AUDIO_CAPTURE_HOTWORD)
return 0;
usecase = get_usecase_from_type(adev, PCM_CAPTURE|VOICE_CALL);
if (usecase != NULL) {
active_input = (struct stream_in *)usecase->stream;
}
usecase = get_usecase_from_id(adev, uc_id);
if (usecase == NULL) {
ALOGE("%s: Could not find the usecase(%d)", __func__, uc_id);
return -EINVAL;
}
active_out = (struct stream_out *)usecase->stream;
if (usecase->type == VOICE_CALL) {
out_snd_device = get_output_snd_device(adev, active_out->devices);
in_snd_device = get_input_snd_device(adev, active_out->devices);
usecase->devices = active_out->devices;
} else {
/*
* If the voice call is active, use the sound devices of voice call usecase
* so that it would not result any device switch. All the usecases will
* be switched to new device when select_devices() is called for voice call
* usecase.
*/
if (adev->in_call) {
vc_usecase = get_usecase_from_id(adev, USECASE_VOICE_CALL);
if (usecase == NULL) {
ALOGE("%s: Could not find the voice call usecase", __func__);
} else {
in_snd_device = vc_usecase->in_snd_device;
out_snd_device = vc_usecase->out_snd_device;
}
}
if (usecase->type == PCM_PLAYBACK) {
usecase->devices = active_out->devices;
in_snd_device = SND_DEVICE_NONE;
if (out_snd_device == SND_DEVICE_NONE) {
out_snd_device = get_output_snd_device(adev, active_out->devices);
if (active_out == adev->primary_output &&
active_input &&
active_input->source == AUDIO_SOURCE_VOICE_COMMUNICATION) {
select_devices(adev, active_input->usecase);
}
}
} else if (usecase->type == PCM_CAPTURE) {
usecase->devices = ((struct stream_in *)usecase->stream)->devices;
out_snd_device = SND_DEVICE_NONE;
if (in_snd_device == SND_DEVICE_NONE) {
if (active_input->source == AUDIO_SOURCE_VOICE_COMMUNICATION &&
adev->primary_output && !adev->primary_output->standby) {
in_snd_device = get_input_snd_device(adev, adev->primary_output->devices);
} else {
in_snd_device = get_input_snd_device(adev, AUDIO_DEVICE_NONE);
}
}
}
}
if (out_snd_device == usecase->out_snd_device &&
in_snd_device == usecase->in_snd_device) {
return 0;
}
ALOGV("%s: out_snd_device(%d: %s) in_snd_device(%d: %s)", __func__,
out_snd_device, get_snd_device_display_name(out_snd_device),
in_snd_device, get_snd_device_display_name(in_snd_device));
/* Disable current sound devices */
if (usecase->out_snd_device != SND_DEVICE_NONE) {
disable_snd_device(adev, usecase, usecase->out_snd_device, false);
}
if (usecase->in_snd_device != SND_DEVICE_NONE) {
disable_snd_device(adev, usecase, usecase->in_snd_device, false);
}
/* Enable new sound devices */
if (out_snd_device != SND_DEVICE_NONE) {
enable_snd_device(adev, usecase, out_snd_device, false);
}
if (in_snd_device != SND_DEVICE_NONE) {
enable_snd_device(adev, usecase, in_snd_device, false);
}
list_for_each(node, &usecase->mixer_list) {
mixer_card = node_to_item(node, struct mixer_card, uc_list_node[usecase->id]);
audio_route_update_mixer(mixer_card->audio_route);
}
usecase->in_snd_device = in_snd_device;
usecase->out_snd_device = out_snd_device;
return 0;
}
static ssize_t read_frames(struct stream_in *in, void *buffer, ssize_t frames);
static int do_in_standby_l(struct stream_in *in);
static audio_format_t in_get_format(const struct audio_stream *stream);
#ifdef PREPROCESSING_ENABLED
static int get_command_status(int status, int fct_status, uint32_t cmd_status) {
if (fct_status != 0)
status = fct_status;
else if (cmd_status != 0)
status = cmd_status;
return status;
}
static uint32_t in_get_aux_channels(struct stream_in *in)
{
if (in->num_preprocessors == 0)
return 0;
/* do not enable quad mic configurations when capturing from other
* microphones than main */
if (!(in->devices & AUDIO_DEVICE_IN_BUILTIN_MIC & ~AUDIO_DEVICE_BIT_IN))
return 0;
return AUDIO_CHANNEL_INDEX_MASK_4;
}
static int in_configure_effect_channels(effect_handle_t effect,
channel_config_t *channel_config)
{
int status = 0;
int fct_status;
int32_t cmd_status;
uint32_t reply_size;
effect_config_t config;
uint32_t cmd[(sizeof(uint32_t) + sizeof(channel_config_t) - 1) / sizeof(uint32_t) + 1];
ALOGV("in_configure_effect_channels(): configure effect with channels: [%04x][%04x]",
channel_config->main_channels,
channel_config->aux_channels);
config.inputCfg.mask = EFFECT_CONFIG_CHANNELS;
config.outputCfg.mask = EFFECT_CONFIG_CHANNELS;
reply_size = sizeof(effect_config_t);
fct_status = (*effect)->command(effect,
EFFECT_CMD_GET_CONFIG,
0,
NULL,
&reply_size,
&config);
if (fct_status != 0) {
ALOGE("in_configure_effect_channels(): EFFECT_CMD_GET_CONFIG failed");
return fct_status;
}
config.inputCfg.channels = channel_config->aux_channels;
config.outputCfg.channels = config.inputCfg.channels;
reply_size = sizeof(uint32_t);
fct_status = (*effect)->command(effect,
EFFECT_CMD_SET_CONFIG,
sizeof(effect_config_t),
&config,
&reply_size,
&cmd_status);
status = get_command_status(status, fct_status, cmd_status);
if (status != 0) {
ALOGE("in_configure_effect_channels(): EFFECT_CMD_SET_CONFIG failed");
return status;
}
/* some implementations need to be re-enabled after a config change */
reply_size = sizeof(uint32_t);
fct_status = (*effect)->command(effect,
EFFECT_CMD_ENABLE,
0,
NULL,
&reply_size,
&cmd_status);
status = get_command_status(status, fct_status, cmd_status);
if (status != 0) {
ALOGE("in_configure_effect_channels(): EFFECT_CMD_ENABLE failed");
return status;
}
return status;
}
static int in_reconfigure_channels(struct stream_in *in,
effect_handle_t effect,
channel_config_t *channel_config,
bool config_changed) {
int status = 0;
ALOGV("in_reconfigure_channels(): config_changed %d effect %p",
config_changed, effect);
/* if config changed, reconfigure all previously added effects */
if (config_changed) {
int i;
ALOGV("%s: config_changed (%d)", __func__, config_changed);
for (i = 0; i < in->num_preprocessors; i++) {
int cur_status = in_configure_effect_channels(in->preprocessors[i].effect_itfe,
channel_config);
ALOGV("%s: in_configure_effect_channels i=(%d), [main_channel,aux_channel]=[%d|%d], status=%d",
__func__, i, channel_config->main_channels, channel_config->aux_channels, cur_status);
if (cur_status != 0) {
ALOGV("in_reconfigure_channels(): error %d configuring effect "
"%d with channels: [%04x][%04x]",
cur_status,
i,
channel_config->main_channels,
channel_config->aux_channels);
status = cur_status;
}
}
} else if (effect != NULL && channel_config->aux_channels) {
/* if aux channels config did not change but aux channels are present,
* we still need to configure the effect being added */
status = in_configure_effect_channels(effect, channel_config);
}
return status;
}
static void in_update_aux_channels(struct stream_in *in,
effect_handle_t effect)
{
uint32_t aux_channels;
channel_config_t channel_config;
int status;
aux_channels = in_get_aux_channels(in);
channel_config.main_channels = in->main_channels;
channel_config.aux_channels = aux_channels;
status = in_reconfigure_channels(in,
effect,
&channel_config,
(aux_channels != in->aux_channels));
if (status != 0) {
ALOGV("in_update_aux_channels(): in_reconfigure_channels error %d", status);
/* resetting aux channels configuration */
aux_channels = 0;
channel_config.aux_channels = 0;
in_reconfigure_channels(in, effect, &channel_config, true);
}
ALOGV("%s: aux_channels=%d, in->aux_channels_changed=%d", __func__, aux_channels, in->aux_channels_changed);
if (in->aux_channels != aux_channels) {
in->aux_channels_changed = true;
in->aux_channels = aux_channels;
do_in_standby_l(in);
}
}
#endif
/* This function reads PCM data and:
* - resample if needed
* - process if pre-processors are attached
* - discard unwanted channels
*/
static ssize_t read_and_process_frames(struct audio_stream_in *stream, void* buffer, ssize_t frames_num)
{
struct stream_in *in = (struct stream_in *)stream;
ssize_t frames_wr = 0; /* Number of frames actually read */
size_t bytes_per_sample = audio_bytes_per_sample(stream->common.get_format(&stream->common));
void *proc_buf_out = buffer;
#ifdef PREPROCESSING_ENABLED
audio_buffer_t in_buf;
audio_buffer_t out_buf;
int i;
bool has_processing = in->num_preprocessors != 0;
#endif
/* Additional channels might be added on top of main_channels:
* - aux_channels (by processing effects)
* - extra channels due to HW limitations
* In case of additional channels, we cannot work inplace
*/
size_t src_channels = in->config.channels;
size_t dst_channels = audio_channel_count_from_in_mask(in->main_channels);
bool channel_remapping_needed = (dst_channels != src_channels);
size_t src_buffer_size = frames_num * src_channels * bytes_per_sample;
#ifdef PREPROCESSING_ENABLED
if (has_processing) {
/* since all the processing below is done in frames and using the config.channels
* as the number of channels, no changes is required in case aux_channels are present */
while (frames_wr < frames_num) {
/* first reload enough frames at the end of process input buffer */
if (in->proc_buf_frames < (size_t)frames_num) {
ssize_t frames_rd;
if (in->proc_buf_size < (size_t)frames_num) {
in->proc_buf_size = (size_t)frames_num;
in->proc_buf_in = realloc(in->proc_buf_in, src_buffer_size);
ALOG_ASSERT((in->proc_buf_in != NULL),
"process_frames() failed to reallocate proc_buf_in");
if (channel_remapping_needed) {
in->proc_buf_out = realloc(in->proc_buf_out, src_buffer_size);
ALOG_ASSERT((in->proc_buf_out != NULL),
"process_frames() failed to reallocate proc_buf_out");
proc_buf_out = in->proc_buf_out;
}
}
frames_rd = read_frames(in,
in->proc_buf_in +
in->proc_buf_frames * src_channels * bytes_per_sample,
frames_num - in->proc_buf_frames);
if (frames_rd < 0) {
/* Return error code */
frames_wr = frames_rd;
break;
}
in->proc_buf_frames += frames_rd;
}
/* in_buf.frameCount and out_buf.frameCount indicate respectively
* the maximum number of frames to be consumed and produced by process() */
in_buf.frameCount = in->proc_buf_frames;
in_buf.s16 = in->proc_buf_in;
out_buf.frameCount = frames_num - frames_wr;
out_buf.s16 = (int16_t *)proc_buf_out + frames_wr * in->config.channels;
/* FIXME: this works because of current pre processing library implementation that
* does the actual process only when the last enabled effect process is called.
* The generic solution is to have an output buffer for each effect and pass it as
* input to the next.
*/
for (i = 0; i < in->num_preprocessors; i++) {
(*in->preprocessors[i].effect_itfe)->process(in->preprocessors[i].effect_itfe,
&in_buf,
&out_buf);
}
/* process() has updated the number of frames consumed and produced in
* in_buf.frameCount and out_buf.frameCount respectively
* move remaining frames to the beginning of in->proc_buf_in */
in->proc_buf_frames -= in_buf.frameCount;
if (in->proc_buf_frames) {
memcpy(in->proc_buf_in,
in->proc_buf_in + in_buf.frameCount * src_channels * bytes_per_sample,
in->proc_buf_frames * in->config.channels * audio_bytes_per_sample(in_get_format(in)));
}
/* if not enough frames were passed to process(), read more and retry. */
if (out_buf.frameCount == 0) {
ALOGW("No frames produced by preproc");
continue;
}
if ((frames_wr + (ssize_t)out_buf.frameCount) <= frames_num) {
frames_wr += out_buf.frameCount;
} else {
/* The effect does not comply to the API. In theory, we should never end up here! */
ALOGE("preprocessing produced too many frames: %d + %zd > %d !",
(unsigned int)frames_wr, out_buf.frameCount, (unsigned int)frames_num);
frames_wr = frames_num;
}
}
}
else
#endif //PREPROCESSING_ENABLED
{
/* No processing effects attached */
if (channel_remapping_needed) {
/* With additional channels, we cannot use original buffer */
if (in->proc_buf_size < src_buffer_size) {
in->proc_buf_size = src_buffer_size;
in->proc_buf_out = realloc(in->proc_buf_out, src_buffer_size);
ALOG_ASSERT((in->proc_buf_out != NULL),
"process_frames() failed to reallocate proc_buf_out");
}
proc_buf_out = in->proc_buf_out;
}
frames_wr = read_frames(in, proc_buf_out, frames_num);
ALOG_ASSERT(frames_wr <= frames_num, "read more frames than requested");
}
if (channel_remapping_needed) {
size_t ret = adjust_channels(proc_buf_out, src_channels, buffer, dst_channels,
bytes_per_sample, frames_wr * src_channels * bytes_per_sample);
ALOG_ASSERT(ret == (frames_wr * dst_channels * bytes_per_sample));
}
return frames_wr;
}
static int get_next_buffer(struct resampler_buffer_provider *buffer_provider,
struct resampler_buffer* buffer)
{
struct stream_in *in;
struct pcm_device *pcm_device;
if (buffer_provider == NULL || buffer == NULL)
return -EINVAL;
in = (struct stream_in *)((char *)buffer_provider -
offsetof(struct stream_in, buf_provider));
if (list_empty(&in->pcm_dev_list)) {
buffer->raw = NULL;
buffer->frame_count = 0;
in->read_status = -ENODEV;
return -ENODEV;
}
pcm_device = node_to_item(list_head(&in->pcm_dev_list),
struct pcm_device, stream_list_node);
if (in->read_buf_frames == 0) {
size_t size_in_bytes = pcm_frames_to_bytes(pcm_device->pcm, in->config.period_size);
if (in->read_buf_size < in->config.period_size) {
in->read_buf_size = in->config.period_size;
in->read_buf = (int16_t *) realloc(in->read_buf, size_in_bytes);
ALOG_ASSERT((in->read_buf != NULL),
"get_next_buffer() failed to reallocate read_buf");
}
in->read_status = pcm_read(pcm_device->pcm, (void*)in->read_buf, size_in_bytes);
if (in->read_status != 0) {
ALOGE("get_next_buffer() pcm_read error %d", in->read_status);
buffer->raw = NULL;
buffer->frame_count = 0;
return in->read_status;
}
in->read_buf_frames = in->config.period_size;
}
buffer->frame_count = (buffer->frame_count > in->read_buf_frames) ?
in->read_buf_frames : buffer->frame_count;
buffer->i16 = in->read_buf + (in->config.period_size - in->read_buf_frames) *
in->config.channels;
return in->read_status;
}
static void release_buffer(struct resampler_buffer_provider *buffer_provider,
struct resampler_buffer* buffer)
{
struct stream_in *in;
if (buffer_provider == NULL || buffer == NULL)
return;
in = (struct stream_in *)((char *)buffer_provider -
offsetof(struct stream_in, buf_provider));
in->read_buf_frames -= buffer->frame_count;
}
/* read_frames() reads frames from kernel driver, down samples to capture rate
* if necessary and output the number of frames requested to the buffer specified */
static ssize_t read_frames(struct stream_in *in, void *buffer, ssize_t frames)
{
ssize_t frames_wr = 0;
struct pcm_device *pcm_device;
if (list_empty(&in->pcm_dev_list)) {
ALOGE("%s: pcm device list empty", __func__);
return -EINVAL;
}
pcm_device = node_to_item(list_head(&in->pcm_dev_list),
struct pcm_device, stream_list_node);
while (frames_wr < frames) {
size_t frames_rd = frames - frames_wr;
ALOGVV("%s: frames_rd: %zd, frames_wr: %zd, in->config.channels: %d",
__func__,frames_rd,frames_wr,in->config.channels);
if (in->resampler != NULL) {
in->resampler->resample_from_provider(in->resampler,
(int16_t *)((char *)buffer +
pcm_frames_to_bytes(pcm_device->pcm, frames_wr)),
&frames_rd);
} else {
struct resampler_buffer buf = {
{ raw : NULL, },
frame_count : frames_rd,
};
get_next_buffer(&in->buf_provider, &buf);
if (buf.raw != NULL) {
memcpy((char *)buffer +
pcm_frames_to_bytes(pcm_device->pcm, frames_wr),
buf.raw,
pcm_frames_to_bytes(pcm_device->pcm, buf.frame_count));
frames_rd = buf.frame_count;
}
release_buffer(&in->buf_provider, &buf);
}
/* in->read_status is updated by getNextBuffer() also called by
* in->resampler->resample_from_provider() */
if (in->read_status != 0)
return in->read_status;
frames_wr += frames_rd;
}
return frames_wr;
}
static int in_release_pcm_devices(struct stream_in *in)
{
struct pcm_device *pcm_device;
struct listnode *node;
struct listnode *next;
list_for_each_safe(node, next, &in->pcm_dev_list) {
pcm_device = node_to_item(node, struct pcm_device, stream_list_node);
list_remove(node);
free(pcm_device);
}
return 0;
}
static int stop_input_stream(struct stream_in *in)
{
struct audio_usecase *uc_info;
struct audio_device *adev = in->dev;
adev->active_input = NULL;
ALOGV("%s: enter: usecase(%d: %s)", __func__,
in->usecase, use_case_table[in->usecase]);
uc_info = get_usecase_from_id(adev, in->usecase);
if (uc_info == NULL) {
ALOGE("%s: Could not find the usecase (%d) in the list",
__func__, in->usecase);
return -EINVAL;
}
/* Disable the tx device */
disable_snd_device(adev, uc_info, uc_info->in_snd_device, true);
list_remove(&uc_info->adev_list_node);
free(uc_info);
if (list_empty(&in->pcm_dev_list)) {
ALOGE("%s: pcm device list empty", __func__);
return -EINVAL;
}
in_release_pcm_devices(in);
list_init(&in->pcm_dev_list);
return 0;
}
int start_input_stream(struct stream_in *in)
{
/* Enable output device and stream routing controls */
int ret = 0;
bool recreate_resampler = false;
struct audio_usecase *uc_info;
struct audio_device *adev = in->dev;
struct pcm_device_profile *pcm_profile;
struct pcm_device *pcm_device;
ALOGV("%s: enter: usecase(%d)", __func__, in->usecase);
adev->active_input = in;
pcm_profile = get_pcm_device(in->usecase_type, in->devices);
if (pcm_profile == NULL) {
ALOGE("%s: Could not find PCM device id for the usecase(%d)",
__func__, in->usecase);
ret = -EINVAL;
goto error_config;
}
if (in->input_flags & AUDIO_INPUT_FLAG_FAST) {
ALOGV("%s: change capture period size to low latency size %d",
__func__, CAPTURE_PERIOD_SIZE_LOW_LATENCY);
pcm_profile->config.period_size = CAPTURE_PERIOD_SIZE_LOW_LATENCY;
}
uc_info = (struct audio_usecase *)calloc(1, sizeof(struct audio_usecase));
uc_info->id = in->usecase;
uc_info->type = PCM_CAPTURE;
uc_info->stream = (struct audio_stream *)in;
uc_info->devices = in->devices;
uc_info->in_snd_device = SND_DEVICE_NONE;
uc_info->out_snd_device = SND_DEVICE_NONE;
pcm_device = (struct pcm_device *)calloc(1, sizeof(struct pcm_device));
pcm_device->pcm_profile = pcm_profile;
list_init(&in->pcm_dev_list);
list_add_tail(&in->pcm_dev_list, &pcm_device->stream_list_node);
list_init(&uc_info->mixer_list);
list_add_tail(&uc_info->mixer_list,
&adev_get_mixer_for_card(adev,
pcm_device->pcm_profile->card)->uc_list_node[uc_info->id]);
list_add_tail(&adev->usecase_list, &uc_info->adev_list_node);
select_devices(adev, in->usecase);
/* Config should be updated as profile can be changed between different calls
* to this function:
* - Trigger resampler creation
* - Config needs to be updated */
if (in->config.rate != pcm_profile->config.rate) {
recreate_resampler = true;
}
in->config = pcm_profile->config;
#ifdef PREPROCESSING_ENABLED
if (in->aux_channels_changed) {
in->config.channels = audio_channel_count_from_in_mask(in->aux_channels);
recreate_resampler = true;
}
#endif
if (in->requested_rate != in->config.rate) {
recreate_resampler = true;
}
if (recreate_resampler) {
if (in->resampler) {
release_resampler(in->resampler);
in->resampler = NULL;
}
in->buf_provider.get_next_buffer = get_next_buffer;
in->buf_provider.release_buffer = release_buffer;
ret = create_resampler(in->config.rate,
in->requested_rate,
in->config.channels,
RESAMPLER_QUALITY_DEFAULT,
&in->buf_provider,
&in->resampler);
}
/* Open the PCM device.
* The HW is limited to support only the default pcm_profile settings.
* As such a change in aux_channels will not have an effect.
*/
ALOGV("%s: Opening PCM device card_id(%d) device_id(%d), channels %d, smp rate %d format %d, \
period_size %d", __func__, pcm_device->pcm_profile->card, pcm_device->pcm_profile->device,
pcm_device->pcm_profile->config.channels,pcm_device->pcm_profile->config.rate,
pcm_device->pcm_profile->config.format, pcm_device->pcm_profile->config.period_size);
if (pcm_profile->type == PCM_HOTWORD_STREAMING) {
if (!adev->sound_trigger_open_for_streaming) {
ALOGE("%s: No handle to sound trigger HAL", __func__);
ret = -EIO;
goto error_open;
}
pcm_device->pcm = NULL;
pcm_device->sound_trigger_handle =
adev->sound_trigger_open_for_streaming();
if (pcm_device->sound_trigger_handle <= 0) {
ALOGE("%s: Failed to open DSP for streaming", __func__);
ret = -EIO;
goto error_open;
}
ALOGV("Opened DSP successfully");
} else {
pcm_device->sound_trigger_handle = 0;
pcm_device->pcm = pcm_open(pcm_device->pcm_profile->card,
pcm_device->pcm_profile->device,
PCM_IN | PCM_MONOTONIC,
&pcm_device->pcm_profile->config);
if (pcm_device->pcm && !pcm_is_ready(pcm_device->pcm)) {
ALOGE("%s: %s", __func__, pcm_get_error(pcm_device->pcm));
pcm_close(pcm_device->pcm);
pcm_device->pcm = NULL;
ret = -EIO;
goto error_open;
}
}
/* force read and proc buffer reallocation in case of frame size or
* channel count change */
#ifdef PREPROCESSING_ENABLED
in->proc_buf_frames = 0;
#endif
in->proc_buf_size = 0;
in->read_buf_size = 0;
in->read_buf_frames = 0;
/* if no supported sample rate is available, use the resampler */
if (in->resampler) {
in->resampler->reset(in->resampler);
}
ALOGV("%s: exit", __func__);
return ret;
error_open:
if (in->resampler) {
release_resampler(in->resampler);
in->resampler = NULL;
}
stop_input_stream(in);
error_config:
ALOGV("%s: exit: status(%d)", __func__, ret);
adev->active_input = NULL;
return ret;
}
static 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);
}
static 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);
}
static int uc_release_pcm_devices(struct audio_usecase *usecase)
{
struct stream_out *out = (struct stream_out *)usecase->stream;
struct pcm_device *pcm_device;
struct listnode *node;
struct listnode *next;
list_for_each_safe(node, next, &out->pcm_dev_list) {
pcm_device = node_to_item(node, struct pcm_device, stream_list_node);
list_remove(node);
free(pcm_device);
}
list_init(&usecase->mixer_list);
return 0;
}
static int uc_select_pcm_devices(struct audio_usecase *usecase)
{
struct stream_out *out = (struct stream_out *)usecase->stream;
struct pcm_device *pcm_device;
struct pcm_device_profile *pcm_profile;
struct mixer_card *mixer_card;
audio_devices_t devices = usecase->devices;
list_init(&usecase->mixer_list);
list_init(&out->pcm_dev_list);
pcm_profile = get_pcm_device(usecase->type, devices);
if (pcm_profile) {
pcm_device = calloc(1, sizeof(struct pcm_device));
pcm_device->pcm_profile = pcm_profile;
list_add_tail(&out->pcm_dev_list, &pcm_device->stream_list_node);
mixer_card = uc_get_mixer_for_card(usecase, pcm_profile->card);
if (mixer_card == NULL) {
mixer_card = adev_get_mixer_for_card(out->dev, pcm_profile->card);
list_add_tail(&usecase->mixer_list, &mixer_card->uc_list_node[usecase->id]);
}
devices &= ~pcm_profile->devices;
} else {
ALOGE("usecase type=%d, devices=%d did not find exact match",
usecase->type, devices);
}
return 0;
}
static int out_close_pcm_devices(struct stream_out *out)
{
struct pcm_device *pcm_device;
struct listnode *node;
struct audio_device *adev = out->dev;
list_for_each(node, &out->pcm_dev_list) {
pcm_device = node_to_item(node, struct pcm_device, stream_list_node);
if (pcm_device->sound_trigger_handle > 0) {
adev->sound_trigger_close_for_streaming(
pcm_device->sound_trigger_handle);
pcm_device->sound_trigger_handle = 0;
}
if (pcm_device->pcm) {
pcm_close(pcm_device->pcm);
pcm_device->pcm = NULL;
}
if (pcm_device->resampler) {
release_resampler(pcm_device->resampler);
pcm_device->resampler = NULL;
}
if (pcm_device->res_buffer) {
free(pcm_device->res_buffer);
pcm_device->res_buffer = NULL;
}
if (pcm_device->dsp_context) {
cras_dsp_context_free(pcm_device->dsp_context);
pcm_device->dsp_context = NULL;
}
}
return 0;
}
static int out_open_pcm_devices(struct stream_out *out)
{
struct pcm_device *pcm_device;
struct listnode *node;
struct audio_device *adev = out->dev;
int ret = 0;
list_for_each(node, &out->pcm_dev_list) {
pcm_device = node_to_item(node, struct pcm_device, stream_list_node);
ALOGV("%s: Opening PCM device card_id(%d) device_id(%d)",
__func__, pcm_device->pcm_profile->card, pcm_device->pcm_profile->device);
if (pcm_device->pcm_profile->dsp_name) {
pcm_device->dsp_context = cras_dsp_context_new(pcm_device->pcm_profile->config.rate,
(adev->mode == AUDIO_MODE_IN_CALL || adev->mode == AUDIO_MODE_IN_COMMUNICATION)
? "voice-comm" : "playback");
if (pcm_device->dsp_context) {
cras_dsp_set_variable(pcm_device->dsp_context, "dsp_name",
pcm_device->pcm_profile->dsp_name);
cras_dsp_load_pipeline(pcm_device->dsp_context);
}
}
pcm_device->pcm = pcm_open(pcm_device->pcm_profile->card, pcm_device->pcm_profile->device,
PCM_OUT | PCM_MONOTONIC, &pcm_device->pcm_profile->config);
if (pcm_device->pcm && !pcm_is_ready(pcm_device->pcm)) {
ALOGE("%s: %s", __func__, pcm_get_error(pcm_device->pcm));
pcm_device->pcm = NULL;
ret = -EIO;
goto error_open;
}
/*
* If the stream rate differs from the PCM rate, we need to
* create a resampler.
*/
if (out->sample_rate != pcm_device->pcm_profile->config.rate) {
ALOGV("%s: create_resampler(), pcm_device_card(%d), pcm_device_id(%d), \
out_rate(%d), device_rate(%d)",__func__,
pcm_device->pcm_profile->card, pcm_device->pcm_profile->device,
out->sample_rate, pcm_device->pcm_profile->config.rate);
ret = create_resampler(out->sample_rate,
pcm_device->pcm_profile->config.rate,
audio_channel_count_from_out_mask(out->channel_mask),
RESAMPLER_QUALITY_DEFAULT,
NULL,
&pcm_device->resampler);
pcm_device->res_byte_count = 0;
pcm_device->res_buffer = NULL;
}
}
return ret;
error_open:
out_close_pcm_devices(out);
return ret;
}
static int disable_output_path_l(struct stream_out *out)
{
struct audio_device *adev = out->dev;
struct audio_usecase *uc_info;
uc_info = get_usecase_from_id(adev, out->usecase);
if (uc_info == NULL) {
ALOGE("%s: Could not find the usecase (%d) in the list",
__func__, out->usecase);
return -EINVAL;
}
disable_snd_device(adev, uc_info, uc_info->out_snd_device, true);
uc_release_pcm_devices(uc_info);
list_remove(&uc_info->adev_list_node);
free(uc_info);
return 0;
}
static void enable_output_path_l(struct stream_out *out)
{
struct audio_device *adev = out->dev;
struct audio_usecase *uc_info;
uc_info = (struct audio_usecase *)calloc(1, sizeof(struct audio_usecase));
uc_info->id = out->usecase;
uc_info->type = PCM_PLAYBACK;
uc_info->stream = (struct audio_stream *)out;
uc_info->devices = out->devices;
uc_info->in_snd_device = SND_DEVICE_NONE;
uc_info->out_snd_device = SND_DEVICE_NONE;
uc_select_pcm_devices(uc_info);
list_add_tail(&adev->usecase_list, &uc_info->adev_list_node);
select_devices(adev, out->usecase);
}
static int stop_output_stream(struct stream_out *out)
{
int ret = 0;
struct audio_device *adev = out->dev;
bool do_disable = true;
ALOGV("%s: enter: usecase(%d: %s)", __func__,
out->usecase, use_case_table[out->usecase]);
ret = disable_output_path_l(out);
ALOGV("%s: exit: status(%d)", __func__, ret);
return ret;
}
int start_output_stream(struct stream_out *out)
{
int ret = 0;
struct audio_device *adev = out->dev;
ALOGV("%s: enter: usecase(%d: %s) devices(%#x) channels(%d)",
__func__, out->usecase, use_case_table[out->usecase], out->devices, out->config.channels);
enable_output_path_l(out);
ret = out_open_pcm_devices(out);
if (ret != 0)
goto error_open;
ALOGV("%s: exit", __func__);
return 0;
error_open:
stop_output_stream(out);
return ret;
}
static int stop_voice_call(struct audio_device *adev)
{
struct audio_usecase *uc_info;
ALOGV("%s: enter", __func__);
adev->in_call = false;
/* TODO: implement voice call stop */
uc_info = get_usecase_from_id(adev, USECASE_VOICE_CALL);
if (uc_info == NULL) {
ALOGE("%s: Could not find the usecase (%d) in the list",
__func__, USECASE_VOICE_CALL);
return -EINVAL;
}
disable_snd_device(adev, uc_info, uc_info->out_snd_device, false);
disable_snd_device(adev, uc_info, uc_info->in_snd_device, true);
uc_release_pcm_devices(uc_info);
list_remove(&uc_info->adev_list_node);
free(uc_info);
ALOGV("%s: exit", __func__);
return 0;
}
/* always called with adev lock held */
static int start_voice_call(struct audio_device *adev)
{
struct audio_usecase *uc_info;
ALOGV("%s: enter", __func__);
uc_info = (struct audio_usecase *)calloc(1, sizeof(struct audio_usecase));
uc_info->id = USECASE_VOICE_CALL;
uc_info->type = VOICE_CALL;
uc_info->stream = (struct audio_stream *)adev->primary_output;
uc_info->devices = adev->primary_output->devices;
uc_info->in_snd_device = SND_DEVICE_NONE;
uc_info->out_snd_device = SND_DEVICE_NONE;
uc_select_pcm_devices(uc_info);
list_add_tail(&adev->usecase_list, &uc_info->adev_list_node);
select_devices(adev, USECASE_VOICE_CALL);
/* TODO: implement voice call start */
/* set cached volume */
set_voice_volume_l(adev, adev->voice_volume);
adev->in_call = true;
ALOGV("%s: exit", __func__);
return 0;
}
static int check_input_parameters(uint32_t sample_rate,
audio_format_t format,
int channel_count)
{
if (format != AUDIO_FORMAT_PCM_16_BIT) return -EINVAL;
if ((channel_count < 1) || (channel_count > 4)) return -EINVAL;
switch (sample_rate) {
case 8000:
case 11025:
case 12000:
case 16000:
case 22050:
case 24000:
case 32000:
case 44100:
case 48000:
break;
default:
return -EINVAL;
}
return 0;
}
static size_t get_input_buffer_size(uint32_t sample_rate,
audio_format_t format,
int channel_count,
usecase_type_t usecase_type,
audio_devices_t devices)
{
size_t size = 0;
struct pcm_device_profile *pcm_profile;
if (check_input_parameters(sample_rate, format, channel_count) != 0)
return 0;
pcm_profile = get_pcm_device(usecase_type, devices);
if (pcm_profile == NULL)
return 0;
/*
* take resampling into account and return the closest majoring
* multiple of 16 frames, as audioflinger expects audio buffers to
* be a multiple of 16 frames
*/
size = (pcm_profile->config.period_size * sample_rate) / pcm_profile->config.rate;
size = ((size + 15) / 16) * 16;
return (size * channel_count * audio_bytes_per_sample(format));
}
static uint32_t out_get_sample_rate(const struct audio_stream *stream)
{
struct stream_out *out = (struct stream_out *)stream;
return out->sample_rate;
}
static int out_set_sample_rate(struct audio_stream *stream, uint32_t rate)
{
(void)stream;
(void)rate;
return -ENOSYS;
}
static size_t out_get_buffer_size(const struct audio_stream *stream)
{
struct stream_out *out = (struct stream_out *)stream;
return out->config.period_size *
audio_stream_out_frame_size((const struct audio_stream_out *)stream);
}
static uint32_t out_get_channels(const struct audio_stream *stream)
{
struct stream_out *out = (struct stream_out *)stream;
return out->channel_mask;
}
static audio_format_t out_get_format(const struct audio_stream *stream)
{
struct stream_out *out = (struct stream_out *)stream;
return out->format;
}
static int out_set_format(struct audio_stream *stream, audio_format_t format)
{
(void)stream;
(void)format;
return -ENOSYS;
}
static int do_out_standby_l(struct stream_out *out)
{
struct audio_device *adev = out->dev;
int status = 0;
out->standby = true;
out_close_pcm_devices(out);
status = stop_output_stream(out);
return status;
}
static int out_standby(struct audio_stream *stream)
{
struct stream_out *out = (struct stream_out *)stream;
struct audio_device *adev = out->dev;
ALOGV("%s: enter: usecase(%d: %s)", __func__,
out->usecase, use_case_table[out->usecase]);
lock_output_stream(out);
if (!out->standby) {
pthread_mutex_lock(&adev->lock);
do_out_standby_l(out);
pthread_mutex_unlock(&adev->lock);
}
pthread_mutex_unlock(&out->lock);
ALOGV("%s: exit", __func__);
return 0;
}
static int out_dump(const struct audio_stream *stream, int fd)
{
(void)stream;
(void)fd;
return 0;
}
static int out_set_parameters(struct audio_stream *stream, const char *kvpairs)
{
struct stream_out *out = (struct stream_out *)stream;
struct audio_device *adev = out->dev;
struct audio_usecase *usecase;
struct listnode *node;
struct str_parms *parms;
char value[32];
int ret, val = 0;
bool devices_changed;
struct pcm_device *pcm_device;
struct pcm_device_profile *pcm_profile;
#ifdef PREPROCESSING_ENABLED
struct stream_in *in = NULL; /* if non-NULL, then force input to standby */
#endif
ALOGV("%s: enter: usecase(%d: %s) kvpairs: %s out->devices(%d) adev->mode(%d)",
__func__, out->usecase, use_case_table[out->usecase], kvpairs, out->devices, adev->mode);
parms = str_parms_create_str(kvpairs);
ret = str_parms_get_str(parms, AUDIO_PARAMETER_STREAM_ROUTING, value, sizeof(value));
if (ret >= 0) {
val = atoi(value);
pthread_mutex_lock(&adev->lock_inputs);
lock_output_stream(out);
pthread_mutex_lock(&adev->lock);
#ifdef PREPROCESSING_ENABLED
if (((int)out->devices != val) && (val != 0) && (!out->standby) &&
(out->usecase == USECASE_AUDIO_PLAYBACK)) {
/* reset active input:
* - to attach the echo reference
* - because a change in output device may change mic settings */
if (adev->active_input && (adev->active_input->source == AUDIO_SOURCE_VOICE_COMMUNICATION ||
adev->active_input->source == AUDIO_SOURCE_MIC)) {
in = adev->active_input;
}
}
#endif
if (val != 0) {
devices_changed = out->devices != (audio_devices_t)val;
out->devices = val;
if (!out->standby) {
if (devices_changed)
do_out_standby_l(out);
else
select_devices(adev, out->usecase);
}
if ((adev->mode == AUDIO_MODE_IN_CALL) && !adev->in_call &&
(out == adev->primary_output)) {
start_voice_call(adev);
} else if ((adev->mode == AUDIO_MODE_IN_CALL) && adev->in_call &&
(out == adev->primary_output)) {
select_devices(adev, USECASE_VOICE_CALL);
}
}
if ((adev->mode == AUDIO_MODE_NORMAL) && adev->in_call &&
(out == adev->primary_output)) {
stop_voice_call(adev);
}
pthread_mutex_unlock(&adev->lock);
pthread_mutex_unlock(&out->lock);
#ifdef PREPROCESSING_ENABLED
if (in) {
/* The lock on adev->lock_inputs prevents input stream from being closed */
lock_input_stream(in);
pthread_mutex_lock(&adev->lock);
LOG_ALWAYS_FATAL_IF(in != adev->active_input);
do_in_standby_l(in);
pthread_mutex_unlock(&adev->lock);
pthread_mutex_unlock(&in->lock);
}
#endif
pthread_mutex_unlock(&adev->lock_inputs);
}
str_parms_destroy(parms);
ALOGV("%s: exit: code(%d)", __func__, ret);
return ret;
}
static char* out_get_parameters(const struct audio_stream *stream, const char *keys)
{
struct stream_out *out = (struct stream_out *)stream;
struct str_parms *query = str_parms_create_str(keys);
char *str;
char value[256];
struct str_parms *reply = str_parms_create();
size_t i, j;
int ret;
bool first = true;
ALOGV("%s: enter: keys - %s", __func__, keys);
ret = str_parms_get_str(query, AUDIO_PARAMETER_STREAM_SUP_CHANNELS, value, sizeof(value));
if (ret >= 0) {
value[0] = '\0';
i = 0;
while (out->supported_channel_masks[i] != 0) {
for (j = 0; j < ARRAY_SIZE(out_channels_name_to_enum_table); j++) {
if (out_channels_name_to_enum_table[j].value == out->supported_channel_masks[i]) {
if (!first) {
strcat(value, "|");
}
strcat(value, out_channels_name_to_enum_table[j].name);
first = false;
break;
}
}
i++;
}
str_parms_add_str(reply, AUDIO_PARAMETER_STREAM_SUP_CHANNELS, value);
str = str_parms_to_str(reply);
} else {
str = strdup(keys);
}
str_parms_destroy(query);
str_parms_destroy(reply);
ALOGV("%s: exit: returns - %s", __func__, str);
return str;
}
static uint32_t out_get_latency(const struct audio_stream_out *stream)
{
struct stream_out *out = (struct stream_out *)stream;
return (out->config.period_count * out->config.period_size * 1000) /
(out->config.rate);
}
static int out_set_volume(struct audio_stream_out *stream, float left,
float right)
{
struct stream_out *out = (struct stream_out *)stream;
struct audio_device *adev = out->dev;
(void)right;
if (out->usecase == USECASE_AUDIO_PLAYBACK_MULTI_CH) {
/* only take left channel into account: the API is for stereo anyway */
out->muted = (left == 0.0f);
return 0;
}
return -ENOSYS;
}
/* Applies the DSP to the samples for the iodev if applicable. */
static void apply_dsp(struct pcm_device *iodev, uint8_t *buf, size_t frames)
{
struct cras_dsp_context *ctx;
struct pipeline *pipeline;
ctx = iodev->dsp_context;
if (!ctx)
return;
pipeline = cras_dsp_get_pipeline(ctx);
if (!pipeline)
return;
cras_dsp_pipeline_apply(pipeline,
buf,
frames);
cras_dsp_put_pipeline(ctx);
}
static ssize_t out_write(struct audio_stream_out *stream, const void *buffer,
size_t bytes)
{
struct stream_out *out = (struct stream_out *)stream;
struct audio_device *adev = out->dev;
ssize_t ret = 0;
struct pcm_device *pcm_device;
struct listnode *node;
size_t frame_size = audio_stream_out_frame_size(stream);
size_t frames_wr = 0, frames_rq = 0;
unsigned char *data = NULL;
struct pcm_config config;
#ifdef PREPROCESSING_ENABLED
size_t in_frames = bytes / frame_size;
size_t out_frames = in_frames;
struct stream_in *in = NULL;
#endif
lock_output_stream(out);
if (out->standby) {
#ifdef PREPROCESSING_ENABLED
pthread_mutex_unlock(&out->lock);
/* Prevent input stream from being closed */
pthread_mutex_lock(&adev->lock_inputs);
lock_output_stream(out);
if (!out->standby) {
pthread_mutex_unlock(&adev->lock_inputs);
goto false_alarm;
}
#endif
pthread_mutex_lock(&adev->lock);
ret = start_output_stream(out);
if (ret != 0) {
pthread_mutex_unlock(&adev->lock);
#ifdef PREPROCESSING_ENABLED
pthread_mutex_unlock(&adev->lock_inputs);
#endif
goto exit;
}
out->standby = false;
#ifdef PREPROCESSING_ENABLED
/* A change in output device may change the microphone selection */
if (adev->active_input &&
(adev->active_input->source == AUDIO_SOURCE_VOICE_COMMUNICATION ||
adev->active_input->source == AUDIO_SOURCE_MIC)) {
in = adev->active_input;
ALOGV("%s: enter: force_input_standby true", __func__);
}
#endif
pthread_mutex_unlock(&adev->lock);
#ifdef PREPROCESSING_ENABLED
if (!in) {
/* Leave mutex locked iff in != NULL */
pthread_mutex_unlock(&adev->lock_inputs);
}
#endif
}
false_alarm:
if (out->muted)
memset((void *)buffer, 0, bytes);
list_for_each(node, &out->pcm_dev_list) {
pcm_device = node_to_item(node, struct pcm_device, stream_list_node);
if (pcm_device->resampler) {
if (bytes * pcm_device->pcm_profile->config.rate / out->sample_rate + frame_size
> pcm_device->res_byte_count) {
pcm_device->res_byte_count =
bytes * pcm_device->pcm_profile->config.rate / out->sample_rate + frame_size;
pcm_device->res_buffer =
realloc(pcm_device->res_buffer, pcm_device->res_byte_count);
ALOGV("%s: resampler res_byte_count = %zu", __func__,
pcm_device->res_byte_count);
}
frames_rq = bytes / frame_size;
frames_wr = pcm_device->res_byte_count / frame_size;
ALOGVV("%s: resampler request frames = %zu frame_size = %zu",
__func__, frames_rq, frame_size);
pcm_device->resampler->resample_from_input(pcm_device->resampler,
(int16_t *)buffer, &frames_rq, (int16_t *)pcm_device->res_buffer, &frames_wr);
ALOGVV("%s: resampler output frames_= %zu", __func__, frames_wr);
}
if (pcm_device->pcm) {
size_t src_channels = audio_channel_count_from_out_mask(out->channel_mask);
size_t dst_channels = pcm_device->pcm_profile->config.channels;
bool channel_remapping_needed = (dst_channels != src_channels);
unsigned audio_bytes;
const void *audio_data;
ALOGVV("%s: writing buffer (%zd bytes) to pcm device", __func__, bytes);
if (pcm_device->resampler && pcm_device->res_buffer) {
audio_data = pcm_device->res_buffer;
audio_bytes = frames_wr * frame_size;
} else {
audio_data = buffer;
audio_bytes = bytes;
}
/*
* This can only be S16_LE stereo because of the supported formats,
* 4 bytes per frame.
*/
apply_dsp(pcm_device, audio_data, audio_bytes/4);
if (channel_remapping_needed) {
const void *remapped_audio_data;
size_t dest_buffer_size = audio_bytes * dst_channels / src_channels;
size_t new_size;
size_t bytes_per_sample = audio_bytes_per_sample(stream->common.get_format(&stream->common));
/* With additional channels, we cannot use original buffer */
if (out->proc_buf_size < dest_buffer_size) {
out->proc_buf_size = dest_buffer_size;
out->proc_buf_out = realloc(out->proc_buf_out, dest_buffer_size);
ALOG_ASSERT((out->proc_buf_out != NULL),
"out_write() failed to reallocate proc_buf_out");
}
new_size = adjust_channels(audio_data, src_channels, out->proc_buf_out, dst_channels,
bytes_per_sample, audio_bytes);
ALOG_ASSERT(new_size == dest_buffer_size);
audio_data = out->proc_buf_out;
audio_bytes = dest_buffer_size;
}
pcm_device->status = pcm_write(pcm_device->pcm, audio_data, audio_bytes);
if (pcm_device->status != 0)
ret = pcm_device->status;
}
}
if (ret == 0)
out->written += bytes / frame_size;
exit:
pthread_mutex_unlock(&out->lock);
if (ret != 0) {
list_for_each(node, &out->pcm_dev_list) {
pcm_device = node_to_item(node, struct pcm_device, stream_list_node);
if (pcm_device->pcm && pcm_device->status != 0)
ALOGE("%s: error %zd - %s", __func__, ret, pcm_get_error(pcm_device->pcm));
}
out_standby(&out->stream.common);
usleep(bytes * 1000000 / audio_stream_out_frame_size(stream) /
out_get_sample_rate(&out->stream.common));
}
#ifdef PREPROCESSING_ENABLED
if (in) {
/* The lock on adev->lock_inputs prevents input stream from being closed */
lock_input_stream(in);
pthread_mutex_lock(&adev->lock);
LOG_ALWAYS_FATAL_IF(in != adev->active_input);
do_in_standby_l(in);
pthread_mutex_unlock(&adev->lock);
pthread_mutex_unlock(&in->lock);
/* This mutex was left locked iff in != NULL */
pthread_mutex_unlock(&adev->lock_inputs);
}
#endif
return bytes;
}
static int out_get_render_position(const struct audio_stream_out *stream,
uint32_t *dsp_frames)
{
(void)stream;
*dsp_frames = 0;
return -EINVAL;
}
static int out_add_audio_effect(const struct audio_stream *stream, effect_handle_t effect)
{
(void)stream;
(void)effect;
return 0;
}
static int out_remove_audio_effect(const struct audio_stream *stream, effect_handle_t effect)
{
(void)stream;
(void)effect;
return 0;
}
static int out_get_next_write_timestamp(const struct audio_stream_out *stream,
int64_t *timestamp)
{
(void)stream;
(void)timestamp;
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;
int ret = -1;
unsigned long dsp_frames;
lock_output_stream(out);
/* FIXME: which device to read from? */
if (!list_empty(&out->pcm_dev_list)) {
unsigned int avail;
struct pcm_device *pcm_device = node_to_item(list_head(&out->pcm_dev_list),
struct pcm_device, stream_list_node);
if (pcm_get_htimestamp(pcm_device->pcm, &avail, timestamp) == 0) {
size_t kernel_buffer_size = out->config.period_size * out->config.period_count;
int64_t signed_frames = out->written - kernel_buffer_size + avail;
/* This adjustment accounts for buffering after app processor.
It is based on estimated DSP latency per use case, rather than exact. */
signed_frames -=
(render_latency(out->usecase) * out->sample_rate / 1000000LL);
/* It would be unusual for this value to be negative, but check just in case ... */
if (signed_frames >= 0) {
*frames = signed_frames;
ret = 0;
}
}
}
pthread_mutex_unlock(&out->lock);
return ret;
}
/** audio_stream_in implementation **/
static uint32_t in_get_sample_rate(const struct audio_stream *stream)
{
struct stream_in *in = (struct stream_in *)stream;
return in->requested_rate;
}
static int in_set_sample_rate(struct audio_stream *stream, uint32_t rate)
{
(void)stream;
(void)rate;
return -ENOSYS;
}
static uint32_t in_get_channels(const struct audio_stream *stream)
{
struct stream_in *in = (struct stream_in *)stream;
return in->main_channels;
}
static audio_format_t in_get_format(const struct audio_stream *stream)
{
(void)stream;
return AUDIO_FORMAT_PCM_16_BIT;
}
static int in_set_format(struct audio_stream *stream, audio_format_t format)
{
(void)stream;
(void)format;
return -ENOSYS;
}
static size_t in_get_buffer_size(const struct audio_stream *stream)
{
struct stream_in *in = (struct stream_in *)stream;
return get_input_buffer_size(in->requested_rate,
in_get_format(stream),
audio_channel_count_from_in_mask(in->main_channels),
in->usecase_type,
in->devices);
}
static int in_close_pcm_devices(struct stream_in *in)
{
struct pcm_device *pcm_device;
struct listnode *node;
struct audio_device *adev = in->dev;
list_for_each(node, &in->pcm_dev_list) {
pcm_device = node_to_item(node, struct pcm_device, stream_list_node);
if (pcm_device) {
if (pcm_device->pcm)
pcm_close(pcm_device->pcm);
pcm_device->pcm = NULL;
if (pcm_device->sound_trigger_handle > 0)
adev->sound_trigger_close_for_streaming(
pcm_device->sound_trigger_handle);
pcm_device->sound_trigger_handle = 0;
}
}
return 0;
}
/* must be called with stream and hw device mutex locked */
static int do_in_standby_l(struct stream_in *in)
{
int status = 0;
if (!in->standby) {
in_close_pcm_devices(in);
status = stop_input_stream(in);
if (in->read_buf) {
free(in->read_buf);
in->read_buf = NULL;
}
in->standby = 1;
}
return 0;
}
// called with adev->lock_inputs locked
static int in_standby_l(struct stream_in *in)
{
struct audio_device *adev = in->dev;
int status = 0;
lock_input_stream(in);
if (!in->standby) {
pthread_mutex_lock(&adev->lock);
status = do_in_standby_l(in);
pthread_mutex_unlock(&adev->lock);
}
pthread_mutex_unlock(&in->lock);
return status;
}
static int in_standby(struct audio_stream *stream)
{
struct stream_in *in = (struct stream_in *)stream;
struct audio_device *adev = in->dev;
int status;
ALOGV("%s: enter", __func__);
pthread_mutex_lock(&adev->lock_inputs);
status = in_standby_l(in);
pthread_mutex_unlock(&adev->lock_inputs);
ALOGV("%s: exit: status(%d)", __func__, status);
return status;
}
static int in_dump(const struct audio_stream *stream, int fd)
{
(void)stream;
(void)fd;
return 0;
}
static int in_set_parameters(struct audio_stream *stream, const char *kvpairs)
{
struct stream_in *in = (struct stream_in *)stream;
struct audio_device *adev = in->dev;
struct str_parms *parms;
char *str;
char value[32];
int ret, val = 0;
struct audio_usecase *uc_info;
bool do_standby = false;
struct listnode *node;
struct pcm_device *pcm_device;
struct pcm_device_profile *pcm_profile;
ALOGV("%s: enter: kvpairs=%s", __func__, kvpairs);
parms = str_parms_create_str(kvpairs);
ret = str_parms_get_str(parms, AUDIO_PARAMETER_STREAM_INPUT_SOURCE, value, sizeof(value));
pthread_mutex_lock(&adev->lock_inputs);
lock_input_stream(in);
pthread_mutex_lock(&adev->lock);
if (ret >= 0) {
val = atoi(value);
/* no audio source uses val == 0 */
if (((int)in->source != val) && (val != 0)) {
in->source = val;
}
}
ret = str_parms_get_str(parms, AUDIO_PARAMETER_STREAM_ROUTING, value, sizeof(value));
if (ret >= 0) {
val = atoi(value);
if (((int)in->devices != val) && (val != 0)) {
in->devices = val;
/* If recording is in progress, change the tx device to new device */
if (!in->standby) {
uc_info = get_usecase_from_id(adev, in->usecase);
if (uc_info == NULL) {
ALOGE("%s: Could not find the usecase (%d) in the list",
__func__, in->usecase);
} else {
if (list_empty(&in->pcm_dev_list))
ALOGE("%s: pcm device list empty", __func__);
else {
pcm_device = node_to_item(list_head(&in->pcm_dev_list),
struct pcm_device, stream_list_node);
if ((pcm_device->pcm_profile->devices & val & ~AUDIO_DEVICE_BIT_IN) == 0) {
do_standby = true;
}
}
}
if (do_standby) {
ret = do_in_standby_l(in);
} else
ret = select_devices(adev, in->usecase);
}
}
}
pthread_mutex_unlock(&adev->lock);
pthread_mutex_unlock(&in->lock);
pthread_mutex_unlock(&adev->lock_inputs);
str_parms_destroy(parms);
if (ret > 0)
ret = 0;
return ret;
}
static char* in_get_parameters(const struct audio_stream *stream,
const char *keys)
{
(void)stream;
(void)keys;
return strdup("");
}
static int in_set_gain(struct audio_stream_in *stream, float gain)
{
(void)stream;
(void)gain;
return 0;
}
static ssize_t read_bytes_from_dsp(struct stream_in *in, void* buffer,
size_t bytes)
{
struct pcm_device *pcm_device;
struct audio_device *adev = in->dev;
pcm_device = node_to_item(list_head(&in->pcm_dev_list),
struct pcm_device, stream_list_node);
if (pcm_device->sound_trigger_handle > 0)
return adev->sound_trigger_read_samples(
pcm_device->sound_trigger_handle, buffer, bytes);
else
return 0;
}
static ssize_t in_read(struct audio_stream_in *stream, void *buffer,
size_t bytes)
{
struct stream_in *in = (struct stream_in *)stream;
struct audio_device *adev = in->dev;
ssize_t frames = -1;
int ret = -1;
int read_and_process_successful = false;
size_t frames_rq = bytes / audio_stream_in_frame_size(stream);
/* no need to acquire adev->lock_inputs because API contract prevents a close */
lock_input_stream(in);
if (in->standby) {
pthread_mutex_unlock(&in->lock);
pthread_mutex_lock(&adev->lock_inputs);
lock_input_stream(in);
if (!in->standby) {
pthread_mutex_unlock(&adev->lock_inputs);
goto false_alarm;
}
pthread_mutex_lock(&adev->lock);
ret = start_input_stream(in);
pthread_mutex_unlock(&adev->lock);
pthread_mutex_unlock(&adev->lock_inputs);
if (ret != 0) {
goto exit;
}
in->standby = 0;
}
false_alarm:
if (!list_empty(&in->pcm_dev_list)) {
if (in->usecase == USECASE_AUDIO_CAPTURE_HOTWORD) {
bytes = read_bytes_from_dsp(in, buffer, bytes);
if (bytes > 0)
read_and_process_successful = true;
} else {
/*
* Read PCM and:
* - resample if needed
* - process if pre-processors are attached
* - discard unwanted channels
*/
frames = read_and_process_frames(stream, buffer, frames_rq);
if (frames >= 0)
read_and_process_successful = true;
}
}
/*
* Instead of writing zeroes here, we could trust the hardware
* to always provide zeroes when muted.
*/
if (read_and_process_successful == true && adev->mic_mute)
memset(buffer, 0, bytes);
exit:
pthread_mutex_unlock(&in->lock);
if (read_and_process_successful == false) {
in_standby(&in->stream.common);
ALOGV("%s: read failed - sleeping for buffer duration", __func__);
usleep(bytes * 1000000 / audio_stream_in_frame_size(stream) /
in->requested_rate);
}
return bytes;
}
static uint32_t in_get_input_frames_lost(struct audio_stream_in *stream)
{
(void)stream;
return 0;
}
static int add_remove_audio_effect(const struct audio_stream *stream,
effect_handle_t effect,
bool enable)
{
struct stream_in *in = (struct stream_in *)stream;
struct audio_device *adev = in->dev;
int status = 0;
effect_descriptor_t desc;
#ifdef PREPROCESSING_ENABLED
int i;
#endif
status = (*effect)->get_descriptor(effect, &desc);
if (status != 0)
return status;
ALOGI("add_remove_audio_effect(), effect type: %08x, enable: %d ", desc.type.timeLow, enable);
pthread_mutex_lock(&adev->lock_inputs);
lock_input_stream(in);
pthread_mutex_lock(&in->dev->lock);
#ifndef PREPROCESSING_ENABLED
if ((in->source == AUDIO_SOURCE_VOICE_COMMUNICATION) &&
in->enable_aec != enable &&
(memcmp(&desc.type, FX_IID_AEC, sizeof(effect_uuid_t)) == 0)) {
in->enable_aec = enable;
if (!in->standby)
select_devices(in->dev, in->usecase);
}
#else
if (enable) {
if (in->num_preprocessors >= MAX_PREPROCESSORS) {
status = -ENOSYS;
goto exit;
}
in->preprocessors[in->num_preprocessors].effect_itfe = effect;
in->num_preprocessors ++;
/* check compatibility between main channel supported and possible auxiliary channels */
in_update_aux_channels(in, effect);//wesley crash
in->aux_channels_changed = true;
} else {
/* if ( enable == false ) */
if (in->num_preprocessors <= 0) {
status = -ENOSYS;
goto exit;
}
status = -EINVAL;
for (i = 0; i < in->num_preprocessors && status != 0; i++) {
if ( in->preprocessors[i].effect_itfe == effect ) {
ALOGV("add_remove_audio_effect found fx at index %d", i);
free(in->preprocessors[i].channel_configs);
in->num_preprocessors--;
memcpy(in->preprocessors + i,
in->preprocessors + i + 1,
(in->num_preprocessors - i) * sizeof(in->preprocessors[0]));
memset(in->preprocessors + in->num_preprocessors,
0,
sizeof(in->preprocessors[0]));
status = 0;
}
}
if (status != 0)
goto exit;
in->aux_channels_changed = false;
ALOGV("%s: enable(%d), in->aux_channels_changed(%d)",
__func__, enable, in->aux_channels_changed);
}
ALOGI("%s: num_preprocessors = %d", __func__, in->num_preprocessors);
exit:
#endif
ALOGW_IF(status != 0, "add_remove_audio_effect() error %d", status);
pthread_mutex_unlock(&in->dev->lock);
pthread_mutex_unlock(&in->lock);
pthread_mutex_unlock(&adev->lock_inputs);
return status;
}
static int in_add_audio_effect(const struct audio_stream *stream,
effect_handle_t effect)
{
ALOGV("%s: effect %p", __func__, effect);
return add_remove_audio_effect(stream, effect, true /* enabled */);
}
static int in_remove_audio_effect(const struct audio_stream *stream,
effect_handle_t effect)
{
ALOGV("%s: effect %p", __func__, effect);
return add_remove_audio_effect(stream, effect, false /* disabled */);
}
static int adev_open_output_stream(struct audio_hw_device *dev,
audio_io_handle_t handle,
audio_devices_t devices,
audio_output_flags_t flags,
struct audio_config *config,
struct audio_stream_out **stream_out,
const char *address __unused)
{
struct audio_device *adev = (struct audio_device *)dev;
struct stream_out *out;
int i, ret;
struct pcm_device_profile *pcm_profile;
ALOGV("%s: enter: sample_rate(%d) channel_mask(%#x) devices(%#x) flags(%#x)",
__func__, config->sample_rate, config->channel_mask, devices, flags);
*stream_out = NULL;
out = (struct stream_out *)calloc(1, sizeof(struct stream_out));
if (devices == AUDIO_DEVICE_NONE)
devices = AUDIO_DEVICE_OUT_SPEAKER;
out->flags = flags;
out->devices = devices;
out->dev = adev;
out->format = config->format;
out->sample_rate = config->sample_rate;
out->channel_mask = AUDIO_CHANNEL_OUT_STEREO;
out->supported_channel_masks[0] = AUDIO_CHANNEL_OUT_STEREO;
out->handle = handle;
pcm_profile = get_pcm_device(PCM_PLAYBACK, devices);
if (pcm_profile == NULL) {
ret = -EINVAL;
goto error_open;
}
out->config = pcm_profile->config;
/* Init use case and pcm_config */
if (out->flags & (AUDIO_OUTPUT_FLAG_DEEP_BUFFER)) {
out->usecase = USECASE_AUDIO_PLAYBACK_DEEP_BUFFER;
out->config = pcm_config_deep_buffer;
out->sample_rate = out->config.rate;
ALOGV("%s: use AUDIO_PLAYBACK_DEEP_BUFFER",__func__);
} else {
out->usecase = USECASE_AUDIO_PLAYBACK;
out->sample_rate = out->config.rate;
}
if (flags & AUDIO_OUTPUT_FLAG_PRIMARY) {
if (adev->primary_output == NULL)
adev->primary_output = out;
else {
ALOGE("%s: Primary output is already opened", __func__);
ret = -EEXIST;
goto error_open;
}
}
/* Check if this usecase is already existing */
pthread_mutex_lock(&adev->lock);
if (get_usecase_from_id(adev, out->usecase) != NULL) {
ALOGE("%s: Usecase (%d) is already present", __func__, out->usecase);
pthread_mutex_unlock(&adev->lock);
ret = -EEXIST;
goto error_open;
}
pthread_mutex_unlock(&adev->lock);
out->stream.common.get_sample_rate = out_get_sample_rate;
out->stream.common.set_sample_rate = out_set_sample_rate;
out->stream.common.get_buffer_size = out_get_buffer_size;
out->stream.common.get_channels = out_get_channels;
out->stream.common.get_format = out_get_format;
out->stream.common.set_format = out_set_format;
out->stream.common.standby = out_standby;
out->stream.common.dump = out_dump;
out->stream.common.set_parameters = out_set_parameters;
out->stream.common.get_parameters = out_get_parameters;
out->stream.common.add_audio_effect = out_add_audio_effect;
out->stream.common.remove_audio_effect = out_remove_audio_effect;
out->stream.get_latency = out_get_latency;
out->stream.set_volume = out_set_volume;
out->stream.write = out_write;
out->stream.get_render_position = out_get_render_position;
out->stream.get_next_write_timestamp = out_get_next_write_timestamp;
out->stream.get_presentation_position = out_get_presentation_position;
out->standby = 1;
/* out->muted = false; by calloc() */
/* out->written = 0; by calloc() */
pthread_mutex_init(&out->lock, (const pthread_mutexattr_t *) NULL);
pthread_mutex_init(&out->pre_lock, (const pthread_mutexattr_t *) NULL);
pthread_cond_init(&out->cond, (const pthread_condattr_t *) NULL);
config->format = out->stream.common.get_format(&out->stream.common);
config->channel_mask = out->stream.common.get_channels(&out->stream.common);
config->sample_rate = out->stream.common.get_sample_rate(&out->stream.common);
*stream_out = &out->stream;
ALOGV("%s: exit", __func__);
return 0;
error_open:
free(out);
*stream_out = NULL;
ALOGV("%s: exit: ret %d", __func__, ret);
return ret;
}
static void adev_close_output_stream(struct audio_hw_device *dev,
struct audio_stream_out *stream)
{
struct stream_out *out = (struct stream_out *)stream;
struct audio_device *adev = out->dev;
(void)dev;
ALOGV("%s: enter", __func__);
out_standby(&stream->common);
pthread_cond_destroy(&out->cond);
pthread_mutex_destroy(&out->lock);
pthread_mutex_destroy(&out->pre_lock);
free(out->proc_buf_out);
free(stream);
ALOGV("%s: exit", __func__);
}
static int adev_set_parameters(struct audio_hw_device *dev, const char *kvpairs)
{
struct audio_device *adev = (struct audio_device *)dev;
struct str_parms *parms;
char *str;
char value[32];
int val;
int ret;
ALOGV("%s: enter: %s", __func__, kvpairs);
parms = str_parms_create_str(kvpairs);
ret = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_TTY_MODE, value, sizeof(value));
if (ret >= 0) {
int tty_mode;
if (strcmp(value, AUDIO_PARAMETER_VALUE_TTY_OFF) == 0)
tty_mode = TTY_MODE_OFF;
else if (strcmp(value, AUDIO_PARAMETER_VALUE_TTY_VCO) == 0)
tty_mode = TTY_MODE_VCO;
else if (strcmp(value, AUDIO_PARAMETER_VALUE_TTY_HCO) == 0)
tty_mode = TTY_MODE_HCO;
else if (strcmp(value, AUDIO_PARAMETER_VALUE_TTY_FULL) == 0)
tty_mode = TTY_MODE_FULL;
else
return -EINVAL;
pthread_mutex_lock(&adev->lock);
if (tty_mode != adev->tty_mode) {
adev->tty_mode = tty_mode;
if (adev->in_call)
select_devices(adev, USECASE_VOICE_CALL);
}
pthread_mutex_unlock(&adev->lock);
}
ret = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_BT_NREC, value, sizeof(value));
if (ret >= 0) {
/* When set to false, HAL should disable EC and NS
* But it is currently not supported.
*/
if (strcmp(value, AUDIO_PARAMETER_VALUE_ON) == 0)
adev->bluetooth_nrec = true;
else
adev->bluetooth_nrec = false;
}
ret = str_parms_get_str(parms, "screen_state", value, sizeof(value));
if (ret >= 0) {
if (strcmp(value, AUDIO_PARAMETER_VALUE_ON) == 0)
adev->screen_off = false;
else
adev->screen_off = true;
}
ret = str_parms_get_int(parms, "rotation", &val);
if (ret >= 0) {
bool reverse_speakers = false;
switch(val) {
/* Assume 0deg rotation means the front camera is up with the usb port
* on the lower left when the user is facing the screen. This assumption
* is device-specific, not platform-specific like this code.
*/
case 180:
reverse_speakers = true;
break;
case 0:
case 90:
case 270:
break;
default:
ALOGE("%s: unexpected rotation of %d", __func__, val);
}
pthread_mutex_lock(&adev->lock);
if (adev->speaker_lr_swap != reverse_speakers) {
adev->speaker_lr_swap = reverse_speakers;
struct mixer_card *mixer_card;
mixer_card = adev_get_mixer_for_card(adev, SOUND_CARD);
if (mixer_card)
audio_route_apply_and_update_path(mixer_card->audio_route,
reverse_speakers ? "speaker-lr-reverse" :
"speaker-lr-normal");
}
pthread_mutex_unlock(&adev->lock);
}
str_parms_destroy(parms);
ALOGV("%s: exit with code(%d)", __func__, ret);
return ret;
}
static char* adev_get_parameters(const struct audio_hw_device *dev,
const char *keys)
{
(void)dev;
(void)keys;
return strdup("");
}
static int adev_init_check(const struct audio_hw_device *dev)
{
(void)dev;
return 0;
}
static int adev_set_voice_volume(struct audio_hw_device *dev, float volume)
{
int ret = 0;
struct audio_device *adev = (struct audio_device *)dev;
pthread_mutex_lock(&adev->lock);
/* cache volume */
adev->voice_volume = volume;
ret = set_voice_volume_l(adev, adev->voice_volume);
pthread_mutex_unlock(&adev->lock);
return ret;
}
static int adev_set_master_volume(struct audio_hw_device *dev, float volume)
{
(void)dev;
(void)volume;
return -ENOSYS;
}
static int adev_get_master_volume(struct audio_hw_device *dev,
float *volume)
{
(void)dev;
(void)volume;
return -ENOSYS;
}
static int adev_set_master_mute(struct audio_hw_device *dev, bool muted)
{
(void)dev;
(void)muted;
return -ENOSYS;
}
static int adev_get_master_mute(struct audio_hw_device *dev, bool *muted)
{
(void)dev;
(void)muted;
return -ENOSYS;
}
static int adev_set_mode(struct audio_hw_device *dev, audio_mode_t mode)
{
struct audio_device *adev = (struct audio_device *)dev;
pthread_mutex_lock(&adev->lock);
if (adev->mode != mode) {
ALOGI("%s mode = %d", __func__, mode);
adev->mode = mode;
}
pthread_mutex_unlock(&adev->lock);
return 0;
}
static int adev_set_mic_mute(struct audio_hw_device *dev, bool state)
{
struct audio_device *adev = (struct audio_device *)dev;
int err = 0;
pthread_mutex_lock(&adev->lock);
adev->mic_mute = state;
if (adev->mode == AUDIO_MODE_IN_CALL) {
/* TODO */
}
pthread_mutex_unlock(&adev->lock);
return err;
}
static int adev_get_mic_mute(const struct audio_hw_device *dev, bool *state)
{
struct audio_device *adev = (struct audio_device *)dev;
*state = adev->mic_mute;
return 0;
}
static size_t adev_get_input_buffer_size(const struct audio_hw_device *dev,
const struct audio_config *config)
{
(void)dev;
/* NOTE: we default to built in mic which may cause a mismatch between what we
* report here and the actual buffer size
*/
return get_input_buffer_size(config->sample_rate,
config->format,
audio_channel_count_from_in_mask(config->channel_mask),
PCM_CAPTURE /* usecase_type */,
AUDIO_DEVICE_IN_BUILTIN_MIC);
}
static int adev_open_input_stream(struct audio_hw_device *dev,
audio_io_handle_t handle __unused,
audio_devices_t devices,
struct audio_config *config,
struct audio_stream_in **stream_in,
audio_input_flags_t flags,
const char *address __unused,
audio_source_t source)
{
struct audio_device *adev = (struct audio_device *)dev;
struct stream_in *in;
struct pcm_device_profile *pcm_profile;
ALOGV("%s: enter", __func__);
*stream_in = NULL;
if (check_input_parameters(config->sample_rate, config->format,
audio_channel_count_from_in_mask(config->channel_mask)) != 0)
return -EINVAL;
usecase_type_t usecase_type = (source == AUDIO_SOURCE_HOTWORD) ?
PCM_HOTWORD_STREAMING : PCM_CAPTURE;
pcm_profile = get_pcm_device(usecase_type, devices);
if (pcm_profile == NULL)
return -EINVAL;
in = (struct stream_in *)calloc(1, sizeof(struct stream_in));
in->stream.common.get_sample_rate = in_get_sample_rate;
in->stream.common.set_sample_rate = in_set_sample_rate;
in->stream.common.get_buffer_size = in_get_buffer_size;
in->stream.common.get_channels = in_get_channels;
in->stream.common.get_format = in_get_format;
in->stream.common.set_format = in_set_format;
in->stream.common.standby = in_standby;
in->stream.common.dump = in_dump;
in->stream.common.set_parameters = in_set_parameters;
in->stream.common.get_parameters = in_get_parameters;
in->stream.common.add_audio_effect = in_add_audio_effect;
in->stream.common.remove_audio_effect = in_remove_audio_effect;
in->stream.set_gain = in_set_gain;
in->stream.read = in_read;
in->stream.get_input_frames_lost = in_get_input_frames_lost;
in->devices = devices;
in->source = source;
in->dev = adev;
in->standby = 1;
in->main_channels = config->channel_mask;
in->requested_rate = config->sample_rate;
if (config->sample_rate != CAPTURE_DEFAULT_SAMPLING_RATE)
flags = flags & ~AUDIO_INPUT_FLAG_FAST;
in->input_flags = flags;
/* HW codec is limited to default channels. No need to update with
* requested channels */
in->config = pcm_profile->config;
/* Update config params with the requested sample rate and channels */
if (source == AUDIO_SOURCE_HOTWORD) {
in->usecase = USECASE_AUDIO_CAPTURE_HOTWORD;
} else {
in->usecase = USECASE_AUDIO_CAPTURE;
}
in->usecase_type = usecase_type;
pthread_mutex_init(&in->lock, (const pthread_mutexattr_t *) NULL);
pthread_mutex_init(&in->pre_lock, (const pthread_mutexattr_t *) NULL);
*stream_in = &in->stream;
ALOGV("%s: exit", __func__);
return 0;
}
static void adev_close_input_stream(struct audio_hw_device *dev,
struct audio_stream_in *stream)
{
struct audio_device *adev = (struct audio_device *)dev;
struct stream_in *in = (struct stream_in*)stream;
ALOGV("%s", __func__);
/* prevent concurrent out_set_parameters, or out_write from standby */
pthread_mutex_lock(&adev->lock_inputs);
in_standby_l(in);
pthread_mutex_destroy(&in->lock);
pthread_mutex_destroy(&in->pre_lock);
free(in->proc_buf_out);
#ifdef PREPROCESSING_ENABLED
int i;
for (i=0; i<in->num_preprocessors; i++) {
free(in->preprocessors[i].channel_configs);
}
if (in->read_buf) {
free(in->read_buf);
}
if (in->proc_buf_in) {
free(in->proc_buf_in);
}
if (in->resampler) {
release_resampler(in->resampler);
}
#endif
free(stream);
pthread_mutex_unlock(&adev->lock_inputs);
return;
}
static int adev_dump(const audio_hw_device_t *device, int fd)
{
(void)device;
(void)fd;
return 0;
}
static int adev_close(hw_device_t *device)
{
struct audio_device *adev = (struct audio_device *)device;
free(adev->snd_dev_ref_cnt);
free_mixer_list(adev);
free(device);
return 0;
}
static int adev_open(const hw_module_t *module, const char *name,
hw_device_t **device)
{
struct audio_device *adev;
int i, ret, retry_count;
ALOGV("%s: enter", __func__);
if (strcmp(name, AUDIO_HARDWARE_INTERFACE) != 0) return -EINVAL;
adev = calloc(1, sizeof(struct audio_device));
adev->device.common.tag = HARDWARE_DEVICE_TAG;
adev->device.common.version = AUDIO_DEVICE_API_VERSION_2_0;
adev->device.common.module = (struct hw_module_t *)module;
adev->device.common.close = adev_close;
adev->device.init_check = adev_init_check;
adev->device.set_voice_volume = adev_set_voice_volume;
adev->device.set_master_volume = adev_set_master_volume;
adev->device.get_master_volume = adev_get_master_volume;
adev->device.set_master_mute = adev_set_master_mute;
adev->device.get_master_mute = adev_get_master_mute;
adev->device.set_mode = adev_set_mode;
adev->device.set_mic_mute = adev_set_mic_mute;
adev->device.get_mic_mute = adev_get_mic_mute;
adev->device.set_parameters = adev_set_parameters;
adev->device.get_parameters = adev_get_parameters;
adev->device.get_input_buffer_size = adev_get_input_buffer_size;
adev->device.open_output_stream = adev_open_output_stream;
adev->device.close_output_stream = adev_close_output_stream;
adev->device.open_input_stream = adev_open_input_stream;
adev->device.close_input_stream = adev_close_input_stream;
adev->device.dump = adev_dump;
/* Set the default route before the PCM stream is opened */
adev->mode = AUDIO_MODE_NORMAL;
adev->active_input = NULL;
adev->primary_output = NULL;
adev->voice_volume = 1.0f;
adev->tty_mode = TTY_MODE_OFF;
adev->bluetooth_nrec = true;
adev->in_call = false;
/* adev->cur_hdmi_channels = 0; by calloc() */
adev->snd_dev_ref_cnt = calloc(SND_DEVICE_MAX, sizeof(int));
adev->dualmic_config = DUALMIC_CONFIG_NONE;
adev->ns_in_voice_rec = false;
list_init(&adev->usecase_list);
if (mixer_init(adev) != 0) {
free(adev->snd_dev_ref_cnt);
free(adev);
ALOGE("%s: Failed to init, aborting.", __func__);
*device = NULL;
return -EINVAL;
}
if (access(SOUND_TRIGGER_HAL_LIBRARY_PATH, R_OK) == 0) {
adev->sound_trigger_lib = dlopen(SOUND_TRIGGER_HAL_LIBRARY_PATH,
RTLD_NOW);
if (adev->sound_trigger_lib == NULL) {
ALOGE("%s: DLOPEN failed for %s", __func__,
SOUND_TRIGGER_HAL_LIBRARY_PATH);
} else {
ALOGV("%s: DLOPEN successful for %s", __func__,
SOUND_TRIGGER_HAL_LIBRARY_PATH);
adev->sound_trigger_open_for_streaming =
(int (*)(void))dlsym(adev->sound_trigger_lib,
"sound_trigger_open_for_streaming");
adev->sound_trigger_read_samples =
(size_t (*)(int, void *, size_t))dlsym(
adev->sound_trigger_lib,
"sound_trigger_read_samples");
adev->sound_trigger_close_for_streaming =
(int (*)(int))dlsym(
adev->sound_trigger_lib,
"sound_trigger_close_for_streaming");
if (!adev->sound_trigger_open_for_streaming ||
!adev->sound_trigger_read_samples ||
!adev->sound_trigger_close_for_streaming) {
ALOGE("%s: Error grabbing functions in %s", __func__,
SOUND_TRIGGER_HAL_LIBRARY_PATH);
adev->sound_trigger_open_for_streaming = 0;
adev->sound_trigger_read_samples = 0;
adev->sound_trigger_close_for_streaming = 0;
}
}
}
*device = &adev->device.common;
cras_dsp_init("/system/etc/cras/speakerdsp.ini");
ALOGV("%s: exit", __func__);
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 = "NVIDIA Tegra Audio HAL",
.author = "The Android Open Source Project",
.methods = &hal_module_methods,
},
};