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 <audio_effects/effect_aec.h> 36 37 extern "C" { 38 #include <tinyalsa/asoundlib.h> 39 } 40 41 42 namespace android_audio_legacy { 43 44 const uint32_t AudioHardware::inputConfigTable[][AudioHardware::INPUT_CONFIG_CNT] = { 45 {8000, 4}, 46 {11025, 4}, 47 {16000, 2}, 48 {22050, 2}, 49 {32000, 1}, 50 {44100, 1} 51 }; 52 53 // trace driver operations for dump 54 // 55 #define DRIVER_TRACE 56 57 enum { 58 DRV_NONE, 59 DRV_PCM_OPEN, 60 DRV_PCM_CLOSE, 61 DRV_PCM_WRITE, 62 DRV_PCM_READ, 63 DRV_MIXER_OPEN, 64 DRV_MIXER_CLOSE, 65 DRV_MIXER_GET, 66 DRV_MIXER_SEL 67 }; 68 69 #ifdef DRIVER_TRACE 70 #define TRACE_DRIVER_IN(op) mDriverOp = op; 71 #define TRACE_DRIVER_OUT mDriverOp = DRV_NONE; 72 #else 73 #define TRACE_DRIVER_IN(op) 74 #define TRACE_DRIVER_OUT 75 #endif 76 77 // ---------------------------------------------------------------------------- 78 79 const char *AudioHardware::inputPathNameDefault = "Default"; 80 const char *AudioHardware::inputPathNameCamcorder = "Camcorder"; 81 const char *AudioHardware::inputPathNameVoiceRecognition = "Voice Recognition"; 82 83 AudioHardware::AudioHardware() : 84 mInit(false), 85 mMicMute(false), 86 mPcm(NULL), 87 mMixer(NULL), 88 mPcmOpenCnt(0), 89 mMixerOpenCnt(0), 90 mInCallAudioMode(false), 91 mVoiceVol(1.0f), 92 mInputSource(AUDIO_SOURCE_DEFAULT), 93 mBluetoothNrec(true), 94 mTTYMode(TTY_MODE_OFF), 95 mSecRilLibHandle(NULL), 96 mRilClient(0), 97 mActivatedCP(false), 98 mEchoReference(NULL), 99 mDriverOp(DRV_NONE) 100 { 101 loadRILD(); 102 mInit = true; 103 } 104 105 AudioHardware::~AudioHardware() 106 { 107 for (size_t index = 0; index < mInputs.size(); index++) { 108 closeInputStream(mInputs[index].get()); 109 } 110 mInputs.clear(); 111 closeOutputStream((AudioStreamOut*)mOutput.get()); 112 113 if (mMixer) { 114 TRACE_DRIVER_IN(DRV_MIXER_CLOSE) 115 mixer_close(mMixer); 116 TRACE_DRIVER_OUT 117 } 118 if (mPcm) { 119 TRACE_DRIVER_IN(DRV_PCM_CLOSE) 120 pcm_close(mPcm); 121 TRACE_DRIVER_OUT 122 } 123 124 if (mSecRilLibHandle) { 125 if (disconnectRILD(mRilClient) != RIL_CLIENT_ERR_SUCCESS) 126 ALOGE("Disconnect_RILD() error"); 127 128 if (closeClientRILD(mRilClient) != RIL_CLIENT_ERR_SUCCESS) 129 ALOGE("CloseClient_RILD() error"); 130 131 mRilClient = 0; 132 133 dlclose(mSecRilLibHandle); 134 mSecRilLibHandle = NULL; 135 } 136 137 mInit = false; 138 } 139 140 status_t AudioHardware::initCheck() 141 { 142 return mInit ? NO_ERROR : NO_INIT; 143 } 144 145 void AudioHardware::loadRILD(void) 146 { 147 mSecRilLibHandle = dlopen("libsecril-client.so", RTLD_NOW); 148 149 if (mSecRilLibHandle) { 150 ALOGV("libsecril-client.so is loaded"); 151 152 openClientRILD = (HRilClient (*)(void)) 153 dlsym(mSecRilLibHandle, "OpenClient_RILD"); 154 disconnectRILD = (int (*)(HRilClient)) 155 dlsym(mSecRilLibHandle, "Disconnect_RILD"); 156 closeClientRILD = (int (*)(HRilClient)) 157 dlsym(mSecRilLibHandle, "CloseClient_RILD"); 158 isConnectedRILD = (int (*)(HRilClient)) 159 dlsym(mSecRilLibHandle, "isConnected_RILD"); 160 connectRILD = (int (*)(HRilClient)) 161 dlsym(mSecRilLibHandle, "Connect_RILD"); 162 setCallVolume = (int (*)(HRilClient, SoundType, int)) 163 dlsym(mSecRilLibHandle, "SetCallVolume"); 164 setCallAudioPath = (int (*)(HRilClient, AudioPath)) 165 dlsym(mSecRilLibHandle, "SetCallAudioPath"); 166 setCallClockSync = (int (*)(HRilClient, SoundClockCondition)) 167 dlsym(mSecRilLibHandle, "SetCallClockSync"); 168 169 if (!openClientRILD || !disconnectRILD || !closeClientRILD || 170 !isConnectedRILD || !connectRILD || 171 !setCallVolume || !setCallAudioPath || !setCallClockSync) { 172 ALOGE("Can't load all functions from libsecril-client.so"); 173 174 dlclose(mSecRilLibHandle); 175 mSecRilLibHandle = NULL; 176 } else { 177 mRilClient = openClientRILD(); 178 if (!mRilClient) { 179 ALOGE("OpenClient_RILD() error"); 180 181 dlclose(mSecRilLibHandle); 182 mSecRilLibHandle = NULL; 183 } 184 } 185 } else { 186 ALOGE("Can't load libsecril-client.so"); 187 } 188 } 189 190 status_t AudioHardware::connectRILDIfRequired(void) 191 { 192 if (!mSecRilLibHandle) { 193 ALOGE("connectIfRequired() lib is not loaded"); 194 return INVALID_OPERATION; 195 } 196 197 if (isConnectedRILD(mRilClient)) { 198 return OK; 199 } 200 201 if (connectRILD(mRilClient) != RIL_CLIENT_ERR_SUCCESS) { 202 ALOGE("Connect_RILD() error"); 203 return INVALID_OPERATION; 204 } 205 206 return OK; 207 } 208 209 AudioStreamOut* AudioHardware::openOutputStream( 210 uint32_t devices, int *format, uint32_t *channels, 211 uint32_t *sampleRate, status_t *status) 212 { 213 sp <AudioStreamOutALSA> out; 214 status_t rc; 215 216 { // scope for the lock 217 Mutex::Autolock lock(mLock); 218 219 // only one output stream allowed 220 if (mOutput != 0) { 221 if (status) { 222 *status = INVALID_OPERATION; 223 } 224 return NULL; 225 } 226 227 out = new AudioStreamOutALSA(); 228 229 rc = out->set(this, devices, format, channels, sampleRate); 230 if (rc == NO_ERROR) { 231 mOutput = out; 232 } 233 } 234 235 if (rc != NO_ERROR) { 236 if (out != 0) { 237 out.clear(); 238 } 239 } 240 if (status) { 241 *status = rc; 242 } 243 244 return out.get(); 245 } 246 247 void AudioHardware::closeOutputStream(AudioStreamOut* out) { 248 sp <AudioStreamOutALSA> spOut; 249 sp<AudioStreamInALSA> spIn; 250 { 251 Mutex::Autolock lock(mLock); 252 if (mOutput == 0 || mOutput.get() != out) { 253 ALOGW("Attempt to close invalid output stream"); 254 return; 255 } 256 spOut = mOutput; 257 mOutput.clear(); 258 if (mEchoReference != NULL) { 259 spIn = getActiveInput_l(); 260 } 261 } 262 if (spIn != 0) { 263 // this will safely release the echo reference by calling releaseEchoReference() 264 // after placing the active input in standby 265 spIn->standby(); 266 } 267 268 spOut.clear(); 269 } 270 271 AudioStreamIn* AudioHardware::openInputStream( 272 uint32_t devices, int *format, uint32_t *channels, 273 uint32_t *sampleRate, status_t *status, 274 AudioSystem::audio_in_acoustics acoustic_flags) 275 { 276 // check for valid input source 277 if (!AudioSystem::isInputDevice((AudioSystem::audio_devices)devices)) { 278 if (status) { 279 *status = BAD_VALUE; 280 } 281 return NULL; 282 } 283 284 status_t rc = NO_ERROR; 285 sp <AudioStreamInALSA> in; 286 287 { // scope for the lock 288 Mutex::Autolock lock(mLock); 289 290 in = new AudioStreamInALSA(); 291 rc = in->set(this, devices, format, channels, sampleRate, acoustic_flags); 292 if (rc == NO_ERROR) { 293 mInputs.add(in); 294 } 295 } 296 297 if (rc != NO_ERROR) { 298 if (in != 0) { 299 in.clear(); 300 } 301 } 302 if (status) { 303 *status = rc; 304 } 305 306 ALOGV("AudioHardware::openInputStream()%p", in.get()); 307 return in.get(); 308 } 309 310 void AudioHardware::closeInputStream(AudioStreamIn* in) { 311 312 sp<AudioStreamInALSA> spIn; 313 { 314 Mutex::Autolock lock(mLock); 315 316 ssize_t index = mInputs.indexOf((AudioStreamInALSA *)in); 317 if (index < 0) { 318 ALOGW("Attempt to close invalid input stream"); 319 return; 320 } 321 spIn = mInputs[index]; 322 mInputs.removeAt(index); 323 } 324 ALOGV("AudioHardware::closeInputStream()%p", in); 325 spIn.clear(); 326 } 327 328 329 status_t AudioHardware::setMode(int mode) 330 { 331 sp<AudioStreamOutALSA> spOut; 332 sp<AudioStreamInALSA> spIn; 333 status_t status; 334 335 // Mutex acquisition order is always out -> in -> hw 336 AutoMutex lock(mLock); 337 338 spOut = mOutput; 339 while (spOut != 0) { 340 if (!spOut->checkStandby()) { 341 int cnt = spOut->prepareLock(); 342 mLock.unlock(); 343 spOut->lock(); 344 mLock.lock(); 345 // make sure that another thread did not change output state while the 346 // mutex is released 347 if ((spOut == mOutput) && (cnt == spOut->standbyCnt())) { 348 break; 349 } 350 spOut->unlock(); 351 spOut = mOutput; 352 } else { 353 spOut.clear(); 354 } 355 } 356 // spOut is not 0 here only if the output is active 357 358 spIn = getActiveInput_l(); 359 while (spIn != 0) { 360 int cnt = spIn->prepareLock(); 361 mLock.unlock(); 362 spIn->lock(); 363 mLock.lock(); 364 // make sure that another thread did not change input state while the 365 // mutex is released 366 if ((spIn == getActiveInput_l()) && (cnt == spIn->standbyCnt())) { 367 break; 368 } 369 spIn->unlock(); 370 spIn = getActiveInput_l(); 371 } 372 // spIn is not 0 here only if the input is active 373 374 int prevMode = mMode; 375 status = AudioHardwareBase::setMode(mode); 376 ALOGV("setMode() : new %d, old %d", mMode, prevMode); 377 if (status == NO_ERROR) { 378 bool modeNeedsCPActive = mMode == AudioSystem::MODE_IN_CALL || 379 mMode == AudioSystem::MODE_RINGTONE; 380 // activate call clock in radio when entering in call or ringtone mode 381 if (modeNeedsCPActive) 382 { 383 if ((!mActivatedCP) && (mSecRilLibHandle) && (connectRILDIfRequired() == OK)) { 384 setCallClockSync(mRilClient, SOUND_CLOCK_START); 385 mActivatedCP = true; 386 } 387 } 388 389 if (mMode == AudioSystem::MODE_IN_CALL && !mInCallAudioMode) { 390 if (spOut != 0) { 391 ALOGV("setMode() in call force output standby"); 392 spOut->doStandby_l(); 393 } 394 if (spIn != 0) { 395 ALOGV("setMode() in call force input standby"); 396 spIn->doStandby_l(); 397 } 398 399 ALOGV("setMode() openPcmOut_l()"); 400 openPcmOut_l(); 401 openMixer_l(); 402 setInputSource_l(AUDIO_SOURCE_DEFAULT); 403 setVoiceVolume_l(mVoiceVol); 404 mInCallAudioMode = true; 405 } 406 if (mMode != AudioSystem::MODE_IN_CALL && mInCallAudioMode) { 407 setInputSource_l(mInputSource); 408 if (mMixer != NULL) { 409 TRACE_DRIVER_IN(DRV_MIXER_GET) 410 struct mixer_ctl *ctl= mixer_get_ctl_by_name(mMixer, "Playback Path"); 411 TRACE_DRIVER_OUT 412 if (ctl != NULL) { 413 ALOGV("setMode() reset Playback Path to RCV"); 414 TRACE_DRIVER_IN(DRV_MIXER_SEL) 415 mixer_ctl_set_enum_by_string(ctl, "RCV"); 416 TRACE_DRIVER_OUT 417 } 418 } 419 ALOGV("setMode() closePcmOut_l()"); 420 closeMixer_l(); 421 closePcmOut_l(); 422 423 if (spOut != 0) { 424 ALOGV("setMode() off call force output standby"); 425 spOut->doStandby_l(); 426 } 427 if (spIn != 0) { 428 ALOGV("setMode() off call force input standby"); 429 spIn->doStandby_l(); 430 } 431 432 mInCallAudioMode = false; 433 } 434 435 if (!modeNeedsCPActive) { 436 if(mActivatedCP) 437 mActivatedCP = false; 438 } 439 } 440 441 if (spIn != 0) { 442 spIn->unlock(); 443 } 444 if (spOut != 0) { 445 spOut->unlock(); 446 } 447 448 return status; 449 } 450 451 status_t AudioHardware::setMicMute(bool state) 452 { 453 ALOGV("setMicMute(%d) mMicMute %d", state, mMicMute); 454 sp<AudioStreamInALSA> spIn; 455 { 456 AutoMutex lock(mLock); 457 if (mMicMute != state) { 458 mMicMute = state; 459 // in call mute is handled by RIL 460 if (mMode != AudioSystem::MODE_IN_CALL) { 461 spIn = getActiveInput_l(); 462 } 463 } 464 } 465 466 if (spIn != 0) { 467 spIn->standby(); 468 } 469 470 return NO_ERROR; 471 } 472 473 status_t AudioHardware::getMicMute(bool* state) 474 { 475 *state = mMicMute; 476 return NO_ERROR; 477 } 478 479 status_t AudioHardware::setParameters(const String8& keyValuePairs) 480 { 481 AudioParameter param = AudioParameter(keyValuePairs); 482 String8 value; 483 String8 key; 484 const char BT_NREC_KEY[] = "bt_headset_nrec"; 485 const char BT_NREC_VALUE_ON[] = "on"; 486 const char TTY_MODE_KEY[] = "tty_mode"; 487 const char TTY_MODE_VALUE_OFF[] = "tty_off"; 488 const char TTY_MODE_VALUE_VCO[] = "tty_vco"; 489 const char TTY_MODE_VALUE_HCO[] = "tty_hco"; 490 const char TTY_MODE_VALUE_FULL[] = "tty_full"; 491 492 key = String8(BT_NREC_KEY); 493 if (param.get(key, value) == NO_ERROR) { 494 if (value == BT_NREC_VALUE_ON) { 495 mBluetoothNrec = true; 496 } else { 497 mBluetoothNrec = false; 498 ALOGD("Turning noise reduction and echo cancellation off for BT " 499 "headset"); 500 } 501 param.remove(String8(BT_NREC_KEY)); 502 } 503 504 key = String8(TTY_MODE_KEY); 505 if (param.get(key, value) == NO_ERROR) { 506 int ttyMode; 507 if (value == TTY_MODE_VALUE_OFF) { 508 ttyMode = TTY_MODE_OFF; 509 } else if (value == TTY_MODE_VALUE_VCO) { 510 ttyMode = TTY_MODE_VCO; 511 } else if (value == TTY_MODE_VALUE_HCO) { 512 ttyMode = TTY_MODE_HCO; 513 } else if (value == TTY_MODE_VALUE_FULL) { 514 ttyMode = TTY_MODE_FULL; 515 } else { 516 return BAD_VALUE; 517 } 518 519 if (ttyMode != mTTYMode) { 520 ALOGV("new tty mode %d", ttyMode); 521 mTTYMode = ttyMode; 522 if (mOutput != 0 && mMode == AudioSystem::MODE_IN_CALL) { 523 setIncallPath_l(mOutput->device()); 524 } 525 } 526 param.remove(String8(TTY_MODE_KEY)); 527 } 528 529 return NO_ERROR; 530 } 531 532 String8 AudioHardware::getParameters(const String8& keys) 533 { 534 AudioParameter request = AudioParameter(keys); 535 AudioParameter reply = AudioParameter(); 536 537 ALOGV("getParameters() %s", keys.string()); 538 539 return reply.toString(); 540 } 541 542 size_t AudioHardware::getInputBufferSize(uint32_t sampleRate, int format, int channelCount) 543 { 544 if (format != AudioSystem::PCM_16_BIT) { 545 ALOGW("getInputBufferSize bad format: %d", format); 546 return 0; 547 } 548 if (channelCount < 1 || channelCount > 2) { 549 ALOGW("getInputBufferSize bad channel count: %d", channelCount); 550 return 0; 551 } 552 553 if (sampleRate != getInputSampleRate(sampleRate)) { 554 ALOGW("getInputBufferSize bad sample rate: %d", sampleRate); 555 return 0; 556 } 557 558 return AudioStreamInALSA::getBufferSize(sampleRate, channelCount); 559 } 560 561 status_t AudioHardware::setVoiceVolume(float volume) 562 { 563 AutoMutex lock(mLock); 564 565 setVoiceVolume_l(volume); 566 567 return NO_ERROR; 568 } 569 570 void AudioHardware::setVoiceVolume_l(float volume) 571 { 572 ALOGD("### setVoiceVolume_l"); 573 574 mVoiceVol = volume; 575 576 if ( (AudioSystem::MODE_IN_CALL == mMode) && (mSecRilLibHandle) && 577 (connectRILDIfRequired() == OK) ) { 578 579 uint32_t device = AudioSystem::DEVICE_OUT_EARPIECE; 580 if (mOutput != 0) { 581 device = mOutput->device(); 582 } 583 int int_volume = (int)(volume * 5); 584 SoundType type; 585 586 ALOGD("### route(%d) call volume(%f)", device, volume); 587 switch (device) { 588 case AudioSystem::DEVICE_OUT_EARPIECE: 589 ALOGD("### earpiece call volume"); 590 type = SOUND_TYPE_VOICE; 591 break; 592 593 case AudioSystem::DEVICE_OUT_SPEAKER: 594 ALOGD("### speaker call volume"); 595 type = SOUND_TYPE_SPEAKER; 596 break; 597 598 case AudioSystem::DEVICE_OUT_BLUETOOTH_SCO: 599 case AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_HEADSET: 600 case AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_CARKIT: 601 ALOGD("### bluetooth call volume"); 602 type = SOUND_TYPE_BTVOICE; 603 break; 604 605 case AudioSystem::DEVICE_OUT_WIRED_HEADSET: 606 case AudioSystem::DEVICE_OUT_WIRED_HEADPHONE: // Use receive path with 3 pole headset. 607 ALOGD("### headset call volume"); 608 type = SOUND_TYPE_HEADSET; 609 break; 610 611 default: 612 ALOGW("### Call volume setting error!!!0x%08x \n", device); 613 type = SOUND_TYPE_VOICE; 614 break; 615 } 616 setCallVolume(mRilClient, type, int_volume); 617 } 618 619 } 620 621 status_t AudioHardware::setMasterVolume(float volume) 622 { 623 ALOGV("Set master volume to %f.\n", volume); 624 // We return an error code here to let the audioflinger do in-software 625 // volume on top of the maximum volume that we set through the SND API. 626 // return error - software mixer will handle it 627 return -1; 628 } 629 630 static const int kDumpLockRetries = 50; 631 static const int kDumpLockSleep = 20000; 632 633 static bool tryLock(Mutex& mutex) 634 { 635 bool locked = false; 636 for (int i = 0; i < kDumpLockRetries; ++i) { 637 if (mutex.tryLock() == NO_ERROR) { 638 locked = true; 639 break; 640 } 641 usleep(kDumpLockSleep); 642 } 643 return locked; 644 } 645 646 status_t AudioHardware::dump(int fd, const Vector<String16>& args) 647 { 648 const size_t SIZE = 256; 649 char buffer[SIZE]; 650 String8 result; 651 652 bool locked = tryLock(mLock); 653 if (!locked) { 654 snprintf(buffer, SIZE, "\n\tAudioHardware maybe deadlocked\n"); 655 } else { 656 mLock.unlock(); 657 } 658 659 snprintf(buffer, SIZE, "\tInit %s\n", (mInit) ? "OK" : "Failed"); 660 result.append(buffer); 661 snprintf(buffer, SIZE, "\tMic Mute %s\n", (mMicMute) ? "ON" : "OFF"); 662 result.append(buffer); 663 snprintf(buffer, SIZE, "\tmPcm: %p\n", mPcm); 664 result.append(buffer); 665 snprintf(buffer, SIZE, "\tmPcmOpenCnt: %d\n", mPcmOpenCnt); 666 result.append(buffer); 667 snprintf(buffer, SIZE, "\tmMixer: %p\n", mMixer); 668 result.append(buffer); 669 snprintf(buffer, SIZE, "\tmMixerOpenCnt: %d\n", mMixerOpenCnt); 670 result.append(buffer); 671 snprintf(buffer, SIZE, "\tIn Call Audio Mode %s\n", 672 (mInCallAudioMode) ? "ON" : "OFF"); 673 result.append(buffer); 674 snprintf(buffer, SIZE, "\tInput source %d\n", mInputSource); 675 result.append(buffer); 676 snprintf(buffer, SIZE, "\tmSecRilLibHandle: %p\n", mSecRilLibHandle); 677 result.append(buffer); 678 snprintf(buffer, SIZE, "\tmRilClient: %p\n", mRilClient); 679 result.append(buffer); 680 snprintf(buffer, SIZE, "\tCP %s\n", 681 (mActivatedCP) ? "Activated" : "Deactivated"); 682 result.append(buffer); 683 snprintf(buffer, SIZE, "\tmDriverOp: %d\n", mDriverOp); 684 result.append(buffer); 685 686 snprintf(buffer, SIZE, "\n\tmOutput %p dump:\n", mOutput.get()); 687 result.append(buffer); 688 write(fd, result.string(), result.size()); 689 if (mOutput != 0) { 690 mOutput->dump(fd, args); 691 } 692 693 snprintf(buffer, SIZE, "\n\t%d inputs opened:\n", mInputs.size()); 694 write(fd, buffer, strlen(buffer)); 695 for (size_t i = 0; i < mInputs.size(); i++) { 696 snprintf(buffer, SIZE, "\t- input %d dump:\n", i); 697 write(fd, buffer, strlen(buffer)); 698 mInputs[i]->dump(fd, args); 699 } 700 701 return NO_ERROR; 702 } 703 704 status_t AudioHardware::setIncallPath_l(uint32_t device) 705 { 706 ALOGV("setIncallPath_l: device %x", device); 707 708 // Setup sound path for CP clocking 709 if ((mSecRilLibHandle) && 710 (connectRILDIfRequired() == OK)) { 711 712 if (mMode == AudioSystem::MODE_IN_CALL) { 713 ALOGD("### incall mode route (%d)", device); 714 AudioPath path; 715 switch(device){ 716 case AudioSystem::DEVICE_OUT_EARPIECE: 717 ALOGD("### incall mode earpiece route"); 718 path = SOUND_AUDIO_PATH_HANDSET; 719 break; 720 721 case AudioSystem::DEVICE_OUT_SPEAKER: 722 ALOGD("### incall mode speaker route"); 723 path = SOUND_AUDIO_PATH_SPEAKER; 724 break; 725 726 case AudioSystem::DEVICE_OUT_BLUETOOTH_SCO: 727 case AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_HEADSET: 728 case AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_CARKIT: 729 ALOGD("### incall mode bluetooth route %s NR", mBluetoothNrec ? "" : "NO"); 730 if (mBluetoothNrec) { 731 path = SOUND_AUDIO_PATH_BLUETOOTH; 732 } else { 733 path = SOUND_AUDIO_PATH_BLUETOOTH_NO_NR; 734 } 735 break; 736 737 case AudioSystem::DEVICE_OUT_WIRED_HEADPHONE : 738 ALOGD("### incall mode headphone route"); 739 path = SOUND_AUDIO_PATH_HEADPHONE; 740 break; 741 case AudioSystem::DEVICE_OUT_WIRED_HEADSET : 742 ALOGD("### incall mode headset route"); 743 path = SOUND_AUDIO_PATH_HEADSET; 744 break; 745 default: 746 ALOGW("### incall mode Error!! route = [%d]", device); 747 path = SOUND_AUDIO_PATH_HANDSET; 748 break; 749 } 750 751 setCallAudioPath(mRilClient, path); 752 753 if (mMixer != NULL) { 754 TRACE_DRIVER_IN(DRV_MIXER_GET) 755 struct mixer_ctl *ctl= mixer_get_ctl_by_name(mMixer, "Voice Call Path"); 756 TRACE_DRIVER_OUT 757 ALOGE_IF(ctl == NULL, "setIncallPath_l() could not get mixer ctl"); 758 if (ctl != NULL) { 759 ALOGV("setIncallPath_l() Voice Call Path, (%x)", device); 760 TRACE_DRIVER_IN(DRV_MIXER_SEL) 761 mixer_ctl_set_enum_by_string(ctl, getVoiceRouteFromDevice(device)); 762 TRACE_DRIVER_OUT 763 } 764 } 765 } 766 } 767 return NO_ERROR; 768 } 769 770 struct pcm *AudioHardware::openPcmOut_l() 771 { 772 ALOGD("openPcmOut_l() mPcmOpenCnt: %d", mPcmOpenCnt); 773 if (mPcmOpenCnt++ == 0) { 774 if (mPcm != NULL) { 775 ALOGE("openPcmOut_l() mPcmOpenCnt == 0 and mPcm == %p\n", mPcm); 776 mPcmOpenCnt--; 777 return NULL; 778 } 779 unsigned flags = PCM_OUT; 780 781 struct pcm_config config = { 782 channels : 2, 783 rate : AUDIO_HW_OUT_SAMPLERATE, 784 period_size : AUDIO_HW_OUT_PERIOD_SZ, 785 period_count : AUDIO_HW_OUT_PERIOD_CNT, 786 format : PCM_FORMAT_S16_LE, 787 start_threshold : 0, 788 stop_threshold : 0, 789 silence_threshold : 0, 790 avail_min : 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 ALOGE("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 ALOGD("closePcmOut_l() mPcmOpenCnt: %d", mPcmOpenCnt); 811 if (mPcmOpenCnt == 0) { 812 ALOGE("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 ALOGV("openMixer_l() mMixerOpenCnt: %d", mMixerOpenCnt); 827 if (mMixerOpenCnt++ == 0) { 828 if (mMixer != NULL) { 829 ALOGE("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 ALOGE("openMixer_l() cannot open mixer"); 838 mMixerOpenCnt--; 839 return NULL; 840 } 841 } 842 return mMixer; 843 } 844 845 void AudioHardware::closeMixer_l() 846 { 847 ALOGV("closeMixer_l() mMixerOpenCnt: %d", mMixerOpenCnt); 848 if (mMixerOpenCnt == 0) { 849 ALOGE("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 ALOGV("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 ALOGV("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 ALOGV("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 ALOGV("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 ALOGV("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 ALOGV("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 ALOGV("-----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 ALOGD("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 ALOGV("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 ALOGV("-----AudioStreamInALSA::write(%p, %d) END", buffer, (int)bytes); 1210 return bytes; 1211 } 1212 ALOGW("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 ALOGE("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 ALOGD("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 ALOGV("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 ALOGV("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 ALOGV("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 ALOGD("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 ALOGV("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 ALOGV("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 ALOGV("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 ALOGV("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 ALOGW("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 ALOGV("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 ALOGV("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 ALOGV("updateEchoReference2: mRefFramesIn:[%d], mRefBufSize:[%d], "\ 1642 "frames:[%d], b.frame_count:[%d]", mRefFramesIn, mRefBufSize,frames,b.frame_count); 1643 } 1644 1645 }else{ 1646 ALOGV("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 ALOGV("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 ALOGV("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 ALOGW("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 ALOGV("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 ALOGV("-----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 ALOGD("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 ALOGV("AudioStreamInALSA::read() force output standby"); 1802 spOut->close_l(); 1803 if (spOut->open_l() != NO_ERROR) { 1804 spOut->doStandby_l(); 1805 } 1806 } 1807 ALOGV("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 ALOGV("-----AudioStreamInALSA::read(%p, %d) END", buffer, (int)bytes); 1836 return framesRd * mChannelCount * sizeof(int16_t); 1837 } 1838 1839 ALOGW("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 ALOGE("-----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 ALOGD("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 avail_min : 0, 1937 }; 1938 1939 ALOGV("open pcm_in driver"); 1940 TRACE_DRIVER_IN(DRV_PCM_OPEN) 1941 mPcm = pcm_open(0, 0, flags, &config); 1942 TRACE_DRIVER_OUT 1943 if (!pcm_is_ready(mPcm)) { 1944 ALOGE("cannot open pcm_in driver: %s\n", pcm_get_error(mPcm)); 1945 TRACE_DRIVER_IN(DRV_PCM_CLOSE) 1946 pcm_close(mPcm); 1947 TRACE_DRIVER_OUT 1948 mPcm = NULL; 1949 return NO_INIT; 1950 } 1951 1952 if (mDownSampler != NULL) { 1953 mDownSampler->reset(mDownSampler); 1954 } 1955 mInputFramesIn = 0; 1956 1957 mProcBufSize = 0; 1958 mProcFramesIn = 0; 1959 mRefBufSize = 0; 1960 mRefFramesIn = 0; 1961 1962 mMixer = mHardware->openMixer_l(); 1963 if (mMixer) { 1964 TRACE_DRIVER_IN(DRV_MIXER_GET) 1965 mRouteCtl = mixer_get_ctl_by_name(mMixer, "Capture MIC Path"); 1966 TRACE_DRIVER_OUT 1967 } 1968 1969 if (mHardware->mode() != AudioSystem::MODE_IN_CALL) { 1970 const char *route = mHardware->getInputRouteFromDevice(mDevices); 1971 ALOGV("read() wakeup setting route %s", route); 1972 if (mRouteCtl) { 1973 TRACE_DRIVER_IN(DRV_MIXER_SEL) 1974 mixer_ctl_set_enum_by_string(mRouteCtl, route); 1975 TRACE_DRIVER_OUT 1976 } 1977 } 1978 1979 return NO_ERROR; 1980 } 1981 1982 status_t AudioHardware::AudioStreamInALSA::dump(int fd, const Vector<String16>& args) 1983 { 1984 const size_t SIZE = 256; 1985 char buffer[SIZE]; 1986 String8 result; 1987 1988 bool locked = tryLock(mLock); 1989 if (!locked) { 1990 snprintf(buffer, SIZE, "\n\t\tAudioStreamInALSA maybe deadlocked\n"); 1991 } else { 1992 mLock.unlock(); 1993 } 1994 1995 snprintf(buffer, SIZE, "\t\tmHardware: %p\n", mHardware); 1996 result.append(buffer); 1997 snprintf(buffer, SIZE, "\t\tmPcm: %p\n", mPcm); 1998 result.append(buffer); 1999 snprintf(buffer, SIZE, "\t\tmMixer: %p\n", mMixer); 2000 result.append(buffer); 2001 snprintf(buffer, SIZE, "\t\tStandby %s\n", (mStandby) ? "ON" : "OFF"); 2002 result.append(buffer); 2003 snprintf(buffer, SIZE, "\t\tmDevices: 0x%08x\n", mDevices); 2004 result.append(buffer); 2005 snprintf(buffer, SIZE, "\t\tmChannels: 0x%08x\n", mChannels); 2006 result.append(buffer); 2007 snprintf(buffer, SIZE, "\t\tmSampleRate: %d\n", mSampleRate); 2008 result.append(buffer); 2009 snprintf(buffer, SIZE, "\t\tmBufferSize: %d\n", mBufferSize); 2010 result.append(buffer); 2011 snprintf(buffer, SIZE, "\t\tmDriverOp: %d\n", mDriverOp); 2012 result.append(buffer); 2013 write(fd, result.string(), result.size()); 2014 2015 return NO_ERROR; 2016 } 2017 2018 bool AudioHardware::AudioStreamInALSA::checkStandby() 2019 { 2020 return mStandby; 2021 } 2022 2023 status_t AudioHardware::AudioStreamInALSA::setParameters(const String8& keyValuePairs) 2024 { 2025 AudioParameter param = AudioParameter(keyValuePairs); 2026 status_t status = NO_ERROR; 2027 int value; 2028 2029 ALOGD("AudioStreamInALSA::setParameters() %s", keyValuePairs.string()); 2030 2031 if (mHardware == NULL) return NO_INIT; 2032 2033 mSleepReq = true; 2034 { 2035 AutoMutex lock(mLock); 2036 mSleepReq = false; 2037 2038 if (param.getInt(String8(AudioParameter::keyInputSource), value) == NO_ERROR) { 2039 AutoMutex hwLock(mHardware->lock()); 2040 2041 mHardware->openMixer_l(); 2042 mHardware->setInputSource_l((audio_source)value); 2043 mHardware->closeMixer_l(); 2044 2045 param.remove(String8(AudioParameter::keyInputSource)); 2046 } 2047 2048 if (param.getInt(String8(AudioParameter::keyRouting), value) == NO_ERROR) 2049 { 2050 if (value != 0) { 2051 AutoMutex hwLock(mHardware->lock()); 2052 2053 if (mDevices != (uint32_t)value) { 2054 mDevices = (uint32_t)value; 2055 if (mHardware->mode() != AudioSystem::MODE_IN_CALL) { 2056 doStandby_l(); 2057 } 2058 } 2059 } 2060 param.remove(String8(AudioParameter::keyRouting)); 2061 } 2062 } 2063 2064 2065 if (param.size()) { 2066 status = BAD_VALUE; 2067 } 2068 2069 return status; 2070 2071 } 2072 2073 String8 AudioHardware::AudioStreamInALSA::getParameters(const String8& keys) 2074 { 2075 AudioParameter param = AudioParameter(keys); 2076 String8 value; 2077 String8 key = String8(AudioParameter::keyRouting); 2078 2079 if (param.get(key, value) == NO_ERROR) { 2080 param.addInt(key, (int)mDevices); 2081 } 2082 2083 ALOGV("AudioStreamInALSA::getParameters() %s", param.toString().string()); 2084 return param.toString(); 2085 } 2086 2087 status_t AudioHardware::AudioStreamInALSA::addAudioEffect(effect_handle_t effect) 2088 { 2089 ALOGV("AudioStreamInALSA::addAudioEffect() %p", effect); 2090 2091 effect_descriptor_t desc; 2092 status_t status = (*effect)->get_descriptor(effect, &desc); 2093 if (status == 0) { 2094 if (memcmp(&desc.type, FX_IID_AEC, sizeof(effect_uuid_t)) == 0) { 2095 ALOGV("AudioStreamInALSA::addAudioEffect() mNeedEchoReference true"); 2096 mNeedEchoReference = true; 2097 standby(); 2098 } 2099 ALOGV("AudioStreamInALSA::addAudioEffect() name %s", desc.name); 2100 } else { 2101 ALOGV("AudioStreamInALSA::addAudioEffect() get_descriptor() error"); 2102 } 2103 2104 AutoMutex lock(mLock); 2105 mPreprocessors.add(effect); 2106 return NO_ERROR; 2107 } 2108 2109 status_t AudioHardware::AudioStreamInALSA::removeAudioEffect(effect_handle_t effect) 2110 { 2111 status_t status = INVALID_OPERATION; 2112 ALOGV("AudioStreamInALSA::removeAudioEffect() %p", effect); 2113 { 2114 AutoMutex lock(mLock); 2115 for (size_t i = 0; i < mPreprocessors.size(); i++) { 2116 if (mPreprocessors[i] == effect) { 2117 mPreprocessors.removeAt(i); 2118 status = NO_ERROR; 2119 break; 2120 } 2121 } 2122 } 2123 2124 if (status == NO_ERROR) { 2125 effect_descriptor_t desc; 2126 if ((*effect)->get_descriptor(effect, &desc) == 0) { 2127 if (memcmp(&desc.type, FX_IID_AEC, sizeof(effect_uuid_t)) == 0) { 2128 ALOGV("AudioStreamInALSA::removeAudioEffect() mNeedEchoReference false"); 2129 mNeedEchoReference = false; 2130 standby(); 2131 } 2132 } 2133 } 2134 2135 return status; 2136 } 2137 2138 extern "C" { 2139 int AudioHardware::AudioStreamInALSA::getNextBufferStatic( 2140 struct resampler_buffer_provider *provider, 2141 struct resampler_buffer* buffer) 2142 { 2143 ResamplerBufferProvider *bufferProvider = (ResamplerBufferProvider *)provider; 2144 return bufferProvider->mInputStream->getNextBuffer(buffer); 2145 } 2146 2147 void AudioHardware::AudioStreamInALSA::releaseBufferStatic( 2148 struct resampler_buffer_provider *provider, 2149 struct resampler_buffer* buffer) 2150 { 2151 ResamplerBufferProvider *bufferProvider = (ResamplerBufferProvider *)provider; 2152 return bufferProvider->mInputStream->releaseBuffer(buffer); 2153 } 2154 2155 }; // extern "C" 2156 2157 status_t AudioHardware::AudioStreamInALSA::getNextBuffer(struct resampler_buffer *buffer) 2158 { 2159 if (mPcm == NULL) { 2160 buffer->raw = NULL; 2161 buffer->frame_count = 0; 2162 mReadStatus = NO_INIT; 2163 return NO_INIT; 2164 } 2165 2166 if (mInputFramesIn == 0) { 2167 TRACE_DRIVER_IN(DRV_PCM_READ) 2168 mReadStatus = pcm_read(mPcm,(void*) mInputBuf, AUDIO_HW_IN_PERIOD_SZ * frameSize()); 2169 TRACE_DRIVER_OUT 2170 if (mReadStatus != 0) { 2171 buffer->raw = NULL; 2172 buffer->frame_count = 0; 2173 return mReadStatus; 2174 } 2175 mInputFramesIn = AUDIO_HW_IN_PERIOD_SZ; 2176 } 2177 2178 buffer->frame_count = (buffer->frame_count > mInputFramesIn) ? mInputFramesIn:buffer->frame_count; 2179 buffer->i16 = mInputBuf + (AUDIO_HW_IN_PERIOD_SZ - mInputFramesIn) * mChannelCount; 2180 2181 return mReadStatus; 2182 } 2183 2184 void AudioHardware::AudioStreamInALSA::releaseBuffer(struct resampler_buffer *buffer) 2185 { 2186 mInputFramesIn -= buffer->frame_count; 2187 } 2188 2189 size_t AudioHardware::AudioStreamInALSA::getBufferSize(uint32_t sampleRate, int channelCount) 2190 { 2191 size_t i; 2192 size_t size = sizeof(inputConfigTable)/sizeof(uint32_t)/INPUT_CONFIG_CNT; 2193 2194 for (i = 0; i < size; i++) { 2195 if (sampleRate == inputConfigTable[i][INPUT_CONFIG_SAMPLE_RATE]) { 2196 return (AUDIO_HW_IN_PERIOD_SZ*channelCount*sizeof(int16_t)) / 2197 inputConfigTable[i][INPUT_CONFIG_BUFFER_RATIO]; 2198 } 2199 } 2200 // this should never happen as getBufferSize() is always called after getInputSampleRate() 2201 // that checks for valid sampling rates. 2202 ALOGE("AudioStreamInALSA::getBufferSize() invalid sampling rate %d", sampleRate); 2203 return 0; 2204 } 2205 2206 int AudioHardware::AudioStreamInALSA::prepareLock() 2207 { 2208 // request sleep next time read() is called so that caller can acquire 2209 // mLock 2210 mSleepReq = true; 2211 return mStandbyCnt; 2212 } 2213 2214 void AudioHardware::AudioStreamInALSA::lock() 2215 { 2216 mLock.lock(); 2217 mSleepReq = false; 2218 } 2219 2220 void AudioHardware::AudioStreamInALSA::unlock() { 2221 mLock.unlock(); 2222 } 2223 2224 //------------------------------------------------------------------------------ 2225 // Factory 2226 //------------------------------------------------------------------------------ 2227 2228 extern "C" AudioHardwareInterface* createAudioHardware(void) { 2229 return new AudioHardware(); 2230 } 2231 2232 }; // namespace android 2233
