Lines Matching refs:usecase
358 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD)
601 struct audio_usecase *usecase)
606 if (usecase == NULL)
609 ALOGV("%s: enter: usecase(%d)", __func__, usecase->id);
611 if (usecase->type == PCM_CAPTURE)
612 snd_device = usecase->in_snd_device;
614 snd_device = usecase->out_snd_device;
615 audio_extn_utils_send_app_type_cfg(adev, usecase);
616 audio_extn_utils_send_audio_calibration(adev, usecase);
617 strcpy(mixer_path, use_case_table[usecase->id]);
619 audio_extn_sound_trigger_update_stream_status(usecase, ST_EVENT_STREAM_BUSY);
620 ALOGD("%s: usecase(%d) apply and update mixer path: %s", __func__, usecase->id, mixer_path);
628 struct audio_usecase *usecase)
633 if (usecase == NULL)
636 ALOGV("%s: enter: usecase(%d)", __func__, usecase->id);
637 if (usecase->type == PCM_CAPTURE)
638 snd_device = usecase->in_snd_device;
640 snd_device = usecase->out_snd_device;
641 strcpy(mixer_path, use_case_table[usecase->id]);
643 ALOGD("%s: usecase(%d) reset and update mixer path: %s", __func__, usecase->id, mixer_path);
645 audio_extn_sound_trigger_update_stream_status(usecase, ST_EVENT_STREAM_FREE);
759 // will be renabled on usecase start
788 uc - existing usecase
789 new_uc - new usecase
872 // NB: case 7 is hypothetical and isn't a practical usecase yet.
874 // the combo devices active on the existing usecase share a backend.
875 // This is because we cannot have a usecase active on a combo device
876 // and a new usecase requests one device in this combo pair.
899 struct audio_usecase *usecase;
928 specified usecase */
933 usecase = node_to_item(node, struct audio_usecase, list);
934 if (usecase->type == PCM_CAPTURE || usecase == uc_info)
938 (usecase->out_snd_device != snd_device &&
939 (usecase->devices & AUDIO_DEVICE_OUT_ALL_CODEC_BACKEND ||
940 usecase->devices & (AUDIO_DEVICE_OUT_USB_DEVICE|AUDIO_DEVICE_OUT_USB_HEADSET)) &&
941 platform_check_backends_match(snd_device, usecase->out_snd_device))) {
942 ALOGV("%s: Usecase (%s) is active on (%s) - disabling ..",
943 __func__, use_case_table[usecase->id],
944 platform_get_snd_device_name(usecase->out_snd_device));
945 disable_audio_route(adev, usecase);
946 switch_device[usecase->id] = true;
953 usecase = node_to_item(node, struct audio_usecase, list);
954 if (switch_device[usecase->id]) {
955 disable_snd_device(adev, usecase->out_snd_device);
961 usecase = node_to_item(node, struct audio_usecase, list);
962 if (switch_device[usecase->id]) {
963 d_device = derive_playback_snd_device(usecase, uc_info,
967 usecase->out_snd_device = d_device;
972 specified usecase to new snd devices */
974 usecase = node_to_item(node, struct audio_usecase, list);
975 if (switch_device[usecase->id] ) {
976 usecase);
987 struct audio_usecase *usecase;
999 * usecase is also switched to earpiece i.e. voice-dmic-ef,
1007 usecase = node_to_item(node, struct audio_usecase, list);
1008 if (usecase->type != PCM_PLAYBACK &&
1009 usecase != uc_info &&
1010 usecase->in_snd_device != snd_device &&
1011 (usecase->id != USECASE_AUDIO_SPKR_CALIB_TX)) {
1012 ALOGV("%s: Usecase (%s) is active on (%s) - disabling ..",
1013 __func__, use_case_table[usecase->id],
1014 platform_get_snd_device_name(usecase->in_snd_device));
1015 disable_audio_route(adev, usecase);
1016 switch_device[usecase->id] = true;
1023 usecase = node_to_item(node, struct audio_usecase, list);
1024 if (switch_device[usecase->id]) {
1025 disable_snd_device(adev, usecase->in_snd_device);
1030 usecase = node_to_item(node, struct audio_usecase, list);
1031 if (switch_device[usecase->id]) {
1037 specified usecase to new snd devices */
1039 usecase = node_to_item(node, struct audio_usecase, list);
1041 if (switch_device[usecase->id] ) {
1042 usecase->in_snd_device = snd_device;
1043 enable_audio_route(adev, usecase);
1213 struct audio_usecase *usecase;
1217 usecase = node_to_item(node, struct audio_usecase, list);
1218 if (usecase->type == VOICE_CALL) {
1219 ALOGV("%s: usecase id %d", __func__, usecase->id);
1220 return usecase->id;
1229 struct audio_usecase *usecase;
1233 usecase = node_to_item(node, struct audio_usecase, list);
1234 if (usecase->id == uc_id)
1235 return usecase;
1240 static bool force_device_switch(struct audio_usecase *usecase)
1242 if (usecase->stream.out == NULL) {
1250 if ((usecase->stream.out->devices & AUDIO_DEVICE_OUT_ALL_A2DP) &&
1264 struct audio_usecase *usecase = NULL;
1273 usecase = get_usecase_from_list(adev, uc_id);
1274 if (usecase == NULL) {
1275 ALOGE("%s: Could not find the usecase(%d)", __func__, uc_id);
1279 if ((usecase->type == VOICE_CALL) ||
1280 (usecase->type == PCM_HFP_CALL)) {
1282 usecase->stream.out->devices);
1283 in_snd_device = platform_get_input_snd_device(adev->platform, usecase->stream.out->devices);
1284 usecase->devices = usecase->stream.out->devices;
1287 * If the voice call is active, use the sound devices of voice call usecase
1290 * usecase. This is to avoid switching devices for voice call when
1298 (usecase->devices == AUDIO_DEVICE_IN_VOICE_CALL))) {
1310 if (usecase->type == PCM_PLAYBACK) {
1311 usecase->devices = usecase->stream.out->devices;
1317 usecase->stream.out->devices);
1322 if (usecase->stream.out == voip_out &&
1326 select_devices(adev, adev->active_input->usecase);
1329 } else if (usecase->type == PCM_CAPTURE) {
1330 usecase->devices = usecase->stream.in->device;
1342 if (usecase->id == USECASE_AUDIO_RECORD_AFE_PROXY) {
1355 if (out_snd_device == usecase->out_snd_device &&
1356 in_snd_device == usecase->in_snd_device) {
1357 if (!force_device_switch(usecase))
1412 if ((usecase->type == VOICE_CALL) &&
1413 (usecase->in_snd_device != SND_DEVICE_NONE) &&
1414 (usecase->out_snd_device != SND_DEVICE_NONE)) {
1418 voice_set_sidetone(adev, usecase->out_snd_device, false);
1422 if (usecase->out_snd_device != SND_DEVICE_NONE) {
1423 disable_audio_route(adev, usecase);
1424 disable_snd_device(adev, usecase->out_snd_device);
1427 if (usecase->in_snd_device != SND_DEVICE_NONE) {
1428 disable_audio_route(adev, usecase);
1429 disable_snd_device(adev, usecase->in_snd_device);
1436 if ((usecase->type == VOICE_CALL) &&
1437 (usecase->in_snd_device != SND_DEVICE_NONE) &&
1438 (usecase->out_snd_device != SND_DEVICE_NONE)) {
1446 if ((usecase->devices & AUDIO_DEVICE_OUT_ALL_CODEC_BACKEND) ||
1447 (usecase->devices & (AUDIO_DEVICE_OUT_USB_DEVICE|AUDIO_DEVICE_OUT_USB_HEADSET)) ||
1448 (usecase->devices & AUDIO_DEVICE_OUT_ALL_A2DP))
1449 check_and_route_playback_usecases(adev, usecase, out_snd_device);
1454 check_and_route_capture_usecases(adev, usecase, in_snd_device);
1458 if (usecase->type == VOICE_CALL)
1463 usecase->in_snd_device = in_snd_device;
1464 usecase->out_snd_device = out_snd_device;
1468 enable_audio_route(adev, usecase);
1470 audio_extn_ma_set_device(usecase);
1476 if (usecase->type == VOICE_CALL) {
1485 if (usecase == voip_usecase) {
1500 ALOGV("%s: enter: usecase(%d: %s)", __func__,
1501 in->usecase, use_case_table[in->usecase]);
1504 if (adev->active_input->usecase == in->usecase) {
1507 ALOGW("%s adev->active_input->usecase %s, v/s in->usecase %s",
1509 use_case_table[adev->active_input->usecase],
1510 use_case_table[in->usecase]);
1514 uc_info = get_usecase_from_list(adev, in->usecase);
1516 ALOGE("%s: Could not find the usecase (%d) in the list",
1517 __func__, in->usecase);
1544 ALOGV("%s: enter: usecase(%d)", __func__, in->usecase);
1556 /* Check if source matches incall recording usecase criteria */
1561 ALOGV("%s: usecase(%d)", __func__, in->usecase);
1563 in->pcm_device_id = platform_get_pcm_device_id(in->usecase, PCM_CAPTURE);
1565 ALOGE("%s: Could not find PCM device id for the usecase(%d)",
1566 __func__, in->usecase);
1573 uc_info->id = in->usecase;
1585 select_devices(adev, in->usecase);
1587 if (in->usecase == USECASE_AUDIO_RECORD_MMAP) {
1601 if (in->usecase == USECASE_AUDIO_RECORD_AFE_PROXY) {
1830 struct audio_usecase *usecase;
1834 usecase = node_to_item(node, struct audio_usecase, list);
1835 if (usecase->devices & AUDIO_DEVICE_OUT_AUX_DIGITAL) {
1842 if (usecase->id == USECASE_VOICE_CALL) {
1847 } else if (usecase->id == USECASE_AUDIO_PLAYBACK_HIFI) {
1862 struct audio_usecase *usecase;
1882 usecase = node_to_item(node, struct audio_usecase, list);
1883 if (usecase->type == PCM_PLAYBACK &&
1884 usecase->devices & AUDIO_DEVICE_OUT_AUX_DIGITAL) {
1885 disable_audio_route(adev, usecase);
1894 usecase = node_to_item(node, struct audio_usecase, list);
1895 if (usecase->type == PCM_PLAYBACK &&
1896 usecase->devices & AUDIO_DEVICE_OUT_AUX_DIGITAL) {
1897 enable_audio_route(adev, usecase);
1909 struct audio_usecase *usecase;
1917 /* set if the valid usecase do not already exist */
1919 usecase = node_to_item(node, struct audio_usecase, list);
1920 if (usecase->type == PCM_PLAYBACK &&
1921 (audio_is_usb_out_device(usecase->devices & AUDIO_DEVICE_OUT_ALL_USB))) {
1922 switch (usecase->id) {
1958 ALOGV("%s: enter: usecase(%d: %s)", __func__,
1959 out->usecase, use_case_table[out->usecase]);
1960 uc_info = get_usecase_from_list(adev, out->usecase);
1962 ALOGE("%s: Could not find the usecase (%d) in the list",
1963 __func__, out->usecase);
1967 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
1972 } else if (out->usecase == USECASE_AUDIO_PLAYBACK_ULL ||
1973 out->usecase == USECASE_AUDIO_PLAYBACK_MMAP) {
1987 /* Must be called after removing the usecase from list */
1992 struct audio_usecase *usecase;
1994 usecase = node_to_item(node, struct audio_usecase, list);
1995 if (usecase->devices & AUDIO_DEVICE_OUT_SPEAKER)
1996 select_devices(adev, usecase->id);
2020 ALOGV("%s: enter: usecase(%d: %s) devices(%#x)",
2021 __func__, out->usecase, use_case_table[out->usecase], out->devices);
2043 out->pcm_device_id = platform_get_pcm_device_id(out->usecase, PCM_PLAYBACK);
2045 ALOGE("%s: Invalid PCM device id(%d) for the usecase(%d)",
2046 __func__, out->pcm_device_id, out->usecase);
2052 uc_info->id = out->usecase;
2059 /* This must be called before adding this usecase to the list */
2083 select_devices(adev, out->usecase);
2087 select_devices(adev, out->usecase);
2094 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
2112 } else if (out->usecase == USECASE_AUDIO_PLAYBACK_MMAP) {
2126 if (out->usecase == USECASE_AUDIO_PLAYBACK_AFE_PROXY) {
2176 if (out->usecase == USECASE_AUDIO_PLAYBACK_ULL ||
2177 out->usecase == USECASE_AUDIO_PLAYBACK_MMAP) {
2322 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
2360 if (out->usecase != USECASE_AUDIO_PLAYBACK_OFFLOAD) {
2365 if (out->usecase == USECASE_AUDIO_PLAYBACK_MMAP) {
2390 ALOGV("%s: enter: usecase(%d: %s)", __func__,
2391 out->usecase, use_case_table[out->usecase]);
2408 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
2494 struct audio_usecase *usecase;
2503 ALOGD("%s: enter: usecase(%d: %s) kvpairs: %s",
2504 __func__, out->usecase, use_case_table[out->usecase], kvpairs);
2516 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD && val == AUDIO_DEVICE_NONE &&
2555 //combo usecase just by pass a2dp
2593 * For example, music playback is active on headset (deep-buffer usecase)
2594 * and if we go to ringtones and select a ringtone, low-latency usecase
2597 * playback to headset+speaker while starting low-lateny usecase for ringtone.
2632 select_devices(adev, out->usecase);
2638 select_devices(adev, out->usecase);
2669 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
2807 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD)
2810 (out->usecase == USECASE_AUDIO_PLAYBACK_MMAP)) {
2815 hw_delay = platform_render_latency(out->usecase)/1000;
2836 int pcm_device_id = platform_get_pcm_device_id(out->usecase,
2862 if (out->usecase == USECASE_AUDIO_PLAYBACK_HIFI) {
2866 } else if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
2875 } else if (out->usecase == USECASE_AUDIO_PLAYBACK_VOIP) {
2917 ALOGW("out_snd_mon_cb for card %d usecase %s, status %s", card,
2918 use_case_table[out->usecase],
2958 if (out->usecase == USECASE_AUDIO_PLAYBACK_MMAP) {
2992 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
3041 if (out->usecase == USECASE_AUDIO_PLAYBACK_VOIP || out->usecase == USECASE_INCALL_MUSIC_UPLINK) {
3060 bool use_mmap = is_mmap_usecase(out->usecase) || out->realtime;
3074 if (out->usecase != USECASE_AUDIO_PLAYBACK_OFFLOAD) {
3081 if (out->usecase != USECASE_AUDIO_PLAYBACK_OFFLOAD) {
3104 if ((out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) && (dsp_frames != NULL)) {
3147 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
3175 (platform_render_latency(out->usecase) * out->sample_rate / 1000000LL);
3216 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
3232 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
3249 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
3264 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
3281 if (out->usecase == USECASE_AUDIO_PLAYBACK_MMAP && !out->standby &&
3299 if (out->usecase == USECASE_AUDIO_PLAYBACK_MMAP && !out->standby &&
3352 if (out->usecase != USECASE_AUDIO_PLAYBACK_MMAP || !out->standby) {
3353 ALOGE("%s: usecase = %d, standby = %d", __func__, out->usecase, out->standby);
3357 out->pcm_device_id = platform_get_pcm_device_id(out->usecase, PCM_PLAYBACK);
3359 ALOGE("%s: Invalid PCM device id(%d) for the usecase(%d)",
3360 __func__, out->pcm_device_id, out->usecase);
3438 if (out->usecase != USECASE_AUDIO_PLAYBACK_MMAP ||
3518 if (in->usecase == USECASE_AUDIO_RECORD_MMAP) {
3611 select_devices(adev, in->usecase);
3665 if (in->usecase != USECASE_AUDIO_RECORD_MMAP)
3712 ALOGW("in_snd_mon_cb for card %d usecase %s, status %s", card,
3713 use_case_table[in->usecase],
3745 if (in->usecase == USECASE_AUDIO_RECORD_MMAP) {
3768 bool use_mmap = is_mmap_usecase(in->usecase) || in->realtime;
3803 in->usecase != USECASE_AUDIO_RECORD_AFE_PROXY) {
3888 struct audio_usecase *usecase;
3891 usecase = node_to_item(node, struct audio_usecase, list);
3892 if (usecase->type == PCM_PLAYBACK)
3893 select_devices(adev, usecase->id);
3897 select_devices(in->dev, in->usecase);
3903 select_devices(in->dev, in->usecase);
3933 if (in->usecase == USECASE_AUDIO_RECORD_MMAP && !in->standby &&
3951 if (in->usecase == USECASE_AUDIO_RECORD_MMAP && !in->standby &&
3986 if (in->usecase != USECASE_AUDIO_RECORD_MMAP || !in->standby) {
3987 ALOGE("%s: usecase = %d, standby = %d", __func__, in->usecase, in->standby);
3992 in->pcm_device_id = platform_get_pcm_device_id(in->usecase, PCM_CAPTURE);
3994 ALOGE("%s: Invalid PCM device id(%d) for the usecase(%d)",
3995 __func__, in->pcm_device_id, in->usecase);
4075 if (in->usecase != USECASE_AUDIO_RECORD_MMAP ||
4103 in->usecase, mic_array, mic_count);
4207 out->usecase = USECASE_AUDIO_PLAYBACK_HIFI;
4210 out->usecase = USECASE_AUDIO_PLAYBACK_MMAP;
4217 out->usecase = USECASE_AUDIO_PLAYBACK_HIFI;
4264 out->usecase = USECASE_AUDIO_PLAYBACK_OFFLOAD;
4384 out->usecase = USECASE_AUDIO_PLAYBACK_AFE_PROXY;
4442 out->usecase = USECASE_AUDIO_PLAYBACK_VOIP;
4457 out->usecase = USECASE_AUDIO_PLAYBACK_DEEP_BUFFER;
4460 out->usecase = USECASE_AUDIO_PLAYBACK_TTS;
4463 out->usecase = USECASE_AUDIO_PLAYBACK_ULL;
4467 out->usecase = USECASE_AUDIO_PLAYBACK_MMAP;
4474 out->usecase = USECASE_AUDIO_PLAYBACK_LOW_LATENCY;
4518 ALOGV("%s: Usecase(%s) config->format %#x out->config.format %#x\n",
4519 __func__, use_case_table[out->usecase], config->format, out->config.format);
4531 /* Check if this usecase is already existing */
4533 if (get_usecase_from_list(adev, out->usecase) != NULL) {
4534 ALOGE("%s: Usecase (%d) is already present", __func__, out->usecase);
4627 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) {
4761 struct audio_usecase *usecase;
4764 usecase = node_to_item(node, struct audio_usecase, list);
4765 if ((usecase->type == PCM_PLAYBACK) &&
4766 (usecase->devices & AUDIO_DEVICE_OUT_ALL_A2DP)) {
4770 lock_output_stream(usecase->stream.out);
4774 select_devices(adev, usecase->id);
4776 pthread_mutex_unlock(&usecase->stream.out->lock);
5101 in->usecase = USECASE_AUDIO_RECORD_AFE_PROXY;
5105 in->usecase = USECASE_AUDIO_RECORD_HIFI;
5118 in->usecase = USECASE_AUDIO_RECORD;
5123 in->usecase = USECASE_AUDIO_RECORD_LOW_LATENCY;
5125 in->realtime = may_use_noirq_mode(adev, in->usecase, in->flags);
5145 in->usecase = USECASE_AUDIO_RECORD_MMAP;
5160 in->usecase = USECASE_AUDIO_RECORD_VOIP;
5468 uc_info = get_usecase_from_list(adev, out->usecase);
5470 ALOGE("%s: Could not find the usecase (%d) in the list",
5471 __func__, out->usecase);
5475 ALOGD("%s: enter: usecase(%d: %s)", __func__,
5476 out->usecase, use_case_table[out->usecase]);
5507 select_devices(adev, out->usecase);
