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