1 /* 2 * Copyright (C) 2013-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 "audio_hw_primary" 18 /*#define LOG_NDEBUG 0*/ 19 /*#define VERY_VERY_VERBOSE_LOGGING*/ 20 #ifdef VERY_VERY_VERBOSE_LOGGING 21 #define ALOGVV ALOGV 22 #else 23 #define ALOGVV(a...) do { } while(0) 24 #endif 25 26 #include <errno.h> 27 #include <pthread.h> 28 #include <stdint.h> 29 #include <sys/time.h> 30 #include <stdlib.h> 31 #include <math.h> 32 #include <dlfcn.h> 33 #include <sys/resource.h> 34 #include <sys/prctl.h> 35 36 #include <cutils/log.h> 37 #include <cutils/str_parms.h> 38 #include <cutils/properties.h> 39 #include <cutils/atomic.h> 40 #include <cutils/sched_policy.h> 41 42 #include <hardware/audio_effect.h> 43 #include <hardware/audio_alsaops.h> 44 #include <system/thread_defs.h> 45 #include <audio_effects/effect_aec.h> 46 #include <audio_effects/effect_ns.h> 47 #include "audio_hw.h" 48 #include "audio_extn.h" 49 #include "platform_api.h" 50 #include <platform.h> 51 #include "voice_extn.h" 52 53 #include "sound/compress_params.h" 54 55 #define COMPRESS_OFFLOAD_FRAGMENT_SIZE (32 * 1024) 56 #define COMPRESS_OFFLOAD_NUM_FRAGMENTS 4 57 /* ToDo: Check and update a proper value in msec */ 58 #define COMPRESS_OFFLOAD_PLAYBACK_LATENCY 96 59 #define COMPRESS_PLAYBACK_VOLUME_MAX 0x2000 60 61 #define PROXY_OPEN_RETRY_COUNT 100 62 #define PROXY_OPEN_WAIT_TIME 20 63 64 static unsigned int configured_low_latency_capture_period_size = 65 LOW_LATENCY_CAPTURE_PERIOD_SIZE; 66 67 /* This constant enables extended precision handling. 68 * TODO The flag is off until more testing is done. 69 */ 70 static const bool k_enable_extended_precision = false; 71 72 struct pcm_config pcm_config_deep_buffer = { 73 .channels = 2, 74 .rate = DEFAULT_OUTPUT_SAMPLING_RATE, 75 .period_size = DEEP_BUFFER_OUTPUT_PERIOD_SIZE, 76 .period_count = DEEP_BUFFER_OUTPUT_PERIOD_COUNT, 77 .format = PCM_FORMAT_S16_LE, 78 .start_threshold = DEEP_BUFFER_OUTPUT_PERIOD_SIZE / 4, 79 .stop_threshold = INT_MAX, 80 .avail_min = DEEP_BUFFER_OUTPUT_PERIOD_SIZE / 4, 81 }; 82 83 struct pcm_config pcm_config_low_latency = { 84 .channels = 2, 85 .rate = DEFAULT_OUTPUT_SAMPLING_RATE, 86 .period_size = LOW_LATENCY_OUTPUT_PERIOD_SIZE, 87 .period_count = LOW_LATENCY_OUTPUT_PERIOD_COUNT, 88 .format = PCM_FORMAT_S16_LE, 89 .start_threshold = LOW_LATENCY_OUTPUT_PERIOD_SIZE / 4, 90 .stop_threshold = INT_MAX, 91 .avail_min = LOW_LATENCY_OUTPUT_PERIOD_SIZE / 4, 92 }; 93 94 struct pcm_config pcm_config_hdmi_multi = { 95 .channels = HDMI_MULTI_DEFAULT_CHANNEL_COUNT, /* changed when the stream is opened */ 96 .rate = DEFAULT_OUTPUT_SAMPLING_RATE, /* changed when the stream is opened */ 97 .period_size = HDMI_MULTI_PERIOD_SIZE, 98 .period_count = HDMI_MULTI_PERIOD_COUNT, 99 .format = PCM_FORMAT_S16_LE, 100 .start_threshold = 0, 101 .stop_threshold = INT_MAX, 102 .avail_min = 0, 103 }; 104 105 struct pcm_config pcm_config_audio_capture = { 106 .channels = 2, 107 .period_count = AUDIO_CAPTURE_PERIOD_COUNT, 108 .format = PCM_FORMAT_S16_LE, 109 }; 110 111 #define AFE_PROXY_CHANNEL_COUNT 2 112 #define AFE_PROXY_SAMPLING_RATE 48000 113 114 #define AFE_PROXY_PLAYBACK_PERIOD_SIZE 768 115 #define AFE_PROXY_PLAYBACK_PERIOD_COUNT 4 116 117 struct pcm_config pcm_config_afe_proxy_playback = { 118 .channels = AFE_PROXY_CHANNEL_COUNT, 119 .rate = AFE_PROXY_SAMPLING_RATE, 120 .period_size = AFE_PROXY_PLAYBACK_PERIOD_SIZE, 121 .period_count = AFE_PROXY_PLAYBACK_PERIOD_COUNT, 122 .format = PCM_FORMAT_S16_LE, 123 .start_threshold = AFE_PROXY_PLAYBACK_PERIOD_SIZE, 124 .stop_threshold = INT_MAX, 125 .avail_min = AFE_PROXY_PLAYBACK_PERIOD_SIZE, 126 }; 127 128 #define AFE_PROXY_RECORD_PERIOD_SIZE 768 129 #define AFE_PROXY_RECORD_PERIOD_COUNT 4 130 131 struct pcm_config pcm_config_afe_proxy_record = { 132 .channels = AFE_PROXY_CHANNEL_COUNT, 133 .rate = AFE_PROXY_SAMPLING_RATE, 134 .period_size = AFE_PROXY_RECORD_PERIOD_SIZE, 135 .period_count = AFE_PROXY_RECORD_PERIOD_COUNT, 136 .format = PCM_FORMAT_S16_LE, 137 .start_threshold = AFE_PROXY_RECORD_PERIOD_SIZE, 138 .stop_threshold = INT_MAX, 139 .avail_min = AFE_PROXY_RECORD_PERIOD_SIZE, 140 }; 141 142 const char * const use_case_table[AUDIO_USECASE_MAX] = { 143 [USECASE_AUDIO_PLAYBACK_DEEP_BUFFER] = "deep-buffer-playback", 144 [USECASE_AUDIO_PLAYBACK_LOW_LATENCY] = "low-latency-playback", 145 [USECASE_AUDIO_PLAYBACK_MULTI_CH] = "multi-channel-playback", 146 [USECASE_AUDIO_PLAYBACK_OFFLOAD] = "compress-offload-playback", 147 148 [USECASE_AUDIO_RECORD] = "audio-record", 149 [USECASE_AUDIO_RECORD_LOW_LATENCY] = "low-latency-record", 150 151 [USECASE_AUDIO_HFP_SCO] = "hfp-sco", 152 [USECASE_AUDIO_HFP_SCO_WB] = "hfp-sco-wb", 153 154 [USECASE_VOICE_CALL] = "voice-call", 155 [USECASE_VOICE2_CALL] = "voice2-call", 156 [USECASE_VOLTE_CALL] = "volte-call", 157 [USECASE_QCHAT_CALL] = "qchat-call", 158 [USECASE_VOWLAN_CALL] = "vowlan-call", 159 160 [USECASE_AUDIO_PLAYBACK_AFE_PROXY] = "afe-proxy-playback", 161 [USECASE_AUDIO_RECORD_AFE_PROXY] = "afe-proxy-record", 162 }; 163 164 165 #define STRING_TO_ENUM(string) { #string, string } 166 167 struct string_to_enum { 168 const char *name; 169 uint32_t value; 170 }; 171 172 static const struct string_to_enum out_channels_name_to_enum_table[] = { 173 STRING_TO_ENUM(AUDIO_CHANNEL_OUT_STEREO), 174 STRING_TO_ENUM(AUDIO_CHANNEL_OUT_5POINT1), 175 STRING_TO_ENUM(AUDIO_CHANNEL_OUT_7POINT1), 176 }; 177 178 static int set_voice_volume_l(struct audio_device *adev, float volume); 179 180 static bool is_supported_format(audio_format_t format) 181 { 182 switch (format) { 183 case AUDIO_FORMAT_MP3: 184 case AUDIO_FORMAT_AAC_LC: 185 case AUDIO_FORMAT_AAC_HE_V1: 186 case AUDIO_FORMAT_AAC_HE_V2: 187 return true; 188 default: 189 break; 190 } 191 return false; 192 } 193 194 static int get_snd_codec_id(audio_format_t format) 195 { 196 int id = 0; 197 198 switch (format & AUDIO_FORMAT_MAIN_MASK) { 199 case AUDIO_FORMAT_MP3: 200 id = SND_AUDIOCODEC_MP3; 201 break; 202 case AUDIO_FORMAT_AAC: 203 id = SND_AUDIOCODEC_AAC; 204 break; 205 default: 206 ALOGE("%s: Unsupported audio format", __func__); 207 } 208 209 return id; 210 } 211 212 int pcm_ioctl(void *pcm, int request, ...) 213 { 214 va_list ap; 215 void * arg; 216 int pcm_fd = *(int*)pcm; 217 218 va_start(ap, request); 219 arg = va_arg(ap, void *); 220 va_end(ap); 221 222 return ioctl(pcm_fd, request, arg); 223 } 224 225 int enable_audio_route(struct audio_device *adev, 226 struct audio_usecase *usecase) 227 { 228 snd_device_t snd_device; 229 char mixer_path[50]; 230 231 if (usecase == NULL) 232 return -EINVAL; 233 234 ALOGV("%s: enter: usecase(%d)", __func__, usecase->id); 235 236 if (usecase->type == PCM_CAPTURE) 237 snd_device = usecase->in_snd_device; 238 else 239 snd_device = usecase->out_snd_device; 240 241 strcpy(mixer_path, use_case_table[usecase->id]); 242 platform_add_backend_name(adev->platform, mixer_path, snd_device); 243 ALOGD("%s: apply and update mixer path: %s", __func__, mixer_path); 244 audio_route_apply_and_update_path(adev->audio_route, mixer_path); 245 246 ALOGV("%s: exit", __func__); 247 return 0; 248 } 249 250 int disable_audio_route(struct audio_device *adev, 251 struct audio_usecase *usecase) 252 { 253 snd_device_t snd_device; 254 char mixer_path[50]; 255 256 if (usecase == NULL) 257 return -EINVAL; 258 259 ALOGV("%s: enter: usecase(%d)", __func__, usecase->id); 260 if (usecase->type == PCM_CAPTURE) 261 snd_device = usecase->in_snd_device; 262 else 263 snd_device = usecase->out_snd_device; 264 strcpy(mixer_path, use_case_table[usecase->id]); 265 platform_add_backend_name(adev->platform, mixer_path, snd_device); 266 ALOGD("%s: reset and update mixer path: %s", __func__, mixer_path); 267 audio_route_reset_and_update_path(adev->audio_route, mixer_path); 268 269 ALOGV("%s: exit", __func__); 270 return 0; 271 } 272 273 int enable_snd_device(struct audio_device *adev, 274 snd_device_t snd_device) 275 { 276 if (snd_device < SND_DEVICE_MIN || 277 snd_device >= SND_DEVICE_MAX) { 278 ALOGE("%s: Invalid sound device %d", __func__, snd_device); 279 return -EINVAL; 280 } 281 282 adev->snd_dev_ref_cnt[snd_device]++; 283 if (adev->snd_dev_ref_cnt[snd_device] > 1) { 284 ALOGV("%s: snd_device(%d: %s) is already active", 285 __func__, snd_device, platform_get_snd_device_name(snd_device)); 286 return 0; 287 } 288 289 if (platform_send_audio_calibration(adev->platform, snd_device) < 0) { 290 adev->snd_dev_ref_cnt[snd_device]--; 291 return -EINVAL; 292 } 293 294 const char * dev_path = platform_get_snd_device_name(snd_device); 295 ALOGD("%s: snd_device(%d: %s)", __func__, snd_device, dev_path); 296 audio_route_apply_and_update_path(adev->audio_route, dev_path); 297 298 return 0; 299 } 300 301 int disable_snd_device(struct audio_device *adev, 302 snd_device_t snd_device) 303 { 304 if (snd_device < SND_DEVICE_MIN || 305 snd_device >= SND_DEVICE_MAX) { 306 ALOGE("%s: Invalid sound device %d", __func__, snd_device); 307 return -EINVAL; 308 } 309 if (adev->snd_dev_ref_cnt[snd_device] <= 0) { 310 ALOGE("%s: device ref cnt is already 0", __func__); 311 return -EINVAL; 312 } 313 adev->snd_dev_ref_cnt[snd_device]--; 314 if (adev->snd_dev_ref_cnt[snd_device] == 0) { 315 const char * dev_path = platform_get_snd_device_name(snd_device); 316 ALOGD("%s: snd_device(%d: %s)", __func__, snd_device, dev_path); 317 audio_route_reset_and_update_path(adev->audio_route, dev_path); 318 } 319 return 0; 320 } 321 322 static void check_usecases_codec_backend(struct audio_device *adev, 323 struct audio_usecase *uc_info, 324 snd_device_t snd_device) 325 { 326 struct listnode *node; 327 struct audio_usecase *usecase; 328 bool switch_device[AUDIO_USECASE_MAX]; 329 int i, num_uc_to_switch = 0; 330 331 /* 332 * This function is to make sure that all the usecases that are active on 333 * the hardware codec backend are always routed to any one device that is 334 * handled by the hardware codec. 335 * For example, if low-latency and deep-buffer usecases are currently active 336 * on speaker and out_set_parameters(headset) is received on low-latency 337 * output, then we have to make sure deep-buffer is also switched to headset, 338 * because of the limitation that both the devices cannot be enabled 339 * at the same time as they share the same backend. 340 */ 341 /* Disable all the usecases on the shared backend other than the 342 specified usecase */ 343 for (i = 0; i < AUDIO_USECASE_MAX; i++) 344 switch_device[i] = false; 345 346 list_for_each(node, &adev->usecase_list) { 347 usecase = node_to_item(node, struct audio_usecase, list); 348 if (usecase->type != PCM_CAPTURE && 349 usecase != uc_info && 350 usecase->out_snd_device != snd_device && 351 usecase->devices & AUDIO_DEVICE_OUT_ALL_CODEC_BACKEND) { 352 ALOGV("%s: Usecase (%s) is active on (%s) - disabling ..", 353 __func__, use_case_table[usecase->id], 354 platform_get_snd_device_name(usecase->out_snd_device)); 355 disable_audio_route(adev, usecase); 356 switch_device[usecase->id] = true; 357 num_uc_to_switch++; 358 } 359 } 360 361 if (num_uc_to_switch) { 362 list_for_each(node, &adev->usecase_list) { 363 usecase = node_to_item(node, struct audio_usecase, list); 364 if (switch_device[usecase->id]) { 365 disable_snd_device(adev, usecase->out_snd_device); 366 } 367 } 368 369 list_for_each(node, &adev->usecase_list) { 370 usecase = node_to_item(node, struct audio_usecase, list); 371 if (switch_device[usecase->id]) { 372 enable_snd_device(adev, snd_device); 373 } 374 } 375 376 /* Re-route all the usecases on the shared backend other than the 377 specified usecase to new snd devices */ 378 list_for_each(node, &adev->usecase_list) { 379 usecase = node_to_item(node, struct audio_usecase, list); 380 /* Update the out_snd_device only before enabling the audio route */ 381 if (switch_device[usecase->id] ) { 382 usecase->out_snd_device = snd_device; 383 enable_audio_route(adev, usecase); 384 } 385 } 386 } 387 } 388 389 static void check_and_route_capture_usecases(struct audio_device *adev, 390 struct audio_usecase *uc_info, 391 snd_device_t snd_device) 392 { 393 struct listnode *node; 394 struct audio_usecase *usecase; 395 bool switch_device[AUDIO_USECASE_MAX]; 396 int i, num_uc_to_switch = 0; 397 398 /* 399 * This function is to make sure that all the active capture usecases 400 * are always routed to the same input sound device. 401 * For example, if audio-record and voice-call usecases are currently 402 * active on speaker(rx) and speaker-mic (tx) and out_set_parameters(earpiece) 403 * is received for voice call then we have to make sure that audio-record 404 * usecase is also switched to earpiece i.e. voice-dmic-ef, 405 * because of the limitation that two devices cannot be enabled 406 * at the same time if they share the same backend. 407 */ 408 for (i = 0; i < AUDIO_USECASE_MAX; i++) 409 switch_device[i] = false; 410 411 list_for_each(node, &adev->usecase_list) { 412 usecase = node_to_item(node, struct audio_usecase, list); 413 if (usecase->type != PCM_PLAYBACK && 414 usecase != uc_info && 415 usecase->in_snd_device != snd_device) { 416 ALOGV("%s: Usecase (%s) is active on (%s) - disabling ..", 417 __func__, use_case_table[usecase->id], 418 platform_get_snd_device_name(usecase->in_snd_device)); 419 disable_audio_route(adev, usecase); 420 switch_device[usecase->id] = true; 421 num_uc_to_switch++; 422 } 423 } 424 425 if (num_uc_to_switch) { 426 list_for_each(node, &adev->usecase_list) { 427 usecase = node_to_item(node, struct audio_usecase, list); 428 if (switch_device[usecase->id]) { 429 disable_snd_device(adev, usecase->in_snd_device); 430 } 431 } 432 433 list_for_each(node, &adev->usecase_list) { 434 usecase = node_to_item(node, struct audio_usecase, list); 435 if (switch_device[usecase->id]) { 436 enable_snd_device(adev, snd_device); 437 } 438 } 439 440 /* Re-route all the usecases on the shared backend other than the 441 specified usecase to new snd devices */ 442 list_for_each(node, &adev->usecase_list) { 443 usecase = node_to_item(node, struct audio_usecase, list); 444 /* Update the in_snd_device only before enabling the audio route */ 445 if (switch_device[usecase->id] ) { 446 usecase->in_snd_device = snd_device; 447 enable_audio_route(adev, usecase); 448 } 449 } 450 } 451 } 452 453 /* must be called with hw device mutex locked */ 454 static int read_hdmi_channel_masks(struct stream_out *out) 455 { 456 int ret = 0; 457 int channels = platform_edid_get_max_channels(out->dev->platform); 458 459 switch (channels) { 460 /* 461 * Do not handle stereo output in Multi-channel cases 462 * Stereo case is handled in normal playback path 463 */ 464 case 6: 465 ALOGV("%s: HDMI supports 5.1", __func__); 466 out->supported_channel_masks[0] = AUDIO_CHANNEL_OUT_5POINT1; 467 break; 468 case 8: 469 ALOGV("%s: HDMI supports 5.1 and 7.1 channels", __func__); 470 out->supported_channel_masks[0] = AUDIO_CHANNEL_OUT_5POINT1; 471 out->supported_channel_masks[1] = AUDIO_CHANNEL_OUT_7POINT1; 472 break; 473 default: 474 ALOGE("HDMI does not support multi channel playback"); 475 ret = -ENOSYS; 476 break; 477 } 478 return ret; 479 } 480 481 static audio_usecase_t get_voice_usecase_id_from_list(struct audio_device *adev) 482 { 483 struct audio_usecase *usecase; 484 struct listnode *node; 485 486 list_for_each(node, &adev->usecase_list) { 487 usecase = node_to_item(node, struct audio_usecase, list); 488 if (usecase->type == VOICE_CALL) { 489 ALOGV("%s: usecase id %d", __func__, usecase->id); 490 return usecase->id; 491 } 492 } 493 return USECASE_INVALID; 494 } 495 496 struct audio_usecase *get_usecase_from_list(struct audio_device *adev, 497 audio_usecase_t uc_id) 498 { 499 struct audio_usecase *usecase; 500 struct listnode *node; 501 502 list_for_each(node, &adev->usecase_list) { 503 usecase = node_to_item(node, struct audio_usecase, list); 504 if (usecase->id == uc_id) 505 return usecase; 506 } 507 return NULL; 508 } 509 510 int select_devices(struct audio_device *adev, 511 audio_usecase_t uc_id) 512 { 513 snd_device_t out_snd_device = SND_DEVICE_NONE; 514 snd_device_t in_snd_device = SND_DEVICE_NONE; 515 struct audio_usecase *usecase = NULL; 516 struct audio_usecase *vc_usecase = NULL; 517 struct audio_usecase *hfp_usecase = NULL; 518 audio_usecase_t hfp_ucid; 519 struct listnode *node; 520 int status = 0; 521 522 usecase = get_usecase_from_list(adev, uc_id); 523 if (usecase == NULL) { 524 ALOGE("%s: Could not find the usecase(%d)", __func__, uc_id); 525 return -EINVAL; 526 } 527 528 if ((usecase->type == VOICE_CALL) || 529 (usecase->type == PCM_HFP_CALL)) { 530 out_snd_device = platform_get_output_snd_device(adev->platform, 531 usecase->stream.out->devices); 532 in_snd_device = platform_get_input_snd_device(adev->platform, usecase->stream.out->devices); 533 usecase->devices = usecase->stream.out->devices; 534 } else { 535 /* 536 * If the voice call is active, use the sound devices of voice call usecase 537 * so that it would not result any device switch. All the usecases will 538 * be switched to new device when select_devices() is called for voice call 539 * usecase. This is to avoid switching devices for voice call when 540 * check_usecases_codec_backend() is called below. 541 */ 542 if (voice_is_in_call(adev)) { 543 vc_usecase = get_usecase_from_list(adev, 544 get_voice_usecase_id_from_list(adev)); 545 if ((vc_usecase != NULL) && 546 ((vc_usecase->devices & AUDIO_DEVICE_OUT_ALL_CODEC_BACKEND) || 547 (usecase->devices == AUDIO_DEVICE_IN_VOICE_CALL))) { 548 in_snd_device = vc_usecase->in_snd_device; 549 out_snd_device = vc_usecase->out_snd_device; 550 } 551 } else if (audio_extn_hfp_is_active(adev)) { 552 hfp_ucid = audio_extn_hfp_get_usecase(); 553 hfp_usecase = get_usecase_from_list(adev, hfp_ucid); 554 if (hfp_usecase->devices & AUDIO_DEVICE_OUT_ALL_CODEC_BACKEND) { 555 in_snd_device = hfp_usecase->in_snd_device; 556 out_snd_device = hfp_usecase->out_snd_device; 557 } 558 } 559 if (usecase->type == PCM_PLAYBACK) { 560 usecase->devices = usecase->stream.out->devices; 561 in_snd_device = SND_DEVICE_NONE; 562 if (out_snd_device == SND_DEVICE_NONE) { 563 out_snd_device = platform_get_output_snd_device(adev->platform, 564 usecase->stream.out->devices); 565 if (usecase->stream.out == adev->primary_output && 566 adev->active_input && 567 adev->active_input->source == AUDIO_SOURCE_VOICE_COMMUNICATION) { 568 select_devices(adev, adev->active_input->usecase); 569 } 570 } 571 } else if (usecase->type == PCM_CAPTURE) { 572 usecase->devices = usecase->stream.in->device; 573 out_snd_device = SND_DEVICE_NONE; 574 if (in_snd_device == SND_DEVICE_NONE) { 575 audio_devices_t out_device = AUDIO_DEVICE_NONE; 576 if (adev->active_input->source == AUDIO_SOURCE_VOICE_COMMUNICATION && 577 adev->primary_output && !adev->primary_output->standby) { 578 out_device = adev->primary_output->devices; 579 } else if (usecase->id == USECASE_AUDIO_RECORD_AFE_PROXY) { 580 out_device = AUDIO_DEVICE_OUT_TELEPHONY_TX; 581 } 582 in_snd_device = platform_get_input_snd_device(adev->platform, out_device); 583 } 584 } 585 } 586 587 if (out_snd_device == usecase->out_snd_device && 588 in_snd_device == usecase->in_snd_device) { 589 return 0; 590 } 591 592 ALOGD("%s: out_snd_device(%d: %s) in_snd_device(%d: %s)", __func__, 593 out_snd_device, platform_get_snd_device_name(out_snd_device), 594 in_snd_device, platform_get_snd_device_name(in_snd_device)); 595 596 /* 597 * Limitation: While in call, to do a device switch we need to disable 598 * and enable both RX and TX devices though one of them is same as current 599 * device. 600 */ 601 if ((usecase->type == VOICE_CALL) && 602 (usecase->in_snd_device != SND_DEVICE_NONE) && 603 (usecase->out_snd_device != SND_DEVICE_NONE)) { 604 status = platform_switch_voice_call_device_pre(adev->platform); 605 } 606 607 /* Disable current sound devices */ 608 if (usecase->out_snd_device != SND_DEVICE_NONE) { 609 disable_audio_route(adev, usecase); 610 disable_snd_device(adev, usecase->out_snd_device); 611 } 612 613 if (usecase->in_snd_device != SND_DEVICE_NONE) { 614 disable_audio_route(adev, usecase); 615 disable_snd_device(adev, usecase->in_snd_device); 616 } 617 618 /* Applicable only on the targets that has external modem. 619 * New device information should be sent to modem before enabling 620 * the devices to reduce in-call device switch time. 621 */ 622 if ((usecase->type == VOICE_CALL) && 623 (usecase->in_snd_device != SND_DEVICE_NONE) && 624 (usecase->out_snd_device != SND_DEVICE_NONE)) { 625 status = platform_switch_voice_call_enable_device_config(adev->platform, 626 out_snd_device, 627 in_snd_device); 628 } 629 630 /* Enable new sound devices */ 631 if (out_snd_device != SND_DEVICE_NONE) { 632 if (usecase->devices & AUDIO_DEVICE_OUT_ALL_CODEC_BACKEND) 633 check_usecases_codec_backend(adev, usecase, out_snd_device); 634 enable_snd_device(adev, out_snd_device); 635 } 636 637 if (in_snd_device != SND_DEVICE_NONE) { 638 check_and_route_capture_usecases(adev, usecase, in_snd_device); 639 enable_snd_device(adev, in_snd_device); 640 } 641 642 if (usecase->type == VOICE_CALL) 643 status = platform_switch_voice_call_device_post(adev->platform, 644 out_snd_device, 645 in_snd_device); 646 647 usecase->in_snd_device = in_snd_device; 648 usecase->out_snd_device = out_snd_device; 649 650 enable_audio_route(adev, usecase); 651 652 /* Applicable only on the targets that has external modem. 653 * Enable device command should be sent to modem only after 654 * enabling voice call mixer controls 655 */ 656 if (usecase->type == VOICE_CALL) 657 status = platform_switch_voice_call_usecase_route_post(adev->platform, 658 out_snd_device, 659 in_snd_device); 660 661 return status; 662 } 663 664 static int stop_input_stream(struct stream_in *in) 665 { 666 int i, ret = 0; 667 struct audio_usecase *uc_info; 668 struct audio_device *adev = in->dev; 669 670 adev->active_input = NULL; 671 672 ALOGV("%s: enter: usecase(%d: %s)", __func__, 673 in->usecase, use_case_table[in->usecase]); 674 uc_info = get_usecase_from_list(adev, in->usecase); 675 if (uc_info == NULL) { 676 ALOGE("%s: Could not find the usecase (%d) in the list", 677 __func__, in->usecase); 678 return -EINVAL; 679 } 680 681 /* 1. Disable stream specific mixer controls */ 682 disable_audio_route(adev, uc_info); 683 684 /* 2. Disable the tx device */ 685 disable_snd_device(adev, uc_info->in_snd_device); 686 687 list_remove(&uc_info->list); 688 free(uc_info); 689 690 ALOGV("%s: exit: status(%d)", __func__, ret); 691 return ret; 692 } 693 694 int start_input_stream(struct stream_in *in) 695 { 696 /* 1. Enable output device and stream routing controls */ 697 int ret = 0; 698 struct audio_usecase *uc_info; 699 struct audio_device *adev = in->dev; 700 701 ALOGV("%s: enter: usecase(%d)", __func__, in->usecase); 702 in->pcm_device_id = platform_get_pcm_device_id(in->usecase, PCM_CAPTURE); 703 if (in->pcm_device_id < 0) { 704 ALOGE("%s: Could not find PCM device id for the usecase(%d)", 705 __func__, in->usecase); 706 ret = -EINVAL; 707 goto error_config; 708 } 709 710 adev->active_input = in; 711 uc_info = (struct audio_usecase *)calloc(1, sizeof(struct audio_usecase)); 712 uc_info->id = in->usecase; 713 uc_info->type = PCM_CAPTURE; 714 uc_info->stream.in = in; 715 uc_info->devices = in->device; 716 uc_info->in_snd_device = SND_DEVICE_NONE; 717 uc_info->out_snd_device = SND_DEVICE_NONE; 718 719 list_add_tail(&adev->usecase_list, &uc_info->list); 720 select_devices(adev, in->usecase); 721 722 ALOGV("%s: Opening PCM device card_id(%d) device_id(%d), channels %d", 723 __func__, adev->snd_card, in->pcm_device_id, in->config.channels); 724 725 unsigned int flags = PCM_IN; 726 unsigned int pcm_open_retry_count = 0; 727 728 if (in->usecase == USECASE_AUDIO_RECORD_AFE_PROXY) { 729 flags |= PCM_MMAP | PCM_NOIRQ; 730 pcm_open_retry_count = PROXY_OPEN_RETRY_COUNT; 731 } 732 733 while (1) { 734 in->pcm = pcm_open(adev->snd_card, in->pcm_device_id, 735 flags, &in->config); 736 if (in->pcm == NULL || !pcm_is_ready(in->pcm)) { 737 ALOGE("%s: %s", __func__, pcm_get_error(in->pcm)); 738 if (in->pcm != NULL) { 739 pcm_close(in->pcm); 740 in->pcm = NULL; 741 } 742 if (pcm_open_retry_count-- == 0) { 743 ret = -EIO; 744 goto error_open; 745 } 746 usleep(PROXY_OPEN_WAIT_TIME * 1000); 747 continue; 748 } 749 break; 750 } 751 752 ALOGV("%s: exit", __func__); 753 return ret; 754 755 error_open: 756 stop_input_stream(in); 757 758 error_config: 759 adev->active_input = NULL; 760 ALOGD("%s: exit: status(%d)", __func__, ret); 761 762 return ret; 763 } 764 765 /* must be called with out->lock locked */ 766 static int send_offload_cmd_l(struct stream_out* out, int command) 767 { 768 struct offload_cmd *cmd = (struct offload_cmd *)calloc(1, sizeof(struct offload_cmd)); 769 770 ALOGVV("%s %d", __func__, command); 771 772 cmd->cmd = command; 773 list_add_tail(&out->offload_cmd_list, &cmd->node); 774 pthread_cond_signal(&out->offload_cond); 775 return 0; 776 } 777 778 /* must be called iwth out->lock locked */ 779 static void stop_compressed_output_l(struct stream_out *out) 780 { 781 out->offload_state = OFFLOAD_STATE_IDLE; 782 out->playback_started = 0; 783 out->send_new_metadata = 1; 784 if (out->compr != NULL) { 785 compress_stop(out->compr); 786 while (out->offload_thread_blocked) { 787 pthread_cond_wait(&out->cond, &out->lock); 788 } 789 } 790 } 791 792 static void *offload_thread_loop(void *context) 793 { 794 struct stream_out *out = (struct stream_out *) context; 795 struct listnode *item; 796 797 out->offload_state = OFFLOAD_STATE_IDLE; 798 out->playback_started = 0; 799 800 setpriority(PRIO_PROCESS, 0, ANDROID_PRIORITY_AUDIO); 801 set_sched_policy(0, SP_FOREGROUND); 802 prctl(PR_SET_NAME, (unsigned long)"Offload Callback", 0, 0, 0); 803 804 ALOGV("%s", __func__); 805 pthread_mutex_lock(&out->lock); 806 for (;;) { 807 struct offload_cmd *cmd = NULL; 808 stream_callback_event_t event; 809 bool send_callback = false; 810 811 ALOGVV("%s offload_cmd_list %d out->offload_state %d", 812 __func__, list_empty(&out->offload_cmd_list), 813 out->offload_state); 814 if (list_empty(&out->offload_cmd_list)) { 815 ALOGV("%s SLEEPING", __func__); 816 pthread_cond_wait(&out->offload_cond, &out->lock); 817 ALOGV("%s RUNNING", __func__); 818 continue; 819 } 820 821 item = list_head(&out->offload_cmd_list); 822 cmd = node_to_item(item, struct offload_cmd, node); 823 list_remove(item); 824 825 ALOGVV("%s STATE %d CMD %d out->compr %p", 826 __func__, out->offload_state, cmd->cmd, out->compr); 827 828 if (cmd->cmd == OFFLOAD_CMD_EXIT) { 829 free(cmd); 830 break; 831 } 832 833 if (out->compr == NULL) { 834 ALOGE("%s: Compress handle is NULL", __func__); 835 pthread_cond_signal(&out->cond); 836 continue; 837 } 838 out->offload_thread_blocked = true; 839 pthread_mutex_unlock(&out->lock); 840 send_callback = false; 841 switch(cmd->cmd) { 842 case OFFLOAD_CMD_WAIT_FOR_BUFFER: 843 compress_wait(out->compr, -1); 844 send_callback = true; 845 event = STREAM_CBK_EVENT_WRITE_READY; 846 break; 847 case OFFLOAD_CMD_PARTIAL_DRAIN: 848 compress_next_track(out->compr); 849 compress_partial_drain(out->compr); 850 send_callback = true; 851 event = STREAM_CBK_EVENT_DRAIN_READY; 852 break; 853 case OFFLOAD_CMD_DRAIN: 854 compress_drain(out->compr); 855 send_callback = true; 856 event = STREAM_CBK_EVENT_DRAIN_READY; 857 break; 858 default: 859 ALOGE("%s unknown command received: %d", __func__, cmd->cmd); 860 break; 861 } 862 pthread_mutex_lock(&out->lock); 863 out->offload_thread_blocked = false; 864 pthread_cond_signal(&out->cond); 865 if (send_callback) { 866 out->offload_callback(event, NULL, out->offload_cookie); 867 } 868 free(cmd); 869 } 870 871 pthread_cond_signal(&out->cond); 872 while (!list_empty(&out->offload_cmd_list)) { 873 item = list_head(&out->offload_cmd_list); 874 list_remove(item); 875 free(node_to_item(item, struct offload_cmd, node)); 876 } 877 pthread_mutex_unlock(&out->lock); 878 879 return NULL; 880 } 881 882 static int create_offload_callback_thread(struct stream_out *out) 883 { 884 pthread_cond_init(&out->offload_cond, (const pthread_condattr_t *) NULL); 885 list_init(&out->offload_cmd_list); 886 pthread_create(&out->offload_thread, (const pthread_attr_t *) NULL, 887 offload_thread_loop, out); 888 return 0; 889 } 890 891 static int destroy_offload_callback_thread(struct stream_out *out) 892 { 893 pthread_mutex_lock(&out->lock); 894 stop_compressed_output_l(out); 895 send_offload_cmd_l(out, OFFLOAD_CMD_EXIT); 896 897 pthread_mutex_unlock(&out->lock); 898 pthread_join(out->offload_thread, (void **) NULL); 899 pthread_cond_destroy(&out->offload_cond); 900 901 return 0; 902 } 903 904 static bool allow_hdmi_channel_config(struct audio_device *adev) 905 { 906 struct listnode *node; 907 struct audio_usecase *usecase; 908 bool ret = true; 909 910 list_for_each(node, &adev->usecase_list) { 911 usecase = node_to_item(node, struct audio_usecase, list); 912 if (usecase->devices & AUDIO_DEVICE_OUT_AUX_DIGITAL) { 913 /* 914 * If voice call is already existing, do not proceed further to avoid 915 * disabling/enabling both RX and TX devices, CSD calls, etc. 916 * Once the voice call done, the HDMI channels can be configured to 917 * max channels of remaining use cases. 918 */ 919 if (usecase->id == USECASE_VOICE_CALL) { 920 ALOGD("%s: voice call is active, no change in HDMI channels", 921 __func__); 922 ret = false; 923 break; 924 } else if (usecase->id == USECASE_AUDIO_PLAYBACK_MULTI_CH) { 925 ALOGD("%s: multi channel playback is active, " 926 "no change in HDMI channels", __func__); 927 ret = false; 928 break; 929 } 930 } 931 } 932 return ret; 933 } 934 935 static int check_and_set_hdmi_channels(struct audio_device *adev, 936 unsigned int channels) 937 { 938 struct listnode *node; 939 struct audio_usecase *usecase; 940 941 /* Check if change in HDMI channel config is allowed */ 942 if (!allow_hdmi_channel_config(adev)) 943 return 0; 944 945 if (channels == adev->cur_hdmi_channels) { 946 ALOGD("%s: Requested channels are same as current", __func__); 947 return 0; 948 } 949 950 platform_set_hdmi_channels(adev->platform, channels); 951 adev->cur_hdmi_channels = channels; 952 953 /* 954 * Deroute all the playback streams routed to HDMI so that 955 * the back end is deactivated. Note that backend will not 956 * be deactivated if any one stream is connected to it. 957 */ 958 list_for_each(node, &adev->usecase_list) { 959 usecase = node_to_item(node, struct audio_usecase, list); 960 if (usecase->type == PCM_PLAYBACK && 961 usecase->devices & AUDIO_DEVICE_OUT_AUX_DIGITAL) { 962 disable_audio_route(adev, usecase); 963 } 964 } 965 966 /* 967 * Enable all the streams disabled above. Now the HDMI backend 968 * will be activated with new channel configuration 969 */ 970 list_for_each(node, &adev->usecase_list) { 971 usecase = node_to_item(node, struct audio_usecase, list); 972 if (usecase->type == PCM_PLAYBACK && 973 usecase->devices & AUDIO_DEVICE_OUT_AUX_DIGITAL) { 974 enable_audio_route(adev, usecase); 975 } 976 } 977 978 return 0; 979 } 980 981 static int stop_output_stream(struct stream_out *out) 982 { 983 int i, ret = 0; 984 struct audio_usecase *uc_info; 985 struct audio_device *adev = out->dev; 986 987 ALOGV("%s: enter: usecase(%d: %s)", __func__, 988 out->usecase, use_case_table[out->usecase]); 989 uc_info = get_usecase_from_list(adev, out->usecase); 990 if (uc_info == NULL) { 991 ALOGE("%s: Could not find the usecase (%d) in the list", 992 __func__, out->usecase); 993 return -EINVAL; 994 } 995 996 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) { 997 if (adev->visualizer_stop_output != NULL) 998 adev->visualizer_stop_output(out->handle, out->pcm_device_id); 999 if (adev->offload_effects_stop_output != NULL) 1000 adev->offload_effects_stop_output(out->handle, out->pcm_device_id); 1001 } 1002 1003 /* 1. Get and set stream specific mixer controls */ 1004 disable_audio_route(adev, uc_info); 1005 1006 /* 2. Disable the rx device */ 1007 disable_snd_device(adev, uc_info->out_snd_device); 1008 1009 list_remove(&uc_info->list); 1010 free(uc_info); 1011 1012 audio_extn_extspk_update(adev->extspk); 1013 1014 /* Must be called after removing the usecase from list */ 1015 if (out->devices & AUDIO_DEVICE_OUT_AUX_DIGITAL) 1016 check_and_set_hdmi_channels(adev, DEFAULT_HDMI_OUT_CHANNELS); 1017 1018 ALOGV("%s: exit: status(%d)", __func__, ret); 1019 return ret; 1020 } 1021 1022 int start_output_stream(struct stream_out *out) 1023 { 1024 int ret = 0; 1025 struct audio_usecase *uc_info; 1026 struct audio_device *adev = out->dev; 1027 1028 ALOGV("%s: enter: usecase(%d: %s) devices(%#x)", 1029 __func__, out->usecase, use_case_table[out->usecase], out->devices); 1030 out->pcm_device_id = platform_get_pcm_device_id(out->usecase, PCM_PLAYBACK); 1031 if (out->pcm_device_id < 0) { 1032 ALOGE("%s: Invalid PCM device id(%d) for the usecase(%d)", 1033 __func__, out->pcm_device_id, out->usecase); 1034 ret = -EINVAL; 1035 goto error_config; 1036 } 1037 1038 uc_info = (struct audio_usecase *)calloc(1, sizeof(struct audio_usecase)); 1039 uc_info->id = out->usecase; 1040 uc_info->type = PCM_PLAYBACK; 1041 uc_info->stream.out = out; 1042 uc_info->devices = out->devices; 1043 uc_info->in_snd_device = SND_DEVICE_NONE; 1044 uc_info->out_snd_device = SND_DEVICE_NONE; 1045 1046 /* This must be called before adding this usecase to the list */ 1047 if (out->devices & AUDIO_DEVICE_OUT_AUX_DIGITAL) 1048 check_and_set_hdmi_channels(adev, out->config.channels); 1049 1050 list_add_tail(&adev->usecase_list, &uc_info->list); 1051 1052 select_devices(adev, out->usecase); 1053 1054 audio_extn_extspk_update(adev->extspk); 1055 1056 ALOGV("%s: Opening PCM device card_id(%d) device_id(%d) format(%#x)", 1057 __func__, adev->snd_card, out->pcm_device_id, out->config.format); 1058 if (out->usecase != USECASE_AUDIO_PLAYBACK_OFFLOAD) { 1059 unsigned int flags = PCM_OUT; 1060 unsigned int pcm_open_retry_count = 0; 1061 if (out->usecase == USECASE_AUDIO_PLAYBACK_AFE_PROXY) { 1062 flags |= PCM_MMAP | PCM_NOIRQ; 1063 pcm_open_retry_count = PROXY_OPEN_RETRY_COUNT; 1064 } else 1065 flags |= PCM_MONOTONIC; 1066 1067 while (1) { 1068 out->pcm = pcm_open(adev->snd_card, out->pcm_device_id, 1069 flags, &out->config); 1070 if (out->pcm == NULL || !pcm_is_ready(out->pcm)) { 1071 ALOGE("%s: %s", __func__, pcm_get_error(out->pcm)); 1072 if (out->pcm != NULL) { 1073 pcm_close(out->pcm); 1074 out->pcm = NULL; 1075 } 1076 if (pcm_open_retry_count-- == 0) { 1077 ret = -EIO; 1078 goto error_open; 1079 } 1080 usleep(PROXY_OPEN_WAIT_TIME * 1000); 1081 continue; 1082 } 1083 break; 1084 } 1085 } else { 1086 out->pcm = NULL; 1087 out->compr = compress_open(adev->snd_card, out->pcm_device_id, 1088 COMPRESS_IN, &out->compr_config); 1089 if (out->compr && !is_compress_ready(out->compr)) { 1090 ALOGE("%s: %s", __func__, compress_get_error(out->compr)); 1091 compress_close(out->compr); 1092 out->compr = NULL; 1093 ret = -EIO; 1094 goto error_open; 1095 } 1096 if (out->offload_callback) 1097 compress_nonblock(out->compr, out->non_blocking); 1098 1099 if (adev->visualizer_start_output != NULL) 1100 adev->visualizer_start_output(out->handle, out->pcm_device_id); 1101 if (adev->offload_effects_start_output != NULL) 1102 adev->offload_effects_start_output(out->handle, out->pcm_device_id); 1103 } 1104 ALOGV("%s: exit", __func__); 1105 return 0; 1106 error_open: 1107 stop_output_stream(out); 1108 error_config: 1109 return ret; 1110 } 1111 1112 static int check_input_parameters(uint32_t sample_rate, 1113 audio_format_t format, 1114 int channel_count) 1115 { 1116 if (format != AUDIO_FORMAT_PCM_16_BIT) return -EINVAL; 1117 1118 if ((channel_count < 1) || (channel_count > 2)) return -EINVAL; 1119 1120 switch (sample_rate) { 1121 case 8000: 1122 case 11025: 1123 case 12000: 1124 case 16000: 1125 case 22050: 1126 case 24000: 1127 case 32000: 1128 case 44100: 1129 case 48000: 1130 break; 1131 default: 1132 return -EINVAL; 1133 } 1134 1135 return 0; 1136 } 1137 1138 static size_t get_input_buffer_size(uint32_t sample_rate, 1139 audio_format_t format, 1140 int channel_count, 1141 bool is_low_latency) 1142 { 1143 size_t size = 0; 1144 1145 if (check_input_parameters(sample_rate, format, channel_count) != 0) 1146 return 0; 1147 1148 size = (sample_rate * AUDIO_CAPTURE_PERIOD_DURATION_MSEC) / 1000; 1149 if (is_low_latency) 1150 size = configured_low_latency_capture_period_size; 1151 /* ToDo: should use frame_size computed based on the format and 1152 channel_count here. */ 1153 size *= sizeof(short) * channel_count; 1154 1155 /* make sure the size is multiple of 32 bytes 1156 * At 48 kHz mono 16-bit PCM: 1157 * 5.000 ms = 240 frames = 15*16*1*2 = 480, a whole multiple of 32 (15) 1158 * 3.333 ms = 160 frames = 10*16*1*2 = 320, a whole multiple of 32 (10) 1159 */ 1160 size += 0x1f; 1161 size &= ~0x1f; 1162 1163 return size; 1164 } 1165 1166 static uint32_t out_get_sample_rate(const struct audio_stream *stream) 1167 { 1168 struct stream_out *out = (struct stream_out *)stream; 1169 1170 return out->sample_rate; 1171 } 1172 1173 static int out_set_sample_rate(struct audio_stream *stream __unused, uint32_t rate __unused) 1174 { 1175 return -ENOSYS; 1176 } 1177 1178 static size_t out_get_buffer_size(const struct audio_stream *stream) 1179 { 1180 struct stream_out *out = (struct stream_out *)stream; 1181 1182 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) { 1183 return out->compr_config.fragment_size; 1184 } 1185 return out->config.period_size * 1186 audio_stream_out_frame_size((const struct audio_stream_out *)stream); 1187 } 1188 1189 static uint32_t out_get_channels(const struct audio_stream *stream) 1190 { 1191 struct stream_out *out = (struct stream_out *)stream; 1192 1193 return out->channel_mask; 1194 } 1195 1196 static audio_format_t out_get_format(const struct audio_stream *stream) 1197 { 1198 struct stream_out *out = (struct stream_out *)stream; 1199 1200 return out->format; 1201 } 1202 1203 static int out_set_format(struct audio_stream *stream __unused, audio_format_t format __unused) 1204 { 1205 return -ENOSYS; 1206 } 1207 1208 static int out_standby(struct audio_stream *stream) 1209 { 1210 struct stream_out *out = (struct stream_out *)stream; 1211 struct audio_device *adev = out->dev; 1212 1213 ALOGV("%s: enter: usecase(%d: %s)", __func__, 1214 out->usecase, use_case_table[out->usecase]); 1215 1216 pthread_mutex_lock(&out->lock); 1217 if (!out->standby) { 1218 pthread_mutex_lock(&adev->lock); 1219 out->standby = true; 1220 if (out->usecase != USECASE_AUDIO_PLAYBACK_OFFLOAD) { 1221 if (out->pcm) { 1222 pcm_close(out->pcm); 1223 out->pcm = NULL; 1224 } 1225 } else { 1226 stop_compressed_output_l(out); 1227 out->gapless_mdata.encoder_delay = 0; 1228 out->gapless_mdata.encoder_padding = 0; 1229 if (out->compr != NULL) { 1230 compress_close(out->compr); 1231 out->compr = NULL; 1232 } 1233 } 1234 stop_output_stream(out); 1235 pthread_mutex_unlock(&adev->lock); 1236 } 1237 pthread_mutex_unlock(&out->lock); 1238 ALOGV("%s: exit", __func__); 1239 return 0; 1240 } 1241 1242 static int out_dump(const struct audio_stream *stream __unused, int fd __unused) 1243 { 1244 return 0; 1245 } 1246 1247 static int parse_compress_metadata(struct stream_out *out, struct str_parms *parms) 1248 { 1249 int ret = 0; 1250 char value[32]; 1251 struct compr_gapless_mdata tmp_mdata; 1252 1253 if (!out || !parms) { 1254 return -EINVAL; 1255 } 1256 1257 ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_DELAY_SAMPLES, value, sizeof(value)); 1258 if (ret >= 0) { 1259 tmp_mdata.encoder_delay = atoi(value); //whats a good limit check? 1260 } else { 1261 return -EINVAL; 1262 } 1263 1264 ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_PADDING_SAMPLES, value, sizeof(value)); 1265 if (ret >= 0) { 1266 tmp_mdata.encoder_padding = atoi(value); 1267 } else { 1268 return -EINVAL; 1269 } 1270 1271 out->gapless_mdata = tmp_mdata; 1272 out->send_new_metadata = 1; 1273 ALOGV("%s new encoder delay %u and padding %u", __func__, 1274 out->gapless_mdata.encoder_delay, out->gapless_mdata.encoder_padding); 1275 1276 return 0; 1277 } 1278 1279 static bool output_drives_call(struct audio_device *adev, struct stream_out *out) 1280 { 1281 return out == adev->primary_output || out == adev->voice_tx_output; 1282 } 1283 1284 static int out_set_parameters(struct audio_stream *stream, const char *kvpairs) 1285 { 1286 struct stream_out *out = (struct stream_out *)stream; 1287 struct audio_device *adev = out->dev; 1288 struct audio_usecase *usecase; 1289 struct listnode *node; 1290 struct str_parms *parms; 1291 char value[32]; 1292 int ret, val = 0; 1293 bool select_new_device = false; 1294 int status = 0; 1295 1296 ALOGD("%s: enter: usecase(%d: %s) kvpairs: %s", 1297 __func__, out->usecase, use_case_table[out->usecase], kvpairs); 1298 parms = str_parms_create_str(kvpairs); 1299 ret = str_parms_get_str(parms, AUDIO_PARAMETER_STREAM_ROUTING, value, sizeof(value)); 1300 if (ret >= 0) { 1301 val = atoi(value); 1302 pthread_mutex_lock(&out->lock); 1303 pthread_mutex_lock(&adev->lock); 1304 1305 /* 1306 * When HDMI cable is unplugged the music playback is paused and 1307 * the policy manager sends routing=0. But the audioflinger 1308 * continues to write data until standby time (3sec). 1309 * As the HDMI core is turned off, the write gets blocked. 1310 * Avoid this by routing audio to speaker until standby. 1311 */ 1312 if (out->devices == AUDIO_DEVICE_OUT_AUX_DIGITAL && 1313 val == AUDIO_DEVICE_NONE) { 1314 val = AUDIO_DEVICE_OUT_SPEAKER; 1315 } 1316 1317 /* 1318 * select_devices() call below switches all the usecases on the same 1319 * backend to the new device. Refer to check_usecases_codec_backend() in 1320 * the select_devices(). But how do we undo this? 1321 * 1322 * For example, music playback is active on headset (deep-buffer usecase) 1323 * and if we go to ringtones and select a ringtone, low-latency usecase 1324 * will be started on headset+speaker. As we can't enable headset+speaker 1325 * and headset devices at the same time, select_devices() switches the music 1326 * playback to headset+speaker while starting low-lateny usecase for ringtone. 1327 * So when the ringtone playback is completed, how do we undo the same? 1328 * 1329 * We are relying on the out_set_parameters() call on deep-buffer output, 1330 * once the ringtone playback is ended. 1331 * NOTE: We should not check if the current devices are same as new devices. 1332 * Because select_devices() must be called to switch back the music 1333 * playback to headset. 1334 */ 1335 if (val != 0) { 1336 out->devices = val; 1337 1338 if (!out->standby) 1339 select_devices(adev, out->usecase); 1340 1341 if (output_drives_call(adev, out)) { 1342 if (!voice_is_in_call(adev)) { 1343 if (adev->mode == AUDIO_MODE_IN_CALL) { 1344 adev->current_call_output = out; 1345 ret = voice_start_call(adev); 1346 } 1347 } else { 1348 adev->current_call_output = out; 1349 voice_update_devices_for_all_voice_usecases(adev); 1350 } 1351 } 1352 } 1353 1354 pthread_mutex_unlock(&adev->lock); 1355 pthread_mutex_unlock(&out->lock); 1356 1357 /*handles device and call state changes*/ 1358 audio_extn_extspk_update(adev->extspk); 1359 } 1360 1361 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) { 1362 parse_compress_metadata(out, parms); 1363 } 1364 1365 str_parms_destroy(parms); 1366 ALOGV("%s: exit: code(%d)", __func__, status); 1367 return status; 1368 } 1369 1370 static char* out_get_parameters(const struct audio_stream *stream, const char *keys) 1371 { 1372 struct stream_out *out = (struct stream_out *)stream; 1373 struct str_parms *query = str_parms_create_str(keys); 1374 char *str; 1375 char value[256]; 1376 struct str_parms *reply = str_parms_create(); 1377 size_t i, j; 1378 int ret; 1379 bool first = true; 1380 ALOGV("%s: enter: keys - %s", __func__, keys); 1381 ret = str_parms_get_str(query, AUDIO_PARAMETER_STREAM_SUP_CHANNELS, value, sizeof(value)); 1382 if (ret >= 0) { 1383 value[0] = '\0'; 1384 i = 0; 1385 while (out->supported_channel_masks[i] != 0) { 1386 for (j = 0; j < ARRAY_SIZE(out_channels_name_to_enum_table); j++) { 1387 if (out_channels_name_to_enum_table[j].value == out->supported_channel_masks[i]) { 1388 if (!first) { 1389 strcat(value, "|"); 1390 } 1391 strcat(value, out_channels_name_to_enum_table[j].name); 1392 first = false; 1393 break; 1394 } 1395 } 1396 i++; 1397 } 1398 str_parms_add_str(reply, AUDIO_PARAMETER_STREAM_SUP_CHANNELS, value); 1399 str = str_parms_to_str(reply); 1400 } else { 1401 str = strdup(keys); 1402 } 1403 str_parms_destroy(query); 1404 str_parms_destroy(reply); 1405 ALOGV("%s: exit: returns - %s", __func__, str); 1406 return str; 1407 } 1408 1409 static uint32_t out_get_latency(const struct audio_stream_out *stream) 1410 { 1411 struct stream_out *out = (struct stream_out *)stream; 1412 1413 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) 1414 return COMPRESS_OFFLOAD_PLAYBACK_LATENCY; 1415 1416 return (out->config.period_count * out->config.period_size * 1000) / 1417 (out->config.rate); 1418 } 1419 1420 static int out_set_volume(struct audio_stream_out *stream, float left, 1421 float right) 1422 { 1423 struct stream_out *out = (struct stream_out *)stream; 1424 int volume[2]; 1425 1426 if (out->usecase == USECASE_AUDIO_PLAYBACK_MULTI_CH) { 1427 /* only take left channel into account: the API is for stereo anyway */ 1428 out->muted = (left == 0.0f); 1429 return 0; 1430 } else if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) { 1431 const char *mixer_ctl_name = "Compress Playback Volume"; 1432 struct audio_device *adev = out->dev; 1433 struct mixer_ctl *ctl; 1434 ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name); 1435 if (!ctl) { 1436 /* try with the control based on device id */ 1437 int pcm_device_id = platform_get_pcm_device_id(out->usecase, 1438 PCM_PLAYBACK); 1439 char ctl_name[128] = {0}; 1440 snprintf(ctl_name, sizeof(ctl_name), 1441 "Compress Playback %d Volume", pcm_device_id); 1442 ctl = mixer_get_ctl_by_name(adev->mixer, ctl_name); 1443 if (!ctl) { 1444 ALOGE("%s: Could not get volume ctl mixer cmd", __func__); 1445 return -EINVAL; 1446 } 1447 } 1448 volume[0] = (int)(left * COMPRESS_PLAYBACK_VOLUME_MAX); 1449 volume[1] = (int)(right * COMPRESS_PLAYBACK_VOLUME_MAX); 1450 mixer_ctl_set_array(ctl, volume, sizeof(volume)/sizeof(volume[0])); 1451 return 0; 1452 } 1453 1454 return -ENOSYS; 1455 } 1456 1457 static ssize_t out_write(struct audio_stream_out *stream, const void *buffer, 1458 size_t bytes) 1459 { 1460 struct stream_out *out = (struct stream_out *)stream; 1461 struct audio_device *adev = out->dev; 1462 ssize_t ret = 0; 1463 1464 pthread_mutex_lock(&out->lock); 1465 if (out->standby) { 1466 out->standby = false; 1467 pthread_mutex_lock(&adev->lock); 1468 ret = start_output_stream(out); 1469 pthread_mutex_unlock(&adev->lock); 1470 /* ToDo: If use case is compress offload should return 0 */ 1471 if (ret != 0) { 1472 out->standby = true; 1473 goto exit; 1474 } 1475 } 1476 1477 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) { 1478 ALOGVV("%s: writing buffer (%d bytes) to compress device", __func__, bytes); 1479 if (out->send_new_metadata) { 1480 ALOGVV("send new gapless metadata"); 1481 compress_set_gapless_metadata(out->compr, &out->gapless_mdata); 1482 out->send_new_metadata = 0; 1483 } 1484 1485 ret = compress_write(out->compr, buffer, bytes); 1486 ALOGVV("%s: writing buffer (%d bytes) to compress device returned %d", __func__, bytes, ret); 1487 if (ret >= 0 && ret < (ssize_t)bytes) { 1488 send_offload_cmd_l(out, OFFLOAD_CMD_WAIT_FOR_BUFFER); 1489 } 1490 if (!out->playback_started) { 1491 compress_start(out->compr); 1492 out->playback_started = 1; 1493 out->offload_state = OFFLOAD_STATE_PLAYING; 1494 } 1495 pthread_mutex_unlock(&out->lock); 1496 return ret; 1497 } else { 1498 if (out->pcm) { 1499 if (out->muted) 1500 memset((void *)buffer, 0, bytes); 1501 ALOGVV("%s: writing buffer (%d bytes) to pcm device", __func__, bytes); 1502 if (out->usecase == USECASE_AUDIO_PLAYBACK_AFE_PROXY) { 1503 ret = pcm_mmap_write(out->pcm, (void *)buffer, bytes); 1504 } 1505 else 1506 ret = pcm_write(out->pcm, (void *)buffer, bytes); 1507 if (ret == 0) 1508 out->written += bytes / (out->config.channels * sizeof(short)); 1509 } 1510 } 1511 1512 exit: 1513 pthread_mutex_unlock(&out->lock); 1514 1515 if (ret != 0) { 1516 if (out->pcm) 1517 ALOGE("%s: error %d - %s", __func__, ret, pcm_get_error(out->pcm)); 1518 out_standby(&out->stream.common); 1519 usleep(bytes * 1000000 / audio_stream_out_frame_size(stream) / 1520 out_get_sample_rate(&out->stream.common)); 1521 } 1522 return bytes; 1523 } 1524 1525 static int out_get_render_position(const struct audio_stream_out *stream, 1526 uint32_t *dsp_frames) 1527 { 1528 struct stream_out *out = (struct stream_out *)stream; 1529 *dsp_frames = 0; 1530 if ((out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) && (dsp_frames != NULL)) { 1531 pthread_mutex_lock(&out->lock); 1532 if (out->compr != NULL) { 1533 compress_get_tstamp(out->compr, (unsigned long *)dsp_frames, 1534 &out->sample_rate); 1535 ALOGVV("%s rendered frames %d sample_rate %d", 1536 __func__, *dsp_frames, out->sample_rate); 1537 } 1538 pthread_mutex_unlock(&out->lock); 1539 return 0; 1540 } else 1541 return -EINVAL; 1542 } 1543 1544 static int out_add_audio_effect(const struct audio_stream *stream __unused, 1545 effect_handle_t effect __unused) 1546 { 1547 return 0; 1548 } 1549 1550 static int out_remove_audio_effect(const struct audio_stream *stream __unused, 1551 effect_handle_t effect __unused) 1552 { 1553 return 0; 1554 } 1555 1556 static int out_get_next_write_timestamp(const struct audio_stream_out *stream __unused, 1557 int64_t *timestamp __unused) 1558 { 1559 return -EINVAL; 1560 } 1561 1562 static int out_get_presentation_position(const struct audio_stream_out *stream, 1563 uint64_t *frames, struct timespec *timestamp) 1564 { 1565 struct stream_out *out = (struct stream_out *)stream; 1566 int ret = -1; 1567 unsigned long dsp_frames; 1568 1569 pthread_mutex_lock(&out->lock); 1570 1571 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) { 1572 if (out->compr != NULL) { 1573 compress_get_tstamp(out->compr, &dsp_frames, 1574 &out->sample_rate); 1575 ALOGVV("%s rendered frames %ld sample_rate %d", 1576 __func__, dsp_frames, out->sample_rate); 1577 *frames = dsp_frames; 1578 ret = 0; 1579 /* this is the best we can do */ 1580 clock_gettime(CLOCK_MONOTONIC, timestamp); 1581 } 1582 } else { 1583 if (out->pcm) { 1584 size_t avail; 1585 if (pcm_get_htimestamp(out->pcm, &avail, timestamp) == 0) { 1586 size_t kernel_buffer_size = out->config.period_size * out->config.period_count; 1587 int64_t signed_frames = out->written - kernel_buffer_size + avail; 1588 // This adjustment accounts for buffering after app processor. 1589 // It is based on estimated DSP latency per use case, rather than exact. 1590 signed_frames -= 1591 (platform_render_latency(out->usecase) * out->sample_rate / 1000000LL); 1592 1593 // It would be unusual for this value to be negative, but check just in case ... 1594 if (signed_frames >= 0) { 1595 *frames = signed_frames; 1596 ret = 0; 1597 } 1598 } 1599 } 1600 } 1601 1602 pthread_mutex_unlock(&out->lock); 1603 1604 return ret; 1605 } 1606 1607 static int out_set_callback(struct audio_stream_out *stream, 1608 stream_callback_t callback, void *cookie) 1609 { 1610 struct stream_out *out = (struct stream_out *)stream; 1611 1612 ALOGV("%s", __func__); 1613 pthread_mutex_lock(&out->lock); 1614 out->offload_callback = callback; 1615 out->offload_cookie = cookie; 1616 pthread_mutex_unlock(&out->lock); 1617 return 0; 1618 } 1619 1620 static int out_pause(struct audio_stream_out* stream) 1621 { 1622 struct stream_out *out = (struct stream_out *)stream; 1623 int status = -ENOSYS; 1624 ALOGV("%s", __func__); 1625 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) { 1626 pthread_mutex_lock(&out->lock); 1627 if (out->compr != NULL && out->offload_state == OFFLOAD_STATE_PLAYING) { 1628 status = compress_pause(out->compr); 1629 out->offload_state = OFFLOAD_STATE_PAUSED; 1630 } 1631 pthread_mutex_unlock(&out->lock); 1632 } 1633 return status; 1634 } 1635 1636 static int out_resume(struct audio_stream_out* stream) 1637 { 1638 struct stream_out *out = (struct stream_out *)stream; 1639 int status = -ENOSYS; 1640 ALOGV("%s", __func__); 1641 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) { 1642 status = 0; 1643 pthread_mutex_lock(&out->lock); 1644 if (out->compr != NULL && out->offload_state == OFFLOAD_STATE_PAUSED) { 1645 status = compress_resume(out->compr); 1646 out->offload_state = OFFLOAD_STATE_PLAYING; 1647 } 1648 pthread_mutex_unlock(&out->lock); 1649 } 1650 return status; 1651 } 1652 1653 static int out_drain(struct audio_stream_out* stream, audio_drain_type_t type ) 1654 { 1655 struct stream_out *out = (struct stream_out *)stream; 1656 int status = -ENOSYS; 1657 ALOGV("%s", __func__); 1658 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) { 1659 pthread_mutex_lock(&out->lock); 1660 if (type == AUDIO_DRAIN_EARLY_NOTIFY) 1661 status = send_offload_cmd_l(out, OFFLOAD_CMD_PARTIAL_DRAIN); 1662 else 1663 status = send_offload_cmd_l(out, OFFLOAD_CMD_DRAIN); 1664 pthread_mutex_unlock(&out->lock); 1665 } 1666 return status; 1667 } 1668 1669 static int out_flush(struct audio_stream_out* stream) 1670 { 1671 struct stream_out *out = (struct stream_out *)stream; 1672 ALOGV("%s", __func__); 1673 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) { 1674 pthread_mutex_lock(&out->lock); 1675 stop_compressed_output_l(out); 1676 pthread_mutex_unlock(&out->lock); 1677 return 0; 1678 } 1679 return -ENOSYS; 1680 } 1681 1682 /** audio_stream_in implementation **/ 1683 static uint32_t in_get_sample_rate(const struct audio_stream *stream) 1684 { 1685 struct stream_in *in = (struct stream_in *)stream; 1686 1687 return in->config.rate; 1688 } 1689 1690 static int in_set_sample_rate(struct audio_stream *stream __unused, uint32_t rate __unused) 1691 { 1692 return -ENOSYS; 1693 } 1694 1695 static size_t in_get_buffer_size(const struct audio_stream *stream) 1696 { 1697 struct stream_in *in = (struct stream_in *)stream; 1698 1699 return in->config.period_size * 1700 audio_stream_in_frame_size((const struct audio_stream_in *)stream); 1701 } 1702 1703 static uint32_t in_get_channels(const struct audio_stream *stream) 1704 { 1705 struct stream_in *in = (struct stream_in *)stream; 1706 1707 return in->channel_mask; 1708 } 1709 1710 static audio_format_t in_get_format(const struct audio_stream *stream __unused) 1711 { 1712 return AUDIO_FORMAT_PCM_16_BIT; 1713 } 1714 1715 static int in_set_format(struct audio_stream *stream __unused, audio_format_t format __unused) 1716 { 1717 return -ENOSYS; 1718 } 1719 1720 static int in_standby(struct audio_stream *stream) 1721 { 1722 struct stream_in *in = (struct stream_in *)stream; 1723 struct audio_device *adev = in->dev; 1724 int status = 0; 1725 ALOGV("%s: enter", __func__); 1726 pthread_mutex_lock(&in->lock); 1727 if (!in->standby) { 1728 pthread_mutex_lock(&adev->lock); 1729 in->standby = true; 1730 if (in->pcm) { 1731 pcm_close(in->pcm); 1732 in->pcm = NULL; 1733 } 1734 adev->enable_voicerx = false; 1735 platform_set_echo_reference(adev, false, AUDIO_DEVICE_NONE ); 1736 status = stop_input_stream(in); 1737 pthread_mutex_unlock(&adev->lock); 1738 } 1739 pthread_mutex_unlock(&in->lock); 1740 ALOGV("%s: exit: status(%d)", __func__, status); 1741 return status; 1742 } 1743 1744 static int in_dump(const struct audio_stream *stream __unused, int fd __unused) 1745 { 1746 return 0; 1747 } 1748 1749 static int in_set_parameters(struct audio_stream *stream, const char *kvpairs) 1750 { 1751 struct stream_in *in = (struct stream_in *)stream; 1752 struct audio_device *adev = in->dev; 1753 struct str_parms *parms; 1754 char *str; 1755 char value[32]; 1756 int ret, val = 0; 1757 int status = 0; 1758 1759 ALOGV("%s: enter: kvpairs=%s", __func__, kvpairs); 1760 parms = str_parms_create_str(kvpairs); 1761 1762 ret = str_parms_get_str(parms, AUDIO_PARAMETER_STREAM_INPUT_SOURCE, value, sizeof(value)); 1763 1764 pthread_mutex_lock(&in->lock); 1765 pthread_mutex_lock(&adev->lock); 1766 if (ret >= 0) { 1767 val = atoi(value); 1768 /* no audio source uses val == 0 */ 1769 if ((in->source != val) && (val != 0)) { 1770 in->source = val; 1771 } 1772 } 1773 1774 ret = str_parms_get_str(parms, AUDIO_PARAMETER_STREAM_ROUTING, value, sizeof(value)); 1775 1776 if (ret >= 0) { 1777 val = atoi(value); 1778 if (((int)in->device != val) && (val != 0)) { 1779 in->device = val; 1780 /* If recording is in progress, change the tx device to new device */ 1781 if (!in->standby) 1782 status = select_devices(adev, in->usecase); 1783 } 1784 } 1785 1786 pthread_mutex_unlock(&adev->lock); 1787 pthread_mutex_unlock(&in->lock); 1788 1789 str_parms_destroy(parms); 1790 ALOGV("%s: exit: status(%d)", __func__, status); 1791 return status; 1792 } 1793 1794 static char* in_get_parameters(const struct audio_stream *stream __unused, 1795 const char *keys __unused) 1796 { 1797 return strdup(""); 1798 } 1799 1800 static int in_set_gain(struct audio_stream_in *stream __unused, float gain __unused) 1801 { 1802 return 0; 1803 } 1804 1805 static ssize_t in_read(struct audio_stream_in *stream, void *buffer, 1806 size_t bytes) 1807 { 1808 struct stream_in *in = (struct stream_in *)stream; 1809 struct audio_device *adev = in->dev; 1810 int i, ret = -1; 1811 1812 pthread_mutex_lock(&in->lock); 1813 if (in->standby) { 1814 pthread_mutex_lock(&adev->lock); 1815 ret = start_input_stream(in); 1816 pthread_mutex_unlock(&adev->lock); 1817 if (ret != 0) { 1818 goto exit; 1819 } 1820 in->standby = 0; 1821 } 1822 1823 if (in->pcm) { 1824 if (in->usecase == USECASE_AUDIO_RECORD_AFE_PROXY) { 1825 ret = pcm_mmap_read(in->pcm, buffer, bytes); 1826 } else 1827 ret = pcm_read(in->pcm, buffer, bytes); 1828 } 1829 1830 /* 1831 * Instead of writing zeroes here, we could trust the hardware 1832 * to always provide zeroes when muted. 1833 * No need to acquire adev->lock to read mic_muted here as we don't change its state. 1834 */ 1835 if (ret == 0 && adev->mic_muted && in->usecase != USECASE_AUDIO_RECORD_AFE_PROXY) 1836 memset(buffer, 0, bytes); 1837 1838 exit: 1839 pthread_mutex_unlock(&in->lock); 1840 1841 if (ret != 0) { 1842 in_standby(&in->stream.common); 1843 ALOGV("%s: read failed - sleeping for buffer duration", __func__); 1844 usleep(bytes * 1000000 / audio_stream_in_frame_size(stream) / 1845 in_get_sample_rate(&in->stream.common)); 1846 } 1847 return bytes; 1848 } 1849 1850 static uint32_t in_get_input_frames_lost(struct audio_stream_in *stream __unused) 1851 { 1852 return 0; 1853 } 1854 1855 static int add_remove_audio_effect(const struct audio_stream *stream, 1856 effect_handle_t effect, 1857 bool enable) 1858 { 1859 struct stream_in *in = (struct stream_in *)stream; 1860 struct audio_device *adev = in->dev; 1861 int status = 0; 1862 effect_descriptor_t desc; 1863 1864 status = (*effect)->get_descriptor(effect, &desc); 1865 if (status != 0) 1866 return status; 1867 1868 pthread_mutex_lock(&in->lock); 1869 pthread_mutex_lock(&in->dev->lock); 1870 if ((in->source == AUDIO_SOURCE_VOICE_COMMUNICATION) && 1871 in->enable_aec != enable && 1872 (memcmp(&desc.type, FX_IID_AEC, sizeof(effect_uuid_t)) == 0)) { 1873 in->enable_aec = enable; 1874 if (!enable) 1875 platform_set_echo_reference(in->dev, enable, AUDIO_DEVICE_NONE); 1876 adev->enable_voicerx = enable; 1877 struct audio_usecase *usecase; 1878 struct listnode *node; 1879 list_for_each(node, &adev->usecase_list) { 1880 usecase = node_to_item(node, struct audio_usecase, list); 1881 if (usecase->type == PCM_PLAYBACK) { 1882 select_devices(adev, usecase->id); 1883 break; 1884 } 1885 } 1886 if (!in->standby) 1887 select_devices(in->dev, in->usecase); 1888 } 1889 if (in->enable_ns != enable && 1890 (memcmp(&desc.type, FX_IID_NS, sizeof(effect_uuid_t)) == 0)) { 1891 in->enable_ns = enable; 1892 if (!in->standby) 1893 select_devices(in->dev, in->usecase); 1894 } 1895 pthread_mutex_unlock(&in->dev->lock); 1896 pthread_mutex_unlock(&in->lock); 1897 1898 return 0; 1899 } 1900 1901 static int in_add_audio_effect(const struct audio_stream *stream, 1902 effect_handle_t effect) 1903 { 1904 ALOGV("%s: effect %p", __func__, effect); 1905 return add_remove_audio_effect(stream, effect, true); 1906 } 1907 1908 static int in_remove_audio_effect(const struct audio_stream *stream, 1909 effect_handle_t effect) 1910 { 1911 ALOGV("%s: effect %p", __func__, effect); 1912 return add_remove_audio_effect(stream, effect, false); 1913 } 1914 1915 static int adev_open_output_stream(struct audio_hw_device *dev, 1916 audio_io_handle_t handle, 1917 audio_devices_t devices, 1918 audio_output_flags_t flags, 1919 struct audio_config *config, 1920 struct audio_stream_out **stream_out, 1921 const char *address __unused) 1922 { 1923 struct audio_device *adev = (struct audio_device *)dev; 1924 struct stream_out *out; 1925 int i, ret; 1926 1927 ALOGV("%s: enter: sample_rate(%d) channel_mask(%#x) devices(%#x) flags(%#x)", 1928 __func__, config->sample_rate, config->channel_mask, devices, flags); 1929 *stream_out = NULL; 1930 out = (struct stream_out *)calloc(1, sizeof(struct stream_out)); 1931 1932 if (devices == AUDIO_DEVICE_NONE) 1933 devices = AUDIO_DEVICE_OUT_SPEAKER; 1934 1935 out->flags = flags; 1936 out->devices = devices; 1937 out->dev = adev; 1938 out->format = config->format; 1939 out->sample_rate = config->sample_rate; 1940 out->channel_mask = AUDIO_CHANNEL_OUT_STEREO; 1941 out->supported_channel_masks[0] = AUDIO_CHANNEL_OUT_STEREO; 1942 out->handle = handle; 1943 1944 /* Init use case and pcm_config */ 1945 if (out->flags & AUDIO_OUTPUT_FLAG_DIRECT && 1946 !(out->flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) && 1947 out->devices & AUDIO_DEVICE_OUT_AUX_DIGITAL) { 1948 pthread_mutex_lock(&adev->lock); 1949 ret = read_hdmi_channel_masks(out); 1950 pthread_mutex_unlock(&adev->lock); 1951 if (ret != 0) 1952 goto error_open; 1953 1954 if (config->sample_rate == 0) 1955 config->sample_rate = DEFAULT_OUTPUT_SAMPLING_RATE; 1956 if (config->channel_mask == 0) 1957 config->channel_mask = AUDIO_CHANNEL_OUT_5POINT1; 1958 1959 out->channel_mask = config->channel_mask; 1960 out->sample_rate = config->sample_rate; 1961 out->usecase = USECASE_AUDIO_PLAYBACK_MULTI_CH; 1962 out->config = pcm_config_hdmi_multi; 1963 out->config.rate = config->sample_rate; 1964 out->config.channels = audio_channel_count_from_out_mask(out->channel_mask); 1965 out->config.period_size = HDMI_MULTI_PERIOD_BYTES / (out->config.channels * 2); 1966 } else if (out->flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) { 1967 if (config->offload_info.version != AUDIO_INFO_INITIALIZER.version || 1968 config->offload_info.size != AUDIO_INFO_INITIALIZER.size) { 1969 ALOGE("%s: Unsupported Offload information", __func__); 1970 ret = -EINVAL; 1971 goto error_open; 1972 } 1973 if (!is_supported_format(config->offload_info.format)) { 1974 ALOGE("%s: Unsupported audio format", __func__); 1975 ret = -EINVAL; 1976 goto error_open; 1977 } 1978 1979 out->compr_config.codec = (struct snd_codec *) 1980 calloc(1, sizeof(struct snd_codec)); 1981 1982 out->usecase = USECASE_AUDIO_PLAYBACK_OFFLOAD; 1983 if (config->offload_info.channel_mask) 1984 out->channel_mask = config->offload_info.channel_mask; 1985 else if (config->channel_mask) 1986 out->channel_mask = config->channel_mask; 1987 out->format = config->offload_info.format; 1988 out->sample_rate = config->offload_info.sample_rate; 1989 1990 out->stream.set_callback = out_set_callback; 1991 out->stream.pause = out_pause; 1992 out->stream.resume = out_resume; 1993 out->stream.drain = out_drain; 1994 out->stream.flush = out_flush; 1995 1996 out->compr_config.codec->id = 1997 get_snd_codec_id(config->offload_info.format); 1998 out->compr_config.fragment_size = COMPRESS_OFFLOAD_FRAGMENT_SIZE; 1999 out->compr_config.fragments = COMPRESS_OFFLOAD_NUM_FRAGMENTS; 2000 out->compr_config.codec->sample_rate = 2001 compress_get_alsa_rate(config->offload_info.sample_rate); 2002 out->compr_config.codec->bit_rate = 2003 config->offload_info.bit_rate; 2004 out->compr_config.codec->ch_in = 2005 audio_channel_count_from_out_mask(config->channel_mask); 2006 out->compr_config.codec->ch_out = out->compr_config.codec->ch_in; 2007 2008 if (flags & AUDIO_OUTPUT_FLAG_NON_BLOCKING) 2009 out->non_blocking = 1; 2010 2011 out->send_new_metadata = 1; 2012 create_offload_callback_thread(out); 2013 ALOGV("%s: offloaded output offload_info version %04x bit rate %d", 2014 __func__, config->offload_info.version, 2015 config->offload_info.bit_rate); 2016 } else if (out->devices == AUDIO_DEVICE_OUT_TELEPHONY_TX) { 2017 if (config->sample_rate == 0) 2018 config->sample_rate = AFE_PROXY_SAMPLING_RATE; 2019 if (config->sample_rate != 48000 && config->sample_rate != 16000 && 2020 config->sample_rate != 8000) { 2021 config->sample_rate = AFE_PROXY_SAMPLING_RATE; 2022 ret = -EINVAL; 2023 goto error_open; 2024 } 2025 out->sample_rate = config->sample_rate; 2026 out->config.rate = config->sample_rate; 2027 if (config->format == AUDIO_FORMAT_DEFAULT) 2028 config->format = AUDIO_FORMAT_PCM_16_BIT; 2029 if (config->format != AUDIO_FORMAT_PCM_16_BIT) { 2030 config->format = AUDIO_FORMAT_PCM_16_BIT; 2031 ret = -EINVAL; 2032 goto error_open; 2033 } 2034 out->format = config->format; 2035 out->usecase = USECASE_AUDIO_PLAYBACK_AFE_PROXY; 2036 out->config = pcm_config_afe_proxy_playback; 2037 adev->voice_tx_output = out; 2038 } else { 2039 if (out->flags & AUDIO_OUTPUT_FLAG_DEEP_BUFFER) { 2040 out->usecase = USECASE_AUDIO_PLAYBACK_DEEP_BUFFER; 2041 out->config = pcm_config_deep_buffer; 2042 } else { 2043 out->usecase = USECASE_AUDIO_PLAYBACK_LOW_LATENCY; 2044 out->config = pcm_config_low_latency; 2045 } 2046 if (config->format != audio_format_from_pcm_format(out->config.format)) { 2047 if (k_enable_extended_precision 2048 && pcm_params_format_test(adev->use_case_table[out->usecase], 2049 pcm_format_from_audio_format(config->format))) { 2050 out->config.format = pcm_format_from_audio_format(config->format); 2051 /* out->format already set to config->format */ 2052 } else { 2053 /* deny the externally proposed config format 2054 * and use the one specified in audio_hw layer configuration. 2055 * Note: out->format is returned by out->stream.common.get_format() 2056 * and is used to set config->format in the code several lines below. 2057 */ 2058 out->format = audio_format_from_pcm_format(out->config.format); 2059 } 2060 } 2061 out->sample_rate = out->config.rate; 2062 } 2063 ALOGV("%s: Usecase(%s) config->format %#x out->config.format %#x\n", 2064 __func__, use_case_table[out->usecase], config->format, out->config.format); 2065 2066 if (flags & AUDIO_OUTPUT_FLAG_PRIMARY) { 2067 if (adev->primary_output == NULL) 2068 adev->primary_output = out; 2069 else { 2070 ALOGE("%s: Primary output is already opened", __func__); 2071 ret = -EEXIST; 2072 goto error_open; 2073 } 2074 } 2075 2076 /* Check if this usecase is already existing */ 2077 pthread_mutex_lock(&adev->lock); 2078 if (get_usecase_from_list(adev, out->usecase) != NULL) { 2079 ALOGE("%s: Usecase (%d) is already present", __func__, out->usecase); 2080 pthread_mutex_unlock(&adev->lock); 2081 ret = -EEXIST; 2082 goto error_open; 2083 } 2084 pthread_mutex_unlock(&adev->lock); 2085 2086 out->stream.common.get_sample_rate = out_get_sample_rate; 2087 out->stream.common.set_sample_rate = out_set_sample_rate; 2088 out->stream.common.get_buffer_size = out_get_buffer_size; 2089 out->stream.common.get_channels = out_get_channels; 2090 out->stream.common.get_format = out_get_format; 2091 out->stream.common.set_format = out_set_format; 2092 out->stream.common.standby = out_standby; 2093 out->stream.common.dump = out_dump; 2094 out->stream.common.set_parameters = out_set_parameters; 2095 out->stream.common.get_parameters = out_get_parameters; 2096 out->stream.common.add_audio_effect = out_add_audio_effect; 2097 out->stream.common.remove_audio_effect = out_remove_audio_effect; 2098 out->stream.get_latency = out_get_latency; 2099 out->stream.set_volume = out_set_volume; 2100 out->stream.write = out_write; 2101 out->stream.get_render_position = out_get_render_position; 2102 out->stream.get_next_write_timestamp = out_get_next_write_timestamp; 2103 out->stream.get_presentation_position = out_get_presentation_position; 2104 2105 out->standby = 1; 2106 /* out->muted = false; by calloc() */ 2107 /* out->written = 0; by calloc() */ 2108 2109 pthread_mutex_init(&out->lock, (const pthread_mutexattr_t *) NULL); 2110 pthread_cond_init(&out->cond, (const pthread_condattr_t *) NULL); 2111 2112 config->format = out->stream.common.get_format(&out->stream.common); 2113 config->channel_mask = out->stream.common.get_channels(&out->stream.common); 2114 config->sample_rate = out->stream.common.get_sample_rate(&out->stream.common); 2115 2116 *stream_out = &out->stream; 2117 ALOGV("%s: exit", __func__); 2118 return 0; 2119 2120 error_open: 2121 free(out); 2122 *stream_out = NULL; 2123 ALOGD("%s: exit: ret %d", __func__, ret); 2124 return ret; 2125 } 2126 2127 static void adev_close_output_stream(struct audio_hw_device *dev __unused, 2128 struct audio_stream_out *stream) 2129 { 2130 struct stream_out *out = (struct stream_out *)stream; 2131 struct audio_device *adev = out->dev; 2132 2133 ALOGV("%s: enter", __func__); 2134 out_standby(&stream->common); 2135 if (out->usecase == USECASE_AUDIO_PLAYBACK_OFFLOAD) { 2136 destroy_offload_callback_thread(out); 2137 2138 if (out->compr_config.codec != NULL) 2139 free(out->compr_config.codec); 2140 } 2141 2142 if (adev->voice_tx_output == out) 2143 adev->voice_tx_output = NULL; 2144 2145 pthread_cond_destroy(&out->cond); 2146 pthread_mutex_destroy(&out->lock); 2147 free(stream); 2148 ALOGV("%s: exit", __func__); 2149 } 2150 2151 static int adev_set_parameters(struct audio_hw_device *dev, const char *kvpairs) 2152 { 2153 struct audio_device *adev = (struct audio_device *)dev; 2154 struct str_parms *parms; 2155 char *str; 2156 char value[32]; 2157 int val; 2158 int ret; 2159 int status = 0; 2160 2161 ALOGD("%s: enter: %s", __func__, kvpairs); 2162 2163 pthread_mutex_lock(&adev->lock); 2164 2165 parms = str_parms_create_str(kvpairs); 2166 status = voice_set_parameters(adev, parms); 2167 if (status != 0) { 2168 goto done; 2169 } 2170 2171 ret = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_BT_NREC, value, sizeof(value)); 2172 if (ret >= 0) { 2173 /* When set to false, HAL should disable EC and NS 2174 * But it is currently not supported. 2175 */ 2176 if (strcmp(value, AUDIO_PARAMETER_VALUE_ON) == 0) 2177 adev->bluetooth_nrec = true; 2178 else 2179 adev->bluetooth_nrec = false; 2180 } 2181 2182 ret = str_parms_get_str(parms, "screen_state", value, sizeof(value)); 2183 if (ret >= 0) { 2184 if (strcmp(value, AUDIO_PARAMETER_VALUE_ON) == 0) 2185 adev->screen_off = false; 2186 else 2187 adev->screen_off = true; 2188 } 2189 2190 ret = str_parms_get_int(parms, "rotation", &val); 2191 if (ret >= 0) { 2192 bool reverse_speakers = false; 2193 switch(val) { 2194 // FIXME: note that the code below assumes that the speakers are in the correct placement 2195 // relative to the user when the device is rotated 90deg from its default rotation. This 2196 // assumption is device-specific, not platform-specific like this code. 2197 case 270: 2198 reverse_speakers = true; 2199 break; 2200 case 0: 2201 case 90: 2202 case 180: 2203 break; 2204 default: 2205 ALOGE("%s: unexpected rotation of %d", __func__, val); 2206 status = -EINVAL; 2207 } 2208 if (status == 0) { 2209 if (adev->speaker_lr_swap != reverse_speakers) { 2210 adev->speaker_lr_swap = reverse_speakers; 2211 // only update the selected device if there is active pcm playback 2212 struct audio_usecase *usecase; 2213 struct listnode *node; 2214 list_for_each(node, &adev->usecase_list) { 2215 usecase = node_to_item(node, struct audio_usecase, list); 2216 if (usecase->type == PCM_PLAYBACK) { 2217 select_devices(adev, usecase->id); 2218 break; 2219 } 2220 } 2221 } 2222 } 2223 } 2224 2225 ret = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_BT_SCO_WB, value, sizeof(value)); 2226 if (ret >= 0) { 2227 adev->bt_wb_speech_enabled = !strcmp(value, AUDIO_PARAMETER_VALUE_ON); 2228 } 2229 2230 audio_extn_hfp_set_parameters(adev, parms); 2231 done: 2232 str_parms_destroy(parms); 2233 pthread_mutex_unlock(&adev->lock); 2234 ALOGV("%s: exit with code(%d)", __func__, status); 2235 return status; 2236 } 2237 2238 static char* adev_get_parameters(const struct audio_hw_device *dev, 2239 const char *keys) 2240 { 2241 struct audio_device *adev = (struct audio_device *)dev; 2242 struct str_parms *reply = str_parms_create(); 2243 struct str_parms *query = str_parms_create_str(keys); 2244 char *str; 2245 2246 pthread_mutex_lock(&adev->lock); 2247 2248 voice_get_parameters(adev, query, reply); 2249 str = str_parms_to_str(reply); 2250 str_parms_destroy(query); 2251 str_parms_destroy(reply); 2252 2253 pthread_mutex_unlock(&adev->lock); 2254 ALOGV("%s: exit: returns - %s", __func__, str); 2255 return str; 2256 } 2257 2258 static int adev_init_check(const struct audio_hw_device *dev __unused) 2259 { 2260 return 0; 2261 } 2262 2263 static int adev_set_voice_volume(struct audio_hw_device *dev, float volume) 2264 { 2265 int ret; 2266 struct audio_device *adev = (struct audio_device *)dev; 2267 2268 audio_extn_extspk_set_voice_vol(adev->extspk, volume); 2269 2270 pthread_mutex_lock(&adev->lock); 2271 ret = voice_set_volume(adev, volume); 2272 pthread_mutex_unlock(&adev->lock); 2273 2274 return ret; 2275 } 2276 2277 static int adev_set_master_volume(struct audio_hw_device *dev __unused, float volume __unused) 2278 { 2279 return -ENOSYS; 2280 } 2281 2282 static int adev_get_master_volume(struct audio_hw_device *dev __unused, 2283 float *volume __unused) 2284 { 2285 return -ENOSYS; 2286 } 2287 2288 static int adev_set_master_mute(struct audio_hw_device *dev __unused, bool muted __unused) 2289 { 2290 return -ENOSYS; 2291 } 2292 2293 static int adev_get_master_mute(struct audio_hw_device *dev __unused, bool *muted __unused) 2294 { 2295 return -ENOSYS; 2296 } 2297 2298 static int adev_set_mode(struct audio_hw_device *dev, audio_mode_t mode) 2299 { 2300 struct audio_device *adev = (struct audio_device *)dev; 2301 2302 pthread_mutex_lock(&adev->lock); 2303 if (adev->mode != mode) { 2304 ALOGD("%s: mode %d\n", __func__, mode); 2305 adev->mode = mode; 2306 if ((mode == AUDIO_MODE_NORMAL || mode == AUDIO_MODE_IN_COMMUNICATION) && 2307 voice_is_in_call(adev)) { 2308 voice_stop_call(adev); 2309 adev->current_call_output = NULL; 2310 } 2311 } 2312 pthread_mutex_unlock(&adev->lock); 2313 2314 audio_extn_extspk_set_mode(adev->extspk, mode); 2315 2316 return 0; 2317 } 2318 2319 static int adev_set_mic_mute(struct audio_hw_device *dev, bool state) 2320 { 2321 int ret; 2322 struct audio_device *adev = (struct audio_device *)dev; 2323 2324 ALOGD("%s: state %d\n", __func__, state); 2325 pthread_mutex_lock(&adev->lock); 2326 ret = voice_set_mic_mute(adev, state); 2327 adev->mic_muted = state; 2328 pthread_mutex_unlock(&adev->lock); 2329 2330 return ret; 2331 } 2332 2333 static int adev_get_mic_mute(const struct audio_hw_device *dev, bool *state) 2334 { 2335 *state = voice_get_mic_mute((struct audio_device *)dev); 2336 return 0; 2337 } 2338 2339 static size_t adev_get_input_buffer_size(const struct audio_hw_device *dev __unused, 2340 const struct audio_config *config) 2341 { 2342 int channel_count = audio_channel_count_from_in_mask(config->channel_mask); 2343 2344 return get_input_buffer_size(config->sample_rate, config->format, channel_count, 2345 false /* is_low_latency: since we don't know, be conservative */); 2346 } 2347 2348 static int adev_open_input_stream(struct audio_hw_device *dev, 2349 audio_io_handle_t handle __unused, 2350 audio_devices_t devices, 2351 struct audio_config *config, 2352 struct audio_stream_in **stream_in, 2353 audio_input_flags_t flags, 2354 const char *address __unused, 2355 audio_source_t source ) 2356 { 2357 struct audio_device *adev = (struct audio_device *)dev; 2358 struct stream_in *in; 2359 int ret = 0, buffer_size, frame_size; 2360 int channel_count = audio_channel_count_from_in_mask(config->channel_mask); 2361 bool is_low_latency = false; 2362 2363 ALOGV("%s: enter", __func__); 2364 *stream_in = NULL; 2365 if (check_input_parameters(config->sample_rate, config->format, channel_count) != 0) 2366 return -EINVAL; 2367 2368 in = (struct stream_in *)calloc(1, sizeof(struct stream_in)); 2369 2370 pthread_mutex_init(&in->lock, (const pthread_mutexattr_t *) NULL); 2371 2372 in->stream.common.get_sample_rate = in_get_sample_rate; 2373 in->stream.common.set_sample_rate = in_set_sample_rate; 2374 in->stream.common.get_buffer_size = in_get_buffer_size; 2375 in->stream.common.get_channels = in_get_channels; 2376 in->stream.common.get_format = in_get_format; 2377 in->stream.common.set_format = in_set_format; 2378 in->stream.common.standby = in_standby; 2379 in->stream.common.dump = in_dump; 2380 in->stream.common.set_parameters = in_set_parameters; 2381 in->stream.common.get_parameters = in_get_parameters; 2382 in->stream.common.add_audio_effect = in_add_audio_effect; 2383 in->stream.common.remove_audio_effect = in_remove_audio_effect; 2384 in->stream.set_gain = in_set_gain; 2385 in->stream.read = in_read; 2386 in->stream.get_input_frames_lost = in_get_input_frames_lost; 2387 2388 in->device = devices; 2389 in->source = source; 2390 in->dev = adev; 2391 in->standby = 1; 2392 in->channel_mask = config->channel_mask; 2393 2394 /* Update config params with the requested sample rate and channels */ 2395 if (in->device == AUDIO_DEVICE_IN_TELEPHONY_RX) { 2396 if (config->sample_rate == 0) 2397 config->sample_rate = AFE_PROXY_SAMPLING_RATE; 2398 if (config->sample_rate != 48000 && config->sample_rate != 16000 && 2399 config->sample_rate != 8000) { 2400 config->sample_rate = AFE_PROXY_SAMPLING_RATE; 2401 ret = -EINVAL; 2402 goto err_open; 2403 } 2404 if (config->format == AUDIO_FORMAT_DEFAULT) 2405 config->format = AUDIO_FORMAT_PCM_16_BIT; 2406 if (config->format != AUDIO_FORMAT_PCM_16_BIT) { 2407 config->format = AUDIO_FORMAT_PCM_16_BIT; 2408 ret = -EINVAL; 2409 goto err_open; 2410 } 2411 2412 in->usecase = USECASE_AUDIO_RECORD_AFE_PROXY; 2413 in->config = pcm_config_afe_proxy_record; 2414 } else { 2415 in->usecase = USECASE_AUDIO_RECORD; 2416 if (config->sample_rate == LOW_LATENCY_CAPTURE_SAMPLE_RATE && 2417 (flags & AUDIO_INPUT_FLAG_FAST) != 0) { 2418 is_low_latency = true; 2419 #if LOW_LATENCY_CAPTURE_USE_CASE 2420 in->usecase = USECASE_AUDIO_RECORD_LOW_LATENCY; 2421 #endif 2422 } 2423 in->config = pcm_config_audio_capture; 2424 2425 frame_size = audio_stream_in_frame_size(&in->stream); 2426 buffer_size = get_input_buffer_size(config->sample_rate, 2427 config->format, 2428 channel_count, 2429 is_low_latency); 2430 in->config.period_size = buffer_size / frame_size; 2431 } 2432 in->config.channels = channel_count; 2433 in->config.rate = config->sample_rate; 2434 2435 2436 *stream_in = &in->stream; 2437 ALOGV("%s: exit", __func__); 2438 return 0; 2439 2440 err_open: 2441 free(in); 2442 *stream_in = NULL; 2443 return ret; 2444 } 2445 2446 static void adev_close_input_stream(struct audio_hw_device *dev __unused, 2447 struct audio_stream_in *stream) 2448 { 2449 ALOGV("%s", __func__); 2450 2451 in_standby(&stream->common); 2452 free(stream); 2453 2454 return; 2455 } 2456 2457 static int adev_dump(const audio_hw_device_t *device __unused, int fd __unused) 2458 { 2459 return 0; 2460 } 2461 2462 /* verifies input and output devices and their capabilities. 2463 * 2464 * This verification is required when enabling extended bit-depth or 2465 * sampling rates, as not all qcom products support it. 2466 * 2467 * Suitable for calling only on initialization such as adev_open(). 2468 * It fills the audio_device use_case_table[] array. 2469 * 2470 * Has a side-effect that it needs to configure audio routing / devices 2471 * in order to power up the devices and read the device parameters. 2472 * It does not acquire any hw device lock. Should restore the devices 2473 * back to "normal state" upon completion. 2474 */ 2475 static int adev_verify_devices(struct audio_device *adev) 2476 { 2477 /* enumeration is a bit difficult because one really wants to pull 2478 * the use_case, device id, etc from the hidden pcm_device_table[]. 2479 * In this case there are the following use cases and device ids. 2480 * 2481 * [USECASE_AUDIO_PLAYBACK_DEEP_BUFFER] = {0, 0}, 2482 * [USECASE_AUDIO_PLAYBACK_LOW_LATENCY] = {15, 15}, 2483 * [USECASE_AUDIO_PLAYBACK_MULTI_CH] = {1, 1}, 2484 * [USECASE_AUDIO_PLAYBACK_OFFLOAD] = {9, 9}, 2485 * [USECASE_AUDIO_RECORD] = {0, 0}, 2486 * [USECASE_AUDIO_RECORD_LOW_LATENCY] = {15, 15}, 2487 * [USECASE_VOICE_CALL] = {2, 2}, 2488 * 2489 * USECASE_AUDIO_PLAYBACK_OFFLOAD, USECASE_AUDIO_PLAYBACK_MULTI_CH omitted. 2490 * USECASE_VOICE_CALL omitted, but possible for either input or output. 2491 */ 2492 2493 /* should be the usecases enabled in adev_open_input_stream() */ 2494 static const int test_in_usecases[] = { 2495 USECASE_AUDIO_RECORD, 2496 USECASE_AUDIO_RECORD_LOW_LATENCY, /* does not appear to be used */ 2497 }; 2498 /* should be the usecases enabled in adev_open_output_stream()*/ 2499 static const int test_out_usecases[] = { 2500 USECASE_AUDIO_PLAYBACK_DEEP_BUFFER, 2501 USECASE_AUDIO_PLAYBACK_LOW_LATENCY, 2502 }; 2503 static const usecase_type_t usecase_type_by_dir[] = { 2504 PCM_PLAYBACK, 2505 PCM_CAPTURE, 2506 }; 2507 static const unsigned flags_by_dir[] = { 2508 PCM_OUT, 2509 PCM_IN, 2510 }; 2511 2512 size_t i; 2513 unsigned dir; 2514 const unsigned card_id = adev->snd_card; 2515 char info[512]; /* for possible debug info */ 2516 2517 for (dir = 0; dir < 2; ++dir) { 2518 const usecase_type_t usecase_type = usecase_type_by_dir[dir]; 2519 const unsigned flags_dir = flags_by_dir[dir]; 2520 const size_t testsize = 2521 dir ? ARRAY_SIZE(test_in_usecases) : ARRAY_SIZE(test_out_usecases); 2522 const int *testcases = 2523 dir ? test_in_usecases : test_out_usecases; 2524 const audio_devices_t audio_device = 2525 dir ? AUDIO_DEVICE_IN_BUILTIN_MIC : AUDIO_DEVICE_OUT_SPEAKER; 2526 2527 for (i = 0; i < testsize; ++i) { 2528 const audio_usecase_t audio_usecase = testcases[i]; 2529 int device_id; 2530 snd_device_t snd_device; 2531 struct pcm_params **pparams; 2532 struct stream_out out; 2533 struct stream_in in; 2534 struct audio_usecase uc_info; 2535 int retval; 2536 2537 pparams = &adev->use_case_table[audio_usecase]; 2538 pcm_params_free(*pparams); /* can accept null input */ 2539 *pparams = NULL; 2540 2541 /* find the device ID for the use case (signed, for error) */ 2542 device_id = platform_get_pcm_device_id(audio_usecase, usecase_type); 2543 if (device_id < 0) 2544 continue; 2545 2546 /* prepare structures for device probing */ 2547 memset(&uc_info, 0, sizeof(uc_info)); 2548 uc_info.id = audio_usecase; 2549 uc_info.type = usecase_type; 2550 if (dir) { 2551 adev->active_input = ∈ 2552 memset(&in, 0, sizeof(in)); 2553 in.device = audio_device; 2554 in.source = AUDIO_SOURCE_VOICE_COMMUNICATION; 2555 uc_info.stream.in = ∈ 2556 } else { 2557 adev->active_input = NULL; 2558 } 2559 memset(&out, 0, sizeof(out)); 2560 out.devices = audio_device; /* only field needed in select_devices */ 2561 uc_info.stream.out = &out; 2562 uc_info.devices = audio_device; 2563 uc_info.in_snd_device = SND_DEVICE_NONE; 2564 uc_info.out_snd_device = SND_DEVICE_NONE; 2565 list_add_tail(&adev->usecase_list, &uc_info.list); 2566 2567 /* select device - similar to start_(in/out)put_stream() */ 2568 retval = select_devices(adev, audio_usecase); 2569 if (retval >= 0) { 2570 *pparams = pcm_params_get(card_id, device_id, flags_dir); 2571 #if LOG_NDEBUG == 0 2572 if (*pparams) { 2573 ALOGV("%s: (%s) card %d device %d", __func__, 2574 dir ? "input" : "output", card_id, device_id); 2575 pcm_params_to_string(*pparams, info, ARRAY_SIZE(info)); 2576 ALOGV(info); /* print parameters */ 2577 } else { 2578 ALOGV("%s: cannot locate card %d device %d", __func__, card_id, device_id); 2579 } 2580 #endif 2581 } 2582 2583 /* deselect device - similar to stop_(in/out)put_stream() */ 2584 /* 1. Get and set stream specific mixer controls */ 2585 retval = disable_audio_route(adev, &uc_info); 2586 /* 2. Disable the rx device */ 2587 retval = disable_snd_device(adev, 2588 dir ? uc_info.in_snd_device : uc_info.out_snd_device); 2589 list_remove(&uc_info.list); 2590 } 2591 } 2592 adev->active_input = NULL; /* restore adev state */ 2593 return 0; 2594 } 2595 2596 static int adev_close(hw_device_t *device) 2597 { 2598 size_t i; 2599 struct audio_device *adev = (struct audio_device *)device; 2600 audio_route_free(adev->audio_route); 2601 free(adev->snd_dev_ref_cnt); 2602 platform_deinit(adev->platform); 2603 audio_extn_extspk_deinit(adev->extspk); 2604 for (i = 0; i < ARRAY_SIZE(adev->use_case_table); ++i) { 2605 pcm_params_free(adev->use_case_table[i]); 2606 } 2607 free(device); 2608 return 0; 2609 } 2610 2611 /* This returns 1 if the input parameter looks at all plausible as a low latency period size, 2612 * or 0 otherwise. A return value of 1 doesn't mean the value is guaranteed to work, 2613 * just that it _might_ work. 2614 */ 2615 static int period_size_is_plausible_for_low_latency(int period_size) 2616 { 2617 switch (period_size) { 2618 case 160: 2619 case 240: 2620 case 320: 2621 case 480: 2622 return 1; 2623 default: 2624 return 0; 2625 } 2626 } 2627 2628 static int adev_open(const hw_module_t *module, const char *name, 2629 hw_device_t **device) 2630 { 2631 struct audio_device *adev; 2632 int i, ret; 2633 2634 ALOGD("%s: enter", __func__); 2635 if (strcmp(name, AUDIO_HARDWARE_INTERFACE) != 0) return -EINVAL; 2636 2637 adev = calloc(1, sizeof(struct audio_device)); 2638 2639 pthread_mutex_init(&adev->lock, (const pthread_mutexattr_t *) NULL); 2640 2641 adev->device.common.tag = HARDWARE_DEVICE_TAG; 2642 adev->device.common.version = AUDIO_DEVICE_API_VERSION_2_0; 2643 adev->device.common.module = (struct hw_module_t *)module; 2644 adev->device.common.close = adev_close; 2645 2646 adev->device.init_check = adev_init_check; 2647 adev->device.set_voice_volume = adev_set_voice_volume; 2648 adev->device.set_master_volume = adev_set_master_volume; 2649 adev->device.get_master_volume = adev_get_master_volume; 2650 adev->device.set_master_mute = adev_set_master_mute; 2651 adev->device.get_master_mute = adev_get_master_mute; 2652 adev->device.set_mode = adev_set_mode; 2653 adev->device.set_mic_mute = adev_set_mic_mute; 2654 adev->device.get_mic_mute = adev_get_mic_mute; 2655 adev->device.set_parameters = adev_set_parameters; 2656 adev->device.get_parameters = adev_get_parameters; 2657 adev->device.get_input_buffer_size = adev_get_input_buffer_size; 2658 adev->device.open_output_stream = adev_open_output_stream; 2659 adev->device.close_output_stream = adev_close_output_stream; 2660 adev->device.open_input_stream = adev_open_input_stream; 2661 adev->device.close_input_stream = adev_close_input_stream; 2662 adev->device.dump = adev_dump; 2663 2664 /* Set the default route before the PCM stream is opened */ 2665 pthread_mutex_lock(&adev->lock); 2666 adev->mode = AUDIO_MODE_NORMAL; 2667 adev->active_input = NULL; 2668 adev->primary_output = NULL; 2669 adev->bluetooth_nrec = true; 2670 adev->acdb_settings = TTY_MODE_OFF; 2671 /* adev->cur_hdmi_channels = 0; by calloc() */ 2672 adev->snd_dev_ref_cnt = calloc(SND_DEVICE_MAX, sizeof(int)); 2673 voice_init(adev); 2674 list_init(&adev->usecase_list); 2675 pthread_mutex_unlock(&adev->lock); 2676 2677 /* Loads platform specific libraries dynamically */ 2678 adev->platform = platform_init(adev); 2679 if (!adev->platform) { 2680 free(adev->snd_dev_ref_cnt); 2681 free(adev); 2682 ALOGE("%s: Failed to init platform data, aborting.", __func__); 2683 *device = NULL; 2684 return -EINVAL; 2685 } 2686 2687 adev->extspk = audio_extn_extspk_init(adev); 2688 2689 if (access(VISUALIZER_LIBRARY_PATH, R_OK) == 0) { 2690 adev->visualizer_lib = dlopen(VISUALIZER_LIBRARY_PATH, RTLD_NOW); 2691 if (adev->visualizer_lib == NULL) { 2692 ALOGE("%s: DLOPEN failed for %s", __func__, VISUALIZER_LIBRARY_PATH); 2693 } else { 2694 ALOGV("%s: DLOPEN successful for %s", __func__, VISUALIZER_LIBRARY_PATH); 2695 adev->visualizer_start_output = 2696 (int (*)(audio_io_handle_t, int))dlsym(adev->visualizer_lib, 2697 "visualizer_hal_start_output"); 2698 adev->visualizer_stop_output = 2699 (int (*)(audio_io_handle_t, int))dlsym(adev->visualizer_lib, 2700 "visualizer_hal_stop_output"); 2701 } 2702 } 2703 2704 if (access(OFFLOAD_EFFECTS_BUNDLE_LIBRARY_PATH, R_OK) == 0) { 2705 adev->offload_effects_lib = dlopen(OFFLOAD_EFFECTS_BUNDLE_LIBRARY_PATH, RTLD_NOW); 2706 if (adev->offload_effects_lib == NULL) { 2707 ALOGE("%s: DLOPEN failed for %s", __func__, 2708 OFFLOAD_EFFECTS_BUNDLE_LIBRARY_PATH); 2709 } else { 2710 ALOGV("%s: DLOPEN successful for %s", __func__, 2711 OFFLOAD_EFFECTS_BUNDLE_LIBRARY_PATH); 2712 adev->offload_effects_start_output = 2713 (int (*)(audio_io_handle_t, int))dlsym(adev->offload_effects_lib, 2714 "offload_effects_bundle_hal_start_output"); 2715 adev->offload_effects_stop_output = 2716 (int (*)(audio_io_handle_t, int))dlsym(adev->offload_effects_lib, 2717 "offload_effects_bundle_hal_stop_output"); 2718 } 2719 } 2720 2721 adev->bt_wb_speech_enabled = false; 2722 adev->enable_voicerx = false; 2723 2724 *device = &adev->device.common; 2725 if (k_enable_extended_precision) 2726 adev_verify_devices(adev); 2727 2728 char value[PROPERTY_VALUE_MAX]; 2729 int trial; 2730 if (property_get("audio_hal.period_size", value, NULL) > 0) { 2731 trial = atoi(value); 2732 if (period_size_is_plausible_for_low_latency(trial)) { 2733 pcm_config_low_latency.period_size = trial; 2734 pcm_config_low_latency.start_threshold = trial / 4; 2735 pcm_config_low_latency.avail_min = trial / 4; 2736 configured_low_latency_capture_period_size = trial; 2737 } 2738 } 2739 if (property_get("audio_hal.in_period_size", value, NULL) > 0) { 2740 trial = atoi(value); 2741 if (period_size_is_plausible_for_low_latency(trial)) { 2742 configured_low_latency_capture_period_size = trial; 2743 } 2744 } 2745 2746 ALOGV("%s: exit", __func__); 2747 return 0; 2748 } 2749 2750 static struct hw_module_methods_t hal_module_methods = { 2751 .open = adev_open, 2752 }; 2753 2754 struct audio_module HAL_MODULE_INFO_SYM = { 2755 .common = { 2756 .tag = HARDWARE_MODULE_TAG, 2757 .module_api_version = AUDIO_MODULE_API_VERSION_0_1, 2758 .hal_api_version = HARDWARE_HAL_API_VERSION, 2759 .id = AUDIO_HARDWARE_MODULE_ID, 2760 .name = "QCOM Audio HAL", 2761 .author = "Code Aurora Forum", 2762 .methods = &hal_module_methods, 2763 }, 2764 }; 2765
