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