hal/voice.c - LeafOS-Project/android_hardware_qcom_audio - Gitiles

 /*
  * Copyright (c) 2013-2014, The Linux Foundation. All rights reserved.
  * Not a contribution.
  *
  * Copyright (C) 2013 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 "voice"
 /*#define LOG_NDEBUG 0*/
 #define LOG_NDDEBUG 0

 #include <errno.h>
 #include <math.h>
 #include <cutils/log.h>
 #include <cutils/str_parms.h>

 #include "audio_hw.h"
 #include "voice.h"
 #include "voice_extn/voice_extn.h"
 #include "platform.h"
 #include "platform_api.h"
 #include "audio_extn.h"

 struct pcm_config pcm_config_voice_call = {
     .channels = 1,
     .rate = 8000,
     .period_size = 160,
     .period_count = 2,
     .format = PCM_FORMAT_S16_LE,
 };

 extern const char * const use_case_table[AUDIO_USECASE_MAX];

 static struct voice_session *voice_get_session_from_use_case(struct audio_device *adev,
                               audio_usecase_t usecase_id)
 {
     struct voice_session *session = NULL;
     int ret = 0;

     ret = voice_extn_get_session_from_use_case(adev, usecase_id, &session);
     if (ret == -ENOSYS) {
         session = &adev->voice.session[VOICE_SESS_IDX];
     }

     return session;
 }

 int stop_call(struct audio_device *adev, audio_usecase_t usecase_id)
 {
     int i, ret = 0;
     struct audio_usecase *uc_info;
     struct voice_session *session = NULL;

     ALOGD("%s: enter usecase:%s", __func__, use_case_table[usecase_id]);

     session = (struct voice_session *)voice_get_session_from_use_case(adev, usecase_id);
     session->state.current = CALL_INACTIVE;

     ret = platform_stop_voice_call(adev->platform, session->vsid);

     /* 1. Close the PCM devices */
     if (session->pcm_rx) {
         pcm_close(session->pcm_rx);
         session->pcm_rx = NULL;
     }
     if (session->pcm_tx) {
         pcm_close(session->pcm_tx);
         session->pcm_tx = NULL;
     }

     uc_info = get_usecase_from_list(adev, usecase_id);
     if (uc_info == NULL) {
         ALOGE("%s: Could not find the usecase (%d) in the list",
               __func__, usecase_id);
         return -EINVAL;
     }

     /* 2. Get and set stream specific mixer controls */
     disable_audio_route(adev, uc_info, true);

     /* 3. Disable the rx and tx devices */
     disable_snd_device(adev, uc_info->out_snd_device, false);
     disable_snd_device(adev, uc_info->in_snd_device, true);

     list_remove(&uc_info->list);
     free(uc_info);

     ALOGD("%s: exit: status(%d)", __func__, ret);
     return ret;
 }

 int start_call(struct audio_device *adev, audio_usecase_t usecase_id)
 {
     int i, ret = 0;
     struct audio_usecase *uc_info;
     int pcm_dev_rx_id, pcm_dev_tx_id;
     uint32_t sample_rate = 8000;
     struct voice_session *session = NULL;
     struct pcm_config voice_config = pcm_config_voice_call;

     ALOGD("%s: enter usecase:%s", __func__, use_case_table[usecase_id]);

     session = (struct voice_session *)voice_get_session_from_use_case(adev, usecase_id);
     uc_info = (struct audio_usecase *)calloc(1, sizeof(struct audio_usecase));
     uc_info->id = usecase_id;
     uc_info->type = VOICE_CALL;
     uc_info->stream.out = 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;

     list_add_tail(&adev->usecase_list, &uc_info->list);

     select_devices(adev, usecase_id);

     pcm_dev_rx_id = platform_get_pcm_device_id(uc_info->id, PCM_PLAYBACK);
     pcm_dev_tx_id = platform_get_pcm_device_id(uc_info->id, PCM_CAPTURE);

     if (pcm_dev_rx_id < 0 || pcm_dev_tx_id < 0) {
         ALOGE("%s: Invalid PCM devices (rx: %d tx: %d) for the usecase(%d)",
               __func__, pcm_dev_rx_id, pcm_dev_tx_id, uc_info->id);
         ret = -EIO;
         goto error_start_voice;
     }
     ret = platform_get_sample_rate(adev->platform, &sample_rate);
     if (ret < 0) {
         ALOGE("platform_get_sample_rate error %d\n", ret);
     } else {
         voice_config.rate = sample_rate;
     }
     ALOGD("voice_config.rate %d\n", voice_config.rate);

     ALOGV("%s: Opening PCM playback device card_id(%d) device_id(%d)",
           __func__, adev->snd_card, pcm_dev_rx_id);
     session->pcm_rx = pcm_open(adev->snd_card,
                                pcm_dev_rx_id,
                                PCM_OUT, &voice_config);
     if (session->pcm_rx && !pcm_is_ready(session->pcm_rx)) {
         ALOGE("%s: %s", __func__, pcm_get_error(session->pcm_rx));
         ret = -EIO;
         goto error_start_voice;
     }

     ALOGV("%s: Opening PCM capture device card_id(%d) device_id(%d)",
           __func__, adev->snd_card, pcm_dev_tx_id);
     session->pcm_tx = pcm_open(adev->snd_card,
                                pcm_dev_tx_id,
                                PCM_IN, &voice_config);
     if (session->pcm_tx && !pcm_is_ready(session->pcm_tx)) {
         ALOGE("%s: %s", __func__, pcm_get_error(session->pcm_tx));
         ret = -EIO;
         goto error_start_voice;
     }
     pcm_start(session->pcm_rx);
     pcm_start(session->pcm_tx);

     voice_set_volume(adev, adev->voice.volume);

     ret = platform_start_voice_call(adev->platform, session->vsid);
     if (ret < 0) {
         ALOGE("%s: platform_start_voice_call error %d\n", __func__, ret);
         goto error_start_voice;
     }

     session->state.current = CALL_ACTIVE;
     return 0;

 error_start_voice:
     stop_call(adev, usecase_id);

     ALOGD("%s: exit: status(%d)", __func__, ret);
     return ret;
 }

 bool voice_is_in_call(struct audio_device *adev)
 {
     bool in_call = false;
     int ret = 0;

     ret = voice_extn_is_in_call(adev, &in_call);
     if (ret == -ENOSYS) {
         in_call = (adev->voice.session[VOICE_SESS_IDX].state.current == CALL_ACTIVE) ? true : false;
     }

     return in_call;
 }

 uint32_t voice_get_active_session_id(struct audio_device *adev)
 {
     int ret = 0;
     uint32_t session_id;

     ret = voice_extn_get_active_session_id(adev, &session_id);
     if (ret == -ENOSYS) {
         session_id = VOICE_VSID;
     }
     return session_id;
 }

 int voice_check_and_set_incall_rec_usecase(struct audio_device *adev,
                                            struct stream_in *in)
 {
     int ret = 0;
     uint32_t session_id;
     int usecase_id;
     int rec_mode = INCALL_REC_NONE;

     if (voice_is_in_call(adev)) {
         switch (in->source) {
         case AUDIO_SOURCE_VOICE_UPLINK:
             if (audio_extn_compr_cap_enabled() &&
                 audio_extn_compr_cap_format_supported(in->config.format)) {
                 in->usecase = USECASE_INCALL_REC_UPLINK_COMPRESS;
             } else
                 in->usecase = USECASE_INCALL_REC_UPLINK;
             rec_mode = INCALL_REC_UPLINK;
             break;
         case AUDIO_SOURCE_VOICE_DOWNLINK:
             if (audio_extn_compr_cap_enabled() &&
                 audio_extn_compr_cap_format_supported(in->config.format)) {
                 in->usecase = USECASE_INCALL_REC_DOWNLINK_COMPRESS;
             } else
                 in->usecase = USECASE_INCALL_REC_DOWNLINK;
             rec_mode = INCALL_REC_DOWNLINK;
             break;
         case AUDIO_SOURCE_VOICE_CALL:
             if (audio_extn_compr_cap_enabled() &&
                 audio_extn_compr_cap_format_supported(in->config.format)) {
                 in->usecase = USECASE_INCALL_REC_UPLINK_AND_DOWNLINK_COMPRESS;
             } else
                 in->usecase = USECASE_INCALL_REC_UPLINK_AND_DOWNLINK;
             rec_mode = INCALL_REC_UPLINK_AND_DOWNLINK;
             break;
         default:
             ALOGV("%s: Source type %d doesnt match incall recording criteria",
                   __func__, in->source);
             return ret;
         }

         session_id = voice_get_active_session_id(adev);
         ret = platform_set_incall_recording_session_id(adev->platform,
                                                        session_id, rec_mode);
         ALOGV("%s: Update usecase to %d",__func__, in->usecase);
     } else {
         ALOGV("%s: voice call not active", __func__);
     }

     return ret;
 }

 int voice_check_and_stop_incall_rec_usecase(struct audio_device *adev,
                                             struct stream_in *in)
 {
     int ret = 0;

     if (in->source == AUDIO_SOURCE_VOICE_UPLINK ||
         in->source == AUDIO_SOURCE_VOICE_DOWNLINK ||
         in->source == AUDIO_SOURCE_VOICE_CALL) {
         ret = platform_stop_incall_recording_usecase(adev->platform);
         ALOGV("%s: Stop In-call recording", __func__);
     }

     return ret;
 }

 int voice_check_and_set_incall_music_usecase(struct audio_device *adev,
                                              struct stream_out *out)
 {
     int ret = 0;

     ret = voice_extn_check_and_set_incall_music_usecase(adev, out);
     if (ret == -ENOSYS) {
         /* Incall music delivery is used only for LCH call state */
         ret = -EINVAL;
     }

     return ret;
 }

 int voice_set_mic_mute(struct audio_device *adev, bool state)
 {
     int err = 0;

     adev->voice.mic_mute = state;
     if (adev->mode == AUDIO_MODE_IN_CALL)
         err = platform_set_mic_mute(adev->platform, state);
     if (adev->mode == AUDIO_MODE_IN_COMMUNICATION)
         err = voice_extn_compress_voip_set_mic_mute(adev, state);

     return err;
 }

 bool voice_get_mic_mute(struct audio_device *adev)
 {
     return adev->voice.mic_mute;
 }

 int voice_set_volume(struct audio_device *adev, float volume)
 {
     int vol, err = 0;

     adev->voice.volume = volume;
     if (adev->mode == AUDIO_MODE_IN_CALL) {
         if (volume < 0.0) {
             volume = 0.0;
         } else if (volume > 1.0) {
             volume = 1.0;
         }

         vol = lrint(volume * 100.0);

         // Voice volume levels from android are mapped to driver volume levels as follows.
         // 0 -> 5, 20 -> 4, 40 ->3, 60 -> 2, 80 -> 1, 100 -> 0
         // So adjust the volume to get the correct volume index in driver
         vol = 100 - vol;

         err = platform_set_voice_volume(adev->platform, vol);
     }
     if (adev->mode == AUDIO_MODE_IN_COMMUNICATION)
         err = voice_extn_compress_voip_set_volume(adev, volume);


     return err;
 }

 int voice_start_call(struct audio_device *adev)
 {
     int ret = 0;

     ret = voice_extn_start_call(adev);
     if (ret == -ENOSYS) {
         ret = start_call(adev, USECASE_VOICE_CALL);
     }

     return ret;
 }

 int voice_stop_call(struct audio_device *adev)
 {
     int ret = 0;

     ret = voice_extn_stop_call(adev);
     if (ret == -ENOSYS) {
         ret = stop_call(adev, USECASE_VOICE_CALL);
     }

     return ret;
 }

 void voice_get_parameters(struct audio_device *adev,
                           struct str_parms *query,
                           struct str_parms *reply)
 {
     voice_extn_get_parameters(adev, query, reply);
 }

 int voice_set_parameters(struct audio_device *adev, struct str_parms *parms)
 {
     char *str;
     char value[32];
     int val;
     int ret = 0, err;
     char *kv_pairs = str_parms_to_str(parms);

     ALOGV_IF(kv_pairs != NULL, "%s: enter: %s", __func__, kv_pairs);

     ret = voice_extn_set_parameters(adev, parms);
     if (ret != 0)
         goto done;

     ret = voice_extn_compress_voip_set_parameters(adev, parms);
     if (ret != 0)
         goto done;

     err = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_TTY_MODE, value, sizeof(value));
     if (err >= 0) {
         int tty_mode;
         str_parms_del(parms, AUDIO_PARAMETER_KEY_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 {
             ret = -EINVAL;
             goto done;
         }

         if (tty_mode != adev->voice.tty_mode) {
             adev->voice.tty_mode = tty_mode;
             adev->acdb_settings = (adev->acdb_settings & TTY_MODE_CLEAR) | tty_mode;
             if (voice_is_in_call(adev))
                voice_update_devices_for_all_voice_usecases(adev);
         }
     }

     err = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_INCALLMUSIC,
                             value, sizeof(value));
     if (err >= 0) {
         str_parms_del(parms, AUDIO_PARAMETER_KEY_INCALLMUSIC);
         if (strcmp(value, AUDIO_PARAMETER_VALUE_TRUE) == 0)
             platform_start_incall_music_usecase(adev->platform);
         else
             platform_stop_incall_music_usecase(adev->platform);
      }

 done:
     ALOGV("%s: exit with code(%d)", __func__, ret);
     free(kv_pairs);
     return ret;
 }

 void voice_init(struct audio_device *adev)
 {
     int i = 0;

     memset(&adev->voice, 0, sizeof(adev->voice));
     adev->voice.tty_mode = TTY_MODE_OFF;
     adev->voice.volume = 1.0f;
     adev->voice.mic_mute = false;
     adev->voice.voice_device_set = false;
     for (i = 0; i < MAX_VOICE_SESSIONS; i++) {
         adev->voice.session[i].pcm_rx = NULL;
         adev->voice.session[i].pcm_tx = NULL;
         adev->voice.session[i].state.current = CALL_INACTIVE;
         adev->voice.session[i].state.new = CALL_INACTIVE;
         adev->voice.session[i].vsid = 0;
     }

     voice_extn_init(adev);
 }

 void voice_update_devices_for_all_voice_usecases(struct audio_device *adev)
 {
     struct listnode *node;
     struct audio_usecase *usecase;

     list_for_each(node, &adev->usecase_list) {
         usecase = node_to_item(node, struct audio_usecase, list);
         if (usecase->type == VOICE_CALL) {
             ALOGV("%s: updating device for usecase:%s", __func__,
                   use_case_table[usecase->id]);
             select_devices(adev, usecase->id);
         }
     }
 }
	/*
	* Copyright (c) 2013-2014, The Linux Foundation. All rights reserved.
	* Not a contribution.
	*
	* Copyright (C) 2013 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 "voice"
	/#define LOG_NDEBUG 0/
	#define LOG_NDDEBUG 0

	#include <errno.h>
	#include <math.h>
	#include <cutils/log.h>
	#include <cutils/str_parms.h>

	#include "audio_hw.h"
	#include "voice.h"
	#include "voice_extn/voice_extn.h"
	#include "platform.h"
	#include "platform_api.h"
	#include "audio_extn.h"

	struct pcm_config pcm_config_voice_call = {
	.channels = 1,
	.rate = 8000,
	.period_size = 160,
	.period_count = 2,
	.format = PCM_FORMAT_S16_LE,
	};

	extern const char * const use_case_table[AUDIO_USECASE_MAX];

	static struct voice_session voice_get_session_from_use_case(struct audio_device adev,
	audio_usecase_t usecase_id)
	{
	struct voice_session *session = NULL;
	int ret = 0;

	ret = voice_extn_get_session_from_use_case(adev, usecase_id, &session);
	if (ret == -ENOSYS) {
	session = &adev->voice.session[VOICE_SESS_IDX];
	}

	return session;
	}

	int stop_call(struct audio_device *adev, audio_usecase_t usecase_id)
	{
	int i, ret = 0;
	struct audio_usecase *uc_info;
	struct voice_session *session = NULL;

	ALOGD("%s: enter usecase:%s", __func__, use_case_table[usecase_id]);

	session = (struct voice_session *)voice_get_session_from_use_case(adev, usecase_id);
	session->state.current = CALL_INACTIVE;

	ret = platform_stop_voice_call(adev->platform, session->vsid);

	/* 1. Close the PCM devices */
	if (session->pcm_rx) {
	pcm_close(session->pcm_rx);
	session->pcm_rx = NULL;
	}
	if (session->pcm_tx) {
	pcm_close(session->pcm_tx);
	session->pcm_tx = NULL;
	}

	uc_info = get_usecase_from_list(adev, usecase_id);
	if (uc_info == NULL) {
	ALOGE("%s: Could not find the usecase (%d) in the list",
	__func__, usecase_id);
	return -EINVAL;
	}

	/* 2. Get and set stream specific mixer controls */
	disable_audio_route(adev, uc_info, true);

	/* 3. Disable the rx and tx devices */
	disable_snd_device(adev, uc_info->out_snd_device, false);
	disable_snd_device(adev, uc_info->in_snd_device, true);

	list_remove(&uc_info->list);
	free(uc_info);

	ALOGD("%s: exit: status(%d)", __func__, ret);
	return ret;
	}

	int start_call(struct audio_device *adev, audio_usecase_t usecase_id)
	{
	int i, ret = 0;
	struct audio_usecase *uc_info;
	int pcm_dev_rx_id, pcm_dev_tx_id;
	uint32_t sample_rate = 8000;
	struct voice_session *session = NULL;
	struct pcm_config voice_config = pcm_config_voice_call;

	ALOGD("%s: enter usecase:%s", __func__, use_case_table[usecase_id]);

	session = (struct voice_session *)voice_get_session_from_use_case(adev, usecase_id);
	uc_info = (struct audio_usecase *)calloc(1, sizeof(struct audio_usecase));
	uc_info->id = usecase_id;
	uc_info->type = VOICE_CALL;
	uc_info->stream.out = 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;

	list_add_tail(&adev->usecase_list, &uc_info->list);

	select_devices(adev, usecase_id);

	pcm_dev_rx_id = platform_get_pcm_device_id(uc_info->id, PCM_PLAYBACK);
	pcm_dev_tx_id = platform_get_pcm_device_id(uc_info->id, PCM_CAPTURE);

	if (pcm_dev_rx_id < 0 \|\| pcm_dev_tx_id < 0) {
	ALOGE("%s: Invalid PCM devices (rx: %d tx: %d) for the usecase(%d)",
	__func__, pcm_dev_rx_id, pcm_dev_tx_id, uc_info->id);
	ret = -EIO;
	goto error_start_voice;
	}
	ret = platform_get_sample_rate(adev->platform, &sample_rate);
	if (ret < 0) {
	ALOGE("platform_get_sample_rate error %d\n", ret);
	} else {
	voice_config.rate = sample_rate;
	}
	ALOGD("voice_config.rate %d\n", voice_config.rate);

	ALOGV("%s: Opening PCM playback device card_id(%d) device_id(%d)",
	__func__, adev->snd_card, pcm_dev_rx_id);
	session->pcm_rx = pcm_open(adev->snd_card,
	pcm_dev_rx_id,
	PCM_OUT, &voice_config);
	if (session->pcm_rx && !pcm_is_ready(session->pcm_rx)) {
	ALOGE("%s: %s", __func__, pcm_get_error(session->pcm_rx));
	ret = -EIO;
	goto error_start_voice;
	}

	ALOGV("%s: Opening PCM capture device card_id(%d) device_id(%d)",
	__func__, adev->snd_card, pcm_dev_tx_id);
	session->pcm_tx = pcm_open(adev->snd_card,
	pcm_dev_tx_id,
	PCM_IN, &voice_config);
	if (session->pcm_tx && !pcm_is_ready(session->pcm_tx)) {
	ALOGE("%s: %s", __func__, pcm_get_error(session->pcm_tx));
	ret = -EIO;
	goto error_start_voice;
	}
	pcm_start(session->pcm_rx);
	pcm_start(session->pcm_tx);

	voice_set_volume(adev, adev->voice.volume);

	ret = platform_start_voice_call(adev->platform, session->vsid);
	if (ret < 0) {
	ALOGE("%s: platform_start_voice_call error %d\n", __func__, ret);
	goto error_start_voice;
	}

	session->state.current = CALL_ACTIVE;
	return 0;

	error_start_voice:
	stop_call(adev, usecase_id);

	ALOGD("%s: exit: status(%d)", __func__, ret);
	return ret;
	}

	bool voice_is_in_call(struct audio_device *adev)
	{
	bool in_call = false;
	int ret = 0;

	ret = voice_extn_is_in_call(adev, &in_call);
	if (ret == -ENOSYS) {
	in_call = (adev->voice.session[VOICE_SESS_IDX].state.current == CALL_ACTIVE) ? true : false;
	}

	return in_call;
	}

	uint32_t voice_get_active_session_id(struct audio_device *adev)
	{
	int ret = 0;
	uint32_t session_id;

	ret = voice_extn_get_active_session_id(adev, &session_id);
	if (ret == -ENOSYS) {
	session_id = VOICE_VSID;
	}
	return session_id;
	}

	int voice_check_and_set_incall_rec_usecase(struct audio_device *adev,
	struct stream_in *in)
	{
	int ret = 0;
	uint32_t session_id;
	int usecase_id;
	int rec_mode = INCALL_REC_NONE;

	if (voice_is_in_call(adev)) {
	switch (in->source) {
	case AUDIO_SOURCE_VOICE_UPLINK:
	if (audio_extn_compr_cap_enabled() &&
	audio_extn_compr_cap_format_supported(in->config.format)) {
	in->usecase = USECASE_INCALL_REC_UPLINK_COMPRESS;
	} else
	in->usecase = USECASE_INCALL_REC_UPLINK;
	rec_mode = INCALL_REC_UPLINK;
	break;
	case AUDIO_SOURCE_VOICE_DOWNLINK:
	if (audio_extn_compr_cap_enabled() &&
	audio_extn_compr_cap_format_supported(in->config.format)) {
	in->usecase = USECASE_INCALL_REC_DOWNLINK_COMPRESS;
	} else
	in->usecase = USECASE_INCALL_REC_DOWNLINK;
	rec_mode = INCALL_REC_DOWNLINK;
	break;
	case AUDIO_SOURCE_VOICE_CALL:
	if (audio_extn_compr_cap_enabled() &&
	audio_extn_compr_cap_format_supported(in->config.format)) {
	in->usecase = USECASE_INCALL_REC_UPLINK_AND_DOWNLINK_COMPRESS;
	} else
	in->usecase = USECASE_INCALL_REC_UPLINK_AND_DOWNLINK;
	rec_mode = INCALL_REC_UPLINK_AND_DOWNLINK;
	break;
	default:
	ALOGV("%s: Source type %d doesnt match incall recording criteria",
	__func__, in->source);
	return ret;
	}

	session_id = voice_get_active_session_id(adev);
	ret = platform_set_incall_recording_session_id(adev->platform,
	session_id, rec_mode);
	ALOGV("%s: Update usecase to %d",__func__, in->usecase);
	} else {
	ALOGV("%s: voice call not active", __func__);
	}

	return ret;
	}

	int voice_check_and_stop_incall_rec_usecase(struct audio_device *adev,
	struct stream_in *in)
	{
	int ret = 0;

	if (in->source == AUDIO_SOURCE_VOICE_UPLINK \|\|
	in->source == AUDIO_SOURCE_VOICE_DOWNLINK \|\|
	in->source == AUDIO_SOURCE_VOICE_CALL) {
	ret = platform_stop_incall_recording_usecase(adev->platform);
	ALOGV("%s: Stop In-call recording", __func__);
	}

	return ret;
	}

	int voice_check_and_set_incall_music_usecase(struct audio_device *adev,
	struct stream_out *out)
	{
	int ret = 0;

	ret = voice_extn_check_and_set_incall_music_usecase(adev, out);
	if (ret == -ENOSYS) {
	/* Incall music delivery is used only for LCH call state */
	ret = -EINVAL;
	}

	return ret;
	}

	int voice_set_mic_mute(struct audio_device *adev, bool state)
	{
	int err = 0;

	adev->voice.mic_mute = state;
	if (adev->mode == AUDIO_MODE_IN_CALL)
	err = platform_set_mic_mute(adev->platform, state);
	if (adev->mode == AUDIO_MODE_IN_COMMUNICATION)
	err = voice_extn_compress_voip_set_mic_mute(adev, state);

	return err;
	}

	bool voice_get_mic_mute(struct audio_device *adev)
	{
	return adev->voice.mic_mute;
	}

	int voice_set_volume(struct audio_device *adev, float volume)
	{
	int vol, err = 0;

	adev->voice.volume = volume;
	if (adev->mode == AUDIO_MODE_IN_CALL) {
	if (volume < 0.0) {
	volume = 0.0;
	} else if (volume > 1.0) {
	volume = 1.0;
	}

	vol = lrint(volume * 100.0);

	// Voice volume levels from android are mapped to driver volume levels as follows.
	// 0 -> 5, 20 -> 4, 40 ->3, 60 -> 2, 80 -> 1, 100 -> 0
	// So adjust the volume to get the correct volume index in driver
	vol = 100 - vol;

	err = platform_set_voice_volume(adev->platform, vol);
	}
	if (adev->mode == AUDIO_MODE_IN_COMMUNICATION)
	err = voice_extn_compress_voip_set_volume(adev, volume);


	return err;
	}

	int voice_start_call(struct audio_device *adev)
	{
	int ret = 0;

	ret = voice_extn_start_call(adev);
	if (ret == -ENOSYS) {
	ret = start_call(adev, USECASE_VOICE_CALL);
	}

	return ret;
	}

	int voice_stop_call(struct audio_device *adev)
	{
	int ret = 0;

	ret = voice_extn_stop_call(adev);
	if (ret == -ENOSYS) {
	ret = stop_call(adev, USECASE_VOICE_CALL);
	}

	return ret;
	}

	void voice_get_parameters(struct audio_device *adev,
	struct str_parms *query,
	struct str_parms *reply)
	{
	voice_extn_get_parameters(adev, query, reply);
	}

	int voice_set_parameters(struct audio_device adev, struct str_parms parms)
	{
	char *str;
	char value[32];
	int val;
	int ret = 0, err;
	char *kv_pairs = str_parms_to_str(parms);

	ALOGV_IF(kv_pairs != NULL, "%s: enter: %s", __func__, kv_pairs);

	ret = voice_extn_set_parameters(adev, parms);
	if (ret != 0)
	goto done;

	ret = voice_extn_compress_voip_set_parameters(adev, parms);
	if (ret != 0)
	goto done;

	err = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_TTY_MODE, value, sizeof(value));
	if (err >= 0) {
	int tty_mode;
	str_parms_del(parms, AUDIO_PARAMETER_KEY_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 {
	ret = -EINVAL;
	goto done;
	}

	if (tty_mode != adev->voice.tty_mode) {
	adev->voice.tty_mode = tty_mode;
	adev->acdb_settings = (adev->acdb_settings & TTY_MODE_CLEAR) \| tty_mode;
	if (voice_is_in_call(adev))
	voice_update_devices_for_all_voice_usecases(adev);
	}
	}

	err = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_INCALLMUSIC,
	value, sizeof(value));
	if (err >= 0) {
	str_parms_del(parms, AUDIO_PARAMETER_KEY_INCALLMUSIC);
	if (strcmp(value, AUDIO_PARAMETER_VALUE_TRUE) == 0)
	platform_start_incall_music_usecase(adev->platform);
	else
	platform_stop_incall_music_usecase(adev->platform);
	}

	done:
	ALOGV("%s: exit with code(%d)", __func__, ret);
	free(kv_pairs);
	return ret;
	}

	void voice_init(struct audio_device *adev)
	{
	int i = 0;

	memset(&adev->voice, 0, sizeof(adev->voice));
	adev->voice.tty_mode = TTY_MODE_OFF;
	adev->voice.volume = 1.0f;
	adev->voice.mic_mute = false;
	adev->voice.voice_device_set = false;
	for (i = 0; i < MAX_VOICE_SESSIONS; i++) {
	adev->voice.session[i].pcm_rx = NULL;
	adev->voice.session[i].pcm_tx = NULL;
	adev->voice.session[i].state.current = CALL_INACTIVE;
	adev->voice.session[i].state.new = CALL_INACTIVE;
	adev->voice.session[i].vsid = 0;
	}

	voice_extn_init(adev);
	}

	void voice_update_devices_for_all_voice_usecases(struct audio_device *adev)
	{
	struct listnode *node;
	struct audio_usecase *usecase;

	list_for_each(node, &adev->usecase_list) {
	usecase = node_to_item(node, struct audio_usecase, list);
	if (usecase->type == VOICE_CALL) {
	ALOGV("%s: updating device for usecase:%s", __func__,
	use_case_table[usecase->id]);
	select_devices(adev, usecase->id);
	}
	}
	}