1 /* 2 ** Copyright 2010, 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 #include <math.h> 18 19 //#define LOG_NDEBUG 0 20 #define LOG_TAG "AudioHardware" 21 22 #include <utils/Log.h> 23 #include <utils/String8.h> 24 25 #include <stdio.h> 26 #include <unistd.h> 27 #include <sys/ioctl.h> 28 #include <sys/types.h> 29 #include <sys/stat.h> 30 #include <sys/resource.h> 31 #include <dlfcn.h> 32 #include <fcntl.h> 33 34 #include "AudioHardware.h" 35 #include <media/AudioRecord.h> 36 #include <audio_effects/effect_aec.h> 37 38 extern "C" { 39 #include <tinyalsa/asoundlib.h> 40 } 41 42 43 namespace android_audio_legacy { 44 45 const uint32_t AudioHardware::inputConfigTable[][AudioHardware::INPUT_CONFIG_CNT] = { 46 {8000, 4}, 47 {11025, 4}, 48 {16000, 2}, 49 {22050, 2}, 50 {32000, 1}, 51 {44100, 1} 52 }; 53 54 // trace driver operations for dump 55 // 56 #define DRIVER_TRACE 57 58 enum { 59 DRV_NONE, 60 DRV_PCM_OPEN, 61 DRV_PCM_CLOSE, 62 DRV_PCM_WRITE, 63 DRV_PCM_READ, 64 DRV_MIXER_OPEN, 65 DRV_MIXER_CLOSE, 66 DRV_MIXER_GET, 67 DRV_MIXER_SEL 68 }; 69 70 #ifdef DRIVER_TRACE 71 #define TRACE_DRIVER_IN(op) mDriverOp = op; 72 #define TRACE_DRIVER_OUT mDriverOp = DRV_NONE; 73 #else 74 #define TRACE_DRIVER_IN(op) 75 #define TRACE_DRIVER_OUT 76 #endif 77 78 // ---------------------------------------------------------------------------- 79 80 const char *AudioHardware::inputPathNameDefault = "Default"; 81 const char *AudioHardware::inputPathNameCamcorder = "Camcorder"; 82 const char *AudioHardware::inputPathNameVoiceRecognition = "Voice Recognition"; 83 84 AudioHardware::AudioHardware() : 85 mInit(false), 86 mMicMute(false), 87 mPcm(NULL), 88 mMixer(NULL), 89 mPcmOpenCnt(0), 90 mMixerOpenCnt(0), 91 mInCallAudioMode(false), 92 mVoiceVol(1.0f), 93 mInputSource(AUDIO_SOURCE_DEFAULT), 94 mBluetoothNrec(true), 95 mTTYMode(TTY_MODE_OFF), 96 mSecRilLibHandle(NULL), 97 mRilClient(0), 98 mActivatedCP(false), 99 mEchoReference(NULL), 100 mDriverOp(DRV_NONE) 101 { 102 loadRILD(); 103 mInit = true; 104 } 105 106 AudioHardware::~AudioHardware() 107 { 108 for (size_t index = 0; index < mInputs.size(); index++) { 109 closeInputStream(mInputs[index].get()); 110 } 111 mInputs.clear(); 112 closeOutputStream((AudioStreamOut*)mOutput.get()); 113 114 if (mMixer) { 115 TRACE_DRIVER_IN(DRV_MIXER_CLOSE) 116 mixer_close(mMixer); 117 TRACE_DRIVER_OUT 118 } 119 if (mPcm) { 120 TRACE_DRIVER_IN(DRV_PCM_CLOSE) 121 pcm_close(mPcm); 122 TRACE_DRIVER_OUT 123 } 124 125 if (mSecRilLibHandle) { 126 if (disconnectRILD(mRilClient) != RIL_CLIENT_ERR_SUCCESS) 127 LOGE("Disconnect_RILD() error"); 128 129 if (closeClientRILD(mRilClient) != RIL_CLIENT_ERR_SUCCESS) 130 LOGE("CloseClient_RILD() error"); 131 132 mRilClient = 0; 133 134 dlclose(mSecRilLibHandle); 135 mSecRilLibHandle = NULL; 136 } 137 138 mInit = false; 139 } 140 141 status_t AudioHardware::initCheck() 142 { 143 return mInit ? NO_ERROR : NO_INIT; 144 } 145 146 void AudioHardware::loadRILD(void) 147 { 148 mSecRilLibHandle = dlopen("libsecril-client.so", RTLD_NOW); 149 150 if (mSecRilLibHandle) { 151 LOGV("libsecril-client.so is loaded"); 152 153 openClientRILD = (HRilClient (*)(void)) 154 dlsym(mSecRilLibHandle, "OpenClient_RILD"); 155 disconnectRILD = (int (*)(HRilClient)) 156 dlsym(mSecRilLibHandle, "Disconnect_RILD"); 157 closeClientRILD = (int (*)(HRilClient)) 158 dlsym(mSecRilLibHandle, "CloseClient_RILD"); 159 isConnectedRILD = (int (*)(HRilClient)) 160 dlsym(mSecRilLibHandle, "isConnected_RILD"); 161 connectRILD = (int (*)(HRilClient)) 162 dlsym(mSecRilLibHandle, "Connect_RILD"); 163 setCallVolume = (int (*)(HRilClient, SoundType, int)) 164 dlsym(mSecRilLibHandle, "SetCallVolume"); 165 setCallAudioPath = (int (*)(HRilClient, AudioPath)) 166 dlsym(mSecRilLibHandle, "SetCallAudioPath"); 167 setCallClockSync = (int (*)(HRilClient, SoundClockCondition)) 168 dlsym(mSecRilLibHandle, "SetCallClockSync"); 169 170 if (!openClientRILD || !disconnectRILD || !closeClientRILD || 171 !isConnectedRILD || !connectRILD || 172 !setCallVolume || !setCallAudioPath || !setCallClockSync) { 173 LOGE("Can't load all functions from libsecril-client.so"); 174 175 dlclose(mSecRilLibHandle); 176 mSecRilLibHandle = NULL; 177 } else { 178 mRilClient = openClientRILD(); 179 if (!mRilClient) { 180 LOGE("OpenClient_RILD() error"); 181 182 dlclose(mSecRilLibHandle); 183 mSecRilLibHandle = NULL; 184 } 185 } 186 } else { 187 LOGE("Can't load libsecril-client.so"); 188 } 189 } 190 191 status_t AudioHardware::connectRILDIfRequired(void) 192 { 193 if (!mSecRilLibHandle) { 194 LOGE("connectIfRequired() lib is not loaded"); 195 return INVALID_OPERATION; 196 } 197 198 if (isConnectedRILD(mRilClient)) { 199 return OK; 200 } 201 202 if (connectRILD(mRilClient) != RIL_CLIENT_ERR_SUCCESS) { 203 LOGE("Connect_RILD() error"); 204 return INVALID_OPERATION; 205 } 206 207 return OK; 208 } 209 210 AudioStreamOut* AudioHardware::openOutputStream( 211 uint32_t devices, int *format, uint32_t *channels, 212 uint32_t *sampleRate, status_t *status) 213 { 214 sp <AudioStreamOutALSA> out; 215 status_t rc; 216 217 { // scope for the lock 218 Mutex::Autolock lock(mLock); 219 220 // only one output stream allowed 221 if (mOutput != 0) { 222 if (status) { 223 *status = INVALID_OPERATION; 224 } 225 return NULL; 226 } 227 228 out = new AudioStreamOutALSA(); 229 230 rc = out->set(this, devices, format, channels, sampleRate); 231 if (rc == NO_ERROR) { 232 mOutput = out; 233 } 234 } 235 236 if (rc != NO_ERROR) { 237 if (out != 0) { 238 out.clear(); 239 } 240 } 241 if (status) { 242 *status = rc; 243 } 244 245 return out.get(); 246 } 247 248 void AudioHardware::closeOutputStream(AudioStreamOut* out) { 249 sp <AudioStreamOutALSA> spOut; 250 sp<AudioStreamInALSA> spIn; 251 { 252 Mutex::Autolock lock(mLock); 253 if (mOutput == 0 || mOutput.get() != out) { 254 LOGW("Attempt to close invalid output stream"); 255 return; 256 } 257 spOut = mOutput; 258 mOutput.clear(); 259 if (mEchoReference != NULL) { 260 spIn = getActiveInput_l(); 261 } 262 } 263 if (spIn != 0) { 264 // this will safely release the echo reference by calling releaseEchoReference() 265 // after placing the active input in standby 266 spIn->standby(); 267 } 268 269 spOut.clear(); 270 } 271 272 AudioStreamIn* AudioHardware::openInputStream( 273 uint32_t devices, int *format, uint32_t *channels, 274 uint32_t *sampleRate, status_t *status, 275 AudioSystem::audio_in_acoustics acoustic_flags) 276 { 277 // check for valid input source 278 if (!AudioSystem::isInputDevice((AudioSystem::audio_devices)devices)) { 279 if (status) { 280 *status = BAD_VALUE; 281 } 282 return NULL; 283 } 284 285 status_t rc = NO_ERROR; 286 sp <AudioStreamInALSA> in; 287 288 { // scope for the lock 289 Mutex::Autolock lock(mLock); 290 291 in = new AudioStreamInALSA(); 292 rc = in->set(this, devices, format, channels, sampleRate, acoustic_flags); 293 if (rc == NO_ERROR) { 294 mInputs.add(in); 295 } 296 } 297 298 if (rc != NO_ERROR) { 299 if (in != 0) { 300 in.clear(); 301 } 302 } 303 if (status) { 304 *status = rc; 305 } 306 307 LOGV("AudioHardware::openInputStream()%p", in.get()); 308 return in.get(); 309 } 310 311 void AudioHardware::closeInputStream(AudioStreamIn* in) { 312 313 sp<AudioStreamInALSA> spIn; 314 { 315 Mutex::Autolock lock(mLock); 316 317 ssize_t index = mInputs.indexOf((AudioStreamInALSA *)in); 318 if (index < 0) { 319 LOGW("Attempt to close invalid input stream"); 320 return; 321 } 322 spIn = mInputs[index]; 323 mInputs.removeAt(index); 324 } 325 LOGV("AudioHardware::closeInputStream()%p", in); 326 spIn.clear(); 327 } 328 329 330 status_t AudioHardware::setMode(int mode) 331 { 332 sp<AudioStreamOutALSA> spOut; 333 sp<AudioStreamInALSA> spIn; 334 status_t status; 335 336 // Mutex acquisition order is always out -> in -> hw 337 AutoMutex lock(mLock); 338 339 spOut = mOutput; 340 while (spOut != 0) { 341 if (!spOut->checkStandby()) { 342 int cnt = spOut->prepareLock(); 343 mLock.unlock(); 344 spOut->lock(); 345 mLock.lock(); 346 // make sure that another thread did not change output state while the 347 // mutex is released 348 if ((spOut == mOutput) && (cnt == spOut->standbyCnt())) { 349 break; 350 } 351 spOut->unlock(); 352 spOut = mOutput; 353 } else { 354 spOut.clear(); 355 } 356 } 357 // spOut is not 0 here only if the output is active 358 359 spIn = getActiveInput_l(); 360 while (spIn != 0) { 361 int cnt = spIn->prepareLock(); 362 mLock.unlock(); 363 spIn->lock(); 364 mLock.lock(); 365 // make sure that another thread did not change input state while the 366 // mutex is released 367 if ((spIn == getActiveInput_l()) && (cnt == spIn->standbyCnt())) { 368 break; 369 } 370 spIn->unlock(); 371 spIn = getActiveInput_l(); 372 } 373 // spIn is not 0 here only if the input is active 374 375 int prevMode = mMode; 376 status = AudioHardwareBase::setMode(mode); 377 LOGV("setMode() : new %d, old %d", mMode, prevMode); 378 if (status == NO_ERROR) { 379 bool modeNeedsCPActive = mMode == AudioSystem::MODE_IN_CALL || 380 mMode == AudioSystem::MODE_RINGTONE; 381 // activate call clock in radio when entering in call or ringtone mode 382 if (modeNeedsCPActive) 383 { 384 if ((!mActivatedCP) && (mSecRilLibHandle) && (connectRILDIfRequired() == OK)) { 385 setCallClockSync(mRilClient, SOUND_CLOCK_START); 386 mActivatedCP = true; 387 } 388 } 389 390 if (mMode == AudioSystem::MODE_IN_CALL && !mInCallAudioMode) { 391 if (spOut != 0) { 392 LOGV("setMode() in call force output standby"); 393 spOut->doStandby_l(); 394 } 395 if (spIn != 0) { 396 LOGV("setMode() in call force input standby"); 397 spIn->doStandby_l(); 398 } 399 400 LOGV("setMode() openPcmOut_l()"); 401 openPcmOut_l(); 402 openMixer_l(); 403 setInputSource_l(AUDIO_SOURCE_DEFAULT); 404 setVoiceVolume_l(mVoiceVol); 405 mInCallAudioMode = true; 406 } 407 if (mMode != AudioSystem::MODE_IN_CALL && mInCallAudioMode) { 408 setInputSource_l(mInputSource); 409 if (mMixer != NULL) { 410 TRACE_DRIVER_IN(DRV_MIXER_GET) 411 struct mixer_ctl *ctl= mixer_get_ctl_by_name(mMixer, "Playback Path"); 412 TRACE_DRIVER_OUT 413 if (ctl != NULL) { 414 LOGV("setMode() reset Playback Path to RCV"); 415 TRACE_DRIVER_IN(DRV_MIXER_SEL) 416 mixer_ctl_set_enum_by_string(ctl, "RCV"); 417 TRACE_DRIVER_OUT 418 } 419 } 420 LOGV("setMode() closePcmOut_l()"); 421 closeMixer_l(); 422 closePcmOut_l(); 423 424 if (spOut != 0) { 425 LOGV("setMode() off call force output standby"); 426 spOut->doStandby_l(); 427 } 428 if (spIn != 0) { 429 LOGV("setMode() off call force input standby"); 430 spIn->doStandby_l(); 431 } 432 433 mInCallAudioMode = false; 434 } 435 436 if (!modeNeedsCPActive) { 437 if(mActivatedCP) 438 mActivatedCP = false; 439 } 440 } 441 442 if (spIn != 0) { 443 spIn->unlock(); 444 } 445 if (spOut != 0) { 446 spOut->unlock(); 447 } 448 449 return status; 450 } 451 452 status_t AudioHardware::setMicMute(bool state) 453 { 454 LOGV("setMicMute(%d) mMicMute %d", state, mMicMute); 455 sp<AudioStreamInALSA> spIn; 456 { 457 AutoMutex lock(mLock); 458 if (mMicMute != state) { 459 mMicMute = state; 460 // in call mute is handled by RIL 461 if (mMode != AudioSystem::MODE_IN_CALL) { 462 spIn = getActiveInput_l(); 463 } 464 } 465 } 466 467 if (spIn != 0) { 468 spIn->standby(); 469 } 470 471 return NO_ERROR; 472 } 473 474 status_t AudioHardware::getMicMute(bool* state) 475 { 476 *state = mMicMute; 477 return NO_ERROR; 478 } 479 480 status_t AudioHardware::setParameters(const String8& keyValuePairs) 481 { 482 AudioParameter param = AudioParameter(keyValuePairs); 483 String8 value; 484 String8 key; 485 const char BT_NREC_KEY[] = "bt_headset_nrec"; 486 const char BT_NREC_VALUE_ON[] = "on"; 487 const char TTY_MODE_KEY[] = "tty_mode"; 488 const char TTY_MODE_VALUE_OFF[] = "tty_off"; 489 const char TTY_MODE_VALUE_VCO[] = "tty_vco"; 490 const char TTY_MODE_VALUE_HCO[] = "tty_hco"; 491 const char TTY_MODE_VALUE_FULL[] = "tty_full"; 492 493 key = String8(BT_NREC_KEY); 494 if (param.get(key, value) == NO_ERROR) { 495 if (value == BT_NREC_VALUE_ON) { 496 mBluetoothNrec = true; 497 } else { 498 mBluetoothNrec = false; 499 LOGD("Turning noise reduction and echo cancellation off for BT " 500 "headset"); 501 } 502 param.remove(String8(BT_NREC_KEY)); 503 } 504 505 key = String8(TTY_MODE_KEY); 506 if (param.get(key, value) == NO_ERROR) { 507 int ttyMode; 508 if (value == TTY_MODE_VALUE_OFF) { 509 ttyMode = TTY_MODE_OFF; 510 } else if (value == TTY_MODE_VALUE_VCO) { 511 ttyMode = TTY_MODE_VCO; 512 } else if (value == TTY_MODE_VALUE_HCO) { 513 ttyMode = TTY_MODE_HCO; 514 } else if (value == TTY_MODE_VALUE_FULL) { 515 ttyMode = TTY_MODE_FULL; 516 } else { 517 return BAD_VALUE; 518 } 519 520 if (ttyMode != mTTYMode) { 521 LOGV("new tty mode %d", ttyMode); 522 mTTYMode = ttyMode; 523 if (mOutput != 0 && mMode == AudioSystem::MODE_IN_CALL) { 524 setIncallPath_l(mOutput->device()); 525 } 526 } 527 param.remove(String8(TTY_MODE_KEY)); 528 } 529 530 return NO_ERROR; 531 } 532 533 String8 AudioHardware::getParameters(const String8& keys) 534 { 535 AudioParameter request = AudioParameter(keys); 536 AudioParameter reply = AudioParameter(); 537 538 LOGV("getParameters() %s", keys.string()); 539 540 return reply.toString(); 541 } 542 543 size_t AudioHardware::getInputBufferSize(uint32_t sampleRate, int format, int channelCount) 544 { 545 if (format != AudioSystem::PCM_16_BIT) { 546 LOGW("getInputBufferSize bad format: %d", format); 547 return 0; 548 } 549 if (channelCount < 1 || channelCount > 2) { 550 LOGW("getInputBufferSize bad channel count: %d", channelCount); 551 return 0; 552 } 553 554 if (sampleRate != getInputSampleRate(sampleRate)) { 555 LOGW("getInputBufferSize bad sample rate: %d", sampleRate); 556 return 0; 557 } 558 559 return AudioStreamInALSA::getBufferSize(sampleRate, channelCount); 560 } 561 562 status_t AudioHardware::setVoiceVolume(float volume) 563 { 564 AutoMutex lock(mLock); 565 566 setVoiceVolume_l(volume); 567 568 return NO_ERROR; 569 } 570 571 void AudioHardware::setVoiceVolume_l(float volume) 572 { 573 LOGD("### setVoiceVolume_l"); 574 575 mVoiceVol = volume; 576 577 if ( (AudioSystem::MODE_IN_CALL == mMode) && (mSecRilLibHandle) && 578 (connectRILDIfRequired() == OK) ) { 579 580 uint32_t device = AudioSystem::DEVICE_OUT_EARPIECE; 581 if (mOutput != 0) { 582 device = mOutput->device(); 583 } 584 int int_volume = (int)(volume * 5); 585 SoundType type; 586 587 LOGD("### route(%d) call volume(%f)", device, volume); 588 switch (device) { 589 case AudioSystem::DEVICE_OUT_EARPIECE: 590 LOGD("### earpiece call volume"); 591 type = SOUND_TYPE_VOICE; 592 break; 593 594 case AudioSystem::DEVICE_OUT_SPEAKER: 595 LOGD("### speaker call volume"); 596 type = SOUND_TYPE_SPEAKER; 597 break; 598 599 case AudioSystem::DEVICE_OUT_BLUETOOTH_SCO: 600 case AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_HEADSET: 601 case AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_CARKIT: 602 LOGD("### bluetooth call volume"); 603 type = SOUND_TYPE_BTVOICE; 604 break; 605 606 case AudioSystem::DEVICE_OUT_WIRED_HEADSET: 607 case AudioSystem::DEVICE_OUT_WIRED_HEADPHONE: // Use receive path with 3 pole headset. 608 LOGD("### headset call volume"); 609 type = SOUND_TYPE_HEADSET; 610 break; 611 612 default: 613 LOGW("### Call volume setting error!!!0x%08x \n", device); 614 type = SOUND_TYPE_VOICE; 615 break; 616 } 617 setCallVolume(mRilClient, type, int_volume); 618 } 619 620 } 621 622 status_t AudioHardware::setMasterVolume(float volume) 623 { 624 LOGV("Set master volume to %f.\n", volume); 625 // We return an error code here to let the audioflinger do in-software 626 // volume on top of the maximum volume that we set through the SND API. 627 // return error - software mixer will handle it 628 return -1; 629 } 630 631 static const int kDumpLockRetries = 50; 632 static const int kDumpLockSleep = 20000; 633 634 static bool tryLock(Mutex& mutex) 635 { 636 bool locked = false; 637 for (int i = 0; i < kDumpLockRetries; ++i) { 638 if (mutex.tryLock() == NO_ERROR) { 639 locked = true; 640 break; 641 } 642 usleep(kDumpLockSleep); 643 } 644 return locked; 645 } 646 647 status_t AudioHardware::dump(int fd, const Vector<String16>& args) 648 { 649 const size_t SIZE = 256; 650 char buffer[SIZE]; 651 String8 result; 652 653 bool locked = tryLock(mLock); 654 if (!locked) { 655 snprintf(buffer, SIZE, "\n\tAudioHardware maybe deadlocked\n"); 656 } else { 657 mLock.unlock(); 658 } 659 660 snprintf(buffer, SIZE, "\tInit %s\n", (mInit) ? "OK" : "Failed"); 661 result.append(buffer); 662 snprintf(buffer, SIZE, "\tMic Mute %s\n", (mMicMute) ? "ON" : "OFF"); 663 result.append(buffer); 664 snprintf(buffer, SIZE, "\tmPcm: %p\n", mPcm); 665 result.append(buffer); 666 snprintf(buffer, SIZE, "\tmPcmOpenCnt: %d\n", mPcmOpenCnt); 667 result.append(buffer); 668 snprintf(buffer, SIZE, "\tmMixer: %p\n", mMixer); 669 result.append(buffer); 670 snprintf(buffer, SIZE, "\tmMixerOpenCnt: %d\n", mMixerOpenCnt); 671 result.append(buffer); 672 snprintf(buffer, SIZE, "\tIn Call Audio Mode %s\n", 673 (mInCallAudioMode) ? "ON" : "OFF"); 674 result.append(buffer); 675 snprintf(buffer, SIZE, "\tInput source %d\n", mInputSource); 676 result.append(buffer); 677 snprintf(buffer, SIZE, "\tmSecRilLibHandle: %p\n", mSecRilLibHandle); 678 result.append(buffer); 679 snprintf(buffer, SIZE, "\tmRilClient: %p\n", mRilClient); 680 result.append(buffer); 681 snprintf(buffer, SIZE, "\tCP %s\n", 682 (mActivatedCP) ? "Activated" : "Deactivated"); 683 result.append(buffer); 684 snprintf(buffer, SIZE, "\tmDriverOp: %d\n", mDriverOp); 685 result.append(buffer); 686 687 snprintf(buffer, SIZE, "\n\tmOutput %p dump:\n", mOutput.get()); 688 result.append(buffer); 689 write(fd, result.string(), result.size()); 690 if (mOutput != 0) { 691 mOutput->dump(fd, args); 692 } 693 694 snprintf(buffer, SIZE, "\n\t%d inputs opened:\n", mInputs.size()); 695 write(fd, buffer, strlen(buffer)); 696 for (size_t i = 0; i < mInputs.size(); i++) { 697 snprintf(buffer, SIZE, "\t- input %d dump:\n", i); 698 write(fd, buffer, strlen(buffer)); 699 mInputs[i]->dump(fd, args); 700 } 701 702 return NO_ERROR; 703 } 704 705 status_t AudioHardware::setIncallPath_l(uint32_t device) 706 { 707 LOGV("setIncallPath_l: device %x", device); 708 709 // Setup sound path for CP clocking 710 if ((mSecRilLibHandle) && 711 (connectRILDIfRequired() == OK)) { 712 713 if (mMode == AudioSystem::MODE_IN_CALL) { 714 LOGD("### incall mode route (%d)", device); 715 AudioPath path; 716 switch(device){ 717 case AudioSystem::DEVICE_OUT_EARPIECE: 718 LOGD("### incall mode earpiece route"); 719 path = SOUND_AUDIO_PATH_HANDSET; 720 break; 721 722 case AudioSystem::DEVICE_OUT_SPEAKER: 723 LOGD("### incall mode speaker route"); 724 path = SOUND_AUDIO_PATH_SPEAKER; 725 break; 726 727 case AudioSystem::DEVICE_OUT_BLUETOOTH_SCO: 728 case AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_HEADSET: 729 case AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_CARKIT: 730 LOGD("### incall mode bluetooth route %s NR", mBluetoothNrec ? "" : "NO"); 731 if (mBluetoothNrec) { 732 path = SOUND_AUDIO_PATH_BLUETOOTH; 733 } else { 734 path = SOUND_AUDIO_PATH_BLUETOOTH_NO_NR; 735 } 736 break; 737 738 case AudioSystem::DEVICE_OUT_WIRED_HEADPHONE : 739 LOGD("### incall mode headphone route"); 740 path = SOUND_AUDIO_PATH_HEADPHONE; 741 break; 742 case AudioSystem::DEVICE_OUT_WIRED_HEADSET : 743 LOGD("### incall mode headset route"); 744 path = SOUND_AUDIO_PATH_HEADSET; 745 break; 746 default: 747 LOGW("### incall mode Error!! route = [%d]", device); 748 path = SOUND_AUDIO_PATH_HANDSET; 749 break; 750 } 751 752 setCallAudioPath(mRilClient, path); 753 754 if (mMixer != NULL) { 755 TRACE_DRIVER_IN(DRV_MIXER_GET) 756 struct mixer_ctl *ctl= mixer_get_ctl_by_name(mMixer, "Voice Call Path"); 757 TRACE_DRIVER_OUT 758 LOGE_IF(ctl == NULL, "setIncallPath_l() could not get mixer ctl"); 759 if (ctl != NULL) { 760 LOGV("setIncallPath_l() Voice Call Path, (%x)", device); 761 TRACE_DRIVER_IN(DRV_MIXER_SEL) 762 mixer_ctl_set_enum_by_string(ctl, getVoiceRouteFromDevice(device)); 763 TRACE_DRIVER_OUT 764 } 765 } 766 } 767 } 768 return NO_ERROR; 769 } 770 771 struct pcm *AudioHardware::openPcmOut_l() 772 { 773 LOGD("openPcmOut_l() mPcmOpenCnt: %d", mPcmOpenCnt); 774 if (mPcmOpenCnt++ == 0) { 775 if (mPcm != NULL) { 776 LOGE("openPcmOut_l() mPcmOpenCnt == 0 and mPcm == %p\n", mPcm); 777 mPcmOpenCnt--; 778 return NULL; 779 } 780 unsigned flags = PCM_OUT; 781 782 struct pcm_config config = { 783 channels : 2, 784 rate : AUDIO_HW_OUT_SAMPLERATE, 785 period_size : AUDIO_HW_OUT_PERIOD_SZ, 786 period_count : AUDIO_HW_OUT_PERIOD_CNT, 787 format : PCM_FORMAT_S16_LE, 788 start_threshold : 0, 789 stop_threshold : 0, 790 silence_threshold : 0, 791 }; 792 793 TRACE_DRIVER_IN(DRV_PCM_OPEN) 794 mPcm = pcm_open(0, 0, flags, &config); 795 TRACE_DRIVER_OUT 796 if (!pcm_is_ready(mPcm)) { 797 LOGE("openPcmOut_l() cannot open pcm_out driver: %s\n", pcm_get_error(mPcm)); 798 TRACE_DRIVER_IN(DRV_PCM_CLOSE) 799 pcm_close(mPcm); 800 TRACE_DRIVER_OUT 801 mPcmOpenCnt--; 802 mPcm = NULL; 803 } 804 } 805 return mPcm; 806 } 807 808 void AudioHardware::closePcmOut_l() 809 { 810 LOGD("closePcmOut_l() mPcmOpenCnt: %d", mPcmOpenCnt); 811 if (mPcmOpenCnt == 0) { 812 LOGE("closePcmOut_l() mPcmOpenCnt == 0"); 813 return; 814 } 815 816 if (--mPcmOpenCnt == 0) { 817 TRACE_DRIVER_IN(DRV_PCM_CLOSE) 818 pcm_close(mPcm); 819 TRACE_DRIVER_OUT 820 mPcm = NULL; 821 } 822 } 823 824 struct mixer *AudioHardware::openMixer_l() 825 { 826 LOGV("openMixer_l() mMixerOpenCnt: %d", mMixerOpenCnt); 827 if (mMixerOpenCnt++ == 0) { 828 if (mMixer != NULL) { 829 LOGE("openMixer_l() mMixerOpenCnt == 0 and mMixer == %p\n", mMixer); 830 mMixerOpenCnt--; 831 return NULL; 832 } 833 TRACE_DRIVER_IN(DRV_MIXER_OPEN) 834 mMixer = mixer_open(0); 835 TRACE_DRIVER_OUT 836 if (mMixer == NULL) { 837 LOGE("openMixer_l() cannot open mixer"); 838 mMixerOpenCnt--; 839 return NULL; 840 } 841 } 842 return mMixer; 843 } 844 845 void AudioHardware::closeMixer_l() 846 { 847 LOGV("closeMixer_l() mMixerOpenCnt: %d", mMixerOpenCnt); 848 if (mMixerOpenCnt == 0) { 849 LOGE("closeMixer_l() mMixerOpenCnt == 0"); 850 return; 851 } 852 853 if (--mMixerOpenCnt == 0) { 854 TRACE_DRIVER_IN(DRV_MIXER_CLOSE) 855 mixer_close(mMixer); 856 TRACE_DRIVER_OUT 857 mMixer = NULL; 858 } 859 } 860 861 const char *AudioHardware::getOutputRouteFromDevice(uint32_t device) 862 { 863 switch (device) { 864 case AudioSystem::DEVICE_OUT_EARPIECE: 865 return "RCV"; 866 case AudioSystem::DEVICE_OUT_SPEAKER: 867 if (mMode == AudioSystem::MODE_RINGTONE) return "RING_SPK"; 868 else return "SPK"; 869 case AudioSystem::DEVICE_OUT_WIRED_HEADPHONE: 870 if (mMode == AudioSystem::MODE_RINGTONE) return "RING_NO_MIC"; 871 else return "HP_NO_MIC"; 872 case AudioSystem::DEVICE_OUT_WIRED_HEADSET: 873 if (mMode == AudioSystem::MODE_RINGTONE) return "RING_HP"; 874 else return "HP"; 875 case (AudioSystem::DEVICE_OUT_SPEAKER|AudioSystem::DEVICE_OUT_WIRED_HEADPHONE): 876 case (AudioSystem::DEVICE_OUT_SPEAKER|AudioSystem::DEVICE_OUT_WIRED_HEADSET): 877 if (mMode == AudioSystem::MODE_RINGTONE) return "RING_SPK_HP"; 878 else return "SPK_HP"; 879 case AudioSystem::DEVICE_OUT_BLUETOOTH_SCO: 880 case AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_HEADSET: 881 case AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_CARKIT: 882 return "BT"; 883 default: 884 return "OFF"; 885 } 886 } 887 888 const char *AudioHardware::getVoiceRouteFromDevice(uint32_t device) 889 { 890 switch (device) { 891 case AudioSystem::DEVICE_OUT_EARPIECE: 892 return "RCV"; 893 case AudioSystem::DEVICE_OUT_SPEAKER: 894 return "SPK"; 895 case AudioSystem::DEVICE_OUT_WIRED_HEADPHONE: 896 case AudioSystem::DEVICE_OUT_WIRED_HEADSET: 897 switch (mTTYMode) { 898 case TTY_MODE_VCO: 899 return "TTY_VCO"; 900 case TTY_MODE_HCO: 901 return "TTY_HCO"; 902 case TTY_MODE_FULL: 903 return "TTY_FULL"; 904 case TTY_MODE_OFF: 905 default: 906 if (device == AudioSystem::DEVICE_OUT_WIRED_HEADPHONE) { 907 return "HP_NO_MIC"; 908 } else { 909 return "HP"; 910 } 911 } 912 case AudioSystem::DEVICE_OUT_BLUETOOTH_SCO: 913 case AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_HEADSET: 914 case AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_CARKIT: 915 return "BT"; 916 default: 917 return "OFF"; 918 } 919 } 920 921 const char *AudioHardware::getInputRouteFromDevice(uint32_t device) 922 { 923 if (mMicMute) { 924 return "MIC OFF"; 925 } 926 927 switch (device) { 928 case AudioSystem::DEVICE_IN_BUILTIN_MIC: 929 return "Main Mic"; 930 case AudioSystem::DEVICE_IN_WIRED_HEADSET: 931 return "Hands Free Mic"; 932 case AudioSystem::DEVICE_IN_BLUETOOTH_SCO_HEADSET: 933 return "BT Sco Mic"; 934 default: 935 return "MIC OFF"; 936 } 937 } 938 939 uint32_t AudioHardware::getInputSampleRate(uint32_t sampleRate) 940 { 941 size_t i; 942 uint32_t prevDelta; 943 uint32_t delta; 944 size_t size = sizeof(inputConfigTable)/sizeof(uint32_t)/INPUT_CONFIG_CNT; 945 946 for (i = 0, prevDelta = 0xFFFFFFFF; i < size; i++, prevDelta = delta) { 947 delta = abs(sampleRate - inputConfigTable[i][INPUT_CONFIG_SAMPLE_RATE]); 948 if (delta > prevDelta) break; 949 } 950 // i is always > 0 here 951 return inputConfigTable[i-1][INPUT_CONFIG_SAMPLE_RATE]; 952 } 953 954 // getActiveInput_l() must be called with mLock held 955 sp <AudioHardware::AudioStreamInALSA> AudioHardware::getActiveInput_l() 956 { 957 sp< AudioHardware::AudioStreamInALSA> spIn; 958 959 for (size_t i = 0; i < mInputs.size(); i++) { 960 // return first input found not being in standby mode 961 // as only one input can be in this state 962 if (!mInputs[i]->checkStandby()) { 963 spIn = mInputs[i]; 964 break; 965 } 966 } 967 968 return spIn; 969 } 970 971 status_t AudioHardware::setInputSource_l(audio_source source) 972 { 973 LOGV("setInputSource_l(%d)", source); 974 if (source != mInputSource) { 975 if ((source == AUDIO_SOURCE_DEFAULT) || (mMode != AudioSystem::MODE_IN_CALL)) { 976 if (mMixer) { 977 TRACE_DRIVER_IN(DRV_MIXER_GET) 978 struct mixer_ctl *ctl= mixer_get_ctl_by_name(mMixer, "Input Source"); 979 TRACE_DRIVER_OUT 980 if (ctl == NULL) { 981 return NO_INIT; 982 } 983 const char* sourceName; 984 switch (source) { 985 case AUDIO_SOURCE_DEFAULT: // intended fall-through 986 case AUDIO_SOURCE_MIC: // intended fall-through 987 case AUDIO_SOURCE_VOICE_COMMUNICATION: 988 sourceName = inputPathNameDefault; 989 break; 990 case AUDIO_SOURCE_CAMCORDER: 991 sourceName = inputPathNameCamcorder; 992 break; 993 case AUDIO_SOURCE_VOICE_RECOGNITION: 994 sourceName = inputPathNameVoiceRecognition; 995 break; 996 case AUDIO_SOURCE_VOICE_UPLINK: // intended fall-through 997 case AUDIO_SOURCE_VOICE_DOWNLINK: // intended fall-through 998 case AUDIO_SOURCE_VOICE_CALL: // intended fall-through 999 default: 1000 return NO_INIT; 1001 } 1002 LOGV("mixer_ctl_set_enum_by_string, Input Source, (%s)", sourceName); 1003 TRACE_DRIVER_IN(DRV_MIXER_SEL) 1004 mixer_ctl_set_enum_by_string(ctl, sourceName); 1005 TRACE_DRIVER_OUT 1006 } 1007 } 1008 mInputSource = source; 1009 } 1010 1011 return NO_ERROR; 1012 } 1013 1014 struct echo_reference_itfe *AudioHardware::getEchoReference(audio_format_t format, 1015 uint32_t channelCount, 1016 uint32_t samplingRate) 1017 { 1018 LOGV("AudioHardware::getEchoReference %p", mEchoReference); 1019 releaseEchoReference(mEchoReference); 1020 if (mOutput != NULL) { 1021 uint32_t wrChannelCount = popcount(mOutput->channels()); 1022 uint32_t wrSampleRate = mOutput->sampleRate(); 1023 1024 int status = create_echo_reference(AUDIO_FORMAT_PCM_16_BIT, 1025 channelCount, 1026 samplingRate, 1027 AUDIO_FORMAT_PCM_16_BIT, 1028 wrChannelCount, 1029 wrSampleRate, 1030 &mEchoReference); 1031 if (status == 0) { 1032 mOutput->addEchoReference(mEchoReference); 1033 } 1034 } 1035 return mEchoReference; 1036 } 1037 1038 void AudioHardware::releaseEchoReference(struct echo_reference_itfe *reference) 1039 { 1040 LOGV("AudioHardware::releaseEchoReference %p", mEchoReference); 1041 if (mEchoReference != NULL && reference == mEchoReference) { 1042 if (mOutput != NULL) { 1043 mOutput->removeEchoReference(reference); 1044 } 1045 release_echo_reference(mEchoReference); 1046 mEchoReference = NULL; 1047 } 1048 } 1049 1050 1051 //------------------------------------------------------------------------------ 1052 // AudioStreamOutALSA 1053 //------------------------------------------------------------------------------ 1054 1055 AudioHardware::AudioStreamOutALSA::AudioStreamOutALSA() : 1056 mHardware(0), mPcm(0), mMixer(0), mRouteCtl(0), 1057 mStandby(true), mDevices(0), mChannels(AUDIO_HW_OUT_CHANNELS), 1058 mSampleRate(AUDIO_HW_OUT_SAMPLERATE), mBufferSize(AUDIO_HW_OUT_PERIOD_BYTES), 1059 mDriverOp(DRV_NONE), mStandbyCnt(0), mSleepReq(false), mEchoReference(NULL) 1060 { 1061 } 1062 1063 status_t AudioHardware::AudioStreamOutALSA::set( 1064 AudioHardware* hw, uint32_t devices, int *pFormat, 1065 uint32_t *pChannels, uint32_t *pRate) 1066 { 1067 int lFormat = pFormat ? *pFormat : 0; 1068 uint32_t lChannels = pChannels ? *pChannels : 0; 1069 uint32_t lRate = pRate ? *pRate : 0; 1070 1071 mHardware = hw; 1072 mDevices = devices; 1073 1074 // fix up defaults 1075 if (lFormat == 0) lFormat = format(); 1076 if (lChannels == 0) lChannels = channels(); 1077 if (lRate == 0) lRate = sampleRate(); 1078 1079 // check values 1080 if ((lFormat != format()) || 1081 (lChannels != channels()) || 1082 (lRate != sampleRate())) { 1083 if (pFormat) *pFormat = format(); 1084 if (pChannels) *pChannels = channels(); 1085 if (pRate) *pRate = sampleRate(); 1086 return BAD_VALUE; 1087 } 1088 1089 if (pFormat) *pFormat = lFormat; 1090 if (pChannels) *pChannels = lChannels; 1091 if (pRate) *pRate = lRate; 1092 1093 mChannels = lChannels; 1094 mSampleRate = lRate; 1095 mBufferSize = AUDIO_HW_OUT_PERIOD_BYTES; 1096 1097 return NO_ERROR; 1098 } 1099 1100 AudioHardware::AudioStreamOutALSA::~AudioStreamOutALSA() 1101 { 1102 standby(); 1103 } 1104 1105 int AudioHardware::AudioStreamOutALSA::getPlaybackDelay(size_t frames, 1106 struct echo_reference_buffer *buffer) 1107 { 1108 size_t kernelFr; 1109 1110 int rc = pcm_get_htimestamp(mPcm, &kernelFr, &buffer->time_stamp); 1111 if (rc < 0) { 1112 buffer->time_stamp.tv_sec = 0; 1113 buffer->time_stamp.tv_nsec = 0; 1114 buffer->delay_ns = 0; 1115 LOGV("getPlaybackDelay(): pcm_get_htimestamp error, setting playbackTimestamp to 0"); 1116 return rc; 1117 } 1118 1119 kernelFr = pcm_get_buffer_size(mPcm) - kernelFr; 1120 1121 // adjust render time stamp with delay added by current driver buffer. 1122 // Add the duration of current frame as we want the render time of the last 1123 // sample being written. 1124 long delayNs = (long)(((int64_t)(kernelFr + frames)* 1000000000) /AUDIO_HW_OUT_SAMPLERATE); 1125 1126 LOGV("AudioStreamOutALSA::getPlaybackDelay delayNs: [%ld], "\ 1127 "kernelFr:[%d], frames:[%d], buffSize:[%d], time_stamp:[%ld].[%ld]", 1128 delayNs, (int)kernelFr, (int)frames, pcm_get_buffer_size(mPcm), 1129 (long)buffer->time_stamp.tv_sec, buffer->time_stamp.tv_nsec); 1130 1131 buffer->delay_ns = delayNs; 1132 1133 return 0; 1134 } 1135 1136 ssize_t AudioHardware::AudioStreamOutALSA::write(const void* buffer, size_t bytes) 1137 { 1138 LOGV("-----AudioStreamInALSA::write(%p, %d) START", buffer, (int)bytes); 1139 status_t status = NO_INIT; 1140 const uint8_t* p = static_cast<const uint8_t*>(buffer); 1141 int ret; 1142 1143 if (mHardware == NULL) return NO_INIT; 1144 1145 if (mSleepReq) { 1146 // 10ms are always shorter than the time to reconfigure the audio path 1147 // which is the only condition when mSleepReq would be true. 1148 usleep(10000); 1149 } 1150 1151 { // scope for the lock 1152 1153 AutoMutex lock(mLock); 1154 1155 if (mStandby) { 1156 AutoMutex hwLock(mHardware->lock()); 1157 1158 LOGD("AudioHardware pcm playback is exiting standby."); 1159 sp<AudioStreamInALSA> spIn = mHardware->getActiveInput_l(); 1160 while (spIn != 0) { 1161 int cnt = spIn->prepareLock(); 1162 mHardware->lock().unlock(); 1163 // Mutex acquisition order is always out -> in -> hw 1164 spIn->lock(); 1165 mHardware->lock().lock(); 1166 // make sure that another thread did not change input state 1167 // while the mutex is released 1168 if ((spIn == mHardware->getActiveInput_l()) && 1169 (cnt == spIn->standbyCnt())) { 1170 LOGV("AudioStreamOutALSA::write() force input standby"); 1171 spIn->close_l(); 1172 break; 1173 } 1174 spIn->unlock(); 1175 spIn = mHardware->getActiveInput_l(); 1176 } 1177 // spIn is not 0 here only if the input was active and has been 1178 // closed above 1179 1180 // open output before input 1181 open_l(); 1182 1183 if (spIn != 0) { 1184 if (spIn->open_l() != NO_ERROR) { 1185 spIn->doStandby_l(); 1186 } 1187 spIn->unlock(); 1188 } 1189 if (mPcm == NULL) { 1190 goto Error; 1191 } 1192 mStandby = false; 1193 } 1194 1195 if (mEchoReference != NULL) { 1196 struct echo_reference_buffer b; 1197 b.raw = (void *)buffer; 1198 b.frame_count = bytes / frameSize(); 1199 1200 getPlaybackDelay(bytes / frameSize(), &b); 1201 mEchoReference->write(mEchoReference, &b); 1202 } 1203 1204 TRACE_DRIVER_IN(DRV_PCM_WRITE) 1205 ret = pcm_write(mPcm,(void*) p, bytes); 1206 TRACE_DRIVER_OUT 1207 1208 if (ret == 0) { 1209 LOGV("-----AudioStreamInALSA::write(%p, %d) END", buffer, (int)bytes); 1210 return bytes; 1211 } 1212 LOGW("write error: %d", errno); 1213 status = -errno; 1214 } 1215 Error: 1216 standby(); 1217 1218 // Simulate audio output timing in case of error 1219 usleep((((bytes * 1000) / frameSize()) * 1000) / sampleRate()); 1220 LOGE("AudioStreamOutALSA::write END WITH ERROR !!!!!!!!!(%p, %u)", buffer, bytes); 1221 return status; 1222 } 1223 1224 status_t AudioHardware::AudioStreamOutALSA::standby() 1225 { 1226 if (mHardware == NULL) return NO_INIT; 1227 1228 mSleepReq = true; 1229 { 1230 AutoMutex lock(mLock); 1231 mSleepReq = false; 1232 1233 { // scope for the AudioHardware lock 1234 AutoMutex hwLock(mHardware->lock()); 1235 1236 doStandby_l(); 1237 } 1238 } 1239 1240 return NO_ERROR; 1241 } 1242 1243 void AudioHardware::AudioStreamOutALSA::doStandby_l() 1244 { 1245 mStandbyCnt++; 1246 1247 if (!mStandby) { 1248 LOGD("AudioHardware pcm playback is going to standby."); 1249 // stop echo reference capture 1250 if (mEchoReference != NULL) { 1251 mEchoReference->write(mEchoReference, NULL); 1252 } 1253 mStandby = true; 1254 } 1255 1256 close_l(); 1257 } 1258 1259 void AudioHardware::AudioStreamOutALSA::close_l() 1260 { 1261 if (mMixer) { 1262 mHardware->closeMixer_l(); 1263 mMixer = NULL; 1264 mRouteCtl = NULL; 1265 } 1266 if (mPcm) { 1267 mHardware->closePcmOut_l(); 1268 mPcm = NULL; 1269 } 1270 } 1271 1272 status_t AudioHardware::AudioStreamOutALSA::open_l() 1273 { 1274 LOGV("open pcm_out driver"); 1275 mPcm = mHardware->openPcmOut_l(); 1276 if (mPcm == NULL) { 1277 return NO_INIT; 1278 } 1279 1280 mMixer = mHardware->openMixer_l(); 1281 if (mMixer) { 1282 LOGV("open playback normal"); 1283 TRACE_DRIVER_IN(DRV_MIXER_GET) 1284 mRouteCtl = mixer_get_ctl_by_name(mMixer, "Playback Path"); 1285 TRACE_DRIVER_OUT 1286 } 1287 if (mHardware->mode() != AudioSystem::MODE_IN_CALL) { 1288 const char *route = mHardware->getOutputRouteFromDevice(mDevices); 1289 LOGV("write() wakeup setting route %s", route); 1290 if (mRouteCtl) { 1291 TRACE_DRIVER_IN(DRV_MIXER_SEL) 1292 mixer_ctl_set_enum_by_string(mRouteCtl, route); 1293 TRACE_DRIVER_OUT 1294 } 1295 } 1296 return NO_ERROR; 1297 } 1298 1299 status_t AudioHardware::AudioStreamOutALSA::dump(int fd, const Vector<String16>& args) 1300 { 1301 const size_t SIZE = 256; 1302 char buffer[SIZE]; 1303 String8 result; 1304 1305 bool locked = tryLock(mLock); 1306 if (!locked) { 1307 snprintf(buffer, SIZE, "\n\t\tAudioStreamOutALSA maybe deadlocked\n"); 1308 } else { 1309 mLock.unlock(); 1310 } 1311 1312 snprintf(buffer, SIZE, "\t\tmHardware: %p\n", mHardware); 1313 result.append(buffer); 1314 snprintf(buffer, SIZE, "\t\tmPcm: %p\n", mPcm); 1315 result.append(buffer); 1316 snprintf(buffer, SIZE, "\t\tmMixer: %p\n", mMixer); 1317 result.append(buffer); 1318 snprintf(buffer, SIZE, "\t\tmRouteCtl: %p\n", mRouteCtl); 1319 result.append(buffer); 1320 snprintf(buffer, SIZE, "\t\tStandby %s\n", (mStandby) ? "ON" : "OFF"); 1321 result.append(buffer); 1322 snprintf(buffer, SIZE, "\t\tmDevices: 0x%08x\n", mDevices); 1323 result.append(buffer); 1324 snprintf(buffer, SIZE, "\t\tmChannels: 0x%08x\n", mChannels); 1325 result.append(buffer); 1326 snprintf(buffer, SIZE, "\t\tmSampleRate: %d\n", mSampleRate); 1327 result.append(buffer); 1328 snprintf(buffer, SIZE, "\t\tmBufferSize: %d\n", mBufferSize); 1329 result.append(buffer); 1330 snprintf(buffer, SIZE, "\t\tmDriverOp: %d\n", mDriverOp); 1331 result.append(buffer); 1332 1333 ::write(fd, result.string(), result.size()); 1334 1335 return NO_ERROR; 1336 } 1337 1338 bool AudioHardware::AudioStreamOutALSA::checkStandby() 1339 { 1340 return mStandby; 1341 } 1342 1343 status_t AudioHardware::AudioStreamOutALSA::setParameters(const String8& keyValuePairs) 1344 { 1345 AudioParameter param = AudioParameter(keyValuePairs); 1346 status_t status = NO_ERROR; 1347 int device; 1348 LOGD("AudioStreamOutALSA::setParameters() %s", keyValuePairs.string()); 1349 1350 if (mHardware == NULL) return NO_INIT; 1351 1352 mSleepReq = true; 1353 { 1354 AutoMutex lock(mLock); 1355 mSleepReq = false; 1356 if (param.getInt(String8(AudioParameter::keyRouting), device) == NO_ERROR) 1357 { 1358 if (device != 0) { 1359 AutoMutex hwLock(mHardware->lock()); 1360 1361 if (mDevices != (uint32_t)device) { 1362 mDevices = (uint32_t)device; 1363 if (mHardware->mode() != AudioSystem::MODE_IN_CALL) { 1364 doStandby_l(); 1365 } 1366 } 1367 if (mHardware->mode() == AudioSystem::MODE_IN_CALL) { 1368 mHardware->setIncallPath_l(device); 1369 } 1370 } 1371 param.remove(String8(AudioParameter::keyRouting)); 1372 } 1373 } 1374 1375 if (param.size()) { 1376 status = BAD_VALUE; 1377 } 1378 1379 1380 return status; 1381 1382 } 1383 1384 String8 AudioHardware::AudioStreamOutALSA::getParameters(const String8& keys) 1385 { 1386 AudioParameter param = AudioParameter(keys); 1387 String8 value; 1388 String8 key = String8(AudioParameter::keyRouting); 1389 1390 if (param.get(key, value) == NO_ERROR) { 1391 param.addInt(key, (int)mDevices); 1392 } 1393 1394 LOGV("AudioStreamOutALSA::getParameters() %s", param.toString().string()); 1395 return param.toString(); 1396 } 1397 1398 status_t AudioHardware::AudioStreamOutALSA::getRenderPosition(uint32_t *dspFrames) 1399 { 1400 //TODO 1401 return INVALID_OPERATION; 1402 } 1403 1404 int AudioHardware::AudioStreamOutALSA::prepareLock() 1405 { 1406 // request sleep next time write() is called so that caller can acquire 1407 // mLock 1408 mSleepReq = true; 1409 return mStandbyCnt; 1410 } 1411 1412 void AudioHardware::AudioStreamOutALSA::lock() 1413 { 1414 mLock.lock(); 1415 mSleepReq = false; 1416 } 1417 1418 void AudioHardware::AudioStreamOutALSA::unlock() { 1419 mLock.unlock(); 1420 } 1421 1422 void AudioHardware::AudioStreamOutALSA::addEchoReference(struct echo_reference_itfe *reference) 1423 { 1424 LOGV("AudioStreamOutALSA::addEchoReference %p", mEchoReference); 1425 if (mEchoReference == NULL) { 1426 mEchoReference = reference; 1427 } 1428 } 1429 1430 void AudioHardware::AudioStreamOutALSA::removeEchoReference(struct echo_reference_itfe *reference) 1431 { 1432 LOGV("AudioStreamOutALSA::removeEchoReference %p", mEchoReference); 1433 if (mEchoReference == reference) { 1434 mEchoReference->write(mEchoReference, NULL); 1435 mEchoReference = NULL; 1436 } 1437 } 1438 1439 1440 //------------------------------------------------------------------------------ 1441 // AudioStreamInALSA 1442 //------------------------------------------------------------------------------ 1443 1444 AudioHardware::AudioStreamInALSA::AudioStreamInALSA() : 1445 mHardware(0), mPcm(0), mMixer(0), mRouteCtl(0), 1446 mStandby(true), mDevices(0), mChannels(AUDIO_HW_IN_CHANNELS), mChannelCount(1), 1447 mSampleRate(AUDIO_HW_IN_SAMPLERATE), mBufferSize(AUDIO_HW_IN_PERIOD_BYTES), 1448 mDownSampler(NULL), mReadStatus(NO_ERROR), mInputBuf(NULL), 1449 mDriverOp(DRV_NONE), mStandbyCnt(0), mSleepReq(false), 1450 mProcBuf(NULL), mProcBufSize(0), mRefBuf(NULL), mRefBufSize(0), 1451 mEchoReference(NULL), mNeedEchoReference(false) 1452 { 1453 } 1454 1455 status_t AudioHardware::AudioStreamInALSA::set( 1456 AudioHardware* hw, uint32_t devices, int *pFormat, 1457 uint32_t *pChannels, uint32_t *pRate, AudioSystem::audio_in_acoustics acoustics) 1458 { 1459 if (pFormat == 0 || *pFormat != AUDIO_HW_IN_FORMAT) { 1460 *pFormat = AUDIO_HW_IN_FORMAT; 1461 return BAD_VALUE; 1462 } 1463 if (pRate == 0) { 1464 return BAD_VALUE; 1465 } 1466 uint32_t rate = AudioHardware::getInputSampleRate(*pRate); 1467 if (rate != *pRate) { 1468 *pRate = rate; 1469 return BAD_VALUE; 1470 } 1471 1472 if (pChannels == 0 || (*pChannels != AudioSystem::CHANNEL_IN_MONO && 1473 *pChannels != AudioSystem::CHANNEL_IN_STEREO)) { 1474 *pChannels = AUDIO_HW_IN_CHANNELS; 1475 return BAD_VALUE; 1476 } 1477 1478 mHardware = hw; 1479 1480 LOGV("AudioStreamInALSA::set(%d, %d, %u)", *pFormat, *pChannels, *pRate); 1481 1482 mBufferSize = getBufferSize(*pRate, AudioSystem::popCount(*pChannels)); 1483 mDevices = devices; 1484 mChannels = *pChannels; 1485 mChannelCount = AudioSystem::popCount(mChannels); 1486 mSampleRate = rate; 1487 if (mSampleRate != AUDIO_HW_OUT_SAMPLERATE) { 1488 mBufferProvider.mProvider.get_next_buffer = getNextBufferStatic; 1489 mBufferProvider.mProvider.release_buffer = releaseBufferStatic; 1490 mBufferProvider.mInputStream = this; 1491 int status = create_resampler(AUDIO_HW_OUT_SAMPLERATE, 1492 mSampleRate, 1493 mChannelCount, 1494 RESAMPLER_QUALITY_VOIP, 1495 &mBufferProvider.mProvider, 1496 &mDownSampler); 1497 if (status != 0) { 1498 LOGW("AudioStreamInALSA::set() downsampler init failed: %d", status); 1499 mDownSampler = NULL; 1500 return status; 1501 } 1502 } 1503 mInputBuf = new int16_t[AUDIO_HW_IN_PERIOD_SZ * mChannelCount]; 1504 1505 return NO_ERROR; 1506 } 1507 1508 AudioHardware::AudioStreamInALSA::~AudioStreamInALSA() 1509 { 1510 standby(); 1511 1512 if (mDownSampler != NULL) { 1513 release_resampler(mDownSampler); 1514 } 1515 delete[] mInputBuf; 1516 delete[] mProcBuf; 1517 } 1518 1519 // readFrames() reads frames from kernel driver, down samples to capture rate if necessary 1520 // and output the number of frames requested to the buffer specified 1521 ssize_t AudioHardware::AudioStreamInALSA::readFrames(void* buffer, ssize_t frames) 1522 { 1523 ssize_t framesWr = 0; 1524 while (framesWr < frames) { 1525 size_t framesRd = frames - framesWr; 1526 if (mDownSampler != NULL) { 1527 mDownSampler->resample_from_provider(mDownSampler, 1528 (int16_t *)((char *)buffer + framesWr * frameSize()), 1529 &framesRd); 1530 } else { 1531 struct resampler_buffer buf = { 1532 { raw : NULL, }, 1533 frame_count : framesRd, 1534 }; 1535 getNextBuffer(&buf); 1536 if (buf.raw != NULL) { 1537 memcpy((char *)buffer + framesWr * frameSize(), 1538 buf.raw, 1539 buf.frame_count * frameSize()); 1540 framesRd = buf.frame_count; 1541 } 1542 releaseBuffer(&buf); 1543 } 1544 // mReadStatus is updated by getNextBuffer() also called by 1545 // mDownSampler->resample_from_provider() 1546 if (mReadStatus != 0) { 1547 return mReadStatus; 1548 } 1549 framesWr += framesRd; 1550 } 1551 return framesWr; 1552 } 1553 1554 // processFrames() reads frames from kernel driver (via readFrames()), calls the active 1555 // audio pre processings and output the number of frames requested to the buffer specified 1556 ssize_t AudioHardware::AudioStreamInALSA::processFrames(void* buffer, ssize_t frames) 1557 { 1558 ssize_t framesWr = 0; 1559 while (framesWr < frames) { 1560 // first reload enough frames at the end of process input buffer 1561 if (mProcFramesIn < (size_t)frames) { 1562 // expand process input buffer if necessary 1563 if (mProcBufSize < (size_t)frames) { 1564 mProcBufSize = (size_t)frames; 1565 mProcBuf = (int16_t *)realloc(mProcBuf, 1566 mProcBufSize * mChannelCount * sizeof(int16_t)); 1567 LOGV("processFrames(): mProcBuf %p size extended to %d frames", 1568 mProcBuf, mProcBufSize); 1569 } 1570 ssize_t framesRd = readFrames(mProcBuf + mProcFramesIn * mChannelCount, 1571 frames - mProcFramesIn); 1572 if (framesRd < 0) { 1573 framesWr = framesRd; 1574 break; 1575 } 1576 mProcFramesIn += framesRd; 1577 } 1578 1579 if (mEchoReference != NULL) { 1580 pushEchoReference(mProcFramesIn); 1581 } 1582 1583 //inBuf.frameCount and outBuf.frameCount indicate respectively the maximum number of frames 1584 //to be consumed and produced by process() 1585 audio_buffer_t inBuf = { 1586 mProcFramesIn, 1587 {mProcBuf} 1588 }; 1589 audio_buffer_t outBuf = { 1590 frames - framesWr, 1591 {(int16_t *)buffer + framesWr * mChannelCount} 1592 }; 1593 1594 for (size_t i = 0; i < mPreprocessors.size(); i++) { 1595 (*mPreprocessors[i])->process(mPreprocessors[i], 1596 &inBuf, 1597 &outBuf); 1598 } 1599 1600 // process() has updated the number of frames consumed and produced in 1601 // inBuf.frameCount and outBuf.frameCount respectively 1602 // move remaining frames to the beginning of mProcBuf 1603 mProcFramesIn -= inBuf.frameCount; 1604 if (mProcFramesIn) { 1605 memcpy(mProcBuf, 1606 mProcBuf + inBuf.frameCount * mChannelCount, 1607 mProcFramesIn * mChannelCount * sizeof(int16_t)); 1608 } 1609 1610 // if not enough frames were passed to process(), read more and retry. 1611 if (outBuf.frameCount == 0) { 1612 continue; 1613 } 1614 framesWr += outBuf.frameCount; 1615 } 1616 return framesWr; 1617 } 1618 1619 int32_t AudioHardware::AudioStreamInALSA::updateEchoReference(size_t frames) 1620 { 1621 struct echo_reference_buffer b; 1622 b.delay_ns = 0; 1623 1624 LOGV("updateEchoReference1 START, frames = [%d], mRefFramesIn = [%d], b.frame_count = [%d]", 1625 frames, mRefFramesIn, frames - mRefFramesIn); 1626 if (mRefFramesIn < frames) { 1627 if (mRefBufSize < frames) { 1628 mRefBufSize = frames; 1629 mRefBuf = (int16_t *)realloc(mRefBuf, 1630 mRefBufSize * mChannelCount * sizeof(int16_t)); 1631 } 1632 1633 b.frame_count = frames - mRefFramesIn; 1634 b.raw = (void *)(mRefBuf + mRefFramesIn * mChannelCount); 1635 1636 getCaptureDelay(frames, &b); 1637 1638 if (mEchoReference->read(mEchoReference, &b) == NO_ERROR) 1639 { 1640 mRefFramesIn += b.frame_count; 1641 LOGV("updateEchoReference2: mRefFramesIn:[%d], mRefBufSize:[%d], "\ 1642 "frames:[%d], b.frame_count:[%d]", mRefFramesIn, mRefBufSize,frames,b.frame_count); 1643 } 1644 1645 }else{ 1646 LOGV("updateEchoReference3: NOT enough frames to read ref buffer"); 1647 } 1648 return b.delay_ns; 1649 } 1650 1651 void AudioHardware::AudioStreamInALSA::pushEchoReference(size_t frames) 1652 { 1653 // read frames from echo reference buffer and update echo delay 1654 // mRefFramesIn is updated with frames available in mRefBuf 1655 int32_t delayUs = (int32_t)(updateEchoReference(frames)/1000); 1656 1657 if (mRefFramesIn < frames) { 1658 frames = mRefFramesIn; 1659 } 1660 1661 audio_buffer_t refBuf = { 1662 frames, 1663 {mRefBuf} 1664 }; 1665 1666 for (size_t i = 0; i < mPreprocessors.size(); i++) { 1667 if ((*mPreprocessors[i])->process_reverse == NULL) { 1668 continue; 1669 } 1670 (*mPreprocessors[i])->process_reverse(mPreprocessors[i], 1671 &refBuf, 1672 NULL); 1673 setPreProcessorEchoDelay(mPreprocessors[i], delayUs); 1674 } 1675 1676 mRefFramesIn -= refBuf.frameCount; 1677 if (mRefFramesIn) { 1678 LOGV("pushEchoReference5: shifting mRefBuf down by = %d frames", mRefFramesIn); 1679 memcpy(mRefBuf, 1680 mRefBuf + refBuf.frameCount * mChannelCount, 1681 mRefFramesIn * mChannelCount * sizeof(int16_t)); 1682 } 1683 } 1684 1685 status_t AudioHardware::AudioStreamInALSA::setPreProcessorEchoDelay(effect_handle_t handle, 1686 int32_t delayUs) 1687 { 1688 uint32_t buf[sizeof(effect_param_t) / sizeof(uint32_t) + 2]; 1689 effect_param_t *param = (effect_param_t *)buf; 1690 1691 param->psize = sizeof(uint32_t); 1692 param->vsize = sizeof(uint32_t); 1693 *(uint32_t *)param->data = AEC_PARAM_ECHO_DELAY; 1694 *((int32_t *)param->data + 1) = delayUs; 1695 1696 LOGV("setPreProcessorEchoDelay: %d us", delayUs); 1697 1698 return setPreprocessorParam(handle, param); 1699 } 1700 1701 status_t AudioHardware::AudioStreamInALSA::setPreprocessorParam(effect_handle_t handle, 1702 effect_param_t *param) 1703 { 1704 uint32_t size = sizeof(int); 1705 uint32_t psize = ((param->psize - 1) / sizeof(int) + 1) * sizeof(int) + param->vsize; 1706 1707 status_t status = (*handle)->command(handle, 1708 EFFECT_CMD_SET_PARAM, 1709 sizeof (effect_param_t) + psize, 1710 param, 1711 &size, 1712 ¶m->status); 1713 if (status == NO_ERROR) { 1714 status = param->status; 1715 } 1716 return status; 1717 } 1718 1719 void AudioHardware::AudioStreamInALSA::getCaptureDelay(size_t frames, 1720 struct echo_reference_buffer *buffer) 1721 { 1722 1723 // read frames available in kernel driver buffer 1724 size_t kernelFr; 1725 struct timespec tstamp; 1726 1727 if (pcm_get_htimestamp(mPcm, &kernelFr, &tstamp) < 0) { 1728 buffer->time_stamp.tv_sec = 0; 1729 buffer->time_stamp.tv_nsec = 0; 1730 buffer->delay_ns = 0; 1731 LOGW("read getCaptureDelay(): pcm_htimestamp error"); 1732 return; 1733 } 1734 1735 // read frames available in audio HAL input buffer 1736 // add number of frames being read as we want the capture time of first sample in current 1737 // buffer 1738 long bufDelay = (long)(((int64_t)(mInputFramesIn + mProcFramesIn) * 1000000000) 1739 / AUDIO_HW_IN_SAMPLERATE); 1740 // add delay introduced by resampler 1741 long rsmpDelay = 0; 1742 if (mDownSampler) { 1743 rsmpDelay = mDownSampler->delay_ns(mDownSampler); 1744 } 1745 1746 long kernelDelay = (long)(((int64_t)kernelFr * 1000000000) / AUDIO_HW_IN_SAMPLERATE); 1747 1748 // correct capture time stamp 1749 long delayNs = kernelDelay + bufDelay + rsmpDelay; 1750 1751 buffer->time_stamp = tstamp; 1752 buffer->delay_ns = delayNs; 1753 LOGV("AudioStreamInALSA::getCaptureDelay TimeStamp = [%ld].[%ld], delayCaptureNs: [%d],"\ 1754 " kernelDelay:[%ld], bufDelay:[%ld], rsmpDelay:[%ld], kernelFr:[%d], "\ 1755 "mInputFramesIn:[%d], mProcFramesIn:[%d], frames:[%d]", 1756 buffer->time_stamp.tv_sec , buffer->time_stamp.tv_nsec, buffer->delay_ns, 1757 kernelDelay, bufDelay, rsmpDelay, kernelFr, mInputFramesIn, mProcFramesIn, frames); 1758 1759 } 1760 1761 ssize_t AudioHardware::AudioStreamInALSA::read(void* buffer, ssize_t bytes) 1762 { 1763 LOGV("-----AudioStreamInALSA::read(%p, %d) START", buffer, (int)bytes); 1764 status_t status = NO_INIT; 1765 1766 if (mHardware == NULL) return NO_INIT; 1767 1768 if (mSleepReq) { 1769 // 10ms are always shorter than the time to reconfigure the audio path 1770 // which is the only condition when mSleepReq would be true. 1771 usleep(10000); 1772 } 1773 1774 { // scope for the lock 1775 AutoMutex lock(mLock); 1776 1777 if (mStandby) { 1778 AutoMutex hwLock(mHardware->lock()); 1779 1780 LOGD("AudioHardware pcm capture is exiting standby."); 1781 sp<AudioStreamOutALSA> spOut = mHardware->output(); 1782 while (spOut != 0) { 1783 spOut->prepareLock(); 1784 mHardware->lock().unlock(); 1785 mLock.unlock(); 1786 // Mutex acquisition order is always out -> in -> hw 1787 spOut->lock(); 1788 mLock.lock(); 1789 mHardware->lock().lock(); 1790 // make sure that another thread did not change output state 1791 // while the mutex is released 1792 if (spOut == mHardware->output()) { 1793 break; 1794 } 1795 spOut->unlock(); 1796 spOut = mHardware->output(); 1797 } 1798 // open output before input 1799 if (spOut != 0) { 1800 if (!spOut->checkStandby()) { 1801 LOGV("AudioStreamInALSA::read() force output standby"); 1802 spOut->close_l(); 1803 if (spOut->open_l() != NO_ERROR) { 1804 spOut->doStandby_l(); 1805 } 1806 } 1807 LOGV("AudioStreamInALSA exit standby mNeedEchoReference %d mEchoReference %p", 1808 mNeedEchoReference, mEchoReference); 1809 if (mNeedEchoReference && mEchoReference == NULL) { 1810 mEchoReference = mHardware->getEchoReference(AUDIO_FORMAT_PCM_16_BIT, 1811 mChannelCount, 1812 mSampleRate); 1813 } 1814 spOut->unlock(); 1815 } 1816 1817 open_l(); 1818 1819 if (mPcm == NULL) { 1820 goto Error; 1821 } 1822 mStandby = false; 1823 } 1824 1825 size_t framesRq = bytes / mChannelCount/sizeof(int16_t); 1826 ssize_t framesRd; 1827 1828 if (mPreprocessors.size() == 0) { 1829 framesRd = readFrames(buffer, framesRq); 1830 } else { 1831 framesRd = processFrames(buffer, framesRq); 1832 } 1833 1834 if (framesRd >= 0) { 1835 LOGV("-----AudioStreamInALSA::read(%p, %d) END", buffer, (int)bytes); 1836 return framesRd * mChannelCount * sizeof(int16_t); 1837 } 1838 1839 LOGW("read error: %d", (int)framesRd); 1840 status = framesRd; 1841 } 1842 1843 Error: 1844 1845 standby(); 1846 1847 // Simulate audio output timing in case of error 1848 usleep((((bytes * 1000) / frameSize()) * 1000) / sampleRate()); 1849 LOGE("-----AudioStreamInALSA::read(%p, %d) END ERROR", buffer, (int)bytes); 1850 return status; 1851 } 1852 1853 status_t AudioHardware::AudioStreamInALSA::standby() 1854 { 1855 if (mHardware == NULL) return NO_INIT; 1856 1857 mSleepReq = true; 1858 { 1859 AutoMutex lock(mLock); 1860 mSleepReq = false; 1861 1862 { // scope for AudioHardware lock 1863 AutoMutex hwLock(mHardware->lock()); 1864 1865 doStandby_l(); 1866 } 1867 } 1868 return NO_ERROR; 1869 } 1870 1871 void AudioHardware::AudioStreamInALSA::doStandby_l() 1872 { 1873 mStandbyCnt++; 1874 1875 if (!mStandby) { 1876 LOGD("AudioHardware pcm capture is going to standby."); 1877 if (mEchoReference != NULL) { 1878 // stop reading from echo reference 1879 mEchoReference->read(mEchoReference, NULL); 1880 // Mutex acquisition order is always out -> in -> hw 1881 sp<AudioStreamOutALSA> spOut = mHardware->output(); 1882 if (spOut != 0) { 1883 spOut->prepareLock(); 1884 mHardware->lock().unlock(); 1885 mLock.unlock(); 1886 spOut->lock(); 1887 mLock.lock(); 1888 mHardware->lock().lock(); 1889 mHardware->releaseEchoReference(mEchoReference); 1890 spOut->unlock(); 1891 } 1892 mEchoReference = NULL; 1893 } 1894 1895 mStandby = true; 1896 } 1897 close_l(); 1898 } 1899 1900 void AudioHardware::AudioStreamInALSA::close_l() 1901 { 1902 if (mMixer) { 1903 mHardware->closeMixer_l(); 1904 mMixer = NULL; 1905 mRouteCtl = NULL; 1906 } 1907 1908 if (mPcm) { 1909 TRACE_DRIVER_IN(DRV_PCM_CLOSE) 1910 pcm_close(mPcm); 1911 TRACE_DRIVER_OUT 1912 mPcm = NULL; 1913 } 1914 1915 delete[] mProcBuf; 1916 mProcBuf = NULL; 1917 mProcBufSize = 0; 1918 delete[] mRefBuf; 1919 mRefBuf = NULL; 1920 mRefBufSize = 0; 1921 } 1922 1923 status_t AudioHardware::AudioStreamInALSA::open_l() 1924 { 1925 unsigned flags = PCM_IN; 1926 1927 struct pcm_config config = { 1928 channels : mChannelCount, 1929 rate : AUDIO_HW_IN_SAMPLERATE, 1930 period_size : AUDIO_HW_IN_PERIOD_SZ, 1931 period_count : AUDIO_HW_IN_PERIOD_CNT, 1932 format : PCM_FORMAT_S16_LE, 1933 start_threshold : 0, 1934 stop_threshold : 0, 1935 silence_threshold : 0, 1936 }; 1937 1938 LOGV("open pcm_in driver"); 1939 TRACE_DRIVER_IN(DRV_PCM_OPEN) 1940 mPcm = pcm_open(0, 0, flags, &config); 1941 TRACE_DRIVER_OUT 1942 if (!pcm_is_ready(mPcm)) { 1943 LOGE("cannot open pcm_in driver: %s\n", pcm_get_error(mPcm)); 1944 TRACE_DRIVER_IN(DRV_PCM_CLOSE) 1945 pcm_close(mPcm); 1946 TRACE_DRIVER_OUT 1947 mPcm = NULL; 1948 return NO_INIT; 1949 } 1950 1951 if (mDownSampler != NULL) { 1952 mDownSampler->reset(mDownSampler); 1953 } 1954 mInputFramesIn = 0; 1955 1956 mProcBufSize = 0; 1957 mProcFramesIn = 0; 1958 mRefBufSize = 0; 1959 mRefFramesIn = 0; 1960 1961 mMixer = mHardware->openMixer_l(); 1962 if (mMixer) { 1963 TRACE_DRIVER_IN(DRV_MIXER_GET) 1964 mRouteCtl = mixer_get_ctl_by_name(mMixer, "Capture MIC Path"); 1965 TRACE_DRIVER_OUT 1966 } 1967 1968 if (mHardware->mode() != AudioSystem::MODE_IN_CALL) { 1969 const char *route = mHardware->getInputRouteFromDevice(mDevices); 1970 LOGV("read() wakeup setting route %s", route); 1971 if (mRouteCtl) { 1972 TRACE_DRIVER_IN(DRV_MIXER_SEL) 1973 mixer_ctl_set_enum_by_string(mRouteCtl, route); 1974 TRACE_DRIVER_OUT 1975 } 1976 } 1977 1978 return NO_ERROR; 1979 } 1980 1981 status_t AudioHardware::AudioStreamInALSA::dump(int fd, const Vector<String16>& args) 1982 { 1983 const size_t SIZE = 256; 1984 char buffer[SIZE]; 1985 String8 result; 1986 1987 bool locked = tryLock(mLock); 1988 if (!locked) { 1989 snprintf(buffer, SIZE, "\n\t\tAudioStreamInALSA maybe deadlocked\n"); 1990 } else { 1991 mLock.unlock(); 1992 } 1993 1994 snprintf(buffer, SIZE, "\t\tmHardware: %p\n", mHardware); 1995 result.append(buffer); 1996 snprintf(buffer, SIZE, "\t\tmPcm: %p\n", mPcm); 1997 result.append(buffer); 1998 snprintf(buffer, SIZE, "\t\tmMixer: %p\n", mMixer); 1999 result.append(buffer); 2000 snprintf(buffer, SIZE, "\t\tStandby %s\n", (mStandby) ? "ON" : "OFF"); 2001 result.append(buffer); 2002 snprintf(buffer, SIZE, "\t\tmDevices: 0x%08x\n", mDevices); 2003 result.append(buffer); 2004 snprintf(buffer, SIZE, "\t\tmChannels: 0x%08x\n", mChannels); 2005 result.append(buffer); 2006 snprintf(buffer, SIZE, "\t\tmSampleRate: %d\n", mSampleRate); 2007 result.append(buffer); 2008 snprintf(buffer, SIZE, "\t\tmBufferSize: %d\n", mBufferSize); 2009 result.append(buffer); 2010 snprintf(buffer, SIZE, "\t\tmDriverOp: %d\n", mDriverOp); 2011 result.append(buffer); 2012 write(fd, result.string(), result.size()); 2013 2014 return NO_ERROR; 2015 } 2016 2017 bool AudioHardware::AudioStreamInALSA::checkStandby() 2018 { 2019 return mStandby; 2020 } 2021 2022 status_t AudioHardware::AudioStreamInALSA::setParameters(const String8& keyValuePairs) 2023 { 2024 AudioParameter param = AudioParameter(keyValuePairs); 2025 status_t status = NO_ERROR; 2026 int value; 2027 2028 LOGD("AudioStreamInALSA::setParameters() %s", keyValuePairs.string()); 2029 2030 if (mHardware == NULL) return NO_INIT; 2031 2032 mSleepReq = true; 2033 { 2034 AutoMutex lock(mLock); 2035 mSleepReq = false; 2036 2037 if (param.getInt(String8(AudioParameter::keyInputSource), value) == NO_ERROR) { 2038 AutoMutex hwLock(mHardware->lock()); 2039 2040 mHardware->openMixer_l(); 2041 mHardware->setInputSource_l((audio_source)value); 2042 mHardware->closeMixer_l(); 2043 2044 param.remove(String8(AudioParameter::keyInputSource)); 2045 } 2046 2047 if (param.getInt(String8(AudioParameter::keyRouting), value) == NO_ERROR) 2048 { 2049 if (value != 0) { 2050 AutoMutex hwLock(mHardware->lock()); 2051 2052 if (mDevices != (uint32_t)value) { 2053 mDevices = (uint32_t)value; 2054 if (mHardware->mode() != AudioSystem::MODE_IN_CALL) { 2055 doStandby_l(); 2056 } 2057 } 2058 } 2059 param.remove(String8(AudioParameter::keyRouting)); 2060 } 2061 } 2062 2063 2064 if (param.size()) { 2065 status = BAD_VALUE; 2066 } 2067 2068 return status; 2069 2070 } 2071 2072 String8 AudioHardware::AudioStreamInALSA::getParameters(const String8& keys) 2073 { 2074 AudioParameter param = AudioParameter(keys); 2075 String8 value; 2076 String8 key = String8(AudioParameter::keyRouting); 2077 2078 if (param.get(key, value) == NO_ERROR) { 2079 param.addInt(key, (int)mDevices); 2080 } 2081 2082 LOGV("AudioStreamInALSA::getParameters() %s", param.toString().string()); 2083 return param.toString(); 2084 } 2085 2086 status_t AudioHardware::AudioStreamInALSA::addAudioEffect(effect_handle_t effect) 2087 { 2088 LOGV("AudioStreamInALSA::addAudioEffect() %p", effect); 2089 2090 effect_descriptor_t desc; 2091 status_t status = (*effect)->get_descriptor(effect, &desc); 2092 if (status == 0) { 2093 if (memcmp(&desc.type, FX_IID_AEC, sizeof(effect_uuid_t)) == 0) { 2094 LOGV("AudioStreamInALSA::addAudioEffect() mNeedEchoReference true"); 2095 mNeedEchoReference = true; 2096 standby(); 2097 } 2098 LOGV("AudioStreamInALSA::addAudioEffect() name %s", desc.name); 2099 } else { 2100 LOGV("AudioStreamInALSA::addAudioEffect() get_descriptor() error"); 2101 } 2102 2103 AutoMutex lock(mLock); 2104 mPreprocessors.add(effect); 2105 return NO_ERROR; 2106 } 2107 2108 status_t AudioHardware::AudioStreamInALSA::removeAudioEffect(effect_handle_t effect) 2109 { 2110 status_t status = INVALID_OPERATION; 2111 LOGV("AudioStreamInALSA::removeAudioEffect() %p", effect); 2112 { 2113 AutoMutex lock(mLock); 2114 for (size_t i = 0; i < mPreprocessors.size(); i++) { 2115 if (mPreprocessors[i] == effect) { 2116 mPreprocessors.removeAt(i); 2117 status = NO_ERROR; 2118 break; 2119 } 2120 } 2121 } 2122 2123 if (status == NO_ERROR) { 2124 effect_descriptor_t desc; 2125 if ((*effect)->get_descriptor(effect, &desc) == 0) { 2126 if (memcmp(&desc.type, FX_IID_AEC, sizeof(effect_uuid_t)) == 0) { 2127 LOGV("AudioStreamInALSA::removeAudioEffect() mNeedEchoReference false"); 2128 mNeedEchoReference = false; 2129 standby(); 2130 } 2131 } 2132 } 2133 2134 return status; 2135 } 2136 2137 extern "C" { 2138 int AudioHardware::AudioStreamInALSA::getNextBufferStatic( 2139 struct resampler_buffer_provider *provider, 2140 struct resampler_buffer* buffer) 2141 { 2142 ResamplerBufferProvider *bufferProvider = (ResamplerBufferProvider *)provider; 2143 return bufferProvider->mInputStream->getNextBuffer(buffer); 2144 } 2145 2146 void AudioHardware::AudioStreamInALSA::releaseBufferStatic( 2147 struct resampler_buffer_provider *provider, 2148 struct resampler_buffer* buffer) 2149 { 2150 ResamplerBufferProvider *bufferProvider = (ResamplerBufferProvider *)provider; 2151 return bufferProvider->mInputStream->releaseBuffer(buffer); 2152 } 2153 2154 }; // extern "C" 2155 2156 status_t AudioHardware::AudioStreamInALSA::getNextBuffer(struct resampler_buffer *buffer) 2157 { 2158 if (mPcm == NULL) { 2159 buffer->raw = NULL; 2160 buffer->frame_count = 0; 2161 mReadStatus = NO_INIT; 2162 return NO_INIT; 2163 } 2164 2165 if (mInputFramesIn == 0) { 2166 TRACE_DRIVER_IN(DRV_PCM_READ) 2167 mReadStatus = pcm_read(mPcm,(void*) mInputBuf, AUDIO_HW_IN_PERIOD_SZ * frameSize()); 2168 TRACE_DRIVER_OUT 2169 if (mReadStatus != 0) { 2170 buffer->raw = NULL; 2171 buffer->frame_count = 0; 2172 return mReadStatus; 2173 } 2174 mInputFramesIn = AUDIO_HW_IN_PERIOD_SZ; 2175 } 2176 2177 buffer->frame_count = (buffer->frame_count > mInputFramesIn) ? mInputFramesIn:buffer->frame_count; 2178 buffer->i16 = mInputBuf + (AUDIO_HW_IN_PERIOD_SZ - mInputFramesIn) * mChannelCount; 2179 2180 return mReadStatus; 2181 } 2182 2183 void AudioHardware::AudioStreamInALSA::releaseBuffer(struct resampler_buffer *buffer) 2184 { 2185 mInputFramesIn -= buffer->frame_count; 2186 } 2187 2188 size_t AudioHardware::AudioStreamInALSA::getBufferSize(uint32_t sampleRate, int channelCount) 2189 { 2190 size_t i; 2191 size_t size = sizeof(inputConfigTable)/sizeof(uint32_t)/INPUT_CONFIG_CNT; 2192 2193 for (i = 0; i < size; i++) { 2194 if (sampleRate == inputConfigTable[i][INPUT_CONFIG_SAMPLE_RATE]) { 2195 return (AUDIO_HW_IN_PERIOD_SZ*channelCount*sizeof(int16_t)) / 2196 inputConfigTable[i][INPUT_CONFIG_BUFFER_RATIO]; 2197 } 2198 } 2199 // this should never happen as getBufferSize() is always called after getInputSampleRate() 2200 // that checks for valid sampling rates. 2201 LOGE("AudioStreamInALSA::getBufferSize() invalid sampling rate %d", sampleRate); 2202 return 0; 2203 } 2204 2205 int AudioHardware::AudioStreamInALSA::prepareLock() 2206 { 2207 // request sleep next time read() is called so that caller can acquire 2208 // mLock 2209 mSleepReq = true; 2210 return mStandbyCnt; 2211 } 2212 2213 void AudioHardware::AudioStreamInALSA::lock() 2214 { 2215 mLock.lock(); 2216 mSleepReq = false; 2217 } 2218 2219 void AudioHardware::AudioStreamInALSA::unlock() { 2220 mLock.unlock(); 2221 } 2222 2223 //------------------------------------------------------------------------------ 2224 // Factory 2225 //------------------------------------------------------------------------------ 2226 2227 extern "C" AudioHardwareInterface* createAudioHardware(void) { 2228 return new AudioHardware(); 2229 } 2230 2231 }; // namespace android 2232
