Commit message: None
CVE: CVE-2017-0812
CWE: CWE-125
Vulnerability description: An elevation of privilege vulnerability in the Android media framework (audio hal). Product: Android. Versions: 7.0, 7.1.1, 7.1.2, 8.0. Android ID: A-62873231.

Project: Android

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;
}

Project: Android

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;
}

Project: Android

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__);
}

Project: Android

static int adev_dump(const audio_hw_device_t *device, int fd)
{
 (void)device;
 (void)fd;

 return 0;
}

Project: Android

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);
}

Project: Android

static int adev_get_master_mute(struct audio_hw_device *dev, bool *muted)
{
 (void)dev;
 (void)muted;

 return -ENOSYS;
}

Project: Android

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;
}

Project: Android

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;
}

Project: Android

static char* adev_get_parameters(const struct audio_hw_device *dev,
 const char *keys)
{
 (void)dev;
 (void)keys;

 return strdup("");
}

Project: Android

static int adev_init_check(const struct audio_hw_device *dev)
{
 (void)dev;

 return 0;
}

Project: Android

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;
}

Project: Android

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;
}

Project: Android

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;
}

Project: Android

static int adev_set_master_mute(struct audio_hw_device *dev, bool muted)
{
 (void)dev;
 (void)muted;

 return -ENOSYS;
}

Project: Android

static int adev_set_master_volume(struct audio_hw_device *dev, float volume)
{
 (void)dev;
 (void)volume;

 return -ENOSYS;
}

Project: Android

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;
}

Project: Android

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;
}

Project: Android

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);
}

Project: Android

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;
}

Project: Android

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;
}

Project: Android

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;
}

Project: Android

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;
}

Project: Android

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;
}

Project: Android

int edid_get_max_channels(struct audio_device *adev)
{
 int max_channels = 2;
 struct mixer_ctl *ctl;
 (void)adev;

 /* TODO */
 return max_channels;
}

Project: Android

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;
}

Project: Android

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);
 }
}

Project: Android

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;
}

Project: Android

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));

}

Project: Android

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;
}

Project: Android

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;
}

Project: Android

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;
}

Project: Android

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;
}

Project: Android

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;
}

Project: Android

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;
}

Project: Android

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;
}

Project: Android

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 */);
}

Project: Android

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;
}

Project: Android

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;
}

Project: Android

static int in_dump(const struct audio_stream *stream, int fd)
{
 (void)stream;
 (void)fd;

 return 0;
}

Project: Android

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;
}

Project: Android

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);
}

Project: Android

static uint32_t in_get_channels(const struct audio_stream *stream)
{
 struct stream_in *in = (struct stream_in *)stream;

 return in->main_channels;
}

Project: Android

static audio_format_t in_get_format(const struct audio_stream *stream)
{
 (void)stream;
 return AUDIO_FORMAT_PCM_16_BIT;
}

Project: Android

static uint32_t in_get_input_frames_lost(struct audio_stream_in *stream)
{
 (void)stream;

 return 0;
}

Project: Android

static char* in_get_parameters(const struct audio_stream *stream,
 const char *keys)
{
 (void)stream;
 (void)keys;

 return strdup("");
}

Project: Android

static uint32_t in_get_sample_rate(const struct audio_stream *stream)
{
 struct stream_in *in = (struct stream_in *)stream;

 return in->requested_rate;
}

Project: Android

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;
}

Project: Android

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;
}

Project: Android

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;
}

Project: Android

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 */);
}

Project: Android

static int in_set_format(struct audio_stream *stream, audio_format_t format)
{
 (void)stream;
 (void)format;

 return -ENOSYS;
}

Project: Android

static int in_set_gain(struct audio_stream_in *stream, float gain)
{
 (void)stream;
 (void)gain;

 return 0;
}

Project: Android

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;
}

Project: Android

static int in_set_sample_rate(struct audio_stream *stream, uint32_t rate)
{
 (void)stream;
 (void)rate;
 return -ENOSYS;
}

Project: Android

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;
}

Project: Android

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);
 }
}

Project: Android

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;
}

Project: Android

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);
}

Project: Android

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);
}

Project: Android

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;
}

Project: Android

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;
}

Project: Android

static int out_dump(const struct audio_stream *stream, int fd)
{
 (void)stream;
 (void)fd;

 return 0;
}

Project: Android

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);
}

Project: Android

static uint32_t out_get_channels(const struct audio_stream *stream)
{
 struct stream_out *out = (struct stream_out *)stream;

 return out->channel_mask;
}

Project: Android

static audio_format_t out_get_format(const struct audio_stream *stream)
{
 struct stream_out *out = (struct stream_out *)stream;

 return out->format;
}

Project: Android

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);
}

Project: Android

static int out_get_next_write_timestamp(const struct audio_stream_out *stream,
 int64_t *timestamp)
{
 (void)stream;
 (void)timestamp;
 return -EINVAL;
}

Project: Android

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;
}

Project: Android

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;
}

Project: Android

static int out_get_render_position(const struct audio_stream_out *stream,
 uint32_t *dsp_frames)
{
 (void)stream;
 *dsp_frames = 0;
 return -EINVAL;
}

Project: Android

static uint32_t out_get_sample_rate(const struct audio_stream *stream)
{
 struct stream_out *out = (struct stream_out *)stream;

 return out->sample_rate;
}

Project: Android

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;
}

Project: Android

static int out_set_format(struct audio_stream *stream, audio_format_t format)
{
 (void)stream;
 (void)format;
 return -ENOSYS;
}

Project: Android

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;
}

Project: Android

static int out_set_sample_rate(struct audio_stream *stream, uint32_t rate)
{
 (void)stream;
 (void)rate;
 return -ENOSYS;
}

Project: Android

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;
}

Project: Android

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;
}

Project: Android

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;
}

Project: Android

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;
}

Project: Android

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;
}

Project: Android

int64_t render_latency(audio_usecase_t usecase)
{
 (void)usecase;
 /* TODO */
 return 0;
}

Project: Android

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;
}

Project: Android

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;
}

Project: Android

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;
}

Project: Android

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;
}

Project: Android

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;
}

Project: Android

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;
}

Project: Android

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;
}

Project: Android

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;
}

Project: Android

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;
}

Project: Android

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;
}