1 /* 2 * Copyright (C) 2015 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 <system/thread_defs.h> 44 #include <audio_effects/effect_aec.h> 45 #include <audio_effects/effect_ns.h> 46 #include <audio_utils/channels.h> 47 #include "audio_hw.h" 48 #include "cras_dsp.h" 49 50 /* TODO: the following PCM device profiles could be read from a config file */ 51 struct pcm_device_profile pcm_device_playback_hs = { 52 .config = { 53 .channels = PLAYBACK_DEFAULT_CHANNEL_COUNT, 54 .rate = PLAYBACK_DEFAULT_SAMPLING_RATE, 55 .period_size = PLAYBACK_PERIOD_SIZE, 56 .period_count = PLAYBACK_PERIOD_COUNT, 57 .format = PCM_FORMAT_S16_LE, 58 .start_threshold = PLAYBACK_START_THRESHOLD, 59 .stop_threshold = PLAYBACK_STOP_THRESHOLD, 60 .silence_threshold = 0, 61 .avail_min = PLAYBACK_AVAILABLE_MIN, 62 }, 63 .card = SOUND_CARD, 64 .id = 1, 65 .device = 0, 66 .type = PCM_PLAYBACK, 67 .devices = AUDIO_DEVICE_OUT_WIRED_HEADSET|AUDIO_DEVICE_OUT_WIRED_HEADPHONE, 68 .dsp_name = "invert_lr", 69 }; 70 71 struct pcm_device_profile pcm_device_capture = { 72 .config = { 73 .channels = CAPTURE_DEFAULT_CHANNEL_COUNT, 74 .rate = CAPTURE_DEFAULT_SAMPLING_RATE, 75 .period_size = CAPTURE_PERIOD_SIZE, 76 .period_count = CAPTURE_PERIOD_COUNT, 77 .format = PCM_FORMAT_S16_LE, 78 .start_threshold = CAPTURE_START_THRESHOLD, 79 .stop_threshold = 0, 80 .silence_threshold = 0, 81 .avail_min = 0, 82 }, 83 .card = SOUND_CARD, 84 .id = 2, 85 .device = 0, 86 .type = PCM_CAPTURE, 87 .devices = AUDIO_DEVICE_IN_BUILTIN_MIC|AUDIO_DEVICE_IN_WIRED_HEADSET|AUDIO_DEVICE_IN_BACK_MIC, 88 }; 89 90 struct pcm_device_profile pcm_device_capture_loopback_aec = { 91 .config = { 92 .channels = CAPTURE_DEFAULT_CHANNEL_COUNT, 93 .rate = CAPTURE_DEFAULT_SAMPLING_RATE, 94 .period_size = CAPTURE_PERIOD_SIZE, 95 .period_count = CAPTURE_PERIOD_COUNT, 96 .format = PCM_FORMAT_S16_LE, 97 .start_threshold = CAPTURE_START_THRESHOLD, 98 .stop_threshold = 0, 99 .silence_threshold = 0, 100 .avail_min = 0, 101 }, 102 .card = SOUND_CARD, 103 .id = 3, 104 .device = 1, 105 .type = PCM_CAPTURE, 106 .devices = SND_DEVICE_IN_LOOPBACK_AEC, 107 }; 108 109 struct pcm_device_profile pcm_device_playback_spk_and_headset = { 110 .config = { 111 .channels = PLAYBACK_DEFAULT_CHANNEL_COUNT, 112 .rate = PLAYBACK_DEFAULT_SAMPLING_RATE, 113 .period_size = PLAYBACK_PERIOD_SIZE, 114 .period_count = PLAYBACK_PERIOD_COUNT, 115 .format = PCM_FORMAT_S16_LE, 116 .start_threshold = PLAYBACK_START_THRESHOLD, 117 .stop_threshold = PLAYBACK_STOP_THRESHOLD, 118 .silence_threshold = 0, 119 .avail_min = PLAYBACK_AVAILABLE_MIN, 120 }, 121 .card = SOUND_CARD, 122 .id = 4, 123 .device = 0, 124 .type = PCM_PLAYBACK, 125 .devices = AUDIO_DEVICE_OUT_SPEAKER|AUDIO_DEVICE_OUT_WIRED_HEADSET|AUDIO_DEVICE_OUT_WIRED_HEADPHONE, 126 .dsp_name = "speaker_eq", 127 }; 128 129 struct pcm_device_profile pcm_device_playback_spk = { 130 .config = { 131 .channels = PLAYBACK_DEFAULT_CHANNEL_COUNT, 132 .rate = PLAYBACK_DEFAULT_SAMPLING_RATE, 133 .period_size = PLAYBACK_PERIOD_SIZE, 134 .period_count = PLAYBACK_PERIOD_COUNT, 135 .format = PCM_FORMAT_S16_LE, 136 .start_threshold = PLAYBACK_START_THRESHOLD, 137 .stop_threshold = PLAYBACK_STOP_THRESHOLD, 138 .silence_threshold = 0, 139 .avail_min = PLAYBACK_AVAILABLE_MIN, 140 }, 141 .card = SOUND_CARD, 142 .id = 5, 143 .device = 0, 144 .type = PCM_PLAYBACK, 145 .devices = AUDIO_DEVICE_OUT_SPEAKER, 146 .dsp_name = "speaker_eq", 147 }; 148 149 static struct pcm_device_profile pcm_device_hotword_streaming = { 150 .config = { 151 .channels = 1, 152 .rate = 16000, 153 .period_size = CAPTURE_PERIOD_SIZE, 154 .period_count = CAPTURE_PERIOD_COUNT, 155 .format = PCM_FORMAT_S16_LE, 156 .start_threshold = CAPTURE_START_THRESHOLD, 157 .stop_threshold = 0, 158 .silence_threshold = 0, 159 .avail_min = 0, 160 }, 161 .card = SOUND_CARD, 162 .id = 0, 163 .type = PCM_HOTWORD_STREAMING, 164 .devices = AUDIO_DEVICE_IN_BUILTIN_MIC | 165 AUDIO_DEVICE_IN_WIRED_HEADSET | 166 AUDIO_DEVICE_IN_BACK_MIC, 167 }; 168 169 struct pcm_device_profile *pcm_devices[] = { 170 &pcm_device_playback_hs, 171 &pcm_device_capture, 172 &pcm_device_playback_spk, 173 &pcm_device_capture_loopback_aec, 174 &pcm_device_playback_spk_and_headset, 175 &pcm_device_hotword_streaming, 176 NULL, 177 }; 178 179 static const char * const use_case_table[AUDIO_USECASE_MAX] = { 180 [USECASE_AUDIO_PLAYBACK] = "playback", 181 [USECASE_AUDIO_PLAYBACK_MULTI_CH] = "playback multi-channel", 182 [USECASE_AUDIO_CAPTURE] = "capture", 183 [USECASE_AUDIO_CAPTURE_HOTWORD] = "capture-hotword", 184 [USECASE_VOICE_CALL] = "voice-call", 185 }; 186 187 188 #define STRING_TO_ENUM(string) { #string, string } 189 190 struct pcm_config pcm_config_deep_buffer = { 191 .channels = 2, 192 .rate = DEEP_BUFFER_OUTPUT_SAMPLING_RATE, 193 .period_size = DEEP_BUFFER_OUTPUT_PERIOD_SIZE, 194 .period_count = DEEP_BUFFER_OUTPUT_PERIOD_COUNT, 195 .format = PCM_FORMAT_S16_LE, 196 .start_threshold = DEEP_BUFFER_OUTPUT_PERIOD_SIZE / 4, 197 .stop_threshold = INT_MAX, 198 .avail_min = DEEP_BUFFER_OUTPUT_PERIOD_SIZE / 4, 199 }; 200 201 struct string_to_enum { 202 const char *name; 203 uint32_t value; 204 }; 205 206 static const struct string_to_enum out_channels_name_to_enum_table[] = { 207 STRING_TO_ENUM(AUDIO_CHANNEL_OUT_STEREO), 208 STRING_TO_ENUM(AUDIO_CHANNEL_OUT_5POINT1), 209 STRING_TO_ENUM(AUDIO_CHANNEL_OUT_7POINT1), 210 }; 211 212 static bool is_supported_format(audio_format_t format) 213 { 214 if (format == AUDIO_FORMAT_MP3 || 215 ((format & AUDIO_FORMAT_MAIN_MASK) == AUDIO_FORMAT_AAC)) 216 return true; 217 218 return false; 219 } 220 221 static int get_snd_codec_id(audio_format_t format) 222 { 223 int id = 0; 224 225 switch (format & AUDIO_FORMAT_MAIN_MASK) { 226 default: 227 ALOGE("%s: Unsupported audio format", __func__); 228 } 229 230 return id; 231 } 232 233 /* Array to store sound devices */ 234 static const char * const device_table[SND_DEVICE_MAX] = { 235 [SND_DEVICE_NONE] = "none", 236 /* Playback sound devices */ 237 [SND_DEVICE_OUT_HANDSET] = "handset", 238 [SND_DEVICE_OUT_SPEAKER] = "speaker", 239 [SND_DEVICE_OUT_HEADPHONES] = "headphones", 240 [SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES] = "speaker-and-headphones", 241 [SND_DEVICE_OUT_VOICE_HANDSET] = "voice-handset", 242 [SND_DEVICE_OUT_VOICE_SPEAKER] = "voice-speaker", 243 [SND_DEVICE_OUT_VOICE_HEADPHONES] = "voice-headphones", 244 [SND_DEVICE_OUT_HDMI] = "hdmi", 245 [SND_DEVICE_OUT_SPEAKER_AND_HDMI] = "speaker-and-hdmi", 246 [SND_DEVICE_OUT_VOICE_TTY_FULL_HEADPHONES] = "voice-tty-full-headphones", 247 [SND_DEVICE_OUT_VOICE_TTY_VCO_HEADPHONES] = "voice-tty-vco-headphones", 248 [SND_DEVICE_OUT_VOICE_TTY_HCO_HANDSET] = "voice-tty-hco-handset", 249 250 /* Capture sound devices */ 251 [SND_DEVICE_IN_HANDSET_MIC] = "handset-mic", 252 [SND_DEVICE_IN_SPEAKER_MIC] = "speaker-mic", 253 [SND_DEVICE_IN_HEADSET_MIC] = "headset-mic", 254 [SND_DEVICE_IN_HANDSET_MIC_AEC] = "handset-mic", 255 [SND_DEVICE_IN_SPEAKER_MIC_AEC] = "voice-speaker-mic", 256 [SND_DEVICE_IN_HEADSET_MIC_AEC] = "headset-mic", 257 [SND_DEVICE_IN_VOICE_SPEAKER_MIC] = "voice-speaker-mic", 258 [SND_DEVICE_IN_VOICE_HEADSET_MIC] = "voice-headset-mic", 259 [SND_DEVICE_IN_HDMI_MIC] = "hdmi-mic", 260 [SND_DEVICE_IN_CAMCORDER_MIC] = "camcorder-mic", 261 [SND_DEVICE_IN_VOICE_DMIC_1] = "voice-dmic-1", 262 [SND_DEVICE_IN_VOICE_SPEAKER_DMIC_1] = "voice-speaker-dmic-1", 263 [SND_DEVICE_IN_VOICE_TTY_FULL_HEADSET_MIC] = "voice-tty-full-headset-mic", 264 [SND_DEVICE_IN_VOICE_TTY_VCO_HANDSET_MIC] = "voice-tty-vco-handset-mic", 265 [SND_DEVICE_IN_VOICE_TTY_HCO_HEADSET_MIC] = "voice-tty-hco-headset-mic", 266 [SND_DEVICE_IN_VOICE_REC_HEADSET_MIC] = "voice-rec-headset-mic", 267 [SND_DEVICE_IN_VOICE_REC_MIC] = "voice-rec-mic", 268 [SND_DEVICE_IN_VOICE_REC_DMIC_1] = "voice-rec-dmic-1", 269 [SND_DEVICE_IN_VOICE_REC_DMIC_NS_1] = "voice-rec-dmic-ns-1", 270 [SND_DEVICE_IN_LOOPBACK_AEC] = "loopback-aec", 271 }; 272 273 struct mixer_card *adev_get_mixer_for_card(struct audio_device *adev, int card) 274 { 275 struct mixer_card *mixer_card; 276 struct listnode *node; 277 278 list_for_each(node, &adev->mixer_list) { 279 mixer_card = node_to_item(node, struct mixer_card, adev_list_node); 280 if (mixer_card->card == card) 281 return mixer_card; 282 } 283 return NULL; 284 } 285 286 struct mixer_card *uc_get_mixer_for_card(struct audio_usecase *usecase, int card) 287 { 288 struct mixer_card *mixer_card; 289 struct listnode *node; 290 291 list_for_each(node, &usecase->mixer_list) { 292 mixer_card = node_to_item(node, struct mixer_card, uc_list_node[usecase->id]); 293 if (mixer_card->card == card) 294 return mixer_card; 295 } 296 return NULL; 297 } 298 299 void free_mixer_list(struct audio_device *adev) 300 { 301 struct mixer_card *mixer_card; 302 struct listnode *node; 303 struct listnode *next; 304 305 list_for_each_safe(node, next, &adev->mixer_list) { 306 mixer_card = node_to_item(node, struct mixer_card, adev_list_node); 307 list_remove(node); 308 audio_route_free(mixer_card->audio_route); 309 free(mixer_card); 310 } 311 } 312 313 int mixer_init(struct audio_device *adev) 314 { 315 int i; 316 int card; 317 int retry_num; 318 struct mixer *mixer; 319 struct audio_route *audio_route; 320 char mixer_path[PATH_MAX]; 321 struct mixer_card *mixer_card; 322 struct listnode *node; 323 324 list_init(&adev->mixer_list); 325 326 for (i = 0; pcm_devices[i] != NULL; i++) { 327 card = pcm_devices[i]->card; 328 if (adev_get_mixer_for_card(adev, card) == NULL) { 329 retry_num = 0; 330 do { 331 mixer = mixer_open(card); 332 if (mixer == NULL) { 333 if (++retry_num > RETRY_NUMBER) { 334 ALOGE("%s unable to open the mixer for--card %d, aborting.", 335 __func__, card); 336 goto error; 337 } 338 usleep(RETRY_US); 339 } 340 } while (mixer == NULL); 341 342 sprintf(mixer_path, "/system/etc/mixer_paths_%d.xml", card); 343 audio_route = audio_route_init(card, mixer_path); 344 if (!audio_route) { 345 ALOGE("%s: Failed to init audio route controls for card %d, aborting.", 346 __func__, card); 347 goto error; 348 } 349 mixer_card = calloc(1, sizeof(struct mixer_card)); 350 mixer_card->card = card; 351 mixer_card->mixer = mixer; 352 mixer_card->audio_route = audio_route; 353 list_add_tail(&adev->mixer_list, &mixer_card->adev_list_node); 354 } 355 } 356 357 return 0; 358 359 error: 360 free_mixer_list(adev); 361 return -ENODEV; 362 } 363 364 const char *get_snd_device_name(snd_device_t snd_device) 365 { 366 const char *name = NULL; 367 368 if (snd_device >= SND_DEVICE_MIN && snd_device < SND_DEVICE_MAX) 369 name = device_table[snd_device]; 370 371 ALOGE_IF(name == NULL, "%s: invalid snd device %d", __func__, snd_device); 372 373 return name; 374 } 375 376 const char *get_snd_device_display_name(snd_device_t snd_device) 377 { 378 const char *name = get_snd_device_name(snd_device); 379 380 if (name == NULL) 381 name = "SND DEVICE NOT FOUND"; 382 383 return name; 384 } 385 386 struct pcm_device_profile *get_pcm_device(usecase_type_t uc_type, audio_devices_t devices) 387 { 388 int i; 389 390 devices &= ~AUDIO_DEVICE_BIT_IN; 391 392 if (!devices) 393 return NULL; 394 395 for (i = 0; pcm_devices[i] != NULL; i++) { 396 if ((pcm_devices[i]->type == uc_type) && 397 (devices & pcm_devices[i]->devices) == devices) 398 return pcm_devices[i]; 399 } 400 401 return NULL; 402 } 403 404 static struct audio_usecase *get_usecase_from_id(struct audio_device *adev, 405 audio_usecase_t uc_id) 406 { 407 struct audio_usecase *usecase; 408 struct listnode *node; 409 410 list_for_each(node, &adev->usecase_list) { 411 usecase = node_to_item(node, struct audio_usecase, adev_list_node); 412 if (usecase->id == uc_id) 413 return usecase; 414 } 415 return NULL; 416 } 417 418 static struct audio_usecase *get_usecase_from_type(struct audio_device *adev, 419 usecase_type_t type) 420 { 421 struct audio_usecase *usecase; 422 struct listnode *node; 423 424 list_for_each(node, &adev->usecase_list) { 425 usecase = node_to_item(node, struct audio_usecase, adev_list_node); 426 if (usecase->type & type) 427 return usecase; 428 } 429 return NULL; 430 } 431 432 /* always called with adev lock held */ 433 static int set_voice_volume_l(struct audio_device *adev, float volume) 434 { 435 int err = 0; 436 (void)volume; 437 438 if (adev->mode == AUDIO_MODE_IN_CALL) { 439 /* TODO */ 440 } 441 return err; 442 } 443 444 445 snd_device_t get_output_snd_device(struct audio_device *adev, audio_devices_t devices) 446 { 447 448 audio_mode_t mode = adev->mode; 449 snd_device_t snd_device = SND_DEVICE_NONE; 450 451 ALOGV("%s: enter: output devices(%#x), mode(%d)", __func__, devices, mode); 452 if (devices == AUDIO_DEVICE_NONE || 453 devices & AUDIO_DEVICE_BIT_IN) { 454 ALOGV("%s: Invalid output devices (%#x)", __func__, devices); 455 goto exit; 456 } 457 458 if (mode == AUDIO_MODE_IN_CALL) { 459 if (devices & AUDIO_DEVICE_OUT_WIRED_HEADPHONE || 460 devices & AUDIO_DEVICE_OUT_WIRED_HEADSET) { 461 if (adev->tty_mode == TTY_MODE_FULL) 462 snd_device = SND_DEVICE_OUT_VOICE_TTY_FULL_HEADPHONES; 463 else if (adev->tty_mode == TTY_MODE_VCO) 464 snd_device = SND_DEVICE_OUT_VOICE_TTY_VCO_HEADPHONES; 465 else if (adev->tty_mode == TTY_MODE_HCO) 466 snd_device = SND_DEVICE_OUT_VOICE_TTY_HCO_HANDSET; 467 else 468 snd_device = SND_DEVICE_OUT_VOICE_HEADPHONES; 469 } else if (devices & AUDIO_DEVICE_OUT_SPEAKER) { 470 snd_device = SND_DEVICE_OUT_VOICE_SPEAKER; 471 } else if (devices & AUDIO_DEVICE_OUT_EARPIECE) { 472 snd_device = SND_DEVICE_OUT_HANDSET; 473 } 474 if (snd_device != SND_DEVICE_NONE) { 475 goto exit; 476 } 477 } 478 479 if (popcount(devices) == 2) { 480 if (devices == (AUDIO_DEVICE_OUT_WIRED_HEADPHONE | 481 AUDIO_DEVICE_OUT_SPEAKER)) { 482 snd_device = SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES; 483 } else if (devices == (AUDIO_DEVICE_OUT_WIRED_HEADSET | 484 AUDIO_DEVICE_OUT_SPEAKER)) { 485 snd_device = SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES; 486 } else { 487 ALOGE("%s: Invalid combo device(%#x)", __func__, devices); 488 goto exit; 489 } 490 if (snd_device != SND_DEVICE_NONE) { 491 goto exit; 492 } 493 } 494 495 if (popcount(devices) != 1) { 496 ALOGE("%s: Invalid output devices(%#x)", __func__, devices); 497 goto exit; 498 } 499 500 if (devices & AUDIO_DEVICE_OUT_WIRED_HEADPHONE || 501 devices & AUDIO_DEVICE_OUT_WIRED_HEADSET) { 502 snd_device = SND_DEVICE_OUT_HEADPHONES; 503 } else if (devices & AUDIO_DEVICE_OUT_SPEAKER) { 504 snd_device = SND_DEVICE_OUT_SPEAKER; 505 } else if (devices & AUDIO_DEVICE_OUT_EARPIECE) { 506 snd_device = SND_DEVICE_OUT_HANDSET; 507 } else { 508 ALOGE("%s: Unknown device(s) %#x", __func__, devices); 509 } 510 exit: 511 ALOGV("%s: exit: snd_device(%s)", __func__, device_table[snd_device]); 512 return snd_device; 513 } 514 515 snd_device_t get_input_snd_device(struct audio_device *adev, audio_devices_t out_device) 516 { 517 audio_source_t source; 518 audio_mode_t mode = adev->mode; 519 audio_devices_t in_device; 520 audio_channel_mask_t channel_mask; 521 snd_device_t snd_device = SND_DEVICE_NONE; 522 struct stream_in *active_input = NULL; 523 struct audio_usecase *usecase; 524 525 usecase = get_usecase_from_type(adev, PCM_CAPTURE|VOICE_CALL); 526 if (usecase != NULL) { 527 active_input = (struct stream_in *)usecase->stream; 528 } 529 source = (active_input == NULL) ? 530 AUDIO_SOURCE_DEFAULT : active_input->source; 531 532 in_device = ((active_input == NULL) ? 533 AUDIO_DEVICE_NONE : active_input->devices) 534 & ~AUDIO_DEVICE_BIT_IN; 535 channel_mask = (active_input == NULL) ? 536 AUDIO_CHANNEL_IN_MONO : active_input->main_channels; 537 538 ALOGV("%s: enter: out_device(%#x) in_device(%#x)", 539 __func__, out_device, in_device); 540 if (mode == AUDIO_MODE_IN_CALL) { 541 if (out_device == AUDIO_DEVICE_NONE) { 542 ALOGE("%s: No output device set for voice call", __func__); 543 goto exit; 544 } 545 if (adev->tty_mode != TTY_MODE_OFF) { 546 if (out_device & AUDIO_DEVICE_OUT_WIRED_HEADPHONE || 547 out_device & AUDIO_DEVICE_OUT_WIRED_HEADSET) { 548 switch (adev->tty_mode) { 549 case TTY_MODE_FULL: 550 snd_device = SND_DEVICE_IN_VOICE_TTY_FULL_HEADSET_MIC; 551 break; 552 case TTY_MODE_VCO: 553 snd_device = SND_DEVICE_IN_VOICE_TTY_VCO_HANDSET_MIC; 554 break; 555 case TTY_MODE_HCO: 556 snd_device = SND_DEVICE_IN_VOICE_TTY_HCO_HEADSET_MIC; 557 break; 558 default: 559 ALOGE("%s: Invalid TTY mode (%#x)", __func__, adev->tty_mode); 560 } 561 goto exit; 562 } 563 } 564 if (out_device & AUDIO_DEVICE_OUT_EARPIECE || 565 out_device & AUDIO_DEVICE_OUT_WIRED_HEADPHONE) { 566 snd_device = SND_DEVICE_IN_HANDSET_MIC; 567 } else if (out_device & AUDIO_DEVICE_OUT_WIRED_HEADSET) { 568 snd_device = SND_DEVICE_IN_VOICE_HEADSET_MIC; 569 } else if (out_device & AUDIO_DEVICE_OUT_SPEAKER) { 570 snd_device = SND_DEVICE_IN_VOICE_SPEAKER_MIC; 571 } 572 } else if (source == AUDIO_SOURCE_CAMCORDER) { 573 if (in_device & AUDIO_DEVICE_IN_BUILTIN_MIC || 574 in_device & AUDIO_DEVICE_IN_BACK_MIC) { 575 snd_device = SND_DEVICE_IN_CAMCORDER_MIC; 576 } 577 } else if (source == AUDIO_SOURCE_VOICE_RECOGNITION) { 578 if (in_device & AUDIO_DEVICE_IN_BUILTIN_MIC) { 579 if (adev->dualmic_config == DUALMIC_CONFIG_1) { 580 if (channel_mask == AUDIO_CHANNEL_IN_FRONT_BACK) 581 snd_device = SND_DEVICE_IN_VOICE_REC_DMIC_1; 582 else if (adev->ns_in_voice_rec) 583 snd_device = SND_DEVICE_IN_VOICE_REC_DMIC_NS_1; 584 } 585 586 if (snd_device == SND_DEVICE_NONE) { 587 snd_device = SND_DEVICE_IN_VOICE_REC_MIC; 588 } 589 } else if (in_device & AUDIO_DEVICE_IN_WIRED_HEADSET) { 590 snd_device = SND_DEVICE_IN_VOICE_REC_HEADSET_MIC; 591 } 592 } else if (source == AUDIO_SOURCE_VOICE_COMMUNICATION || source == AUDIO_SOURCE_MIC) { 593 if (out_device & AUDIO_DEVICE_OUT_SPEAKER) 594 in_device = AUDIO_DEVICE_IN_BACK_MIC; 595 if (active_input) { 596 if (active_input->enable_aec) { 597 if (in_device & AUDIO_DEVICE_IN_BACK_MIC) { 598 snd_device = SND_DEVICE_IN_SPEAKER_MIC_AEC; 599 } else if (in_device & AUDIO_DEVICE_IN_BUILTIN_MIC) { 600 if (out_device & AUDIO_DEVICE_OUT_WIRED_HEADPHONE) { 601 snd_device = SND_DEVICE_IN_SPEAKER_MIC_AEC; 602 } else { 603 snd_device = SND_DEVICE_IN_HANDSET_MIC_AEC; 604 } 605 } else if (in_device & AUDIO_DEVICE_IN_WIRED_HEADSET) { 606 snd_device = SND_DEVICE_IN_HEADSET_MIC_AEC; 607 } 608 } 609 /* TODO: set echo reference */ 610 } 611 } else if (source == AUDIO_SOURCE_DEFAULT) { 612 goto exit; 613 } 614 615 616 if (snd_device != SND_DEVICE_NONE) { 617 goto exit; 618 } 619 620 if (in_device != AUDIO_DEVICE_NONE && 621 !(in_device & AUDIO_DEVICE_IN_VOICE_CALL) && 622 !(in_device & AUDIO_DEVICE_IN_COMMUNICATION)) { 623 if (in_device & AUDIO_DEVICE_IN_BUILTIN_MIC) { 624 snd_device = SND_DEVICE_IN_HANDSET_MIC; 625 } else if (in_device & AUDIO_DEVICE_IN_BACK_MIC) { 626 snd_device = SND_DEVICE_IN_SPEAKER_MIC; 627 } else if (in_device & AUDIO_DEVICE_IN_WIRED_HEADSET) { 628 snd_device = SND_DEVICE_IN_HEADSET_MIC; 629 } else if (in_device & AUDIO_DEVICE_IN_AUX_DIGITAL) { 630 snd_device = SND_DEVICE_IN_HDMI_MIC; 631 } else { 632 ALOGE("%s: Unknown input device(s) %#x", __func__, in_device); 633 ALOGW("%s: Using default handset-mic", __func__); 634 snd_device = SND_DEVICE_IN_HANDSET_MIC; 635 } 636 } else { 637 if (out_device & AUDIO_DEVICE_OUT_EARPIECE) { 638 snd_device = SND_DEVICE_IN_HANDSET_MIC; 639 } else if (out_device & AUDIO_DEVICE_OUT_WIRED_HEADSET) { 640 snd_device = SND_DEVICE_IN_HEADSET_MIC; 641 } else if (out_device & AUDIO_DEVICE_OUT_SPEAKER) { 642 snd_device = SND_DEVICE_IN_SPEAKER_MIC; 643 } else if (out_device & AUDIO_DEVICE_OUT_WIRED_HEADPHONE) { 644 snd_device = SND_DEVICE_IN_HANDSET_MIC; 645 } else { 646 ALOGE("%s: Unknown output device(s) %#x", __func__, out_device); 647 ALOGW("%s: Using default handset-mic", __func__); 648 snd_device = SND_DEVICE_IN_HANDSET_MIC; 649 } 650 } 651 exit: 652 ALOGV("%s: exit: in_snd_device(%s)", __func__, device_table[snd_device]); 653 return snd_device; 654 } 655 656 int set_hdmi_channels(struct audio_device *adev, int channel_count) 657 { 658 struct mixer_ctl *ctl; 659 const char *mixer_ctl_name = ""; 660 (void)adev; 661 (void)channel_count; 662 /* TODO */ 663 664 return 0; 665 } 666 667 int edid_get_max_channels(struct audio_device *adev) 668 { 669 int max_channels = 2; 670 struct mixer_ctl *ctl; 671 (void)adev; 672 673 /* TODO */ 674 return max_channels; 675 } 676 677 /* Delay in Us */ 678 int64_t render_latency(audio_usecase_t usecase) 679 { 680 (void)usecase; 681 /* TODO */ 682 return 0; 683 } 684 685 static int enable_snd_device(struct audio_device *adev, 686 struct audio_usecase *uc_info, 687 snd_device_t snd_device, 688 bool update_mixer) 689 { 690 struct mixer_card *mixer_card; 691 struct listnode *node; 692 const char *snd_device_name = get_snd_device_name(snd_device); 693 694 if (snd_device_name == NULL) 695 return -EINVAL; 696 697 adev->snd_dev_ref_cnt[snd_device]++; 698 if (adev->snd_dev_ref_cnt[snd_device] > 1) { 699 ALOGV("%s: snd_device(%d: %s) is already active", 700 __func__, snd_device, snd_device_name); 701 return 0; 702 } 703 704 ALOGV("%s: snd_device(%d: %s)", __func__, 705 snd_device, snd_device_name); 706 707 list_for_each(node, &uc_info->mixer_list) { 708 mixer_card = node_to_item(node, struct mixer_card, uc_list_node[uc_info->id]); 709 audio_route_apply_path(mixer_card->audio_route, snd_device_name); 710 if (update_mixer) 711 audio_route_update_mixer(mixer_card->audio_route); 712 } 713 714 return 0; 715 } 716 717 static int disable_snd_device(struct audio_device *adev, 718 struct audio_usecase *uc_info, 719 snd_device_t snd_device, 720 bool update_mixer) 721 { 722 struct mixer_card *mixer_card; 723 struct listnode *node; 724 const char *snd_device_name = get_snd_device_name(snd_device); 725 726 if (snd_device_name == NULL) 727 return -EINVAL; 728 729 if (adev->snd_dev_ref_cnt[snd_device] <= 0) { 730 ALOGE("%s: device ref cnt is already 0", __func__); 731 return -EINVAL; 732 } 733 adev->snd_dev_ref_cnt[snd_device]--; 734 if (adev->snd_dev_ref_cnt[snd_device] == 0) { 735 ALOGV("%s: snd_device(%d: %s)", __func__, 736 snd_device, snd_device_name); 737 list_for_each(node, &uc_info->mixer_list) { 738 mixer_card = node_to_item(node, struct mixer_card, uc_list_node[uc_info->id]); 739 audio_route_reset_path(mixer_card->audio_route, snd_device_name); 740 if (update_mixer) 741 audio_route_update_mixer(mixer_card->audio_route); 742 } 743 } 744 return 0; 745 } 746 747 static int select_devices(struct audio_device *adev, 748 audio_usecase_t uc_id) 749 { 750 snd_device_t out_snd_device = SND_DEVICE_NONE; 751 snd_device_t in_snd_device = SND_DEVICE_NONE; 752 struct audio_usecase *usecase = NULL; 753 struct audio_usecase *vc_usecase = NULL; 754 struct listnode *node; 755 struct stream_in *active_input = NULL; 756 struct stream_out *active_out; 757 struct mixer_card *mixer_card; 758 759 ALOGV("%s: usecase(%d)", __func__, uc_id); 760 761 if (uc_id == USECASE_AUDIO_CAPTURE_HOTWORD) 762 return 0; 763 764 usecase = get_usecase_from_type(adev, PCM_CAPTURE|VOICE_CALL); 765 if (usecase != NULL) { 766 active_input = (struct stream_in *)usecase->stream; 767 } 768 769 usecase = get_usecase_from_id(adev, uc_id); 770 if (usecase == NULL) { 771 ALOGE("%s: Could not find the usecase(%d)", __func__, uc_id); 772 return -EINVAL; 773 } 774 active_out = (struct stream_out *)usecase->stream; 775 776 if (usecase->type == VOICE_CALL) { 777 out_snd_device = get_output_snd_device(adev, active_out->devices); 778 in_snd_device = get_input_snd_device(adev, active_out->devices); 779 usecase->devices = active_out->devices; 780 } else { 781 /* 782 * If the voice call is active, use the sound devices of voice call usecase 783 * so that it would not result any device switch. All the usecases will 784 * be switched to new device when select_devices() is called for voice call 785 * usecase. 786 */ 787 if (adev->in_call) { 788 vc_usecase = get_usecase_from_id(adev, USECASE_VOICE_CALL); 789 if (usecase == NULL) { 790 ALOGE("%s: Could not find the voice call usecase", __func__); 791 } else { 792 in_snd_device = vc_usecase->in_snd_device; 793 out_snd_device = vc_usecase->out_snd_device; 794 } 795 } 796 if (usecase->type == PCM_PLAYBACK) { 797 usecase->devices = active_out->devices; 798 in_snd_device = SND_DEVICE_NONE; 799 if (out_snd_device == SND_DEVICE_NONE) { 800 out_snd_device = get_output_snd_device(adev, active_out->devices); 801 if (active_out == adev->primary_output && 802 active_input && 803 active_input->source == AUDIO_SOURCE_VOICE_COMMUNICATION) { 804 select_devices(adev, active_input->usecase); 805 } 806 } 807 } else if (usecase->type == PCM_CAPTURE) { 808 usecase->devices = ((struct stream_in *)usecase->stream)->devices; 809 out_snd_device = SND_DEVICE_NONE; 810 if (in_snd_device == SND_DEVICE_NONE) { 811 if (active_input->source == AUDIO_SOURCE_VOICE_COMMUNICATION && 812 adev->primary_output && !adev->primary_output->standby) { 813 in_snd_device = get_input_snd_device(adev, adev->primary_output->devices); 814 } else { 815 in_snd_device = get_input_snd_device(adev, AUDIO_DEVICE_NONE); 816 } 817 } 818 } 819 } 820 821 if (out_snd_device == usecase->out_snd_device && 822 in_snd_device == usecase->in_snd_device) { 823 return 0; 824 } 825 826 ALOGV("%s: out_snd_device(%d: %s) in_snd_device(%d: %s)", __func__, 827 out_snd_device, get_snd_device_display_name(out_snd_device), 828 in_snd_device, get_snd_device_display_name(in_snd_device)); 829 830 831 /* Disable current sound devices */ 832 if (usecase->out_snd_device != SND_DEVICE_NONE) { 833 disable_snd_device(adev, usecase, usecase->out_snd_device, false); 834 } 835 836 if (usecase->in_snd_device != SND_DEVICE_NONE) { 837 disable_snd_device(adev, usecase, usecase->in_snd_device, false); 838 } 839 840 /* Enable new sound devices */ 841 if (out_snd_device != SND_DEVICE_NONE) { 842 enable_snd_device(adev, usecase, out_snd_device, false); 843 } 844 845 if (in_snd_device != SND_DEVICE_NONE) { 846 enable_snd_device(adev, usecase, in_snd_device, false); 847 } 848 849 list_for_each(node, &usecase->mixer_list) { 850 mixer_card = node_to_item(node, struct mixer_card, uc_list_node[usecase->id]); 851 audio_route_update_mixer(mixer_card->audio_route); 852 } 853 854 usecase->in_snd_device = in_snd_device; 855 usecase->out_snd_device = out_snd_device; 856 857 return 0; 858 } 859 860 static ssize_t read_frames(struct stream_in *in, void *buffer, ssize_t frames); 861 static int do_in_standby_l(struct stream_in *in); 862 static audio_format_t in_get_format(const struct audio_stream *stream); 863 864 #ifdef PREPROCESSING_ENABLED 865 static int get_command_status(int status, int fct_status, uint32_t cmd_status) { 866 if (fct_status != 0) 867 status = fct_status; 868 else if (cmd_status != 0) 869 status = cmd_status; 870 return status; 871 } 872 873 static uint32_t in_get_aux_channels(struct stream_in *in) 874 { 875 if (in->num_preprocessors == 0) 876 return 0; 877 878 /* do not enable quad mic configurations when capturing from other 879 * microphones than main */ 880 if (!(in->devices & AUDIO_DEVICE_IN_BUILTIN_MIC & ~AUDIO_DEVICE_BIT_IN)) 881 return 0; 882 883 return AUDIO_CHANNEL_INDEX_MASK_4; 884 } 885 886 static int in_configure_effect_channels(effect_handle_t effect, 887 channel_config_t *channel_config) 888 { 889 int status = 0; 890 int fct_status; 891 int32_t cmd_status; 892 uint32_t reply_size; 893 effect_config_t config; 894 uint32_t cmd[(sizeof(uint32_t) + sizeof(channel_config_t) - 1) / sizeof(uint32_t) + 1]; 895 896 ALOGV("in_configure_effect_channels(): configure effect with channels: [%04x][%04x]", 897 channel_config->main_channels, 898 channel_config->aux_channels); 899 900 config.inputCfg.mask = EFFECT_CONFIG_CHANNELS; 901 config.outputCfg.mask = EFFECT_CONFIG_CHANNELS; 902 reply_size = sizeof(effect_config_t); 903 fct_status = (*effect)->command(effect, 904 EFFECT_CMD_GET_CONFIG, 905 0, 906 NULL, 907 &reply_size, 908 &config); 909 if (fct_status != 0) { 910 ALOGE("in_configure_effect_channels(): EFFECT_CMD_GET_CONFIG failed"); 911 return fct_status; 912 } 913 914 config.inputCfg.channels = channel_config->aux_channels; 915 config.outputCfg.channels = config.inputCfg.channels; 916 reply_size = sizeof(uint32_t); 917 fct_status = (*effect)->command(effect, 918 EFFECT_CMD_SET_CONFIG, 919 sizeof(effect_config_t), 920 &config, 921 &reply_size, 922 &cmd_status); 923 status = get_command_status(status, fct_status, cmd_status); 924 if (status != 0) { 925 ALOGE("in_configure_effect_channels(): EFFECT_CMD_SET_CONFIG failed"); 926 return status; 927 } 928 929 /* some implementations need to be re-enabled after a config change */ 930 reply_size = sizeof(uint32_t); 931 fct_status = (*effect)->command(effect, 932 EFFECT_CMD_ENABLE, 933 0, 934 NULL, 935 &reply_size, 936 &cmd_status); 937 status = get_command_status(status, fct_status, cmd_status); 938 if (status != 0) { 939 ALOGE("in_configure_effect_channels(): EFFECT_CMD_ENABLE failed"); 940 return status; 941 } 942 943 return status; 944 } 945 946 static int in_reconfigure_channels(struct stream_in *in, 947 effect_handle_t effect, 948 channel_config_t *channel_config, 949 bool config_changed) { 950 951 int status = 0; 952 953 ALOGV("in_reconfigure_channels(): config_changed %d effect %p", 954 config_changed, effect); 955 956 /* if config changed, reconfigure all previously added effects */ 957 if (config_changed) { 958 int i; 959 ALOGV("%s: config_changed (%d)", __func__, config_changed); 960 for (i = 0; i < in->num_preprocessors; i++) { 961 int cur_status = in_configure_effect_channels(in->preprocessors[i].effect_itfe, 962 channel_config); 963 ALOGV("%s: in_configure_effect_channels i=(%d), [main_channel,aux_channel]=[%d|%d], status=%d", 964 __func__, i, channel_config->main_channels, channel_config->aux_channels, cur_status); 965 if (cur_status != 0) { 966 ALOGV("in_reconfigure_channels(): error %d configuring effect " 967 "%d with channels: [%04x][%04x]", 968 cur_status, 969 i, 970 channel_config->main_channels, 971 channel_config->aux_channels); 972 status = cur_status; 973 } 974 } 975 } else if (effect != NULL && channel_config->aux_channels) { 976 /* if aux channels config did not change but aux channels are present, 977 * we still need to configure the effect being added */ 978 status = in_configure_effect_channels(effect, channel_config); 979 } 980 return status; 981 } 982 983 static void in_update_aux_channels(struct stream_in *in, 984 effect_handle_t effect) 985 { 986 uint32_t aux_channels; 987 channel_config_t channel_config; 988 int status; 989 990 aux_channels = in_get_aux_channels(in); 991 992 channel_config.main_channels = in->main_channels; 993 channel_config.aux_channels = aux_channels; 994 status = in_reconfigure_channels(in, 995 effect, 996 &channel_config, 997 (aux_channels != in->aux_channels)); 998 999 if (status != 0) { 1000 ALOGV("in_update_aux_channels(): in_reconfigure_channels error %d", status); 1001 /* resetting aux channels configuration */ 1002 aux_channels = 0; 1003 channel_config.aux_channels = 0; 1004 in_reconfigure_channels(in, effect, &channel_config, true); 1005 } 1006 ALOGV("%s: aux_channels=%d, in->aux_channels_changed=%d", __func__, aux_channels, in->aux_channels_changed); 1007 if (in->aux_channels != aux_channels) { 1008 in->aux_channels_changed = true; 1009 in->aux_channels = aux_channels; 1010 do_in_standby_l(in); 1011 } 1012 } 1013 #endif 1014 1015 /* This function reads PCM data and: 1016 * - resample if needed 1017 * - process if pre-processors are attached 1018 * - discard unwanted channels 1019 */ 1020 static ssize_t read_and_process_frames(struct audio_stream_in *stream, void* buffer, ssize_t frames_num) 1021 { 1022 struct stream_in *in = (struct stream_in *)stream; 1023 ssize_t frames_wr = 0; /* Number of frames actually read */ 1024 size_t bytes_per_sample = audio_bytes_per_sample(stream->common.get_format(&stream->common)); 1025 void *proc_buf_out = buffer; 1026 #ifdef PREPROCESSING_ENABLED 1027 audio_buffer_t in_buf; 1028 audio_buffer_t out_buf; 1029 int i; 1030 bool has_processing = in->num_preprocessors != 0; 1031 #endif 1032 /* Additional channels might be added on top of main_channels: 1033 * - aux_channels (by processing effects) 1034 * - extra channels due to HW limitations 1035 * In case of additional channels, we cannot work inplace 1036 */ 1037 size_t src_channels = in->config.channels; 1038 size_t dst_channels = audio_channel_count_from_in_mask(in->main_channels); 1039 bool channel_remapping_needed = (dst_channels != src_channels); 1040 size_t src_buffer_size = frames_num * src_channels * bytes_per_sample; 1041 1042 #ifdef PREPROCESSING_ENABLED 1043 if (has_processing) { 1044 /* since all the processing below is done in frames and using the config.channels 1045 * as the number of channels, no changes is required in case aux_channels are present */ 1046 while (frames_wr < frames_num) { 1047 /* first reload enough frames at the end of process input buffer */ 1048 if (in->proc_buf_frames < (size_t)frames_num) { 1049 ssize_t frames_rd; 1050 if (in->proc_buf_size < (size_t)frames_num) { 1051 in->proc_buf_size = (size_t)frames_num; 1052 in->proc_buf_in = realloc(in->proc_buf_in, src_buffer_size); 1053 ALOG_ASSERT((in->proc_buf_in != NULL), 1054 "process_frames() failed to reallocate proc_buf_in"); 1055 if (channel_remapping_needed) { 1056 in->proc_buf_out = realloc(in->proc_buf_out, src_buffer_size); 1057 ALOG_ASSERT((in->proc_buf_out != NULL), 1058 "process_frames() failed to reallocate proc_buf_out"); 1059 proc_buf_out = in->proc_buf_out; 1060 } 1061 } 1062 frames_rd = read_frames(in, 1063 in->proc_buf_in + 1064 in->proc_buf_frames * src_channels * bytes_per_sample, 1065 frames_num - in->proc_buf_frames); 1066 if (frames_rd < 0) { 1067 /* Return error code */ 1068 frames_wr = frames_rd; 1069 break; 1070 } 1071 in->proc_buf_frames += frames_rd; 1072 } 1073 1074 /* in_buf.frameCount and out_buf.frameCount indicate respectively 1075 * the maximum number of frames to be consumed and produced by process() */ 1076 in_buf.frameCount = in->proc_buf_frames; 1077 in_buf.s16 = in->proc_buf_in; 1078 out_buf.frameCount = frames_num - frames_wr; 1079 out_buf.s16 = (int16_t *)proc_buf_out + frames_wr * in->config.channels; 1080 1081 /* FIXME: this works because of current pre processing library implementation that 1082 * does the actual process only when the last enabled effect process is called. 1083 * The generic solution is to have an output buffer for each effect and pass it as 1084 * input to the next. 1085 */ 1086 for (i = 0; i < in->num_preprocessors; i++) { 1087 (*in->preprocessors[i].effect_itfe)->process(in->preprocessors[i].effect_itfe, 1088 &in_buf, 1089 &out_buf); 1090 } 1091 1092 /* process() has updated the number of frames consumed and produced in 1093 * in_buf.frameCount and out_buf.frameCount respectively 1094 * move remaining frames to the beginning of in->proc_buf_in */ 1095 in->proc_buf_frames -= in_buf.frameCount; 1096 1097 if (in->proc_buf_frames) { 1098 memcpy(in->proc_buf_in, 1099 in->proc_buf_in + in_buf.frameCount * src_channels * bytes_per_sample, 1100 in->proc_buf_frames * in->config.channels * audio_bytes_per_sample(in_get_format(in))); 1101 } 1102 1103 /* if not enough frames were passed to process(), read more and retry. */ 1104 if (out_buf.frameCount == 0) { 1105 ALOGW("No frames produced by preproc"); 1106 continue; 1107 } 1108 1109 if ((frames_wr + (ssize_t)out_buf.frameCount) <= frames_num) { 1110 frames_wr += out_buf.frameCount; 1111 } else { 1112 /* The effect does not comply to the API. In theory, we should never end up here! */ 1113 ALOGE("preprocessing produced too many frames: %d + %zd > %d !", 1114 (unsigned int)frames_wr, out_buf.frameCount, (unsigned int)frames_num); 1115 frames_wr = frames_num; 1116 } 1117 } 1118 } 1119 else 1120 #endif //PREPROCESSING_ENABLED 1121 { 1122 /* No processing effects attached */ 1123 if (channel_remapping_needed) { 1124 /* With additional channels, we cannot use original buffer */ 1125 if (in->proc_buf_size < src_buffer_size) { 1126 in->proc_buf_size = src_buffer_size; 1127 in->proc_buf_out = realloc(in->proc_buf_out, src_buffer_size); 1128 ALOG_ASSERT((in->proc_buf_out != NULL), 1129 "process_frames() failed to reallocate proc_buf_out"); 1130 } 1131 proc_buf_out = in->proc_buf_out; 1132 } 1133 frames_wr = read_frames(in, proc_buf_out, frames_num); 1134 ALOG_ASSERT(frames_wr <= frames_num, "read more frames than requested"); 1135 } 1136 1137 if (channel_remapping_needed) { 1138 size_t ret = adjust_channels(proc_buf_out, src_channels, buffer, dst_channels, 1139 bytes_per_sample, frames_wr * src_channels * bytes_per_sample); 1140 ALOG_ASSERT(ret == (frames_wr * dst_channels * bytes_per_sample)); 1141 } 1142 1143 return frames_wr; 1144 } 1145 1146 static int get_next_buffer(struct resampler_buffer_provider *buffer_provider, 1147 struct resampler_buffer* buffer) 1148 { 1149 struct stream_in *in; 1150 struct pcm_device *pcm_device; 1151 1152 if (buffer_provider == NULL || buffer == NULL) 1153 return -EINVAL; 1154 1155 in = (struct stream_in *)((char *)buffer_provider - 1156 offsetof(struct stream_in, buf_provider)); 1157 1158 if (list_empty(&in->pcm_dev_list)) { 1159 buffer->raw = NULL; 1160 buffer->frame_count = 0; 1161 in->read_status = -ENODEV; 1162 return -ENODEV; 1163 } 1164 1165 pcm_device = node_to_item(list_head(&in->pcm_dev_list), 1166 struct pcm_device, stream_list_node); 1167 1168 if (in->read_buf_frames == 0) { 1169 size_t size_in_bytes = pcm_frames_to_bytes(pcm_device->pcm, in->config.period_size); 1170 if (in->read_buf_size < in->config.period_size) { 1171 in->read_buf_size = in->config.period_size; 1172 in->read_buf = (int16_t *) realloc(in->read_buf, size_in_bytes); 1173 ALOG_ASSERT((in->read_buf != NULL), 1174 "get_next_buffer() failed to reallocate read_buf"); 1175 } 1176 1177 in->read_status = pcm_read(pcm_device->pcm, (void*)in->read_buf, size_in_bytes); 1178 1179 if (in->read_status != 0) { 1180 ALOGE("get_next_buffer() pcm_read error %d", in->read_status); 1181 buffer->raw = NULL; 1182 buffer->frame_count = 0; 1183 return in->read_status; 1184 } 1185 in->read_buf_frames = in->config.period_size; 1186 } 1187 1188 buffer->frame_count = (buffer->frame_count > in->read_buf_frames) ? 1189 in->read_buf_frames : buffer->frame_count; 1190 buffer->i16 = in->read_buf + (in->config.period_size - in->read_buf_frames) * 1191 in->config.channels; 1192 return in->read_status; 1193 } 1194 1195 static void release_buffer(struct resampler_buffer_provider *buffer_provider, 1196 struct resampler_buffer* buffer) 1197 { 1198 struct stream_in *in; 1199 1200 if (buffer_provider == NULL || buffer == NULL) 1201 return; 1202 1203 in = (struct stream_in *)((char *)buffer_provider - 1204 offsetof(struct stream_in, buf_provider)); 1205 1206 in->read_buf_frames -= buffer->frame_count; 1207 } 1208 1209 /* read_frames() reads frames from kernel driver, down samples to capture rate 1210 * if necessary and output the number of frames requested to the buffer specified */ 1211 static ssize_t read_frames(struct stream_in *in, void *buffer, ssize_t frames) 1212 { 1213 ssize_t frames_wr = 0; 1214 1215 struct pcm_device *pcm_device; 1216 1217 if (list_empty(&in->pcm_dev_list)) { 1218 ALOGE("%s: pcm device list empty", __func__); 1219 return -EINVAL; 1220 } 1221 1222 pcm_device = node_to_item(list_head(&in->pcm_dev_list), 1223 struct pcm_device, stream_list_node); 1224 1225 while (frames_wr < frames) { 1226 size_t frames_rd = frames - frames_wr; 1227 ALOGVV("%s: frames_rd: %zd, frames_wr: %zd, in->config.channels: %d", 1228 __func__,frames_rd,frames_wr,in->config.channels); 1229 if (in->resampler != NULL) { 1230 in->resampler->resample_from_provider(in->resampler, 1231 (int16_t *)((char *)buffer + 1232 pcm_frames_to_bytes(pcm_device->pcm, frames_wr)), 1233 &frames_rd); 1234 } else { 1235 struct resampler_buffer buf = { 1236 { raw : NULL, }, 1237 frame_count : frames_rd, 1238 }; 1239 get_next_buffer(&in->buf_provider, &buf); 1240 if (buf.raw != NULL) { 1241 memcpy((char *)buffer + 1242 pcm_frames_to_bytes(pcm_device->pcm, frames_wr), 1243 buf.raw, 1244 pcm_frames_to_bytes(pcm_device->pcm, buf.frame_count)); 1245 frames_rd = buf.frame_count; 1246 } 1247 release_buffer(&in->buf_provider, &buf); 1248 } 1249 /* in->read_status is updated by getNextBuffer() also called by 1250 * in->resampler->resample_from_provider() */ 1251 if (in->read_status != 0) 1252 return in->read_status; 1253 1254 frames_wr += frames_rd; 1255 } 1256 return frames_wr; 1257 } 1258 1259 static int in_release_pcm_devices(struct stream_in *in) 1260 { 1261 struct pcm_device *pcm_device; 1262 struct listnode *node; 1263 struct listnode *next; 1264 1265 list_for_each_safe(node, next, &in->pcm_dev_list) { 1266 pcm_device = node_to_item(node, struct pcm_device, stream_list_node); 1267 list_remove(node); 1268 free(pcm_device); 1269 } 1270 1271 return 0; 1272 } 1273 1274 static int stop_input_stream(struct stream_in *in) 1275 { 1276 struct audio_usecase *uc_info; 1277 struct audio_device *adev = in->dev; 1278 1279 adev->active_input = NULL; 1280 ALOGV("%s: enter: usecase(%d: %s)", __func__, 1281 in->usecase, use_case_table[in->usecase]); 1282 uc_info = get_usecase_from_id(adev, in->usecase); 1283 if (uc_info == NULL) { 1284 ALOGE("%s: Could not find the usecase (%d) in the list", 1285 __func__, in->usecase); 1286 return -EINVAL; 1287 } 1288 1289 /* Disable the tx device */ 1290 disable_snd_device(adev, uc_info, uc_info->in_snd_device, true); 1291 1292 list_remove(&uc_info->adev_list_node); 1293 free(uc_info); 1294 1295 if (list_empty(&in->pcm_dev_list)) { 1296 ALOGE("%s: pcm device list empty", __func__); 1297 return -EINVAL; 1298 } 1299 1300 in_release_pcm_devices(in); 1301 list_init(&in->pcm_dev_list); 1302 1303 return 0; 1304 } 1305 1306 int start_input_stream(struct stream_in *in) 1307 { 1308 /* Enable output device and stream routing controls */ 1309 int ret = 0; 1310 bool recreate_resampler = false; 1311 struct audio_usecase *uc_info; 1312 struct audio_device *adev = in->dev; 1313 struct pcm_device_profile *pcm_profile; 1314 struct pcm_device *pcm_device; 1315 1316 ALOGV("%s: enter: usecase(%d)", __func__, in->usecase); 1317 adev->active_input = in; 1318 pcm_profile = get_pcm_device(in->usecase_type, in->devices); 1319 if (pcm_profile == NULL) { 1320 ALOGE("%s: Could not find PCM device id for the usecase(%d)", 1321 __func__, in->usecase); 1322 ret = -EINVAL; 1323 goto error_config; 1324 } 1325 1326 if (in->input_flags & AUDIO_INPUT_FLAG_FAST) { 1327 ALOGV("%s: change capture period size to low latency size %d", 1328 __func__, CAPTURE_PERIOD_SIZE_LOW_LATENCY); 1329 pcm_profile->config.period_size = CAPTURE_PERIOD_SIZE_LOW_LATENCY; 1330 } 1331 1332 uc_info = (struct audio_usecase *)calloc(1, sizeof(struct audio_usecase)); 1333 uc_info->id = in->usecase; 1334 uc_info->type = PCM_CAPTURE; 1335 uc_info->stream = (struct audio_stream *)in; 1336 uc_info->devices = in->devices; 1337 uc_info->in_snd_device = SND_DEVICE_NONE; 1338 uc_info->out_snd_device = SND_DEVICE_NONE; 1339 1340 pcm_device = (struct pcm_device *)calloc(1, sizeof(struct pcm_device)); 1341 pcm_device->pcm_profile = pcm_profile; 1342 list_init(&in->pcm_dev_list); 1343 list_add_tail(&in->pcm_dev_list, &pcm_device->stream_list_node); 1344 1345 list_init(&uc_info->mixer_list); 1346 list_add_tail(&uc_info->mixer_list, 1347 &adev_get_mixer_for_card(adev, 1348 pcm_device->pcm_profile->card)->uc_list_node[uc_info->id]); 1349 1350 list_add_tail(&adev->usecase_list, &uc_info->adev_list_node); 1351 1352 select_devices(adev, in->usecase); 1353 1354 /* Config should be updated as profile can be changed between different calls 1355 * to this function: 1356 * - Trigger resampler creation 1357 * - Config needs to be updated */ 1358 if (in->config.rate != pcm_profile->config.rate) { 1359 recreate_resampler = true; 1360 } 1361 in->config = pcm_profile->config; 1362 1363 #ifdef PREPROCESSING_ENABLED 1364 if (in->aux_channels_changed) { 1365 in->config.channels = audio_channel_count_from_in_mask(in->aux_channels); 1366 recreate_resampler = true; 1367 } 1368 #endif 1369 1370 if (in->requested_rate != in->config.rate) { 1371 recreate_resampler = true; 1372 } 1373 1374 if (recreate_resampler) { 1375 if (in->resampler) { 1376 release_resampler(in->resampler); 1377 in->resampler = NULL; 1378 } 1379 in->buf_provider.get_next_buffer = get_next_buffer; 1380 in->buf_provider.release_buffer = release_buffer; 1381 ret = create_resampler(in->config.rate, 1382 in->requested_rate, 1383 in->config.channels, 1384 RESAMPLER_QUALITY_DEFAULT, 1385 &in->buf_provider, 1386 &in->resampler); 1387 } 1388 1389 /* Open the PCM device. 1390 * The HW is limited to support only the default pcm_profile settings. 1391 * As such a change in aux_channels will not have an effect. 1392 */ 1393 ALOGV("%s: Opening PCM device card_id(%d) device_id(%d), channels %d, smp rate %d format %d, \ 1394 period_size %d", __func__, pcm_device->pcm_profile->card, pcm_device->pcm_profile->device, 1395 pcm_device->pcm_profile->config.channels,pcm_device->pcm_profile->config.rate, 1396 pcm_device->pcm_profile->config.format, pcm_device->pcm_profile->config.period_size); 1397 1398 if (pcm_profile->type == PCM_HOTWORD_STREAMING) { 1399 if (!adev->sound_trigger_open_for_streaming) { 1400 ALOGE("%s: No handle to sound trigger HAL", __func__); 1401 ret = -EIO; 1402 goto error_open; 1403 } 1404 pcm_device->pcm = NULL; 1405 pcm_device->sound_trigger_handle = 1406 adev->sound_trigger_open_for_streaming(); 1407 if (pcm_device->sound_trigger_handle <= 0) { 1408 ALOGE("%s: Failed to open DSP for streaming", __func__); 1409 ret = -EIO; 1410 goto error_open; 1411 } 1412 ALOGV("Opened DSP successfully"); 1413 } else { 1414 pcm_device->sound_trigger_handle = 0; 1415 pcm_device->pcm = pcm_open(pcm_device->pcm_profile->card, 1416 pcm_device->pcm_profile->device, 1417 PCM_IN | PCM_MONOTONIC, 1418 &pcm_device->pcm_profile->config); 1419 if (pcm_device->pcm && !pcm_is_ready(pcm_device->pcm)) { 1420 ALOGE("%s: %s", __func__, pcm_get_error(pcm_device->pcm)); 1421 pcm_close(pcm_device->pcm); 1422 pcm_device->pcm = NULL; 1423 ret = -EIO; 1424 goto error_open; 1425 } 1426 } 1427 1428 /* force read and proc buffer reallocation in case of frame size or 1429 * channel count change */ 1430 #ifdef PREPROCESSING_ENABLED 1431 in->proc_buf_frames = 0; 1432 #endif 1433 in->proc_buf_size = 0; 1434 in->read_buf_size = 0; 1435 in->read_buf_frames = 0; 1436 1437 /* if no supported sample rate is available, use the resampler */ 1438 if (in->resampler) { 1439 in->resampler->reset(in->resampler); 1440 } 1441 1442 ALOGV("%s: exit", __func__); 1443 return ret; 1444 1445 error_open: 1446 if (in->resampler) { 1447 release_resampler(in->resampler); 1448 in->resampler = NULL; 1449 } 1450 stop_input_stream(in); 1451 1452 error_config: 1453 ALOGV("%s: exit: status(%d)", __func__, ret); 1454 adev->active_input = NULL; 1455 return ret; 1456 } 1457 1458 static void lock_input_stream(struct stream_in *in) 1459 { 1460 pthread_mutex_lock(&in->pre_lock); 1461 pthread_mutex_lock(&in->lock); 1462 pthread_mutex_unlock(&in->pre_lock); 1463 } 1464 1465 static void lock_output_stream(struct stream_out *out) 1466 { 1467 pthread_mutex_lock(&out->pre_lock); 1468 pthread_mutex_lock(&out->lock); 1469 pthread_mutex_unlock(&out->pre_lock); 1470 } 1471 1472 static int uc_release_pcm_devices(struct audio_usecase *usecase) 1473 { 1474 struct stream_out *out = (struct stream_out *)usecase->stream; 1475 struct pcm_device *pcm_device; 1476 struct listnode *node; 1477 struct listnode *next; 1478 1479 list_for_each_safe(node, next, &out->pcm_dev_list) { 1480 pcm_device = node_to_item(node, struct pcm_device, stream_list_node); 1481 list_remove(node); 1482 free(pcm_device); 1483 } 1484 list_init(&usecase->mixer_list); 1485 1486 return 0; 1487 } 1488 1489 static int uc_select_pcm_devices(struct audio_usecase *usecase) 1490 1491 { 1492 struct stream_out *out = (struct stream_out *)usecase->stream; 1493 struct pcm_device *pcm_device; 1494 struct pcm_device_profile *pcm_profile; 1495 struct mixer_card *mixer_card; 1496 audio_devices_t devices = usecase->devices; 1497 1498 list_init(&usecase->mixer_list); 1499 list_init(&out->pcm_dev_list); 1500 1501 pcm_profile = get_pcm_device(usecase->type, devices); 1502 if (pcm_profile) { 1503 pcm_device = calloc(1, sizeof(struct pcm_device)); 1504 pcm_device->pcm_profile = pcm_profile; 1505 list_add_tail(&out->pcm_dev_list, &pcm_device->stream_list_node); 1506 mixer_card = uc_get_mixer_for_card(usecase, pcm_profile->card); 1507 if (mixer_card == NULL) { 1508 mixer_card = adev_get_mixer_for_card(out->dev, pcm_profile->card); 1509 list_add_tail(&usecase->mixer_list, &mixer_card->uc_list_node[usecase->id]); 1510 } 1511 devices &= ~pcm_profile->devices; 1512 } else { 1513 ALOGE("usecase type=%d, devices=%d did not find exact match", 1514 usecase->type, devices); 1515 } 1516 1517 return 0; 1518 } 1519 1520 static int out_close_pcm_devices(struct stream_out *out) 1521 { 1522 struct pcm_device *pcm_device; 1523 struct listnode *node; 1524 struct audio_device *adev = out->dev; 1525 1526 list_for_each(node, &out->pcm_dev_list) { 1527 pcm_device = node_to_item(node, struct pcm_device, stream_list_node); 1528 if (pcm_device->sound_trigger_handle > 0) { 1529 adev->sound_trigger_close_for_streaming( 1530 pcm_device->sound_trigger_handle); 1531 pcm_device->sound_trigger_handle = 0; 1532 } 1533 if (pcm_device->pcm) { 1534 pcm_close(pcm_device->pcm); 1535 pcm_device->pcm = NULL; 1536 } 1537 if (pcm_device->resampler) { 1538 release_resampler(pcm_device->resampler); 1539 pcm_device->resampler = NULL; 1540 } 1541 if (pcm_device->res_buffer) { 1542 free(pcm_device->res_buffer); 1543 pcm_device->res_buffer = NULL; 1544 } 1545 if (pcm_device->dsp_context) { 1546 cras_dsp_context_free(pcm_device->dsp_context); 1547 pcm_device->dsp_context = NULL; 1548 } 1549 } 1550 1551 return 0; 1552 } 1553 1554 static int out_open_pcm_devices(struct stream_out *out) 1555 { 1556 struct pcm_device *pcm_device; 1557 struct listnode *node; 1558 struct audio_device *adev = out->dev; 1559 int ret = 0; 1560 1561 list_for_each(node, &out->pcm_dev_list) { 1562 pcm_device = node_to_item(node, struct pcm_device, stream_list_node); 1563 ALOGV("%s: Opening PCM device card_id(%d) device_id(%d)", 1564 __func__, pcm_device->pcm_profile->card, pcm_device->pcm_profile->device); 1565 1566 if (pcm_device->pcm_profile->dsp_name) { 1567 pcm_device->dsp_context = cras_dsp_context_new(pcm_device->pcm_profile->config.rate, 1568 (adev->mode == AUDIO_MODE_IN_CALL || adev->mode == AUDIO_MODE_IN_COMMUNICATION) 1569 ? "voice-comm" : "playback"); 1570 if (pcm_device->dsp_context) { 1571 cras_dsp_set_variable(pcm_device->dsp_context, "dsp_name", 1572 pcm_device->pcm_profile->dsp_name); 1573 cras_dsp_load_pipeline(pcm_device->dsp_context); 1574 } 1575 } 1576 1577 pcm_device->pcm = pcm_open(pcm_device->pcm_profile->card, pcm_device->pcm_profile->device, 1578 PCM_OUT | PCM_MONOTONIC, &pcm_device->pcm_profile->config); 1579 1580 if (pcm_device->pcm && !pcm_is_ready(pcm_device->pcm)) { 1581 ALOGE("%s: %s", __func__, pcm_get_error(pcm_device->pcm)); 1582 pcm_device->pcm = NULL; 1583 ret = -EIO; 1584 goto error_open; 1585 } 1586 /* 1587 * If the stream rate differs from the PCM rate, we need to 1588 * create a resampler. 1589 */ 1590 if (out->sample_rate != pcm_device->pcm_profile->config.rate) { 1591 ALOGV("%s: create_resampler(), pcm_device_card(%d), pcm_device_id(%d), \ 1592 out_rate(%d), device_rate(%d)",__func__, 1593 pcm_device->pcm_profile->card, pcm_device->pcm_profile->device, 1594 out->sample_rate, pcm_device->pcm_profile->config.rate); 1595 ret = create_resampler(out->sample_rate, 1596 pcm_device->pcm_profile->config.rate, 1597 audio_channel_count_from_out_mask(out->channel_mask), 1598 RESAMPLER_QUALITY_DEFAULT, 1599 NULL, 1600 &pcm_device->resampler); 1601 pcm_device->res_byte_count = 0; 1602 pcm_device->res_buffer = NULL; 1603 } 1604 } 1605 return ret; 1606 1607 error_open: 1608 out_close_pcm_devices(out); 1609 return ret; 1610 } 1611 1612 static int disable_output_path_l(struct stream_out *out) 1613 { 1614 struct audio_device *adev = out->dev; 1615 struct audio_usecase *uc_info; 1616 1617 uc_info = get_usecase_from_id(adev, out->usecase); 1618 if (uc_info == NULL) { 1619 ALOGE("%s: Could not find the usecase (%d) in the list", 1620 __func__, out->usecase); 1621 return -EINVAL; 1622 } 1623 disable_snd_device(adev, uc_info, uc_info->out_snd_device, true); 1624 uc_release_pcm_devices(uc_info); 1625 list_remove(&uc_info->adev_list_node); 1626 free(uc_info); 1627 1628 return 0; 1629 } 1630 1631 static void enable_output_path_l(struct stream_out *out) 1632 { 1633 struct audio_device *adev = out->dev; 1634 struct audio_usecase *uc_info; 1635 1636 uc_info = (struct audio_usecase *)calloc(1, sizeof(struct audio_usecase)); 1637 uc_info->id = out->usecase; 1638 uc_info->type = PCM_PLAYBACK; 1639 uc_info->stream = (struct audio_stream *)out; 1640 uc_info->devices = out->devices; 1641 uc_info->in_snd_device = SND_DEVICE_NONE; 1642 uc_info->out_snd_device = SND_DEVICE_NONE; 1643 uc_select_pcm_devices(uc_info); 1644 1645 list_add_tail(&adev->usecase_list, &uc_info->adev_list_node); 1646 1647 select_devices(adev, out->usecase); 1648 } 1649 1650 static int stop_output_stream(struct stream_out *out) 1651 { 1652 int ret = 0; 1653 struct audio_device *adev = out->dev; 1654 bool do_disable = true; 1655 1656 ALOGV("%s: enter: usecase(%d: %s)", __func__, 1657 out->usecase, use_case_table[out->usecase]); 1658 1659 ret = disable_output_path_l(out); 1660 1661 ALOGV("%s: exit: status(%d)", __func__, ret); 1662 return ret; 1663 } 1664 1665 int start_output_stream(struct stream_out *out) 1666 { 1667 int ret = 0; 1668 struct audio_device *adev = out->dev; 1669 1670 ALOGV("%s: enter: usecase(%d: %s) devices(%#x) channels(%d)", 1671 __func__, out->usecase, use_case_table[out->usecase], out->devices, out->config.channels); 1672 1673 enable_output_path_l(out); 1674 1675 ret = out_open_pcm_devices(out); 1676 if (ret != 0) 1677 goto error_open; 1678 ALOGV("%s: exit", __func__); 1679 return 0; 1680 error_open: 1681 stop_output_stream(out); 1682 return ret; 1683 } 1684 1685 static int stop_voice_call(struct audio_device *adev) 1686 { 1687 struct audio_usecase *uc_info; 1688 1689 ALOGV("%s: enter", __func__); 1690 adev->in_call = false; 1691 1692 /* TODO: implement voice call stop */ 1693 1694 uc_info = get_usecase_from_id(adev, USECASE_VOICE_CALL); 1695 if (uc_info == NULL) { 1696 ALOGE("%s: Could not find the usecase (%d) in the list", 1697 __func__, USECASE_VOICE_CALL); 1698 return -EINVAL; 1699 } 1700 1701 disable_snd_device(adev, uc_info, uc_info->out_snd_device, false); 1702 disable_snd_device(adev, uc_info, uc_info->in_snd_device, true); 1703 1704 uc_release_pcm_devices(uc_info); 1705 list_remove(&uc_info->adev_list_node); 1706 free(uc_info); 1707 1708 ALOGV("%s: exit", __func__); 1709 return 0; 1710 } 1711 1712 /* always called with adev lock held */ 1713 static int start_voice_call(struct audio_device *adev) 1714 { 1715 struct audio_usecase *uc_info; 1716 1717 ALOGV("%s: enter", __func__); 1718 1719 uc_info = (struct audio_usecase *)calloc(1, sizeof(struct audio_usecase)); 1720 uc_info->id = USECASE_VOICE_CALL; 1721 uc_info->type = VOICE_CALL; 1722 uc_info->stream = (struct audio_stream *)adev->primary_output; 1723 uc_info->devices = adev->primary_output->devices; 1724 uc_info->in_snd_device = SND_DEVICE_NONE; 1725 uc_info->out_snd_device = SND_DEVICE_NONE; 1726 1727 uc_select_pcm_devices(uc_info); 1728 1729 list_add_tail(&adev->usecase_list, &uc_info->adev_list_node); 1730 1731 select_devices(adev, USECASE_VOICE_CALL); 1732 1733 1734 /* TODO: implement voice call start */ 1735 1736 /* set cached volume */ 1737 set_voice_volume_l(adev, adev->voice_volume); 1738 1739 adev->in_call = true; 1740 ALOGV("%s: exit", __func__); 1741 return 0; 1742 } 1743 1744 static int check_input_parameters(uint32_t sample_rate, 1745 audio_format_t format, 1746 int channel_count) 1747 { 1748 if (format != AUDIO_FORMAT_PCM_16_BIT) return -EINVAL; 1749 1750 if ((channel_count < 1) || (channel_count > 4)) return -EINVAL; 1751 1752 switch (sample_rate) { 1753 case 8000: 1754 case 11025: 1755 case 12000: 1756 case 16000: 1757 case 22050: 1758 case 24000: 1759 case 32000: 1760 case 44100: 1761 case 48000: 1762 break; 1763 default: 1764 return -EINVAL; 1765 } 1766 1767 return 0; 1768 } 1769 1770 static size_t get_input_buffer_size(uint32_t sample_rate, 1771 audio_format_t format, 1772 int channel_count, 1773 usecase_type_t usecase_type, 1774 audio_devices_t devices) 1775 { 1776 size_t size = 0; 1777 struct pcm_device_profile *pcm_profile; 1778 1779 if (check_input_parameters(sample_rate, format, channel_count) != 0) 1780 return 0; 1781 1782 pcm_profile = get_pcm_device(usecase_type, devices); 1783 if (pcm_profile == NULL) 1784 return 0; 1785 1786 /* 1787 * take resampling into account and return the closest majoring 1788 * multiple of 16 frames, as audioflinger expects audio buffers to 1789 * be a multiple of 16 frames 1790 */ 1791 size = (pcm_profile->config.period_size * sample_rate) / pcm_profile->config.rate; 1792 size = ((size + 15) / 16) * 16; 1793 1794 return (size * channel_count * audio_bytes_per_sample(format)); 1795 1796 } 1797 1798 static uint32_t out_get_sample_rate(const struct audio_stream *stream) 1799 { 1800 struct stream_out *out = (struct stream_out *)stream; 1801 1802 return out->sample_rate; 1803 } 1804 1805 static int out_set_sample_rate(struct audio_stream *stream, uint32_t rate) 1806 { 1807 (void)stream; 1808 (void)rate; 1809 return -ENOSYS; 1810 } 1811 1812 static size_t out_get_buffer_size(const struct audio_stream *stream) 1813 { 1814 struct stream_out *out = (struct stream_out *)stream; 1815 1816 return out->config.period_size * 1817 audio_stream_out_frame_size((const struct audio_stream_out *)stream); 1818 } 1819 1820 static uint32_t out_get_channels(const struct audio_stream *stream) 1821 { 1822 struct stream_out *out = (struct stream_out *)stream; 1823 1824 return out->channel_mask; 1825 } 1826 1827 static audio_format_t out_get_format(const struct audio_stream *stream) 1828 { 1829 struct stream_out *out = (struct stream_out *)stream; 1830 1831 return out->format; 1832 } 1833 1834 static int out_set_format(struct audio_stream *stream, audio_format_t format) 1835 { 1836 (void)stream; 1837 (void)format; 1838 return -ENOSYS; 1839 } 1840 1841 static int do_out_standby_l(struct stream_out *out) 1842 { 1843 struct audio_device *adev = out->dev; 1844 int status = 0; 1845 1846 out->standby = true; 1847 out_close_pcm_devices(out); 1848 status = stop_output_stream(out); 1849 1850 return status; 1851 } 1852 1853 static int out_standby(struct audio_stream *stream) 1854 { 1855 struct stream_out *out = (struct stream_out *)stream; 1856 struct audio_device *adev = out->dev; 1857 1858 ALOGV("%s: enter: usecase(%d: %s)", __func__, 1859 out->usecase, use_case_table[out->usecase]); 1860 lock_output_stream(out); 1861 if (!out->standby) { 1862 pthread_mutex_lock(&adev->lock); 1863 do_out_standby_l(out); 1864 pthread_mutex_unlock(&adev->lock); 1865 } 1866 pthread_mutex_unlock(&out->lock); 1867 ALOGV("%s: exit", __func__); 1868 return 0; 1869 } 1870 1871 static int out_dump(const struct audio_stream *stream, int fd) 1872 { 1873 (void)stream; 1874 (void)fd; 1875 1876 return 0; 1877 } 1878 1879 static int out_set_parameters(struct audio_stream *stream, const char *kvpairs) 1880 { 1881 struct stream_out *out = (struct stream_out *)stream; 1882 struct audio_device *adev = out->dev; 1883 struct audio_usecase *usecase; 1884 struct listnode *node; 1885 struct str_parms *parms; 1886 char value[32]; 1887 int ret, val = 0; 1888 struct audio_usecase *uc_info; 1889 bool do_standby = false; 1890 struct pcm_device *pcm_device; 1891 struct pcm_device_profile *pcm_profile; 1892 #ifdef PREPROCESSING_ENABLED 1893 struct stream_in *in = NULL; /* if non-NULL, then force input to standby */ 1894 #endif 1895 1896 ALOGV("%s: enter: usecase(%d: %s) kvpairs: %s out->devices(%d) adev->mode(%d)", 1897 __func__, out->usecase, use_case_table[out->usecase], kvpairs, out->devices, adev->mode); 1898 parms = str_parms_create_str(kvpairs); 1899 ret = str_parms_get_str(parms, AUDIO_PARAMETER_STREAM_ROUTING, value, sizeof(value)); 1900 if (ret >= 0) { 1901 val = atoi(value); 1902 pthread_mutex_lock(&adev->lock_inputs); 1903 lock_output_stream(out); 1904 pthread_mutex_lock(&adev->lock); 1905 #ifdef PREPROCESSING_ENABLED 1906 if (((int)out->devices != val) && (val != 0) && (!out->standby) && 1907 (out->usecase == USECASE_AUDIO_PLAYBACK)) { 1908 /* reset active input: 1909 * - to attach the echo reference 1910 * - because a change in output device may change mic settings */ 1911 if (adev->active_input && (adev->active_input->source == AUDIO_SOURCE_VOICE_COMMUNICATION || 1912 adev->active_input->source == AUDIO_SOURCE_MIC)) { 1913 in = adev->active_input; 1914 } 1915 } 1916 #endif 1917 if (val != 0) { 1918 out->devices = val; 1919 1920 if (!out->standby) { 1921 uc_info = get_usecase_from_id(adev, out->usecase); 1922 if (uc_info == NULL) { 1923 ALOGE("%s: Could not find the usecase (%d) in the list", 1924 __func__, out->usecase); 1925 } else { 1926 list_for_each(node, &out->pcm_dev_list) { 1927 pcm_device = node_to_item(node, struct pcm_device, stream_list_node); 1928 if ((pcm_device->pcm_profile->devices & val) == 0) 1929 do_standby = true; 1930 val &= ~pcm_device->pcm_profile->devices; 1931 } 1932 if (val != 0) 1933 do_standby = true; 1934 } 1935 if (do_standby) 1936 do_out_standby_l(out); 1937 else 1938 select_devices(adev, out->usecase); 1939 } 1940 1941 if ((adev->mode == AUDIO_MODE_IN_CALL) && !adev->in_call && 1942 (out == adev->primary_output)) { 1943 start_voice_call(adev); 1944 } else if ((adev->mode == AUDIO_MODE_IN_CALL) && adev->in_call && 1945 (out == adev->primary_output)) { 1946 select_devices(adev, USECASE_VOICE_CALL); 1947 } 1948 } 1949 1950 if ((adev->mode == AUDIO_MODE_NORMAL) && adev->in_call && 1951 (out == adev->primary_output)) { 1952 stop_voice_call(adev); 1953 } 1954 pthread_mutex_unlock(&adev->lock); 1955 pthread_mutex_unlock(&out->lock); 1956 #ifdef PREPROCESSING_ENABLED 1957 if (in) { 1958 /* The lock on adev->lock_inputs prevents input stream from being closed */ 1959 lock_input_stream(in); 1960 pthread_mutex_lock(&adev->lock); 1961 LOG_ALWAYS_FATAL_IF(in != adev->active_input); 1962 do_in_standby_l(in); 1963 pthread_mutex_unlock(&adev->lock); 1964 pthread_mutex_unlock(&in->lock); 1965 } 1966 #endif 1967 pthread_mutex_unlock(&adev->lock_inputs); 1968 } 1969 1970 str_parms_destroy(parms); 1971 ALOGV("%s: exit: code(%d)", __func__, ret); 1972 return ret; 1973 } 1974 1975 static char* out_get_parameters(const struct audio_stream *stream, const char *keys) 1976 { 1977 struct stream_out *out = (struct stream_out *)stream; 1978 struct str_parms *query = str_parms_create_str(keys); 1979 char *str; 1980 char value[256]; 1981 struct str_parms *reply = str_parms_create(); 1982 size_t i, j; 1983 int ret; 1984 bool first = true; 1985 ALOGV("%s: enter: keys - %s", __func__, keys); 1986 ret = str_parms_get_str(query, AUDIO_PARAMETER_STREAM_SUP_CHANNELS, value, sizeof(value)); 1987 if (ret >= 0) { 1988 value[0] = '\0'; 1989 i = 0; 1990 while (out->supported_channel_masks[i] != 0) { 1991 for (j = 0; j < ARRAY_SIZE(out_channels_name_to_enum_table); j++) { 1992 if (out_channels_name_to_enum_table[j].value == out->supported_channel_masks[i]) { 1993 if (!first) { 1994 strcat(value, "|"); 1995 } 1996 strcat(value, out_channels_name_to_enum_table[j].name); 1997 first = false; 1998 break; 1999 } 2000 } 2001 i++; 2002 } 2003 str_parms_add_str(reply, AUDIO_PARAMETER_STREAM_SUP_CHANNELS, value); 2004 str = str_parms_to_str(reply); 2005 } else { 2006 str = strdup(keys); 2007 } 2008 str_parms_destroy(query); 2009 str_parms_destroy(reply); 2010 ALOGV("%s: exit: returns - %s", __func__, str); 2011 return str; 2012 } 2013 2014 static uint32_t out_get_latency(const struct audio_stream_out *stream) 2015 { 2016 struct stream_out *out = (struct stream_out *)stream; 2017 2018 return (out->config.period_count * out->config.period_size * 1000) / 2019 (out->config.rate); 2020 } 2021 2022 static int out_set_volume(struct audio_stream_out *stream, float left, 2023 float right) 2024 { 2025 struct stream_out *out = (struct stream_out *)stream; 2026 struct audio_device *adev = out->dev; 2027 (void)right; 2028 2029 if (out->usecase == USECASE_AUDIO_PLAYBACK_MULTI_CH) { 2030 /* only take left channel into account: the API is for stereo anyway */ 2031 out->muted = (left == 0.0f); 2032 return 0; 2033 } 2034 2035 return -ENOSYS; 2036 } 2037 2038 /* Applies the DSP to the samples for the iodev if applicable. */ 2039 static void apply_dsp(struct pcm_device *iodev, uint8_t *buf, size_t frames) 2040 { 2041 struct cras_dsp_context *ctx; 2042 struct pipeline *pipeline; 2043 2044 ctx = iodev->dsp_context; 2045 if (!ctx) 2046 return; 2047 2048 pipeline = cras_dsp_get_pipeline(ctx); 2049 if (!pipeline) 2050 return; 2051 2052 cras_dsp_pipeline_apply(pipeline, 2053 buf, 2054 frames); 2055 2056 cras_dsp_put_pipeline(ctx); 2057 } 2058 2059 static ssize_t out_write(struct audio_stream_out *stream, const void *buffer, 2060 size_t bytes) 2061 { 2062 struct stream_out *out = (struct stream_out *)stream; 2063 struct audio_device *adev = out->dev; 2064 ssize_t ret = 0; 2065 struct pcm_device *pcm_device; 2066 struct listnode *node; 2067 size_t frame_size = audio_stream_out_frame_size(stream); 2068 size_t frames_wr = 0, frames_rq = 0; 2069 unsigned char *data = NULL; 2070 struct pcm_config config; 2071 #ifdef PREPROCESSING_ENABLED 2072 size_t in_frames = bytes / frame_size; 2073 size_t out_frames = in_frames; 2074 struct stream_in *in = NULL; 2075 #endif 2076 2077 lock_output_stream(out); 2078 if (out->standby) { 2079 #ifdef PREPROCESSING_ENABLED 2080 pthread_mutex_unlock(&out->lock); 2081 /* Prevent input stream from being closed */ 2082 pthread_mutex_lock(&adev->lock_inputs); 2083 lock_output_stream(out); 2084 if (!out->standby) { 2085 pthread_mutex_unlock(&adev->lock_inputs); 2086 goto false_alarm; 2087 } 2088 #endif 2089 pthread_mutex_lock(&adev->lock); 2090 ret = start_output_stream(out); 2091 if (ret != 0) { 2092 pthread_mutex_unlock(&adev->lock); 2093 #ifdef PREPROCESSING_ENABLED 2094 pthread_mutex_unlock(&adev->lock_inputs); 2095 #endif 2096 goto exit; 2097 } 2098 out->standby = false; 2099 2100 #ifdef PREPROCESSING_ENABLED 2101 /* A change in output device may change the microphone selection */ 2102 if (adev->active_input && 2103 (adev->active_input->source == AUDIO_SOURCE_VOICE_COMMUNICATION || 2104 adev->active_input->source == AUDIO_SOURCE_MIC)) { 2105 in = adev->active_input; 2106 ALOGV("%s: enter: force_input_standby true", __func__); 2107 } 2108 #endif 2109 pthread_mutex_unlock(&adev->lock); 2110 #ifdef PREPROCESSING_ENABLED 2111 if (!in) { 2112 /* Leave mutex locked iff in != NULL */ 2113 pthread_mutex_unlock(&adev->lock_inputs); 2114 } 2115 #endif 2116 } 2117 false_alarm: 2118 2119 if (out->muted) 2120 memset((void *)buffer, 0, bytes); 2121 list_for_each(node, &out->pcm_dev_list) { 2122 pcm_device = node_to_item(node, struct pcm_device, stream_list_node); 2123 if (pcm_device->resampler) { 2124 if (bytes * pcm_device->pcm_profile->config.rate / out->sample_rate + frame_size 2125 > pcm_device->res_byte_count) { 2126 pcm_device->res_byte_count = 2127 bytes * pcm_device->pcm_profile->config.rate / out->sample_rate + frame_size; 2128 pcm_device->res_buffer = 2129 realloc(pcm_device->res_buffer, pcm_device->res_byte_count); 2130 ALOGV("%s: resampler res_byte_count = %zu", __func__, 2131 pcm_device->res_byte_count); 2132 } 2133 frames_rq = bytes / frame_size; 2134 frames_wr = pcm_device->res_byte_count / frame_size; 2135 ALOGVV("%s: resampler request frames = %zu frame_size = %zu", 2136 __func__, frames_rq, frame_size); 2137 pcm_device->resampler->resample_from_input(pcm_device->resampler, 2138 (int16_t *)buffer, &frames_rq, (int16_t *)pcm_device->res_buffer, &frames_wr); 2139 ALOGVV("%s: resampler output frames_= %zu", __func__, frames_wr); 2140 } 2141 if (pcm_device->pcm) { 2142 size_t src_channels = audio_channel_count_from_out_mask(out->channel_mask); 2143 size_t dst_channels = pcm_device->pcm_profile->config.channels; 2144 bool channel_remapping_needed = (dst_channels != src_channels); 2145 unsigned audio_bytes; 2146 const void *audio_data; 2147 2148 ALOGVV("%s: writing buffer (%zd bytes) to pcm device", __func__, bytes); 2149 if (pcm_device->resampler && pcm_device->res_buffer) { 2150 audio_data = pcm_device->res_buffer; 2151 audio_bytes = frames_wr * frame_size; 2152 } else { 2153 audio_data = buffer; 2154 audio_bytes = bytes; 2155 } 2156 2157 /* 2158 * This can only be S16_LE stereo because of the supported formats, 2159 * 4 bytes per frame. 2160 */ 2161 apply_dsp(pcm_device, audio_data, audio_bytes/4); 2162 2163 if (channel_remapping_needed) { 2164 const void *remapped_audio_data; 2165 size_t dest_buffer_size = audio_bytes * dst_channels / src_channels; 2166 size_t new_size; 2167 size_t bytes_per_sample = audio_bytes_per_sample(stream->common.get_format(&stream->common)); 2168 2169 /* With additional channels, we cannot use original buffer */ 2170 if (out->proc_buf_size < dest_buffer_size) { 2171 out->proc_buf_size = dest_buffer_size; 2172 out->proc_buf_out = realloc(out->proc_buf_out, dest_buffer_size); 2173 ALOG_ASSERT((out->proc_buf_out != NULL), 2174 "out_write() failed to reallocate proc_buf_out"); 2175 } 2176 new_size = adjust_channels(audio_data, src_channels, out->proc_buf_out, dst_channels, 2177 bytes_per_sample, audio_bytes); 2178 ALOG_ASSERT(new_size == dest_buffer_size); 2179 audio_data = out->proc_buf_out; 2180 audio_bytes = dest_buffer_size; 2181 } 2182 2183 pcm_device->status = pcm_write(pcm_device->pcm, audio_data, audio_bytes); 2184 if (pcm_device->status != 0) 2185 ret = pcm_device->status; 2186 } 2187 } 2188 if (ret == 0) 2189 out->written += bytes / frame_size; 2190 2191 exit: 2192 pthread_mutex_unlock(&out->lock); 2193 2194 if (ret != 0) { 2195 list_for_each(node, &out->pcm_dev_list) { 2196 pcm_device = node_to_item(node, struct pcm_device, stream_list_node); 2197 if (pcm_device->pcm && pcm_device->status != 0) 2198 ALOGE("%s: error %zd - %s", __func__, ret, pcm_get_error(pcm_device->pcm)); 2199 } 2200 out_standby(&out->stream.common); 2201 usleep(bytes * 1000000 / audio_stream_out_frame_size(stream) / 2202 out_get_sample_rate(&out->stream.common)); 2203 } 2204 2205 #ifdef PREPROCESSING_ENABLED 2206 if (in) { 2207 /* The lock on adev->lock_inputs prevents input stream from being closed */ 2208 lock_input_stream(in); 2209 pthread_mutex_lock(&adev->lock); 2210 LOG_ALWAYS_FATAL_IF(in != adev->active_input); 2211 do_in_standby_l(in); 2212 pthread_mutex_unlock(&adev->lock); 2213 pthread_mutex_unlock(&in->lock); 2214 /* This mutex was left locked iff in != NULL */ 2215 pthread_mutex_unlock(&adev->lock_inputs); 2216 } 2217 #endif 2218 2219 return bytes; 2220 } 2221 2222 static int out_get_render_position(const struct audio_stream_out *stream, 2223 uint32_t *dsp_frames) 2224 { 2225 (void)stream; 2226 *dsp_frames = 0; 2227 return -EINVAL; 2228 } 2229 2230 static int out_add_audio_effect(const struct audio_stream *stream, effect_handle_t effect) 2231 { 2232 (void)stream; 2233 (void)effect; 2234 return 0; 2235 } 2236 2237 static int out_remove_audio_effect(const struct audio_stream *stream, effect_handle_t effect) 2238 { 2239 (void)stream; 2240 (void)effect; 2241 return 0; 2242 } 2243 2244 static int out_get_next_write_timestamp(const struct audio_stream_out *stream, 2245 int64_t *timestamp) 2246 { 2247 (void)stream; 2248 (void)timestamp; 2249 return -EINVAL; 2250 } 2251 2252 static int out_get_presentation_position(const struct audio_stream_out *stream, 2253 uint64_t *frames, struct timespec *timestamp) 2254 { 2255 struct stream_out *out = (struct stream_out *)stream; 2256 int ret = -1; 2257 unsigned long dsp_frames; 2258 2259 lock_output_stream(out); 2260 2261 /* FIXME: which device to read from? */ 2262 if (!list_empty(&out->pcm_dev_list)) { 2263 unsigned int avail; 2264 struct pcm_device *pcm_device = node_to_item(list_head(&out->pcm_dev_list), 2265 struct pcm_device, stream_list_node); 2266 2267 if (pcm_get_htimestamp(pcm_device->pcm, &avail, timestamp) == 0) { 2268 size_t kernel_buffer_size = out->config.period_size * out->config.period_count; 2269 int64_t signed_frames = out->written - kernel_buffer_size + avail; 2270 /* This adjustment accounts for buffering after app processor. 2271 It is based on estimated DSP latency per use case, rather than exact. */ 2272 signed_frames -= 2273 (render_latency(out->usecase) * out->sample_rate / 1000000LL); 2274 2275 /* It would be unusual for this value to be negative, but check just in case ... */ 2276 if (signed_frames >= 0) { 2277 *frames = signed_frames; 2278 ret = 0; 2279 } 2280 } 2281 } 2282 2283 pthread_mutex_unlock(&out->lock); 2284 2285 return ret; 2286 } 2287 2288 /** audio_stream_in implementation **/ 2289 static uint32_t in_get_sample_rate(const struct audio_stream *stream) 2290 { 2291 struct stream_in *in = (struct stream_in *)stream; 2292 2293 return in->requested_rate; 2294 } 2295 2296 static int in_set_sample_rate(struct audio_stream *stream, uint32_t rate) 2297 { 2298 (void)stream; 2299 (void)rate; 2300 return -ENOSYS; 2301 } 2302 2303 static uint32_t in_get_channels(const struct audio_stream *stream) 2304 { 2305 struct stream_in *in = (struct stream_in *)stream; 2306 2307 return in->main_channels; 2308 } 2309 2310 static audio_format_t in_get_format(const struct audio_stream *stream) 2311 { 2312 (void)stream; 2313 return AUDIO_FORMAT_PCM_16_BIT; 2314 } 2315 2316 static int in_set_format(struct audio_stream *stream, audio_format_t format) 2317 { 2318 (void)stream; 2319 (void)format; 2320 2321 return -ENOSYS; 2322 } 2323 2324 static size_t in_get_buffer_size(const struct audio_stream *stream) 2325 { 2326 struct stream_in *in = (struct stream_in *)stream; 2327 2328 return get_input_buffer_size(in->requested_rate, 2329 in_get_format(stream), 2330 audio_channel_count_from_in_mask(in->main_channels), 2331 in->usecase_type, 2332 in->devices); 2333 } 2334 2335 static int in_close_pcm_devices(struct stream_in *in) 2336 { 2337 struct pcm_device *pcm_device; 2338 struct listnode *node; 2339 struct audio_device *adev = in->dev; 2340 2341 list_for_each(node, &in->pcm_dev_list) { 2342 pcm_device = node_to_item(node, struct pcm_device, stream_list_node); 2343 if (pcm_device) { 2344 if (pcm_device->pcm) 2345 pcm_close(pcm_device->pcm); 2346 pcm_device->pcm = NULL; 2347 if (pcm_device->sound_trigger_handle > 0) 2348 adev->sound_trigger_close_for_streaming( 2349 pcm_device->sound_trigger_handle); 2350 pcm_device->sound_trigger_handle = 0; 2351 } 2352 } 2353 return 0; 2354 } 2355 2356 2357 /* must be called with stream and hw device mutex locked */ 2358 static int do_in_standby_l(struct stream_in *in) 2359 { 2360 int status = 0; 2361 2362 if (!in->standby) { 2363 2364 in_close_pcm_devices(in); 2365 2366 status = stop_input_stream(in); 2367 2368 if (in->read_buf) { 2369 free(in->read_buf); 2370 in->read_buf = NULL; 2371 } 2372 2373 in->standby = 1; 2374 } 2375 return 0; 2376 } 2377 2378 // called with adev->lock_inputs locked 2379 static int in_standby_l(struct stream_in *in) 2380 { 2381 struct audio_device *adev = in->dev; 2382 int status = 0; 2383 lock_input_stream(in); 2384 if (!in->standby) { 2385 pthread_mutex_lock(&adev->lock); 2386 status = do_in_standby_l(in); 2387 pthread_mutex_unlock(&adev->lock); 2388 } 2389 pthread_mutex_unlock(&in->lock); 2390 return status; 2391 } 2392 2393 static int in_standby(struct audio_stream *stream) 2394 { 2395 struct stream_in *in = (struct stream_in *)stream; 2396 struct audio_device *adev = in->dev; 2397 int status; 2398 ALOGV("%s: enter", __func__); 2399 pthread_mutex_lock(&adev->lock_inputs); 2400 status = in_standby_l(in); 2401 pthread_mutex_unlock(&adev->lock_inputs); 2402 ALOGV("%s: exit: status(%d)", __func__, status); 2403 return status; 2404 } 2405 2406 static int in_dump(const struct audio_stream *stream, int fd) 2407 { 2408 (void)stream; 2409 (void)fd; 2410 2411 return 0; 2412 } 2413 2414 static int in_set_parameters(struct audio_stream *stream, const char *kvpairs) 2415 { 2416 struct stream_in *in = (struct stream_in *)stream; 2417 struct audio_device *adev = in->dev; 2418 struct str_parms *parms; 2419 char *str; 2420 char value[32]; 2421 int ret, val = 0; 2422 struct audio_usecase *uc_info; 2423 bool do_standby = false; 2424 struct listnode *node; 2425 struct pcm_device *pcm_device; 2426 struct pcm_device_profile *pcm_profile; 2427 2428 ALOGV("%s: enter: kvpairs=%s", __func__, kvpairs); 2429 parms = str_parms_create_str(kvpairs); 2430 2431 ret = str_parms_get_str(parms, AUDIO_PARAMETER_STREAM_INPUT_SOURCE, value, sizeof(value)); 2432 2433 pthread_mutex_lock(&adev->lock_inputs); 2434 lock_input_stream(in); 2435 pthread_mutex_lock(&adev->lock); 2436 if (ret >= 0) { 2437 val = atoi(value); 2438 /* no audio source uses val == 0 */ 2439 if (((int)in->source != val) && (val != 0)) { 2440 in->source = val; 2441 } 2442 } 2443 2444 ret = str_parms_get_str(parms, AUDIO_PARAMETER_STREAM_ROUTING, value, sizeof(value)); 2445 if (ret >= 0) { 2446 val = atoi(value); 2447 if (((int)in->devices != val) && (val != 0)) { 2448 in->devices = val; 2449 /* If recording is in progress, change the tx device to new device */ 2450 if (!in->standby) { 2451 uc_info = get_usecase_from_id(adev, in->usecase); 2452 if (uc_info == NULL) { 2453 ALOGE("%s: Could not find the usecase (%d) in the list", 2454 __func__, in->usecase); 2455 } else { 2456 if (list_empty(&in->pcm_dev_list)) 2457 ALOGE("%s: pcm device list empty", __func__); 2458 else { 2459 pcm_device = node_to_item(list_head(&in->pcm_dev_list), 2460 struct pcm_device, stream_list_node); 2461 if ((pcm_device->pcm_profile->devices & val & ~AUDIO_DEVICE_BIT_IN) == 0) { 2462 do_standby = true; 2463 } 2464 } 2465 } 2466 if (do_standby) { 2467 ret = do_in_standby_l(in); 2468 } else 2469 ret = select_devices(adev, in->usecase); 2470 } 2471 } 2472 } 2473 pthread_mutex_unlock(&adev->lock); 2474 pthread_mutex_unlock(&in->lock); 2475 pthread_mutex_unlock(&adev->lock_inputs); 2476 str_parms_destroy(parms); 2477 2478 if (ret > 0) 2479 ret = 0; 2480 2481 return ret; 2482 } 2483 2484 static char* in_get_parameters(const struct audio_stream *stream, 2485 const char *keys) 2486 { 2487 (void)stream; 2488 (void)keys; 2489 2490 return strdup(""); 2491 } 2492 2493 static int in_set_gain(struct audio_stream_in *stream, float gain) 2494 { 2495 (void)stream; 2496 (void)gain; 2497 2498 return 0; 2499 } 2500 2501 static ssize_t read_bytes_from_dsp(struct stream_in *in, void* buffer, 2502 size_t bytes) 2503 { 2504 struct pcm_device *pcm_device; 2505 struct audio_device *adev = in->dev; 2506 2507 pcm_device = node_to_item(list_head(&in->pcm_dev_list), 2508 struct pcm_device, stream_list_node); 2509 2510 if (pcm_device->sound_trigger_handle > 0) 2511 return adev->sound_trigger_read_samples( 2512 pcm_device->sound_trigger_handle, buffer, bytes); 2513 else 2514 return 0; 2515 } 2516 2517 static ssize_t in_read(struct audio_stream_in *stream, void *buffer, 2518 size_t bytes) 2519 { 2520 struct stream_in *in = (struct stream_in *)stream; 2521 struct audio_device *adev = in->dev; 2522 ssize_t frames = -1; 2523 int ret = -1; 2524 int read_and_process_successful = false; 2525 2526 size_t frames_rq = bytes / audio_stream_in_frame_size(stream); 2527 2528 /* no need to acquire adev->lock_inputs because API contract prevents a close */ 2529 lock_input_stream(in); 2530 if (in->standby) { 2531 pthread_mutex_unlock(&in->lock); 2532 pthread_mutex_lock(&adev->lock_inputs); 2533 lock_input_stream(in); 2534 if (!in->standby) { 2535 pthread_mutex_unlock(&adev->lock_inputs); 2536 goto false_alarm; 2537 } 2538 pthread_mutex_lock(&adev->lock); 2539 ret = start_input_stream(in); 2540 pthread_mutex_unlock(&adev->lock); 2541 pthread_mutex_unlock(&adev->lock_inputs); 2542 if (ret != 0) { 2543 goto exit; 2544 } 2545 in->standby = 0; 2546 } 2547 false_alarm: 2548 2549 if (!list_empty(&in->pcm_dev_list)) { 2550 if (in->usecase == USECASE_AUDIO_CAPTURE_HOTWORD) { 2551 bytes = read_bytes_from_dsp(in, buffer, bytes); 2552 if (bytes > 0) 2553 read_and_process_successful = true; 2554 } else { 2555 /* 2556 * Read PCM and: 2557 * - resample if needed 2558 * - process if pre-processors are attached 2559 * - discard unwanted channels 2560 */ 2561 frames = read_and_process_frames(stream, buffer, frames_rq); 2562 if (frames >= 0) 2563 read_and_process_successful = true; 2564 } 2565 } 2566 2567 /* 2568 * Instead of writing zeroes here, we could trust the hardware 2569 * to always provide zeroes when muted. 2570 */ 2571 if (read_and_process_successful == true && adev->mic_mute) 2572 memset(buffer, 0, bytes); 2573 2574 exit: 2575 pthread_mutex_unlock(&in->lock); 2576 2577 if (read_and_process_successful == false) { 2578 in_standby(&in->stream.common); 2579 ALOGV("%s: read failed - sleeping for buffer duration", __func__); 2580 usleep(bytes * 1000000 / audio_stream_in_frame_size(stream) / 2581 in->requested_rate); 2582 } 2583 return bytes; 2584 } 2585 2586 static uint32_t in_get_input_frames_lost(struct audio_stream_in *stream) 2587 { 2588 (void)stream; 2589 2590 return 0; 2591 } 2592 2593 static int add_remove_audio_effect(const struct audio_stream *stream, 2594 effect_handle_t effect, 2595 bool enable) 2596 { 2597 struct stream_in *in = (struct stream_in *)stream; 2598 struct audio_device *adev = in->dev; 2599 int status = 0; 2600 effect_descriptor_t desc; 2601 #ifdef PREPROCESSING_ENABLED 2602 int i; 2603 #endif 2604 status = (*effect)->get_descriptor(effect, &desc); 2605 if (status != 0) 2606 return status; 2607 2608 ALOGI("add_remove_audio_effect(), effect type: %08x, enable: %d ", desc.type.timeLow, enable); 2609 2610 pthread_mutex_lock(&adev->lock_inputs); 2611 lock_input_stream(in); 2612 pthread_mutex_lock(&in->dev->lock); 2613 #ifndef PREPROCESSING_ENABLED 2614 if ((in->source == AUDIO_SOURCE_VOICE_COMMUNICATION) && 2615 in->enable_aec != enable && 2616 (memcmp(&desc.type, FX_IID_AEC, sizeof(effect_uuid_t)) == 0)) { 2617 in->enable_aec = enable; 2618 if (!in->standby) 2619 select_devices(in->dev, in->usecase); 2620 } 2621 #else 2622 if (enable) { 2623 if (in->num_preprocessors >= MAX_PREPROCESSORS) { 2624 status = -ENOSYS; 2625 goto exit; 2626 } 2627 in->preprocessors[in->num_preprocessors].effect_itfe = effect; 2628 in->num_preprocessors ++; 2629 /* check compatibility between main channel supported and possible auxiliary channels */ 2630 in_update_aux_channels(in, effect);//wesley crash 2631 in->aux_channels_changed = true; 2632 } else { 2633 /* if ( enable == false ) */ 2634 if (in->num_preprocessors <= 0) { 2635 status = -ENOSYS; 2636 goto exit; 2637 } 2638 status = -EINVAL; 2639 for (i = 0; i < in->num_preprocessors && status != 0; i++) { 2640 if ( in->preprocessors[i].effect_itfe == effect ) { 2641 ALOGV("add_remove_audio_effect found fx at index %d", i); 2642 free(in->preprocessors[i].channel_configs); 2643 in->num_preprocessors--; 2644 memcpy(in->preprocessors + i, 2645 in->preprocessors + i + 1, 2646 (in->num_preprocessors - i) * sizeof(in->preprocessors[0])); 2647 memset(in->preprocessors + in->num_preprocessors, 2648 0, 2649 sizeof(in->preprocessors[0])); 2650 status = 0; 2651 } 2652 } 2653 if (status != 0) 2654 goto exit; 2655 in->aux_channels_changed = false; 2656 ALOGV("%s: enable(%d), in->aux_channels_changed(%d)", 2657 __func__, enable, in->aux_channels_changed); 2658 } 2659 ALOGI("%s: num_preprocessors = %d", __func__, in->num_preprocessors); 2660 2661 exit: 2662 #endif 2663 ALOGW_IF(status != 0, "add_remove_audio_effect() error %d", status); 2664 pthread_mutex_unlock(&in->dev->lock); 2665 pthread_mutex_unlock(&in->lock); 2666 pthread_mutex_unlock(&adev->lock_inputs); 2667 return status; 2668 } 2669 2670 static int in_add_audio_effect(const struct audio_stream *stream, 2671 effect_handle_t effect) 2672 { 2673 ALOGV("%s: effect %p", __func__, effect); 2674 return add_remove_audio_effect(stream, effect, true /* enabled */); 2675 } 2676 2677 static int in_remove_audio_effect(const struct audio_stream *stream, 2678 effect_handle_t effect) 2679 { 2680 ALOGV("%s: effect %p", __func__, effect); 2681 return add_remove_audio_effect(stream, effect, false /* disabled */); 2682 } 2683 2684 static int adev_open_output_stream(struct audio_hw_device *dev, 2685 audio_io_handle_t handle, 2686 audio_devices_t devices, 2687 audio_output_flags_t flags, 2688 struct audio_config *config, 2689 struct audio_stream_out **stream_out, 2690 const char *address __unused) 2691 { 2692 struct audio_device *adev = (struct audio_device *)dev; 2693 struct stream_out *out; 2694 int i, ret; 2695 struct pcm_device_profile *pcm_profile; 2696 2697 ALOGV("%s: enter: sample_rate(%d) channel_mask(%#x) devices(%#x) flags(%#x)", 2698 __func__, config->sample_rate, config->channel_mask, devices, flags); 2699 *stream_out = NULL; 2700 out = (struct stream_out *)calloc(1, sizeof(struct stream_out)); 2701 2702 if (devices == AUDIO_DEVICE_NONE) 2703 devices = AUDIO_DEVICE_OUT_SPEAKER; 2704 2705 out->flags = flags; 2706 out->devices = devices; 2707 out->dev = adev; 2708 out->format = config->format; 2709 out->sample_rate = config->sample_rate; 2710 out->channel_mask = AUDIO_CHANNEL_OUT_STEREO; 2711 out->supported_channel_masks[0] = AUDIO_CHANNEL_OUT_STEREO; 2712 out->handle = handle; 2713 2714 pcm_profile = get_pcm_device(PCM_PLAYBACK, devices); 2715 if (pcm_profile == NULL) { 2716 ret = -EINVAL; 2717 goto error_open; 2718 } 2719 out->config = pcm_profile->config; 2720 2721 /* Init use case and pcm_config */ 2722 if (out->flags & (AUDIO_OUTPUT_FLAG_DEEP_BUFFER)) { 2723 out->usecase = USECASE_AUDIO_PLAYBACK_DEEP_BUFFER; 2724 out->config = pcm_config_deep_buffer; 2725 out->sample_rate = out->config.rate; 2726 ALOGV("%s: use AUDIO_PLAYBACK_DEEP_BUFFER",__func__); 2727 } else { 2728 out->usecase = USECASE_AUDIO_PLAYBACK; 2729 out->sample_rate = out->config.rate; 2730 } 2731 2732 if (flags & AUDIO_OUTPUT_FLAG_PRIMARY) { 2733 if (adev->primary_output == NULL) 2734 adev->primary_output = out; 2735 else { 2736 ALOGE("%s: Primary output is already opened", __func__); 2737 ret = -EEXIST; 2738 goto error_open; 2739 } 2740 } 2741 2742 /* Check if this usecase is already existing */ 2743 pthread_mutex_lock(&adev->lock); 2744 if (get_usecase_from_id(adev, out->usecase) != NULL) { 2745 ALOGE("%s: Usecase (%d) is already present", __func__, out->usecase); 2746 pthread_mutex_unlock(&adev->lock); 2747 ret = -EEXIST; 2748 goto error_open; 2749 } 2750 pthread_mutex_unlock(&adev->lock); 2751 2752 out->stream.common.get_sample_rate = out_get_sample_rate; 2753 out->stream.common.set_sample_rate = out_set_sample_rate; 2754 out->stream.common.get_buffer_size = out_get_buffer_size; 2755 out->stream.common.get_channels = out_get_channels; 2756 out->stream.common.get_format = out_get_format; 2757 out->stream.common.set_format = out_set_format; 2758 out->stream.common.standby = out_standby; 2759 out->stream.common.dump = out_dump; 2760 out->stream.common.set_parameters = out_set_parameters; 2761 out->stream.common.get_parameters = out_get_parameters; 2762 out->stream.common.add_audio_effect = out_add_audio_effect; 2763 out->stream.common.remove_audio_effect = out_remove_audio_effect; 2764 out->stream.get_latency = out_get_latency; 2765 out->stream.set_volume = out_set_volume; 2766 out->stream.write = out_write; 2767 out->stream.get_render_position = out_get_render_position; 2768 out->stream.get_next_write_timestamp = out_get_next_write_timestamp; 2769 out->stream.get_presentation_position = out_get_presentation_position; 2770 2771 out->standby = 1; 2772 /* out->muted = false; by calloc() */ 2773 /* out->written = 0; by calloc() */ 2774 2775 pthread_mutex_init(&out->lock, (const pthread_mutexattr_t *) NULL); 2776 pthread_mutex_init(&out->pre_lock, (const pthread_mutexattr_t *) NULL); 2777 pthread_cond_init(&out->cond, (const pthread_condattr_t *) NULL); 2778 2779 config->format = out->stream.common.get_format(&out->stream.common); 2780 config->channel_mask = out->stream.common.get_channels(&out->stream.common); 2781 config->sample_rate = out->stream.common.get_sample_rate(&out->stream.common); 2782 2783 *stream_out = &out->stream; 2784 ALOGV("%s: exit", __func__); 2785 return 0; 2786 2787 error_open: 2788 free(out); 2789 *stream_out = NULL; 2790 ALOGV("%s: exit: ret %d", __func__, ret); 2791 return ret; 2792 } 2793 2794 static void adev_close_output_stream(struct audio_hw_device *dev, 2795 struct audio_stream_out *stream) 2796 { 2797 struct stream_out *out = (struct stream_out *)stream; 2798 struct audio_device *adev = out->dev; 2799 (void)dev; 2800 2801 ALOGV("%s: enter", __func__); 2802 out_standby(&stream->common); 2803 pthread_cond_destroy(&out->cond); 2804 pthread_mutex_destroy(&out->lock); 2805 pthread_mutex_destroy(&out->pre_lock); 2806 free(out->proc_buf_out); 2807 free(stream); 2808 ALOGV("%s: exit", __func__); 2809 } 2810 2811 static int adev_set_parameters(struct audio_hw_device *dev, const char *kvpairs) 2812 { 2813 struct audio_device *adev = (struct audio_device *)dev; 2814 struct str_parms *parms; 2815 char *str; 2816 char value[32]; 2817 int val; 2818 int ret; 2819 2820 ALOGV("%s: enter: %s", __func__, kvpairs); 2821 2822 parms = str_parms_create_str(kvpairs); 2823 ret = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_TTY_MODE, value, sizeof(value)); 2824 if (ret >= 0) { 2825 int tty_mode; 2826 2827 if (strcmp(value, AUDIO_PARAMETER_VALUE_TTY_OFF) == 0) 2828 tty_mode = TTY_MODE_OFF; 2829 else if (strcmp(value, AUDIO_PARAMETER_VALUE_TTY_VCO) == 0) 2830 tty_mode = TTY_MODE_VCO; 2831 else if (strcmp(value, AUDIO_PARAMETER_VALUE_TTY_HCO) == 0) 2832 tty_mode = TTY_MODE_HCO; 2833 else if (strcmp(value, AUDIO_PARAMETER_VALUE_TTY_FULL) == 0) 2834 tty_mode = TTY_MODE_FULL; 2835 else 2836 return -EINVAL; 2837 2838 pthread_mutex_lock(&adev->lock); 2839 if (tty_mode != adev->tty_mode) { 2840 adev->tty_mode = tty_mode; 2841 if (adev->in_call) 2842 select_devices(adev, USECASE_VOICE_CALL); 2843 } 2844 pthread_mutex_unlock(&adev->lock); 2845 } 2846 2847 ret = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_BT_NREC, value, sizeof(value)); 2848 if (ret >= 0) { 2849 /* When set to false, HAL should disable EC and NS 2850 * But it is currently not supported. 2851 */ 2852 if (strcmp(value, AUDIO_PARAMETER_VALUE_ON) == 0) 2853 adev->bluetooth_nrec = true; 2854 else 2855 adev->bluetooth_nrec = false; 2856 } 2857 2858 ret = str_parms_get_str(parms, "screen_state", value, sizeof(value)); 2859 if (ret >= 0) { 2860 if (strcmp(value, AUDIO_PARAMETER_VALUE_ON) == 0) 2861 adev->screen_off = false; 2862 else 2863 adev->screen_off = true; 2864 } 2865 2866 ret = str_parms_get_int(parms, "rotation", &val); 2867 if (ret >= 0) { 2868 bool reverse_speakers = false; 2869 switch(val) { 2870 /* Assume 0deg rotation means the front camera is up with the usb port 2871 * on the lower left when the user is facing the screen. This assumption 2872 * is device-specific, not platform-specific like this code. 2873 */ 2874 case 180: 2875 reverse_speakers = true; 2876 break; 2877 case 0: 2878 case 90: 2879 case 270: 2880 break; 2881 default: 2882 ALOGE("%s: unexpected rotation of %d", __func__, val); 2883 } 2884 pthread_mutex_lock(&adev->lock); 2885 if (adev->speaker_lr_swap != reverse_speakers) { 2886 adev->speaker_lr_swap = reverse_speakers; 2887 struct mixer_card *mixer_card; 2888 mixer_card = adev_get_mixer_for_card(adev, SOUND_CARD); 2889 if (mixer_card) 2890 audio_route_apply_and_update_path(mixer_card->audio_route, 2891 reverse_speakers ? "speaker-lr-reverse" : 2892 "speaker-lr-normal"); 2893 } 2894 pthread_mutex_unlock(&adev->lock); 2895 } 2896 2897 str_parms_destroy(parms); 2898 ALOGV("%s: exit with code(%d)", __func__, ret); 2899 return ret; 2900 } 2901 2902 static char* adev_get_parameters(const struct audio_hw_device *dev, 2903 const char *keys) 2904 { 2905 (void)dev; 2906 (void)keys; 2907 2908 return strdup(""); 2909 } 2910 2911 static int adev_init_check(const struct audio_hw_device *dev) 2912 { 2913 (void)dev; 2914 2915 return 0; 2916 } 2917 2918 static int adev_set_voice_volume(struct audio_hw_device *dev, float volume) 2919 { 2920 int ret = 0; 2921 struct audio_device *adev = (struct audio_device *)dev; 2922 pthread_mutex_lock(&adev->lock); 2923 /* cache volume */ 2924 adev->voice_volume = volume; 2925 ret = set_voice_volume_l(adev, adev->voice_volume); 2926 pthread_mutex_unlock(&adev->lock); 2927 return ret; 2928 } 2929 2930 static int adev_set_master_volume(struct audio_hw_device *dev, float volume) 2931 { 2932 (void)dev; 2933 (void)volume; 2934 2935 return -ENOSYS; 2936 } 2937 2938 static int adev_get_master_volume(struct audio_hw_device *dev, 2939 float *volume) 2940 { 2941 (void)dev; 2942 (void)volume; 2943 2944 return -ENOSYS; 2945 } 2946 2947 static int adev_set_master_mute(struct audio_hw_device *dev, bool muted) 2948 { 2949 (void)dev; 2950 (void)muted; 2951 2952 return -ENOSYS; 2953 } 2954 2955 static int adev_get_master_mute(struct audio_hw_device *dev, bool *muted) 2956 { 2957 (void)dev; 2958 (void)muted; 2959 2960 return -ENOSYS; 2961 } 2962 2963 static int adev_set_mode(struct audio_hw_device *dev, audio_mode_t mode) 2964 { 2965 struct audio_device *adev = (struct audio_device *)dev; 2966 2967 pthread_mutex_lock(&adev->lock); 2968 if (adev->mode != mode) { 2969 ALOGI("%s mode = %d", __func__, mode); 2970 adev->mode = mode; 2971 } 2972 pthread_mutex_unlock(&adev->lock); 2973 return 0; 2974 } 2975 2976 static int adev_set_mic_mute(struct audio_hw_device *dev, bool state) 2977 { 2978 struct audio_device *adev = (struct audio_device *)dev; 2979 int err = 0; 2980 2981 pthread_mutex_lock(&adev->lock); 2982 adev->mic_mute = state; 2983 2984 if (adev->mode == AUDIO_MODE_IN_CALL) { 2985 /* TODO */ 2986 } 2987 2988 pthread_mutex_unlock(&adev->lock); 2989 return err; 2990 } 2991 2992 static int adev_get_mic_mute(const struct audio_hw_device *dev, bool *state) 2993 { 2994 struct audio_device *adev = (struct audio_device *)dev; 2995 2996 *state = adev->mic_mute; 2997 2998 return 0; 2999 } 3000 3001 static size_t adev_get_input_buffer_size(const struct audio_hw_device *dev, 3002 const struct audio_config *config) 3003 { 3004 (void)dev; 3005 3006 /* NOTE: we default to built in mic which may cause a mismatch between what we 3007 * report here and the actual buffer size 3008 */ 3009 return get_input_buffer_size(config->sample_rate, 3010 config->format, 3011 audio_channel_count_from_in_mask(config->channel_mask), 3012 PCM_CAPTURE /* usecase_type */, 3013 AUDIO_DEVICE_IN_BUILTIN_MIC); 3014 } 3015 3016 static int adev_open_input_stream(struct audio_hw_device *dev, 3017 audio_io_handle_t handle __unused, 3018 audio_devices_t devices, 3019 struct audio_config *config, 3020 struct audio_stream_in **stream_in, 3021 audio_input_flags_t flags, 3022 const char *address __unused, 3023 audio_source_t source) 3024 { 3025 struct audio_device *adev = (struct audio_device *)dev; 3026 struct stream_in *in; 3027 struct pcm_device_profile *pcm_profile; 3028 3029 ALOGV("%s: enter", __func__); 3030 3031 *stream_in = NULL; 3032 if (check_input_parameters(config->sample_rate, config->format, 3033 audio_channel_count_from_in_mask(config->channel_mask)) != 0) 3034 return -EINVAL; 3035 3036 usecase_type_t usecase_type = (source == AUDIO_SOURCE_HOTWORD) ? 3037 PCM_HOTWORD_STREAMING : PCM_CAPTURE; 3038 pcm_profile = get_pcm_device(usecase_type, devices); 3039 if (pcm_profile == NULL) 3040 return -EINVAL; 3041 3042 in = (struct stream_in *)calloc(1, sizeof(struct stream_in)); 3043 3044 in->stream.common.get_sample_rate = in_get_sample_rate; 3045 in->stream.common.set_sample_rate = in_set_sample_rate; 3046 in->stream.common.get_buffer_size = in_get_buffer_size; 3047 in->stream.common.get_channels = in_get_channels; 3048 in->stream.common.get_format = in_get_format; 3049 in->stream.common.set_format = in_set_format; 3050 in->stream.common.standby = in_standby; 3051 in->stream.common.dump = in_dump; 3052 in->stream.common.set_parameters = in_set_parameters; 3053 in->stream.common.get_parameters = in_get_parameters; 3054 in->stream.common.add_audio_effect = in_add_audio_effect; 3055 in->stream.common.remove_audio_effect = in_remove_audio_effect; 3056 in->stream.set_gain = in_set_gain; 3057 in->stream.read = in_read; 3058 in->stream.get_input_frames_lost = in_get_input_frames_lost; 3059 3060 in->devices = devices; 3061 in->source = source; 3062 in->dev = adev; 3063 in->standby = 1; 3064 in->main_channels = config->channel_mask; 3065 in->requested_rate = config->sample_rate; 3066 if (config->sample_rate != CAPTURE_DEFAULT_SAMPLING_RATE) 3067 flags = flags & ~AUDIO_INPUT_FLAG_FAST; 3068 in->input_flags = flags; 3069 /* HW codec is limited to default channels. No need to update with 3070 * requested channels */ 3071 in->config = pcm_profile->config; 3072 3073 /* Update config params with the requested sample rate and channels */ 3074 if (source == AUDIO_SOURCE_HOTWORD) { 3075 in->usecase = USECASE_AUDIO_CAPTURE_HOTWORD; 3076 } else { 3077 in->usecase = USECASE_AUDIO_CAPTURE; 3078 } 3079 in->usecase_type = usecase_type; 3080 3081 pthread_mutex_init(&in->lock, (const pthread_mutexattr_t *) NULL); 3082 pthread_mutex_init(&in->pre_lock, (const pthread_mutexattr_t *) NULL); 3083 3084 *stream_in = &in->stream; 3085 ALOGV("%s: exit", __func__); 3086 return 0; 3087 } 3088 3089 static void adev_close_input_stream(struct audio_hw_device *dev, 3090 struct audio_stream_in *stream) 3091 { 3092 struct audio_device *adev = (struct audio_device *)dev; 3093 struct stream_in *in = (struct stream_in*)stream; 3094 ALOGV("%s", __func__); 3095 3096 /* prevent concurrent out_set_parameters, or out_write from standby */ 3097 pthread_mutex_lock(&adev->lock_inputs); 3098 3099 in_standby_l(in); 3100 pthread_mutex_destroy(&in->lock); 3101 pthread_mutex_destroy(&in->pre_lock); 3102 free(in->proc_buf_out); 3103 3104 #ifdef PREPROCESSING_ENABLED 3105 int i; 3106 3107 for (i=0; i<in->num_preprocessors; i++) { 3108 free(in->preprocessors[i].channel_configs); 3109 } 3110 3111 if (in->read_buf) { 3112 free(in->read_buf); 3113 } 3114 3115 if (in->proc_buf_in) { 3116 free(in->proc_buf_in); 3117 } 3118 3119 if (in->resampler) { 3120 release_resampler(in->resampler); 3121 } 3122 #endif 3123 3124 free(stream); 3125 3126 pthread_mutex_unlock(&adev->lock_inputs); 3127 3128 return; 3129 } 3130 3131 static int adev_dump(const audio_hw_device_t *device, int fd) 3132 { 3133 (void)device; 3134 (void)fd; 3135 3136 return 0; 3137 } 3138 3139 static int adev_close(hw_device_t *device) 3140 { 3141 struct audio_device *adev = (struct audio_device *)device; 3142 free(adev->snd_dev_ref_cnt); 3143 free_mixer_list(adev); 3144 free(device); 3145 return 0; 3146 } 3147 3148 static int adev_open(const hw_module_t *module, const char *name, 3149 hw_device_t **device) 3150 { 3151 struct audio_device *adev; 3152 int i, ret, retry_count; 3153 3154 ALOGV("%s: enter", __func__); 3155 if (strcmp(name, AUDIO_HARDWARE_INTERFACE) != 0) return -EINVAL; 3156 3157 adev = calloc(1, sizeof(struct audio_device)); 3158 3159 adev->device.common.tag = HARDWARE_DEVICE_TAG; 3160 adev->device.common.version = AUDIO_DEVICE_API_VERSION_2_0; 3161 adev->device.common.module = (struct hw_module_t *)module; 3162 adev->device.common.close = adev_close; 3163 3164 adev->device.init_check = adev_init_check; 3165 adev->device.set_voice_volume = adev_set_voice_volume; 3166 adev->device.set_master_volume = adev_set_master_volume; 3167 adev->device.get_master_volume = adev_get_master_volume; 3168 adev->device.set_master_mute = adev_set_master_mute; 3169 adev->device.get_master_mute = adev_get_master_mute; 3170 adev->device.set_mode = adev_set_mode; 3171 adev->device.set_mic_mute = adev_set_mic_mute; 3172 adev->device.get_mic_mute = adev_get_mic_mute; 3173 adev->device.set_parameters = adev_set_parameters; 3174 adev->device.get_parameters = adev_get_parameters; 3175 adev->device.get_input_buffer_size = adev_get_input_buffer_size; 3176 adev->device.open_output_stream = adev_open_output_stream; 3177 adev->device.close_output_stream = adev_close_output_stream; 3178 adev->device.open_input_stream = adev_open_input_stream; 3179 adev->device.close_input_stream = adev_close_input_stream; 3180 adev->device.dump = adev_dump; 3181 3182 /* Set the default route before the PCM stream is opened */ 3183 adev->mode = AUDIO_MODE_NORMAL; 3184 adev->active_input = NULL; 3185 adev->primary_output = NULL; 3186 adev->voice_volume = 1.0f; 3187 adev->tty_mode = TTY_MODE_OFF; 3188 adev->bluetooth_nrec = true; 3189 adev->in_call = false; 3190 /* adev->cur_hdmi_channels = 0; by calloc() */ 3191 adev->snd_dev_ref_cnt = calloc(SND_DEVICE_MAX, sizeof(int)); 3192 3193 adev->dualmic_config = DUALMIC_CONFIG_NONE; 3194 adev->ns_in_voice_rec = false; 3195 3196 list_init(&adev->usecase_list); 3197 3198 if (mixer_init(adev) != 0) { 3199 free(adev->snd_dev_ref_cnt); 3200 free(adev); 3201 ALOGE("%s: Failed to init, aborting.", __func__); 3202 *device = NULL; 3203 return -EINVAL; 3204 } 3205 3206 3207 if (access(SOUND_TRIGGER_HAL_LIBRARY_PATH, R_OK) == 0) { 3208 adev->sound_trigger_lib = dlopen(SOUND_TRIGGER_HAL_LIBRARY_PATH, 3209 RTLD_NOW); 3210 if (adev->sound_trigger_lib == NULL) { 3211 ALOGE("%s: DLOPEN failed for %s", __func__, 3212 SOUND_TRIGGER_HAL_LIBRARY_PATH); 3213 } else { 3214 ALOGV("%s: DLOPEN successful for %s", __func__, 3215 SOUND_TRIGGER_HAL_LIBRARY_PATH); 3216 adev->sound_trigger_open_for_streaming = 3217 (int (*)(void))dlsym(adev->sound_trigger_lib, 3218 "sound_trigger_open_for_streaming"); 3219 adev->sound_trigger_read_samples = 3220 (size_t (*)(int, void *, size_t))dlsym( 3221 adev->sound_trigger_lib, 3222 "sound_trigger_read_samples"); 3223 adev->sound_trigger_close_for_streaming = 3224 (int (*)(int))dlsym( 3225 adev->sound_trigger_lib, 3226 "sound_trigger_close_for_streaming"); 3227 if (!adev->sound_trigger_open_for_streaming || 3228 !adev->sound_trigger_read_samples || 3229 !adev->sound_trigger_close_for_streaming) { 3230 3231 ALOGE("%s: Error grabbing functions in %s", __func__, 3232 SOUND_TRIGGER_HAL_LIBRARY_PATH); 3233 adev->sound_trigger_open_for_streaming = 0; 3234 adev->sound_trigger_read_samples = 0; 3235 adev->sound_trigger_close_for_streaming = 0; 3236 } 3237 } 3238 } 3239 3240 *device = &adev->device.common; 3241 3242 cras_dsp_init("/system/etc/cras/speakerdsp.ini"); 3243 3244 ALOGV("%s: exit", __func__); 3245 return 0; 3246 } 3247 3248 static struct hw_module_methods_t hal_module_methods = { 3249 .open = adev_open, 3250 }; 3251 3252 struct audio_module HAL_MODULE_INFO_SYM = { 3253 .common = { 3254 .tag = HARDWARE_MODULE_TAG, 3255 .module_api_version = AUDIO_MODULE_API_VERSION_0_1, 3256 .hal_api_version = HARDWARE_HAL_API_VERSION, 3257 .id = AUDIO_HARDWARE_MODULE_ID, 3258 .name = "NVIDIA Tegra Audio HAL", 3259 .author = "The Android Open Source Project", 3260 .methods = &hal_module_methods, 3261 }, 3262 }; 3263
