1 /*
2  * Copyright (C) 2014 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 #define LOG_TAG "voice"
18 /*#define LOG_NDEBUG 0*/
19 #define LOG_NDDEBUG 0
20 
21 #include <errno.h>
22 #include <math.h>
23 #include <cutils/log.h>
24 #include <cutils/str_parms.h>
25 
26 #include "audio_hw.h"
27 #include "voice.h"
28 #include "voice_extn/voice_extn.h"
29 #include "platform.h"
30 #include "platform_api.h"
31 
32 struct pcm_config pcm_config_voice_call = {
33     .channels = 1,
34     .rate = 8000,
35     .period_size = 160,
36     .period_count = 2,
37     .format = PCM_FORMAT_S16_LE,
38 };
39 
voice_get_session_from_use_case(struct audio_device * adev,audio_usecase_t usecase_id)40 static struct voice_session *voice_get_session_from_use_case(struct audio_device *adev,
41                               audio_usecase_t usecase_id)
42 {
43     struct voice_session *session = NULL;
44     int ret = 0;
45 
46     ret = voice_extn_get_session_from_use_case(adev, usecase_id, &session);
47     if (ret == -ENOSYS) {
48         session = &adev->voice.session[VOICE_SESS_IDX];
49     }
50 
51     return session;
52 }
53 
voice_stop_usecase(struct audio_device * adev,audio_usecase_t usecase_id)54 int voice_stop_usecase(struct audio_device *adev, audio_usecase_t usecase_id)
55 {
56     int i, ret = 0;
57     struct audio_usecase *uc_info;
58     struct voice_session *session = NULL;
59 
60     ALOGD("%s: enter usecase:%s", __func__, use_case_table[usecase_id]);
61 
62     session = (struct voice_session *)voice_get_session_from_use_case(adev, usecase_id);
63     session->state.current = CALL_INACTIVE;
64 
65     ret = platform_stop_voice_call(adev->platform, session->vsid);
66 
67     /* 1. Close the PCM devices */
68     if (session->pcm_rx) {
69         pcm_close(session->pcm_rx);
70         session->pcm_rx = NULL;
71     }
72     if (session->pcm_tx) {
73         pcm_close(session->pcm_tx);
74         session->pcm_tx = NULL;
75     }
76 
77     uc_info = get_usecase_from_list(adev, usecase_id);
78     if (uc_info == NULL) {
79         ALOGE("%s: Could not find the usecase (%d) in the list",
80               __func__, usecase_id);
81         return -EINVAL;
82     }
83 
84     /* 2. Get and set stream specific mixer controls */
85     disable_audio_route(adev, uc_info);
86 
87     /* 3. Disable the rx and tx devices */
88     disable_snd_device(adev, uc_info->out_snd_device);
89     disable_snd_device(adev, uc_info->in_snd_device);
90 
91     list_remove(&uc_info->list);
92     free(uc_info);
93 
94     ALOGD("%s: exit: status(%d)", __func__, ret);
95     return ret;
96 }
97 
voice_start_usecase(struct audio_device * adev,audio_usecase_t usecase_id)98 int voice_start_usecase(struct audio_device *adev, audio_usecase_t usecase_id)
99 {
100     int i, ret = 0;
101     struct audio_usecase *uc_info;
102     int pcm_dev_rx_id, pcm_dev_tx_id;
103     struct voice_session *session = NULL;
104     struct pcm_config voice_config = pcm_config_voice_call;
105 
106     ALOGD("%s: enter usecase:%s", __func__, use_case_table[usecase_id]);
107 
108     session = (struct voice_session *)voice_get_session_from_use_case(adev, usecase_id);
109     uc_info = (struct audio_usecase *)calloc(1, sizeof(struct audio_usecase));
110     uc_info->id = usecase_id;
111     uc_info->type = VOICE_CALL;
112     uc_info->stream.out = adev->current_call_output ;
113     uc_info->devices = adev->current_call_output ->devices;
114     uc_info->in_snd_device = SND_DEVICE_NONE;
115     uc_info->out_snd_device = SND_DEVICE_NONE;
116 
117     list_add_tail(&adev->usecase_list, &uc_info->list);
118 
119     select_devices(adev, usecase_id);
120 
121     pcm_dev_rx_id = platform_get_pcm_device_id(uc_info->id, PCM_PLAYBACK);
122     pcm_dev_tx_id = platform_get_pcm_device_id(uc_info->id, PCM_CAPTURE);
123 
124     if (pcm_dev_rx_id < 0 || pcm_dev_tx_id < 0) {
125         ALOGE("%s: Invalid PCM devices (rx: %d tx: %d) for the usecase(%d)",
126               __func__, pcm_dev_rx_id, pcm_dev_tx_id, uc_info->id);
127         ret = -EIO;
128         goto error_start_voice;
129     }
130 
131     ALOGV("%s: Opening PCM playback device card_id(%d) device_id(%d)",
132           __func__, adev->snd_card, pcm_dev_rx_id);
133     session->pcm_rx = pcm_open(adev->snd_card,
134                                pcm_dev_rx_id,
135                                PCM_OUT, &voice_config);
136     if (session->pcm_rx && !pcm_is_ready(session->pcm_rx)) {
137         ALOGE("%s: %s", __func__, pcm_get_error(session->pcm_rx));
138         ret = -EIO;
139         goto error_start_voice;
140     }
141 
142     ALOGV("%s: Opening PCM capture device card_id(%d) device_id(%d)",
143           __func__, adev->snd_card, pcm_dev_tx_id);
144     session->pcm_tx = pcm_open(adev->snd_card,
145                                pcm_dev_tx_id,
146                                PCM_IN, &voice_config);
147     if (session->pcm_tx && !pcm_is_ready(session->pcm_tx)) {
148         ALOGE("%s: %s", __func__, pcm_get_error(session->pcm_tx));
149         ret = -EIO;
150         goto error_start_voice;
151     }
152     pcm_start(session->pcm_rx);
153     pcm_start(session->pcm_tx);
154 
155     voice_set_volume(adev, adev->voice.volume);
156 
157     ret = platform_start_voice_call(adev->platform, session->vsid);
158     if (ret < 0) {
159         ALOGE("%s: platform_start_voice_call error %d\n", __func__, ret);
160         goto error_start_voice;
161     }
162 
163     session->state.current = CALL_ACTIVE;
164     goto done;
165 
166 error_start_voice:
167     voice_stop_usecase(adev, usecase_id);
168 
169 done:
170     ALOGD("%s: exit: status(%d)", __func__, ret);
171     return ret;
172 }
173 
voice_is_call_state_active(struct audio_device * adev)174 bool voice_is_call_state_active(struct audio_device *adev)
175 {
176     bool call_state = false;
177     int ret = 0;
178 
179     ret = voice_extn_is_call_state_active(adev, &call_state);
180     if (ret == -ENOSYS) {
181         call_state = (adev->voice.session[VOICE_SESS_IDX].state.current == CALL_ACTIVE) ? true : false;
182     }
183 
184     return call_state;
185 }
186 
voice_is_in_call(struct audio_device * adev)187 bool voice_is_in_call(struct audio_device *adev)
188 {
189     return adev->voice.in_call;
190 }
191 
voice_is_in_call_rec_stream(struct stream_in * in)192 bool voice_is_in_call_rec_stream(struct stream_in *in)
193 {
194     bool in_call_rec = false;
195     int ret = 0;
196 
197     ret = voice_extn_is_in_call_rec_stream(in, &in_call_rec);
198     if (ret == -ENOSYS) {
199         in_call_rec = false;
200     }
201 
202     return in_call_rec;
203 }
204 
voice_get_active_session_id(struct audio_device * adev)205 uint32_t voice_get_active_session_id(struct audio_device *adev)
206 {
207     int ret = 0;
208     uint32_t session_id;
209 
210     ret = voice_extn_get_active_session_id(adev, &session_id);
211     if (ret == -ENOSYS) {
212         session_id = VOICE_VSID;
213     }
214     return session_id;
215 }
216 
voice_check_and_set_incall_rec_usecase(struct audio_device * adev,struct stream_in * in)217 int voice_check_and_set_incall_rec_usecase(struct audio_device *adev,
218                                            struct stream_in *in)
219 {
220     int ret = 0;
221     uint32_t session_id;
222     int usecase_id;
223     int rec_mode = INCALL_REC_NONE;
224 
225     if (voice_is_call_state_active(adev)) {
226         switch (in->source) {
227         case AUDIO_SOURCE_VOICE_UPLINK:
228             in->usecase = USECASE_INCALL_REC_UPLINK;
229             rec_mode = INCALL_REC_UPLINK;
230             break;
231         case AUDIO_SOURCE_VOICE_DOWNLINK:
232             in->usecase = USECASE_INCALL_REC_DOWNLINK;
233             rec_mode = INCALL_REC_DOWNLINK;
234             break;
235         case AUDIO_SOURCE_VOICE_CALL:
236             in->usecase = USECASE_INCALL_REC_UPLINK_AND_DOWNLINK;
237             rec_mode = INCALL_REC_UPLINK_AND_DOWNLINK;
238             break;
239         default:
240             ALOGV("%s: Source type %d doesnt match incall recording criteria",
241                   __func__, in->source);
242             return ret;
243         }
244 
245         session_id = voice_get_active_session_id(adev);
246         ret = platform_set_incall_recording_session_id(adev->platform,
247                                                        session_id, rec_mode);
248         ALOGV("%s: Update usecase to %d",__func__, in->usecase);
249     } else {
250         ALOGV("%s: voice call not active", __func__);
251     }
252 
253     return ret;
254 }
255 
voice_check_and_stop_incall_rec_usecase(struct audio_device * adev,struct stream_in * in)256 int voice_check_and_stop_incall_rec_usecase(struct audio_device *adev,
257                                             struct stream_in *in)
258 {
259     int ret = 0;
260 
261     if (in->source == AUDIO_SOURCE_VOICE_UPLINK ||
262         in->source == AUDIO_SOURCE_VOICE_DOWNLINK ||
263         in->source == AUDIO_SOURCE_VOICE_CALL) {
264         ret = platform_stop_incall_recording_usecase(adev->platform);
265         ALOGV("%s: Stop In-call recording", __func__);
266     }
267 
268     return ret;
269 }
270 
voice_check_and_set_incall_music_usecase(struct audio_device * adev,struct stream_out * out)271 int voice_check_and_set_incall_music_usecase(struct audio_device *adev,
272                                              struct stream_out *out)
273 {
274     int ret = 0;
275 
276     ret = voice_extn_check_and_set_incall_music_usecase(adev, out);
277     if (ret == -ENOSYS) {
278         /* Incall music delivery is used only for LCH call state */
279         ret = -EINVAL;
280     }
281 
282     return ret;
283 }
284 
voice_set_mic_mute(struct audio_device * adev,bool state)285 int voice_set_mic_mute(struct audio_device *adev, bool state)
286 {
287     int err = 0;
288 
289     adev->voice.mic_mute = state;
290     if (adev->mode == AUDIO_MODE_IN_CALL)
291         err = platform_set_mic_mute(adev->platform, state);
292 
293     return err;
294 }
295 
voice_get_mic_mute(struct audio_device * adev)296 bool voice_get_mic_mute(struct audio_device *adev)
297 {
298     return adev->voice.mic_mute;
299 }
300 
voice_set_volume(struct audio_device * adev,float volume)301 int voice_set_volume(struct audio_device *adev, float volume)
302 {
303     int vol, err = 0;
304 
305     adev->voice.volume = volume;
306     if (adev->mode == AUDIO_MODE_IN_CALL) {
307         if (volume < 0.0) {
308             volume = 0.0;
309         } else if (volume > 1.0) {
310             volume = 1.0;
311         }
312 
313         vol = lrint(volume * 100.0);
314 
315         // Voice volume levels from android are mapped to driver volume levels as follows.
316         // 0 -> 5, 20 -> 4, 40 ->3, 60 -> 2, 80 -> 1, 100 -> 0
317         // So adjust the volume to get the correct volume index in driver
318         vol = 100 - vol;
319 
320         err = platform_set_voice_volume(adev->platform, vol);
321     }
322 
323     return err;
324 }
325 
voice_start_call(struct audio_device * adev)326 int voice_start_call(struct audio_device *adev)
327 {
328     int ret = 0;
329 
330     adev->voice.in_call = true;
331     ret = voice_extn_start_call(adev);
332     if (ret == -ENOSYS) {
333         ret = voice_start_usecase(adev, USECASE_VOICE_CALL);
334     }
335 
336     return ret;
337 }
338 
voice_stop_call(struct audio_device * adev)339 int voice_stop_call(struct audio_device *adev)
340 {
341     int ret = 0;
342 
343     adev->voice.in_call = false;
344     ret = voice_extn_stop_call(adev);
345     if (ret == -ENOSYS) {
346         ret = voice_stop_usecase(adev, USECASE_VOICE_CALL);
347     }
348 
349     return ret;
350 }
351 
voice_get_parameters(struct audio_device * adev,struct str_parms * query,struct str_parms * reply)352 void voice_get_parameters(struct audio_device *adev,
353                           struct str_parms *query,
354                           struct str_parms *reply)
355 {
356     voice_extn_get_parameters(adev, query, reply);
357 }
358 
voice_set_parameters(struct audio_device * adev,struct str_parms * parms)359 int voice_set_parameters(struct audio_device *adev, struct str_parms *parms)
360 {
361     char *str;
362     char value[32];
363     int val;
364     int ret = 0, err;
365     char *kv_pairs = str_parms_to_str(parms);
366 
367     ALOGV_IF(kv_pairs != NULL, "%s: enter: %s", __func__, kv_pairs);
368 
369     ret = voice_extn_set_parameters(adev, parms);
370     if (ret != 0) {
371         if (ret == -ENOSYS) {
372             ret = 0; /* ignore error */
373         } else {
374             goto done;
375         }
376     }
377 
378     err = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_TTY_MODE, value, sizeof(value));
379     if (err >= 0) {
380         int tty_mode;
381         str_parms_del(parms, AUDIO_PARAMETER_KEY_TTY_MODE);
382         if (strcmp(value, AUDIO_PARAMETER_VALUE_TTY_OFF) == 0)
383             tty_mode = TTY_MODE_OFF;
384         else if (strcmp(value, AUDIO_PARAMETER_VALUE_TTY_VCO) == 0)
385             tty_mode = TTY_MODE_VCO;
386         else if (strcmp(value, AUDIO_PARAMETER_VALUE_TTY_HCO) == 0)
387             tty_mode = TTY_MODE_HCO;
388         else if (strcmp(value, AUDIO_PARAMETER_VALUE_TTY_FULL) == 0)
389             tty_mode = TTY_MODE_FULL;
390         else {
391             ret = -EINVAL;
392             goto done;
393         }
394 
395         if (tty_mode != adev->voice.tty_mode) {
396             adev->voice.tty_mode = tty_mode;
397             adev->acdb_settings = (adev->acdb_settings & TTY_MODE_CLEAR) | tty_mode;
398             if (voice_is_call_state_active(adev))
399                voice_update_devices_for_all_voice_usecases(adev);
400         }
401     }
402 
403     err = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_HAC,
404                             value, sizeof(value));
405     if (err >= 0) {
406         bool hac = false;
407         str_parms_del(parms, AUDIO_PARAMETER_KEY_HAC);
408         if (strcmp(value, AUDIO_PARAMETER_VALUE_HAC_ON) == 0)
409             hac = true;
410 
411         if (hac != adev->voice.hac) {
412             adev->voice.hac = hac;
413             if (voice_is_in_call(adev))
414                 voice_update_devices_for_all_voice_usecases(adev);
415         }
416      }
417 
418     err = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_INCALLMUSIC,
419                             value, sizeof(value));
420     if (err >= 0) {
421         str_parms_del(parms, AUDIO_PARAMETER_KEY_INCALLMUSIC);
422         if (strcmp(value, AUDIO_PARAMETER_VALUE_TRUE) == 0)
423             platform_start_incall_music_usecase(adev->platform);
424         else
425             platform_stop_incall_music_usecase(adev->platform);
426      }
427 
428 done:
429     ALOGV("%s: exit with code(%d)", __func__, ret);
430     free(kv_pairs);
431     return ret;
432 }
433 
voice_init(struct audio_device * adev)434 void voice_init(struct audio_device *adev)
435 {
436     int i = 0;
437 
438     memset(&adev->voice, 0, sizeof(adev->voice));
439     adev->voice.tty_mode = TTY_MODE_OFF;
440     adev->voice.hac = false;
441     adev->voice.volume = 1.0f;
442     adev->voice.mic_mute = false;
443     adev->voice.in_call = false;
444     for (i = 0; i < MAX_VOICE_SESSIONS; i++) {
445         adev->voice.session[i].pcm_rx = NULL;
446         adev->voice.session[i].pcm_tx = NULL;
447         adev->voice.session[i].state.current = CALL_INACTIVE;
448         adev->voice.session[i].state.new = CALL_INACTIVE;
449         adev->voice.session[i].vsid = VOICE_VSID;
450     }
451 
452     voice_extn_init(adev);
453 }
454 
voice_update_devices_for_all_voice_usecases(struct audio_device * adev)455 void voice_update_devices_for_all_voice_usecases(struct audio_device *adev)
456 {
457     struct listnode *node;
458     struct audio_usecase *usecase;
459 
460     list_for_each(node, &adev->usecase_list) {
461         usecase = node_to_item(node, struct audio_usecase, list);
462         if (usecase->type == VOICE_CALL) {
463             ALOGV("%s: updating device for usecase:%s", __func__,
464                   use_case_table[usecase->id]);
465             usecase->stream.out = adev->current_call_output;
466             select_devices(adev, usecase->id);
467         }
468     }
469 }
470 
471 
472