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 21 #define LOG_TAG "AudioHardware" 22 23 #include <utils/Log.h> 24 #include <utils/String8.h> 25 26 #include <stdio.h> 27 #include <unistd.h> 28 #include <sys/ioctl.h> 29 #include <sys/types.h> 30 #include <sys/stat.h> 31 #include <sys/resource.h> 32 #include <dlfcn.h> 33 #include <fcntl.h> 34 35 #include "AudioHardware.h" 36 #include <media/AudioRecord.h> 37 #include <hardware_legacy/power.h> 38 39 extern "C" { 40 #include "alsa_audio.h" 41 } 42 43 44 namespace android { 45 46 const uint32_t AudioHardware::inputSamplingRates[] = { 47 8000, 11025, 16000, 22050, 44100 48 }; 49 50 // trace driver operations for dump 51 // 52 #define DRIVER_TRACE 53 54 enum { 55 DRV_NONE, 56 DRV_PCM_OPEN, 57 DRV_PCM_CLOSE, 58 DRV_PCM_WRITE, 59 DRV_PCM_READ, 60 DRV_MIXER_OPEN, 61 DRV_MIXER_CLOSE, 62 DRV_MIXER_GET, 63 DRV_MIXER_SEL 64 }; 65 66 #ifdef DRIVER_TRACE 67 #define TRACE_DRIVER_IN(op) mDriverOp = op; 68 #define TRACE_DRIVER_OUT mDriverOp = DRV_NONE; 69 #else 70 #define TRACE_DRIVER_IN(op) 71 #define TRACE_DRIVER_OUT 72 #endif 73 74 // ---------------------------------------------------------------------------- 75 76 AudioHardware::AudioHardware() : 77 mInit(false), 78 mMicMute(false), 79 mPcm(NULL), 80 mMixer(NULL), 81 mPcmOpenCnt(0), 82 mMixerOpenCnt(0), 83 mInCallAudioMode(false), 84 mInputSource("Default"), 85 mBluetoothNrec(true), 86 mSecRilLibHandle(NULL), 87 mRilClient(0), 88 mActivatedCP(false), 89 mDriverOp(DRV_NONE) 90 { 91 loadRILD(); 92 mInit = true; 93 } 94 95 AudioHardware::~AudioHardware() 96 { 97 for (size_t index = 0; index < mInputs.size(); index++) { 98 closeInputStream(mInputs[index].get()); 99 } 100 mInputs.clear(); 101 closeOutputStream((AudioStreamOut*)mOutput.get()); 102 103 if (mMixer) { 104 TRACE_DRIVER_IN(DRV_MIXER_CLOSE) 105 mixer_close(mMixer); 106 TRACE_DRIVER_OUT 107 } 108 if (mPcm) { 109 TRACE_DRIVER_IN(DRV_PCM_CLOSE) 110 pcm_close(mPcm); 111 TRACE_DRIVER_OUT 112 } 113 114 if (mSecRilLibHandle) { 115 if (disconnectRILD(mRilClient) != RIL_CLIENT_ERR_SUCCESS) 116 LOGE("Disconnect_RILD() error"); 117 118 if (closeClientRILD(mRilClient) != RIL_CLIENT_ERR_SUCCESS) 119 LOGE("CloseClient_RILD() error"); 120 121 mRilClient = 0; 122 123 dlclose(mSecRilLibHandle); 124 mSecRilLibHandle = NULL; 125 } 126 127 mInit = false; 128 } 129 130 status_t AudioHardware::initCheck() 131 { 132 return mInit ? NO_ERROR : NO_INIT; 133 } 134 135 void AudioHardware::loadRILD(void) 136 { 137 mSecRilLibHandle = dlopen("libsecril-client.so", RTLD_NOW); 138 139 if (mSecRilLibHandle) { 140 LOGV("libsecril-client.so is loaded"); 141 142 openClientRILD = (HRilClient (*)(void)) 143 dlsym(mSecRilLibHandle, "OpenClient_RILD"); 144 disconnectRILD = (int (*)(HRilClient)) 145 dlsym(mSecRilLibHandle, "Disconnect_RILD"); 146 closeClientRILD = (int (*)(HRilClient)) 147 dlsym(mSecRilLibHandle, "CloseClient_RILD"); 148 isConnectedRILD = (int (*)(HRilClient)) 149 dlsym(mSecRilLibHandle, "isConnected_RILD"); 150 connectRILD = (int (*)(HRilClient)) 151 dlsym(mSecRilLibHandle, "Connect_RILD"); 152 setCallVolume = (int (*)(HRilClient, SoundType, int)) 153 dlsym(mSecRilLibHandle, "SetCallVolume"); 154 setCallAudioPath = (int (*)(HRilClient, AudioPath)) 155 dlsym(mSecRilLibHandle, "SetCallAudioPath"); 156 setCallClockSync = (int (*)(HRilClient, SoundClockCondition)) 157 dlsym(mSecRilLibHandle, "SetCallClockSync"); 158 159 if (!openClientRILD || !disconnectRILD || !closeClientRILD || 160 !isConnectedRILD || !connectRILD || 161 !setCallVolume || !setCallAudioPath || !setCallClockSync) { 162 LOGE("Can't load all functions from libsecril-client.so"); 163 164 dlclose(mSecRilLibHandle); 165 mSecRilLibHandle = NULL; 166 } else { 167 mRilClient = openClientRILD(); 168 if (!mRilClient) { 169 LOGE("OpenClient_RILD() error"); 170 171 dlclose(mSecRilLibHandle); 172 mSecRilLibHandle = NULL; 173 } 174 } 175 } else { 176 LOGE("Can't load libsecril-client.so"); 177 } 178 } 179 180 status_t AudioHardware::connectRILDIfRequired(void) 181 { 182 if (!mSecRilLibHandle) { 183 LOGE("connectIfRequired() lib is not loaded"); 184 return INVALID_OPERATION; 185 } 186 187 if (isConnectedRILD(mRilClient)) { 188 return OK; 189 } 190 191 if (connectRILD(mRilClient) != RIL_CLIENT_ERR_SUCCESS) { 192 LOGE("Connect_RILD() error"); 193 return INVALID_OPERATION; 194 } 195 196 return OK; 197 } 198 199 AudioStreamOut* AudioHardware::openOutputStream( 200 uint32_t devices, int *format, uint32_t *channels, 201 uint32_t *sampleRate, status_t *status) 202 { 203 sp <AudioStreamOutALSA> out; 204 status_t rc; 205 206 { // scope for the lock 207 Mutex::Autolock lock(mLock); 208 209 // only one output stream allowed 210 if (mOutput != 0) { 211 if (status) { 212 *status = INVALID_OPERATION; 213 } 214 return NULL; 215 } 216 217 out = new AudioStreamOutALSA(); 218 219 rc = out->set(this, devices, format, channels, sampleRate); 220 if (rc == NO_ERROR) { 221 mOutput = out; 222 } 223 } 224 225 if (rc != NO_ERROR) { 226 if (out != 0) { 227 out.clear(); 228 } 229 } 230 if (status) { 231 *status = rc; 232 } 233 234 return out.get(); 235 } 236 237 void AudioHardware::closeOutputStream(AudioStreamOut* out) { 238 sp <AudioStreamOutALSA> spOut; 239 { 240 Mutex::Autolock lock(mLock); 241 if (mOutput == 0 || mOutput.get() != out) { 242 LOGW("Attempt to close invalid output stream"); 243 return; 244 } 245 spOut = mOutput; 246 mOutput.clear(); 247 } 248 spOut.clear(); 249 } 250 251 AudioStreamIn* AudioHardware::openInputStream( 252 uint32_t devices, int *format, uint32_t *channels, 253 uint32_t *sampleRate, status_t *status, 254 AudioSystem::audio_in_acoustics acoustic_flags) 255 { 256 // check for valid input source 257 if (!AudioSystem::isInputDevice((AudioSystem::audio_devices)devices)) { 258 if (status) { 259 *status = BAD_VALUE; 260 } 261 return NULL; 262 } 263 264 status_t rc = NO_ERROR; 265 sp <AudioStreamInALSA> in; 266 267 { // scope for the lock 268 Mutex::Autolock lock(mLock); 269 270 in = new AudioStreamInALSA(); 271 rc = in->set(this, devices, format, channels, sampleRate, acoustic_flags); 272 if (rc == NO_ERROR) { 273 mInputs.add(in); 274 } 275 } 276 277 if (rc != NO_ERROR) { 278 if (in != 0) { 279 in.clear(); 280 } 281 } 282 if (status) { 283 *status = rc; 284 } 285 286 LOGV("AudioHardware::openInputStream()%p", in.get()); 287 return in.get(); 288 } 289 290 void AudioHardware::closeInputStream(AudioStreamIn* in) { 291 292 sp<AudioStreamInALSA> spIn; 293 { 294 Mutex::Autolock lock(mLock); 295 296 ssize_t index = mInputs.indexOf((AudioStreamInALSA *)in); 297 if (index < 0) { 298 LOGW("Attempt to close invalid input stream"); 299 return; 300 } 301 spIn = mInputs[index]; 302 mInputs.removeAt(index); 303 } 304 LOGV("AudioHardware::closeInputStream()%p", in); 305 spIn.clear(); 306 } 307 308 309 status_t AudioHardware::setMode(int mode) 310 { 311 sp<AudioStreamOutALSA> spOut; 312 sp<AudioStreamInALSA> spIn; 313 status_t status; 314 315 // bump thread priority to speed up mutex acquisition 316 int priority = getpriority(PRIO_PROCESS, 0); 317 setpriority(PRIO_PROCESS, 0, ANDROID_PRIORITY_URGENT_AUDIO); 318 319 // Mutex acquisition order is always out -> in -> hw 320 AutoMutex lock(mLock); 321 322 spOut = mOutput; 323 while (spOut != 0) { 324 if (!spOut->checkStandby()) { 325 int cnt = spOut->standbyCnt(); 326 mLock.unlock(); 327 spOut->lock(); 328 mLock.lock(); 329 // make sure that another thread did not change output state while the 330 // mutex is released 331 if ((spOut == mOutput) && (cnt == spOut->standbyCnt())) { 332 break; 333 } 334 spOut->unlock(); 335 spOut = mOutput; 336 } else { 337 spOut.clear(); 338 } 339 } 340 // spOut is not 0 here only if the output is active 341 342 spIn = getActiveInput_l(); 343 while (spIn != 0) { 344 int cnt = spIn->standbyCnt(); 345 mLock.unlock(); 346 spIn->lock(); 347 mLock.lock(); 348 // make sure that another thread did not change input state while the 349 // mutex is released 350 if ((spIn == getActiveInput_l()) && (cnt == spIn->standbyCnt())) { 351 break; 352 } 353 spIn->unlock(); 354 spIn = getActiveInput_l(); 355 } 356 // spIn is not 0 here only if the input is active 357 358 setpriority(PRIO_PROCESS, 0, priority); 359 360 int prevMode = mMode; 361 status = AudioHardwareBase::setMode(mode); 362 LOGV("setMode() : new %d, old %d", mMode, prevMode); 363 if (status == NO_ERROR) { 364 // activate call clock in radio when entering in call or ringtone mode 365 if (prevMode == AudioSystem::MODE_NORMAL) 366 { 367 if ((!mActivatedCP) && (mSecRilLibHandle) && (connectRILDIfRequired() == OK)) { 368 setCallClockSync(mRilClient, SOUND_CLOCK_START); 369 mActivatedCP = true; 370 } 371 } 372 373 if (mMode == AudioSystem::MODE_IN_CALL && !mInCallAudioMode) { 374 if (spOut != 0) { 375 LOGV("setMode() in call force output standby"); 376 spOut->doStandby_l(); 377 } 378 if (spIn != 0) { 379 LOGV("setMode() in call force input standby"); 380 spIn->doStandby_l(); 381 } 382 383 LOGV("setMode() openPcmOut_l()"); 384 openPcmOut_l(); 385 openMixer_l(); 386 setInputSource_l(String8("Default")); 387 mInCallAudioMode = true; 388 } 389 if (mMode == AudioSystem::MODE_NORMAL && mInCallAudioMode) { 390 setInputSource_l(mInputSource); 391 if (mMixer != NULL) { 392 TRACE_DRIVER_IN(DRV_MIXER_GET) 393 struct mixer_ctl *ctl= mixer_get_control(mMixer, "Playback Path", 0); 394 TRACE_DRIVER_OUT 395 if (ctl != NULL) { 396 LOGV("setMode() reset Playback Path to RCV"); 397 TRACE_DRIVER_IN(DRV_MIXER_SEL) 398 mixer_ctl_select(ctl, "RCV"); 399 TRACE_DRIVER_OUT 400 } 401 } 402 LOGV("setMode() closePcmOut_l()"); 403 closeMixer_l(); 404 closePcmOut_l(); 405 406 if (spOut != 0) { 407 LOGV("setMode() off call force output standby"); 408 spOut->doStandby_l(); 409 } 410 if (spIn != 0) { 411 LOGV("setMode() off call force input standby"); 412 spIn->doStandby_l(); 413 } 414 415 mInCallAudioMode = false; 416 } 417 418 if (mMode == AudioSystem::MODE_NORMAL) { 419 if(mActivatedCP) 420 mActivatedCP = false; 421 } 422 } 423 424 if (spIn != 0) { 425 spIn->unlock(); 426 } 427 if (spOut != 0) { 428 spOut->unlock(); 429 } 430 431 return status; 432 } 433 434 status_t AudioHardware::setMicMute(bool state) 435 { 436 LOGV("setMicMute(%d) mMicMute %d", state, mMicMute); 437 sp<AudioStreamInALSA> spIn; 438 { 439 AutoMutex lock(mLock); 440 if (mMicMute != state) { 441 mMicMute = state; 442 // in call mute is handled by RIL 443 if (mMode != AudioSystem::MODE_IN_CALL) { 444 spIn = getActiveInput_l(); 445 } 446 } 447 } 448 449 if (spIn != 0) { 450 spIn->standby(); 451 } 452 453 return NO_ERROR; 454 } 455 456 status_t AudioHardware::getMicMute(bool* state) 457 { 458 *state = mMicMute; 459 return NO_ERROR; 460 } 461 462 status_t AudioHardware::setParameters(const String8& keyValuePairs) 463 { 464 AudioParameter param = AudioParameter(keyValuePairs); 465 String8 value; 466 String8 key; 467 const char BT_NREC_KEY[] = "bt_headset_nrec"; 468 const char BT_NREC_VALUE_ON[] = "on"; 469 470 key = String8(BT_NREC_KEY); 471 if (param.get(key, value) == NO_ERROR) { 472 if (value == BT_NREC_VALUE_ON) { 473 mBluetoothNrec = true; 474 } else { 475 mBluetoothNrec = false; 476 LOGD("Turning noise reduction and echo cancellation off for BT " 477 "headset"); 478 } 479 } 480 481 return NO_ERROR; 482 } 483 484 String8 AudioHardware::getParameters(const String8& keys) 485 { 486 AudioParameter request = AudioParameter(keys); 487 AudioParameter reply = AudioParameter(); 488 489 LOGV("getParameters() %s", keys.string()); 490 491 return reply.toString(); 492 } 493 494 size_t AudioHardware::getInputBufferSize(uint32_t sampleRate, int format, int channelCount) 495 { 496 if (format != AudioSystem::PCM_16_BIT) { 497 LOGW("getInputBufferSize bad format: %d", format); 498 return 0; 499 } 500 if (channelCount < 1 || channelCount > 2) { 501 LOGW("getInputBufferSize bad channel count: %d", channelCount); 502 return 0; 503 } 504 if (sampleRate != 8000 && sampleRate != 11025 && sampleRate != 16000 && 505 sampleRate != 22050 && sampleRate != 44100) { 506 LOGW("getInputBufferSize bad sample rate: %d", sampleRate); 507 return 0; 508 } 509 510 return AudioStreamInALSA::getBufferSize(sampleRate, channelCount); 511 } 512 513 514 status_t AudioHardware::setVoiceVolume(float volume) 515 { 516 LOGD("### setVoiceVolume"); 517 518 AutoMutex lock(mLock); 519 if ( (AudioSystem::MODE_IN_CALL == mMode) && (mSecRilLibHandle) && 520 (connectRILDIfRequired() == OK) ) { 521 522 uint32_t device = AudioSystem::DEVICE_OUT_EARPIECE; 523 if (mOutput != 0) { 524 device = mOutput->device(); 525 } 526 int int_volume = (int)(volume * 5); 527 SoundType type; 528 529 LOGD("### route(%d) call volume(%f)", device, volume); 530 switch (device) { 531 case AudioSystem::DEVICE_OUT_EARPIECE: 532 LOGD("### earpiece call volume"); 533 type = SOUND_TYPE_VOICE; 534 break; 535 536 case AudioSystem::DEVICE_OUT_SPEAKER: 537 LOGD("### speaker call volume"); 538 type = SOUND_TYPE_SPEAKER; 539 break; 540 541 case AudioSystem::DEVICE_OUT_BLUETOOTH_SCO: 542 case AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_HEADSET: 543 case AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_CARKIT: 544 LOGD("### bluetooth call volume"); 545 type = SOUND_TYPE_BTVOICE; 546 break; 547 548 case AudioSystem::DEVICE_OUT_WIRED_HEADSET: 549 case AudioSystem::DEVICE_OUT_WIRED_HEADPHONE: // Use receive path with 3 pole headset. 550 LOGD("### headset call volume"); 551 type = SOUND_TYPE_HEADSET; 552 break; 553 554 default: 555 LOGW("### Call volume setting error!!!0x%08x \n", device); 556 type = SOUND_TYPE_VOICE; 557 break; 558 } 559 setCallVolume(mRilClient, type, int_volume); 560 } 561 562 return NO_ERROR; 563 } 564 565 status_t AudioHardware::setMasterVolume(float volume) 566 { 567 LOGV("Set master volume to %f.\n", volume); 568 // We return an error code here to let the audioflinger do in-software 569 // volume on top of the maximum volume that we set through the SND API. 570 // return error - software mixer will handle it 571 return -1; 572 } 573 574 static const int kDumpLockRetries = 50; 575 static const int kDumpLockSleep = 20000; 576 577 static bool tryLock(Mutex& mutex) 578 { 579 bool locked = false; 580 for (int i = 0; i < kDumpLockRetries; ++i) { 581 if (mutex.tryLock() == NO_ERROR) { 582 locked = true; 583 break; 584 } 585 usleep(kDumpLockSleep); 586 } 587 return locked; 588 } 589 590 status_t AudioHardware::dump(int fd, const Vector<String16>& args) 591 { 592 const size_t SIZE = 256; 593 char buffer[SIZE]; 594 String8 result; 595 596 bool locked = tryLock(mLock); 597 if (!locked) { 598 snprintf(buffer, SIZE, "\n\tAudioHardware maybe deadlocked\n"); 599 } else { 600 mLock.unlock(); 601 } 602 603 snprintf(buffer, SIZE, "\tInit %s\n", (mInit) ? "OK" : "Failed"); 604 result.append(buffer); 605 snprintf(buffer, SIZE, "\tMic Mute %s\n", (mMicMute) ? "ON" : "OFF"); 606 result.append(buffer); 607 snprintf(buffer, SIZE, "\tmPcm: %p\n", mPcm); 608 result.append(buffer); 609 snprintf(buffer, SIZE, "\tmPcmOpenCnt: %d\n", mPcmOpenCnt); 610 result.append(buffer); 611 snprintf(buffer, SIZE, "\tmMixer: %p\n", mMixer); 612 result.append(buffer); 613 snprintf(buffer, SIZE, "\tmMixerOpenCnt: %d\n", mMixerOpenCnt); 614 result.append(buffer); 615 snprintf(buffer, SIZE, "\tIn Call Audio Mode %s\n", 616 (mInCallAudioMode) ? "ON" : "OFF"); 617 result.append(buffer); 618 snprintf(buffer, SIZE, "\tInput source %s\n", mInputSource.string()); 619 result.append(buffer); 620 snprintf(buffer, SIZE, "\tmSecRilLibHandle: %p\n", mSecRilLibHandle); 621 result.append(buffer); 622 snprintf(buffer, SIZE, "\tmRilClient: %p\n", mRilClient); 623 result.append(buffer); 624 snprintf(buffer, SIZE, "\tCP %s\n", 625 (mActivatedCP) ? "Activated" : "Deactivated"); 626 result.append(buffer); 627 snprintf(buffer, SIZE, "\tmDriverOp: %d\n", mDriverOp); 628 result.append(buffer); 629 630 snprintf(buffer, SIZE, "\n\tmOutput %p dump:\n", mOutput.get()); 631 result.append(buffer); 632 write(fd, result.string(), result.size()); 633 if (mOutput != 0) { 634 mOutput->dump(fd, args); 635 } 636 637 snprintf(buffer, SIZE, "\n\t%d inputs opened:\n", mInputs.size()); 638 write(fd, buffer, strlen(buffer)); 639 for (size_t i = 0; i < mInputs.size(); i++) { 640 snprintf(buffer, SIZE, "\t- input %d dump:\n", i); 641 write(fd, buffer, strlen(buffer)); 642 mInputs[i]->dump(fd, args); 643 } 644 645 return NO_ERROR; 646 } 647 648 status_t AudioHardware::setIncallPath_l(uint32_t device) 649 { 650 LOGV("setIncallPath_l: device %x", device); 651 652 // Setup sound path for CP clocking 653 if ((mSecRilLibHandle) && 654 (connectRILDIfRequired() == OK)) { 655 656 if (mMode == AudioSystem::MODE_IN_CALL) { 657 LOGD("### incall mode route (%d)", device); 658 AudioPath path; 659 switch(device){ 660 case AudioSystem::DEVICE_OUT_EARPIECE: 661 LOGD("### incall mode earpiece route"); 662 path = SOUND_AUDIO_PATH_HANDSET; 663 break; 664 665 case AudioSystem::DEVICE_OUT_SPEAKER: 666 LOGD("### incall mode speaker route"); 667 path = SOUND_AUDIO_PATH_SPEAKER; 668 break; 669 670 case AudioSystem::DEVICE_OUT_BLUETOOTH_SCO: 671 case AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_HEADSET: 672 case AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_CARKIT: 673 LOGD("### incall mode bluetooth route %s NR", mBluetoothNrec ? "" : "NO"); 674 if (mBluetoothNrec) { 675 path = SOUND_AUDIO_PATH_BLUETOOTH; 676 } else { 677 path = SOUND_AUDIO_PATH_BLUETOOTH_NO_NR; 678 } 679 break; 680 681 case AudioSystem::DEVICE_OUT_WIRED_HEADPHONE : 682 LOGD("### incall mode headphone route"); 683 path = SOUND_AUDIO_PATH_HEADPHONE; 684 break; 685 686 case AudioSystem::DEVICE_OUT_WIRED_HEADSET : 687 LOGD("### incall mode headset route"); 688 path = SOUND_AUDIO_PATH_HEADSET; 689 break; 690 691 default: 692 LOGW("### incall mode Error!! route = [%d]", device); 693 path = SOUND_AUDIO_PATH_HANDSET; 694 break; 695 } 696 697 setCallAudioPath(mRilClient, path); 698 699 if (mMixer != NULL) { 700 TRACE_DRIVER_IN(DRV_MIXER_GET) 701 struct mixer_ctl *ctl= mixer_get_control(mMixer, "Voice Call Path", 0); 702 TRACE_DRIVER_OUT 703 LOGE_IF(ctl == NULL, "setIncallPath_l() could not get mixer ctl"); 704 if (ctl != NULL) { 705 LOGV("setIncallPath_l() Voice Call Path, (%x)", device); 706 TRACE_DRIVER_IN(DRV_MIXER_SEL) 707 mixer_ctl_select(ctl, getVoiceRouteFromDevice(device)); 708 TRACE_DRIVER_OUT 709 } 710 } 711 } 712 } 713 return NO_ERROR; 714 } 715 716 struct pcm *AudioHardware::openPcmOut_l() 717 { 718 LOGD("openPcmOut_l() mPcmOpenCnt: %d", mPcmOpenCnt); 719 if (mPcmOpenCnt++ == 0) { 720 if (mPcm != NULL) { 721 LOGE("openPcmOut_l() mPcmOpenCnt == 0 and mPcm == %p\n", mPcm); 722 mPcmOpenCnt--; 723 return NULL; 724 } 725 unsigned flags = PCM_OUT; 726 727 flags |= (AUDIO_HW_OUT_PERIOD_MULT - 1) << PCM_PERIOD_SZ_SHIFT; 728 flags |= (AUDIO_HW_OUT_PERIOD_CNT - PCM_PERIOD_CNT_MIN) << PCM_PERIOD_CNT_SHIFT; 729 730 TRACE_DRIVER_IN(DRV_PCM_OPEN) 731 mPcm = pcm_open(flags); 732 TRACE_DRIVER_OUT 733 if (!pcm_ready(mPcm)) { 734 LOGE("openPcmOut_l() cannot open pcm_out driver: %s\n", pcm_error(mPcm)); 735 TRACE_DRIVER_IN(DRV_PCM_CLOSE) 736 pcm_close(mPcm); 737 TRACE_DRIVER_OUT 738 mPcmOpenCnt--; 739 mPcm = NULL; 740 } 741 } 742 return mPcm; 743 } 744 745 void AudioHardware::closePcmOut_l() 746 { 747 LOGD("closePcmOut_l() mPcmOpenCnt: %d", mPcmOpenCnt); 748 if (mPcmOpenCnt == 0) { 749 LOGE("closePcmOut_l() mPcmOpenCnt == 0"); 750 return; 751 } 752 753 if (--mPcmOpenCnt == 0) { 754 TRACE_DRIVER_IN(DRV_PCM_CLOSE) 755 pcm_close(mPcm); 756 TRACE_DRIVER_OUT 757 mPcm = NULL; 758 } 759 } 760 761 struct mixer *AudioHardware::openMixer_l() 762 { 763 LOGV("openMixer_l() mMixerOpenCnt: %d", mMixerOpenCnt); 764 if (mMixerOpenCnt++ == 0) { 765 if (mMixer != NULL) { 766 LOGE("openMixer_l() mMixerOpenCnt == 0 and mMixer == %p\n", mMixer); 767 mMixerOpenCnt--; 768 return NULL; 769 } 770 TRACE_DRIVER_IN(DRV_MIXER_OPEN) 771 mMixer = mixer_open(); 772 TRACE_DRIVER_OUT 773 if (mMixer == NULL) { 774 LOGE("openMixer_l() cannot open mixer"); 775 mMixerOpenCnt--; 776 return NULL; 777 } 778 } 779 return mMixer; 780 } 781 782 void AudioHardware::closeMixer_l() 783 { 784 LOGV("closeMixer_l() mMixerOpenCnt: %d", mMixerOpenCnt); 785 if (mMixerOpenCnt == 0) { 786 LOGE("closeMixer_l() mMixerOpenCnt == 0"); 787 return; 788 } 789 790 if (--mMixerOpenCnt == 0) { 791 TRACE_DRIVER_IN(DRV_MIXER_CLOSE) 792 mixer_close(mMixer); 793 TRACE_DRIVER_OUT 794 mMixer = NULL; 795 } 796 } 797 798 const char *AudioHardware::getOutputRouteFromDevice(uint32_t device) 799 { 800 switch (device) { 801 case AudioSystem::DEVICE_OUT_EARPIECE: 802 return "RCV"; 803 case AudioSystem::DEVICE_OUT_SPEAKER: 804 if (mMode == AudioSystem::MODE_RINGTONE) return "RING_SPK"; 805 else return "SPK"; 806 case AudioSystem::DEVICE_OUT_WIRED_HEADPHONE: 807 if (mMode == AudioSystem::MODE_RINGTONE) return "RING_NO_MIC"; 808 else return "HP_NO_MIC"; 809 case AudioSystem::DEVICE_OUT_WIRED_HEADSET: 810 if (mMode == AudioSystem::MODE_RINGTONE) return "RING_HP"; 811 else return "HP"; 812 case (AudioSystem::DEVICE_OUT_SPEAKER|AudioSystem::DEVICE_OUT_WIRED_HEADPHONE): 813 case (AudioSystem::DEVICE_OUT_SPEAKER|AudioSystem::DEVICE_OUT_WIRED_HEADSET): 814 if (mMode == AudioSystem::MODE_RINGTONE) return "RING_SPK_HP"; 815 else return "SPK_HP"; 816 case AudioSystem::DEVICE_OUT_BLUETOOTH_SCO: 817 case AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_HEADSET: 818 case AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_CARKIT: 819 return "BT"; 820 default: 821 return "OFF"; 822 } 823 } 824 825 const char *AudioHardware::getVoiceRouteFromDevice(uint32_t device) 826 { 827 switch (device) { 828 case AudioSystem::DEVICE_OUT_EARPIECE: 829 return "RCV"; 830 case AudioSystem::DEVICE_OUT_SPEAKER: 831 return "SPK"; 832 case AudioSystem::DEVICE_OUT_WIRED_HEADPHONE: 833 return "HP_NO_MIC"; 834 case AudioSystem::DEVICE_OUT_WIRED_HEADSET: 835 return "HP"; 836 case AudioSystem::DEVICE_OUT_BLUETOOTH_SCO: 837 case AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_HEADSET: 838 case AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_CARKIT: 839 return "BT"; 840 default: 841 return "OFF"; 842 } 843 } 844 845 const char *AudioHardware::getInputRouteFromDevice(uint32_t device) 846 { 847 if (mMicMute) { 848 return "MIC OFF"; 849 } 850 851 switch (device) { 852 case AudioSystem::DEVICE_IN_BUILTIN_MIC: 853 return "Main Mic"; 854 case AudioSystem::DEVICE_IN_WIRED_HEADSET: 855 return "Hands Free Mic"; 856 case AudioSystem::DEVICE_IN_BLUETOOTH_SCO_HEADSET: 857 return "BT Sco Mic"; 858 default: 859 return "MIC OFF"; 860 } 861 } 862 863 uint32_t AudioHardware::getInputSampleRate(uint32_t sampleRate) 864 { 865 uint32_t i; 866 uint32_t prevDelta; 867 uint32_t delta; 868 869 for (i = 0, prevDelta = 0xFFFFFFFF; i < sizeof(inputSamplingRates)/sizeof(uint32_t); i++, prevDelta = delta) { 870 delta = abs(sampleRate - inputSamplingRates[i]); 871 if (delta > prevDelta) break; 872 } 873 // i is always > 0 here 874 return inputSamplingRates[i-1]; 875 } 876 877 // getActiveInput_l() must be called with mLock held 878 sp <AudioHardware::AudioStreamInALSA> AudioHardware::getActiveInput_l() 879 { 880 sp< AudioHardware::AudioStreamInALSA> spIn; 881 882 for (size_t i = 0; i < mInputs.size(); i++) { 883 // return first input found not being in standby mode 884 // as only one input can be in this state 885 if (!mInputs[i]->checkStandby()) { 886 spIn = mInputs[i]; 887 break; 888 } 889 } 890 891 return spIn; 892 } 893 894 status_t AudioHardware::setInputSource_l(String8 source) 895 { 896 LOGV("setInputSource_l(%s)", source.string()); 897 if (source != mInputSource) { 898 if ((source == "Default") || (mMode != AudioSystem::MODE_IN_CALL)) { 899 if (mMixer) { 900 TRACE_DRIVER_IN(DRV_MIXER_GET) 901 struct mixer_ctl *ctl= mixer_get_control(mMixer, "Input Source", 0); 902 TRACE_DRIVER_OUT 903 if (ctl == NULL) { 904 return NO_INIT; 905 } 906 LOGV("mixer_ctl_select, Input Source, (%s)", source.string()); 907 TRACE_DRIVER_IN(DRV_MIXER_SEL) 908 mixer_ctl_select(ctl, source.string()); 909 TRACE_DRIVER_OUT 910 } 911 } 912 mInputSource = source; 913 } 914 915 return NO_ERROR; 916 } 917 918 919 //------------------------------------------------------------------------------ 920 // AudioStreamOutALSA 921 //------------------------------------------------------------------------------ 922 923 AudioHardware::AudioStreamOutALSA::AudioStreamOutALSA() : 924 mHardware(0), mPcm(0), mMixer(0), mRouteCtl(0), 925 mStandby(true), mDevices(0), mChannels(AUDIO_HW_OUT_CHANNELS), 926 mSampleRate(AUDIO_HW_OUT_SAMPLERATE), mBufferSize(AUDIO_HW_OUT_PERIOD_BYTES), 927 mDriverOp(DRV_NONE), mStandbyCnt(0) 928 { 929 } 930 931 status_t AudioHardware::AudioStreamOutALSA::set( 932 AudioHardware* hw, uint32_t devices, int *pFormat, 933 uint32_t *pChannels, uint32_t *pRate) 934 { 935 int lFormat = pFormat ? *pFormat : 0; 936 uint32_t lChannels = pChannels ? *pChannels : 0; 937 uint32_t lRate = pRate ? *pRate : 0; 938 939 mHardware = hw; 940 mDevices = devices; 941 942 // fix up defaults 943 if (lFormat == 0) lFormat = format(); 944 if (lChannels == 0) lChannels = channels(); 945 if (lRate == 0) lRate = sampleRate(); 946 947 // check values 948 if ((lFormat != format()) || 949 (lChannels != channels()) || 950 (lRate != sampleRate())) { 951 if (pFormat) *pFormat = format(); 952 if (pChannels) *pChannels = channels(); 953 if (pRate) *pRate = sampleRate(); 954 return BAD_VALUE; 955 } 956 957 if (pFormat) *pFormat = lFormat; 958 if (pChannels) *pChannels = lChannels; 959 if (pRate) *pRate = lRate; 960 961 mChannels = lChannels; 962 mSampleRate = lRate; 963 mBufferSize = AUDIO_HW_OUT_PERIOD_BYTES; 964 965 return NO_ERROR; 966 } 967 968 AudioHardware::AudioStreamOutALSA::~AudioStreamOutALSA() 969 { 970 standby(); 971 } 972 973 ssize_t AudioHardware::AudioStreamOutALSA::write(const void* buffer, size_t bytes) 974 { 975 // LOGV("AudioStreamOutALSA::write(%p, %u)", buffer, bytes); 976 status_t status = NO_INIT; 977 const uint8_t* p = static_cast<const uint8_t*>(buffer); 978 int ret; 979 980 if (mHardware == NULL) return NO_INIT; 981 982 { // scope for the lock 983 984 AutoMutex lock(mLock); 985 986 if (mStandby) { 987 AutoMutex hwLock(mHardware->lock()); 988 989 LOGD("AudioHardware pcm playback is exiting standby."); 990 acquire_wake_lock (PARTIAL_WAKE_LOCK, "AudioOutLock"); 991 992 sp<AudioStreamInALSA> spIn = mHardware->getActiveInput_l(); 993 while (spIn != 0) { 994 int cnt = spIn->standbyCnt(); 995 mHardware->lock().unlock(); 996 // Mutex acquisition order is always out -> in -> hw 997 spIn->lock(); 998 mHardware->lock().lock(); 999 // make sure that another thread did not change input state 1000 // while the mutex is released 1001 if ((spIn == mHardware->getActiveInput_l()) && 1002 (cnt == spIn->standbyCnt())) { 1003 LOGV("AudioStreamOutALSA::write() force input standby"); 1004 spIn->close_l(); 1005 break; 1006 } 1007 spIn->unlock(); 1008 spIn = mHardware->getActiveInput_l(); 1009 } 1010 // spIn is not 0 here only if the input was active and has been 1011 // closed above 1012 1013 // open output before input 1014 open_l(); 1015 1016 if (spIn != 0) { 1017 if (spIn->open_l() != NO_ERROR) { 1018 spIn->doStandby_l(); 1019 } 1020 spIn->unlock(); 1021 } 1022 if (mPcm == NULL) { 1023 release_wake_lock("AudioOutLock"); 1024 goto Error; 1025 } 1026 mStandby = false; 1027 } 1028 1029 TRACE_DRIVER_IN(DRV_PCM_WRITE) 1030 ret = pcm_write(mPcm,(void*) p, bytes); 1031 TRACE_DRIVER_OUT 1032 1033 if (ret == 0) { 1034 return bytes; 1035 } 1036 LOGW("write error: %d", errno); 1037 status = -errno; 1038 } 1039 Error: 1040 1041 standby(); 1042 1043 // Simulate audio output timing in case of error 1044 usleep((((bytes * 1000) / frameSize()) * 1000) / sampleRate()); 1045 1046 return status; 1047 } 1048 1049 status_t AudioHardware::AudioStreamOutALSA::standby() 1050 { 1051 if (mHardware == NULL) return NO_INIT; 1052 1053 AutoMutex lock(mLock); 1054 1055 { // scope for the AudioHardware lock 1056 AutoMutex hwLock(mHardware->lock()); 1057 1058 doStandby_l(); 1059 } 1060 1061 return NO_ERROR; 1062 } 1063 1064 void AudioHardware::AudioStreamOutALSA::doStandby_l() 1065 { 1066 mStandbyCnt++; 1067 1068 if (!mStandby) { 1069 LOGD("AudioHardware pcm playback is going to standby."); 1070 release_wake_lock("AudioOutLock"); 1071 mStandby = true; 1072 } 1073 1074 close_l(); 1075 } 1076 1077 void AudioHardware::AudioStreamOutALSA::close_l() 1078 { 1079 if (mMixer) { 1080 mHardware->closeMixer_l(); 1081 mMixer = NULL; 1082 mRouteCtl = NULL; 1083 } 1084 if (mPcm) { 1085 mHardware->closePcmOut_l(); 1086 mPcm = NULL; 1087 } 1088 } 1089 1090 status_t AudioHardware::AudioStreamOutALSA::open_l() 1091 { 1092 LOGV("open pcm_out driver"); 1093 mPcm = mHardware->openPcmOut_l(); 1094 if (mPcm == NULL) { 1095 return NO_INIT; 1096 } 1097 1098 mMixer = mHardware->openMixer_l(); 1099 if (mMixer) { 1100 LOGV("open playback normal"); 1101 TRACE_DRIVER_IN(DRV_MIXER_GET) 1102 mRouteCtl = mixer_get_control(mMixer, "Playback Path", 0); 1103 TRACE_DRIVER_OUT 1104 } 1105 if (mHardware->mode() != AudioSystem::MODE_IN_CALL) { 1106 const char *route = mHardware->getOutputRouteFromDevice(mDevices); 1107 LOGV("write() wakeup setting route %s", route); 1108 if (mRouteCtl) { 1109 TRACE_DRIVER_IN(DRV_MIXER_SEL) 1110 mixer_ctl_select(mRouteCtl, route); 1111 TRACE_DRIVER_OUT 1112 } 1113 } 1114 return NO_ERROR; 1115 } 1116 1117 status_t AudioHardware::AudioStreamOutALSA::dump(int fd, const Vector<String16>& args) 1118 { 1119 const size_t SIZE = 256; 1120 char buffer[SIZE]; 1121 String8 result; 1122 1123 bool locked = tryLock(mLock); 1124 if (!locked) { 1125 snprintf(buffer, SIZE, "\n\t\tAudioStreamOutALSA maybe deadlocked\n"); 1126 } else { 1127 mLock.unlock(); 1128 } 1129 1130 snprintf(buffer, SIZE, "\t\tmHardware: %p\n", mHardware); 1131 result.append(buffer); 1132 snprintf(buffer, SIZE, "\t\tmPcm: %p\n", mPcm); 1133 result.append(buffer); 1134 snprintf(buffer, SIZE, "\t\tmMixer: %p\n", mMixer); 1135 result.append(buffer); 1136 snprintf(buffer, SIZE, "\t\tmRouteCtl: %p\n", mRouteCtl); 1137 result.append(buffer); 1138 snprintf(buffer, SIZE, "\t\tStandby %s\n", (mStandby) ? "ON" : "OFF"); 1139 result.append(buffer); 1140 snprintf(buffer, SIZE, "\t\tmDevices: 0x%08x\n", mDevices); 1141 result.append(buffer); 1142 snprintf(buffer, SIZE, "\t\tmChannels: 0x%08x\n", mChannels); 1143 result.append(buffer); 1144 snprintf(buffer, SIZE, "\t\tmSampleRate: %d\n", mSampleRate); 1145 result.append(buffer); 1146 snprintf(buffer, SIZE, "\t\tmBufferSize: %d\n", mBufferSize); 1147 result.append(buffer); 1148 snprintf(buffer, SIZE, "\t\tmDriverOp: %d\n", mDriverOp); 1149 result.append(buffer); 1150 1151 ::write(fd, result.string(), result.size()); 1152 1153 return NO_ERROR; 1154 } 1155 1156 bool AudioHardware::AudioStreamOutALSA::checkStandby() 1157 { 1158 return mStandby; 1159 } 1160 1161 status_t AudioHardware::AudioStreamOutALSA::setParameters(const String8& keyValuePairs) 1162 { 1163 AudioParameter param = AudioParameter(keyValuePairs); 1164 status_t status = NO_ERROR; 1165 int device; 1166 LOGD("AudioStreamOutALSA::setParameters() %s", keyValuePairs.string()); 1167 1168 if (mHardware == NULL) return NO_INIT; 1169 1170 { 1171 AutoMutex lock(mLock); 1172 1173 if (param.getInt(String8(AudioParameter::keyRouting), device) == NO_ERROR) 1174 { 1175 AutoMutex hwLock(mHardware->lock()); 1176 1177 if (mDevices != (uint32_t)device) { 1178 mDevices = (uint32_t)device; 1179 if (mHardware->mode() != AudioSystem::MODE_IN_CALL) { 1180 doStandby_l(); 1181 } 1182 } 1183 if (mHardware->mode() == AudioSystem::MODE_IN_CALL) { 1184 mHardware->setIncallPath_l(device); 1185 } 1186 param.remove(String8(AudioParameter::keyRouting)); 1187 } 1188 } 1189 1190 if (param.size()) { 1191 status = BAD_VALUE; 1192 } 1193 1194 1195 return status; 1196 1197 } 1198 1199 String8 AudioHardware::AudioStreamOutALSA::getParameters(const String8& keys) 1200 { 1201 AudioParameter param = AudioParameter(keys); 1202 String8 value; 1203 String8 key = String8(AudioParameter::keyRouting); 1204 1205 if (param.get(key, value) == NO_ERROR) { 1206 param.addInt(key, (int)mDevices); 1207 } 1208 1209 LOGV("AudioStreamOutALSA::getParameters() %s", param.toString().string()); 1210 return param.toString(); 1211 } 1212 1213 status_t AudioHardware::AudioStreamOutALSA::getRenderPosition(uint32_t *dspFrames) 1214 { 1215 //TODO 1216 return INVALID_OPERATION; 1217 } 1218 1219 //------------------------------------------------------------------------------ 1220 // AudioStreamInALSA 1221 //------------------------------------------------------------------------------ 1222 1223 AudioHardware::AudioStreamInALSA::AudioStreamInALSA() : 1224 mHardware(0), mPcm(0), mMixer(0), mRouteCtl(0), 1225 mStandby(true), mDevices(0), mChannels(AUDIO_HW_IN_CHANNELS), mChannelCount(1), 1226 mSampleRate(AUDIO_HW_IN_SAMPLERATE), mBufferSize(AUDIO_HW_IN_PERIOD_BYTES), 1227 mDownSampler(NULL), mReadStatus(NO_ERROR), mDriverOp(DRV_NONE), 1228 mStandbyCnt(0) 1229 { 1230 } 1231 1232 status_t AudioHardware::AudioStreamInALSA::set( 1233 AudioHardware* hw, uint32_t devices, int *pFormat, 1234 uint32_t *pChannels, uint32_t *pRate, AudioSystem::audio_in_acoustics acoustics) 1235 { 1236 if (pFormat == 0 || *pFormat != AUDIO_HW_IN_FORMAT) { 1237 *pFormat = AUDIO_HW_IN_FORMAT; 1238 return BAD_VALUE; 1239 } 1240 if (pRate == 0) { 1241 return BAD_VALUE; 1242 } 1243 uint32_t rate = AudioHardware::getInputSampleRate(*pRate); 1244 if (rate != *pRate) { 1245 *pRate = rate; 1246 return BAD_VALUE; 1247 } 1248 1249 if (pChannels == 0 || (*pChannels != AudioSystem::CHANNEL_IN_MONO && 1250 *pChannels != AudioSystem::CHANNEL_IN_STEREO)) { 1251 *pChannels = AUDIO_HW_IN_CHANNELS; 1252 return BAD_VALUE; 1253 } 1254 1255 mHardware = hw; 1256 1257 LOGV("AudioStreamInALSA::set(%d, %d, %u)", *pFormat, *pChannels, *pRate); 1258 1259 mBufferSize = getBufferSize(*pRate, AudioSystem::popCount(*pChannels)); 1260 mDevices = devices; 1261 mChannels = *pChannels; 1262 mChannelCount = AudioSystem::popCount(mChannels); 1263 mSampleRate = rate; 1264 if (mSampleRate != AUDIO_HW_OUT_SAMPLERATE) { 1265 mDownSampler = new AudioHardware::DownSampler(mSampleRate, 1266 mChannelCount, 1267 AUDIO_HW_IN_PERIOD_SZ, 1268 this); 1269 status_t status = mDownSampler->initCheck(); 1270 if (status != NO_ERROR) { 1271 delete mDownSampler; 1272 LOGW("AudioStreamInALSA::set() downsampler init failed: %d", status); 1273 return status; 1274 } 1275 1276 mPcmIn = new int16_t[AUDIO_HW_IN_PERIOD_SZ * mChannelCount]; 1277 } 1278 return NO_ERROR; 1279 } 1280 1281 AudioHardware::AudioStreamInALSA::~AudioStreamInALSA() 1282 { 1283 standby(); 1284 if (mDownSampler != NULL) { 1285 delete mDownSampler; 1286 if (mPcmIn != NULL) { 1287 delete[] mPcmIn; 1288 } 1289 } 1290 } 1291 1292 ssize_t AudioHardware::AudioStreamInALSA::read(void* buffer, ssize_t bytes) 1293 { 1294 // LOGV("AudioStreamInALSA::read(%p, %u)", buffer, bytes); 1295 status_t status = NO_INIT; 1296 int ret; 1297 1298 if (mHardware == NULL) return NO_INIT; 1299 1300 { // scope for the lock 1301 AutoMutex lock(mLock); 1302 1303 if (mStandby) { 1304 AutoMutex hwLock(mHardware->lock()); 1305 1306 LOGD("AudioHardware pcm capture is exiting standby."); 1307 acquire_wake_lock (PARTIAL_WAKE_LOCK, "AudioInLock"); 1308 1309 sp<AudioStreamOutALSA> spOut = mHardware->output(); 1310 while (spOut != 0) { 1311 if (!spOut->checkStandby()) { 1312 int cnt = spOut->standbyCnt(); 1313 mHardware->lock().unlock(); 1314 mLock.unlock(); 1315 // Mutex acquisition order is always out -> in -> hw 1316 spOut->lock(); 1317 mLock.lock(); 1318 mHardware->lock().lock(); 1319 // make sure that another thread did not change output state 1320 // while the mutex is released 1321 if ((spOut == mHardware->output()) && (cnt == spOut->standbyCnt())) { 1322 LOGV("AudioStreamInALSA::read() force output standby"); 1323 spOut->close_l(); 1324 break; 1325 } 1326 spOut->unlock(); 1327 spOut = mHardware->output(); 1328 } else { 1329 spOut.clear(); 1330 } 1331 } 1332 // spOut is not 0 here only if the output was active and has been 1333 // closed above 1334 1335 // open output before input 1336 if (spOut != 0) { 1337 if (spOut->open_l() != NO_ERROR) { 1338 spOut->doStandby_l(); 1339 } 1340 spOut->unlock(); 1341 } 1342 1343 open_l(); 1344 1345 if (mPcm == NULL) { 1346 release_wake_lock("AudioInLock"); 1347 goto Error; 1348 } 1349 mStandby = false; 1350 } 1351 1352 1353 if (mDownSampler != NULL) { 1354 size_t frames = bytes / frameSize(); 1355 size_t framesIn = 0; 1356 mReadStatus = 0; 1357 do { 1358 size_t outframes = frames - framesIn; 1359 mDownSampler->resample( 1360 (int16_t *)buffer + (framesIn * mChannelCount), 1361 &outframes); 1362 framesIn += outframes; 1363 } while ((framesIn < frames) && mReadStatus == 0); 1364 ret = mReadStatus; 1365 bytes = framesIn * frameSize(); 1366 } else { 1367 TRACE_DRIVER_IN(DRV_PCM_READ) 1368 ret = pcm_read(mPcm, buffer, bytes); 1369 TRACE_DRIVER_OUT 1370 } 1371 1372 if (ret == 0) { 1373 return bytes; 1374 } 1375 1376 LOGW("read error: %d", ret); 1377 status = ret; 1378 } 1379 1380 Error: 1381 1382 standby(); 1383 1384 // Simulate audio output timing in case of error 1385 usleep((((bytes * 1000) / frameSize()) * 1000) / sampleRate()); 1386 1387 return status; 1388 } 1389 1390 status_t AudioHardware::AudioStreamInALSA::standby() 1391 { 1392 if (mHardware == NULL) return NO_INIT; 1393 1394 AutoMutex lock(mLock); 1395 1396 { // scope for AudioHardware lock 1397 AutoMutex hwLock(mHardware->lock()); 1398 1399 doStandby_l(); 1400 } 1401 return NO_ERROR; 1402 } 1403 1404 void AudioHardware::AudioStreamInALSA::doStandby_l() 1405 { 1406 mStandbyCnt++; 1407 1408 if (!mStandby) { 1409 LOGD("AudioHardware pcm capture is going to standby."); 1410 release_wake_lock("AudioInLock"); 1411 mStandby = true; 1412 } 1413 close_l(); 1414 } 1415 1416 void AudioHardware::AudioStreamInALSA::close_l() 1417 { 1418 if (mMixer) { 1419 mHardware->closeMixer_l(); 1420 mMixer = NULL; 1421 mRouteCtl = NULL; 1422 } 1423 1424 if (mPcm) { 1425 TRACE_DRIVER_IN(DRV_PCM_CLOSE) 1426 pcm_close(mPcm); 1427 TRACE_DRIVER_OUT 1428 mPcm = NULL; 1429 } 1430 } 1431 1432 status_t AudioHardware::AudioStreamInALSA::open_l() 1433 { 1434 unsigned flags = PCM_IN; 1435 if (mChannels == AudioSystem::CHANNEL_IN_MONO) { 1436 flags |= PCM_MONO; 1437 } 1438 flags |= (AUDIO_HW_IN_PERIOD_MULT - 1) << PCM_PERIOD_SZ_SHIFT; 1439 flags |= (AUDIO_HW_IN_PERIOD_CNT - PCM_PERIOD_CNT_MIN) 1440 << PCM_PERIOD_CNT_SHIFT; 1441 1442 LOGV("open pcm_in driver"); 1443 TRACE_DRIVER_IN(DRV_PCM_OPEN) 1444 mPcm = pcm_open(flags); 1445 TRACE_DRIVER_OUT 1446 if (!pcm_ready(mPcm)) { 1447 LOGE("cannot open pcm_in driver: %s\n", pcm_error(mPcm)); 1448 TRACE_DRIVER_IN(DRV_PCM_CLOSE) 1449 pcm_close(mPcm); 1450 TRACE_DRIVER_OUT 1451 mPcm = NULL; 1452 return NO_INIT; 1453 } 1454 1455 if (mDownSampler != NULL) { 1456 mInPcmInBuf = 0; 1457 mDownSampler->reset(); 1458 } 1459 1460 mMixer = mHardware->openMixer_l(); 1461 if (mMixer) { 1462 TRACE_DRIVER_IN(DRV_MIXER_GET) 1463 mRouteCtl = mixer_get_control(mMixer, "Capture MIC Path", 0); 1464 TRACE_DRIVER_OUT 1465 } 1466 1467 if (mHardware->mode() != AudioSystem::MODE_IN_CALL) { 1468 const char *route = mHardware->getInputRouteFromDevice(mDevices); 1469 LOGV("read() wakeup setting route %s", route); 1470 if (mRouteCtl) { 1471 TRACE_DRIVER_IN(DRV_MIXER_SEL) 1472 mixer_ctl_select(mRouteCtl, route); 1473 TRACE_DRIVER_OUT 1474 } 1475 } 1476 1477 return NO_ERROR; 1478 } 1479 1480 status_t AudioHardware::AudioStreamInALSA::dump(int fd, const Vector<String16>& args) 1481 { 1482 const size_t SIZE = 256; 1483 char buffer[SIZE]; 1484 String8 result; 1485 1486 bool locked = tryLock(mLock); 1487 if (!locked) { 1488 snprintf(buffer, SIZE, "\n\t\tAudioStreamInALSA maybe deadlocked\n"); 1489 } else { 1490 mLock.unlock(); 1491 } 1492 1493 snprintf(buffer, SIZE, "\t\tmHardware: %p\n", mHardware); 1494 result.append(buffer); 1495 snprintf(buffer, SIZE, "\t\tmPcm: %p\n", mPcm); 1496 result.append(buffer); 1497 snprintf(buffer, SIZE, "\t\tmMixer: %p\n", mMixer); 1498 result.append(buffer); 1499 snprintf(buffer, SIZE, "\t\tStandby %s\n", (mStandby) ? "ON" : "OFF"); 1500 result.append(buffer); 1501 snprintf(buffer, SIZE, "\t\tmDevices: 0x%08x\n", mDevices); 1502 result.append(buffer); 1503 snprintf(buffer, SIZE, "\t\tmChannels: 0x%08x\n", mChannels); 1504 result.append(buffer); 1505 snprintf(buffer, SIZE, "\t\tmSampleRate: %d\n", mSampleRate); 1506 result.append(buffer); 1507 snprintf(buffer, SIZE, "\t\tmBufferSize: %d\n", mBufferSize); 1508 result.append(buffer); 1509 snprintf(buffer, SIZE, "\t\tmDriverOp: %d\n", mDriverOp); 1510 result.append(buffer); 1511 write(fd, result.string(), result.size()); 1512 1513 return NO_ERROR; 1514 } 1515 1516 bool AudioHardware::AudioStreamInALSA::checkStandby() 1517 { 1518 return mStandby; 1519 } 1520 1521 status_t AudioHardware::AudioStreamInALSA::setParameters(const String8& keyValuePairs) 1522 { 1523 AudioParameter param = AudioParameter(keyValuePairs); 1524 status_t status = NO_ERROR; 1525 int value; 1526 String8 source; 1527 1528 LOGD("AudioStreamInALSA::setParameters() %s", keyValuePairs.string()); 1529 1530 if (mHardware == NULL) return NO_INIT; 1531 1532 { 1533 AutoMutex lock(mLock); 1534 1535 if (param.get(String8(INPUT_SOURCE_KEY), source) == NO_ERROR) { 1536 AutoMutex hwLock(mHardware->lock()); 1537 1538 mHardware->openMixer_l(); 1539 mHardware->setInputSource_l(source); 1540 mHardware->closeMixer_l(); 1541 1542 param.remove(String8(INPUT_SOURCE_KEY)); 1543 } 1544 1545 if (param.getInt(String8(AudioParameter::keyRouting), value) == NO_ERROR) 1546 { 1547 if (value != 0) { 1548 AutoMutex hwLock(mHardware->lock()); 1549 1550 if (mDevices != (uint32_t)value) { 1551 mDevices = (uint32_t)value; 1552 if (mHardware->mode() != AudioSystem::MODE_IN_CALL) { 1553 doStandby_l(); 1554 } 1555 } 1556 } 1557 param.remove(String8(AudioParameter::keyRouting)); 1558 } 1559 } 1560 1561 1562 if (param.size()) { 1563 status = BAD_VALUE; 1564 } 1565 1566 return status; 1567 1568 } 1569 1570 String8 AudioHardware::AudioStreamInALSA::getParameters(const String8& keys) 1571 { 1572 AudioParameter param = AudioParameter(keys); 1573 String8 value; 1574 String8 key = String8(AudioParameter::keyRouting); 1575 1576 if (param.get(key, value) == NO_ERROR) { 1577 param.addInt(key, (int)mDevices); 1578 } 1579 1580 LOGV("AudioStreamInALSA::getParameters() %s", param.toString().string()); 1581 return param.toString(); 1582 } 1583 1584 status_t AudioHardware::AudioStreamInALSA::getNextBuffer(AudioHardware::BufferProvider::Buffer* buffer) 1585 { 1586 if (mPcm == NULL) { 1587 buffer->raw = NULL; 1588 buffer->frameCount = 0; 1589 mReadStatus = NO_INIT; 1590 return NO_INIT; 1591 } 1592 1593 if (mInPcmInBuf == 0) { 1594 TRACE_DRIVER_IN(DRV_PCM_READ) 1595 mReadStatus = pcm_read(mPcm,(void*) mPcmIn, AUDIO_HW_IN_PERIOD_SZ * frameSize()); 1596 TRACE_DRIVER_OUT 1597 if (mReadStatus != 0) { 1598 buffer->raw = NULL; 1599 buffer->frameCount = 0; 1600 return mReadStatus; 1601 } 1602 mInPcmInBuf = AUDIO_HW_IN_PERIOD_SZ; 1603 } 1604 1605 buffer->frameCount = (buffer->frameCount > mInPcmInBuf) ? mInPcmInBuf : buffer->frameCount; 1606 buffer->i16 = mPcmIn + (AUDIO_HW_IN_PERIOD_SZ - mInPcmInBuf) * mChannelCount; 1607 1608 return mReadStatus; 1609 } 1610 1611 void AudioHardware::AudioStreamInALSA::releaseBuffer(Buffer* buffer) 1612 { 1613 mInPcmInBuf -= buffer->frameCount; 1614 } 1615 1616 size_t AudioHardware::AudioStreamInALSA::getBufferSize(uint32_t sampleRate, int channelCount) 1617 { 1618 size_t ratio; 1619 1620 switch (sampleRate) { 1621 case 8000: 1622 case 11025: 1623 ratio = 4; 1624 break; 1625 case 16000: 1626 case 22050: 1627 ratio = 2; 1628 break; 1629 case 44100: 1630 default: 1631 ratio = 1; 1632 break; 1633 } 1634 1635 return (AUDIO_HW_IN_PERIOD_SZ*channelCount*sizeof(int16_t)) / ratio ; 1636 } 1637 1638 //------------------------------------------------------------------------------ 1639 // DownSampler 1640 //------------------------------------------------------------------------------ 1641 1642 /* 1643 * 2.30 fixed point FIR filter coefficients for conversion 44100 -> 22050. 1644 * (Works equivalently for 22010 -> 11025 or any other halving, of course.) 1645 * 1646 * Transition band from about 18 kHz, passband ripple < 0.1 dB, 1647 * stopband ripple at about -55 dB, linear phase. 1648 * 1649 * Design and display in MATLAB or Octave using: 1650 * 1651 * filter = fir1(19, 0.5); filter = round(filter * 2**30); freqz(filter * 2**-30); 1652 */ 1653 static const int32_t filter_22khz_coeff[] = { 1654 2089257, 2898328, -5820678, -10484531, 1655 19038724, 30542725, -50469415, -81505260, 1656 152544464, 478517512, 478517512, 152544464, 1657 -81505260, -50469415, 30542725, 19038724, 1658 -10484531, -5820678, 2898328, 2089257, 1659 }; 1660 #define NUM_COEFF_22KHZ (sizeof(filter_22khz_coeff) / sizeof(filter_22khz_coeff[0])) 1661 #define OVERLAP_22KHZ (NUM_COEFF_22KHZ - 2) 1662 1663 /* 1664 * Convolution of signals A and reverse(B). (In our case, the filter response 1665 * is symmetric, so the reversing doesn't matter.) 1666 * A is taken to be in 0.16 fixed-point, and B is taken to be in 2.30 fixed-point. 1667 * The answer will be in 16.16 fixed-point, unclipped. 1668 * 1669 * This function would probably be the prime candidate for SIMD conversion if 1670 * you want more speed. 1671 */ 1672 int32_t fir_convolve(const int16_t* a, const int32_t* b, int num_samples) 1673 { 1674 int32_t sum = 1 << 13; 1675 for (int i = 0; i < num_samples; ++i) { 1676 sum += a[i] * (b[i] >> 16); 1677 } 1678 return sum >> 14; 1679 } 1680 1681 /* Clip from 16.16 fixed-point to 0.16 fixed-point. */ 1682 int16_t clip(int32_t x) 1683 { 1684 if (x < -32768) { 1685 return -32768; 1686 } else if (x > 32767) { 1687 return 32767; 1688 } else { 1689 return x; 1690 } 1691 } 1692 1693 /* 1694 * Convert a chunk from 44 kHz to 22 kHz. Will update num_samples_in and num_samples_out 1695 * accordingly, since it may leave input samples in the buffer due to overlap. 1696 * 1697 * Input and output are taken to be in 0.16 fixed-point. 1698 */ 1699 void resample_2_1(int16_t* input, int16_t* output, int* num_samples_in, int* num_samples_out) 1700 { 1701 if (*num_samples_in < (int)NUM_COEFF_22KHZ) { 1702 *num_samples_out = 0; 1703 return; 1704 } 1705 1706 int odd_smp = *num_samples_in & 0x1; 1707 int num_samples = *num_samples_in - odd_smp - OVERLAP_22KHZ; 1708 1709 for (int i = 0; i < num_samples; i += 2) { 1710 output[i / 2] = clip(fir_convolve(input + i, filter_22khz_coeff, NUM_COEFF_22KHZ)); 1711 } 1712 1713 memmove(input, input + num_samples, (OVERLAP_22KHZ + odd_smp) * sizeof(*input)); 1714 *num_samples_out = num_samples / 2; 1715 *num_samples_in = OVERLAP_22KHZ + odd_smp; 1716 } 1717 1718 /* 1719 * 2.30 fixed point FIR filter coefficients for conversion 22050 -> 16000, 1720 * or 11025 -> 8000. 1721 * 1722 * Transition band from about 14 kHz, passband ripple < 0.1 dB, 1723 * stopband ripple at about -50 dB, linear phase. 1724 * 1725 * Design and display in MATLAB or Octave using: 1726 * 1727 * filter = fir1(23, 16000 / 22050); filter = round(filter * 2**30); freqz(filter * 2**-30); 1728 */ 1729 static const int32_t filter_16khz_coeff[] = { 1730 2057290, -2973608, 1880478, 4362037, 1731 -14639744, 18523609, -1609189, -38502470, 1732 78073125, -68353935, -59103896, 617555440, 1733 617555440, -59103896, -68353935, 78073125, 1734 -38502470, -1609189, 18523609, -14639744, 1735 4362037, 1880478, -2973608, 2057290, 1736 }; 1737 #define NUM_COEFF_16KHZ (sizeof(filter_16khz_coeff) / sizeof(filter_16khz_coeff[0])) 1738 #define OVERLAP_16KHZ (NUM_COEFF_16KHZ - 1) 1739 1740 /* 1741 * Convert a chunk from 22 kHz to 16 kHz. Will update num_samples_in and 1742 * num_samples_out accordingly, since it may leave input samples in the buffer 1743 * due to overlap. 1744 * 1745 * This implementation is rather ad-hoc; it first low-pass filters the data 1746 * into a temporary buffer, and then converts chunks of 441 input samples at a 1747 * time into 320 output samples by simple linear interpolation. A better 1748 * implementation would use a polyphase filter bank to do these two operations 1749 * in one step. 1750 * 1751 * Input and output are taken to be in 0.16 fixed-point. 1752 */ 1753 1754 #define RESAMPLE_16KHZ_SAMPLES_IN 441 1755 #define RESAMPLE_16KHZ_SAMPLES_OUT 320 1756 1757 void resample_441_320(int16_t* input, int16_t* output, int* num_samples_in, int* num_samples_out) 1758 { 1759 const int num_blocks = (*num_samples_in - OVERLAP_16KHZ) / RESAMPLE_16KHZ_SAMPLES_IN; 1760 if (num_blocks < 1) { 1761 *num_samples_out = 0; 1762 return; 1763 } 1764 1765 for (int i = 0; i < num_blocks; ++i) { 1766 uint32_t tmp[RESAMPLE_16KHZ_SAMPLES_IN]; 1767 for (int j = 0; j < RESAMPLE_16KHZ_SAMPLES_IN; ++j) { 1768 tmp[j] = fir_convolve(input + i * RESAMPLE_16KHZ_SAMPLES_IN + j, 1769 filter_16khz_coeff, 1770 NUM_COEFF_16KHZ); 1771 } 1772 1773 const float step_float = (float)RESAMPLE_16KHZ_SAMPLES_IN / (float)RESAMPLE_16KHZ_SAMPLES_OUT; 1774 1775 uint32_t in_sample_num = 0; // 16.16 fixed point 1776 const uint32_t step = (uint32_t)(step_float * 65536.0f + 0.5f); // 16.16 fixed point 1777 for (int j = 0; j < RESAMPLE_16KHZ_SAMPLES_OUT; ++j, in_sample_num += step) { 1778 const uint32_t whole = in_sample_num >> 16; 1779 const uint32_t frac = (in_sample_num & 0xffff); // 0.16 fixed point 1780 const int32_t s1 = tmp[whole]; 1781 const int32_t s2 = tmp[whole + 1]; 1782 *output++ = clip(s1 + (((s2 - s1) * (int32_t)frac) >> 16)); 1783 } 1784 } 1785 1786 const int samples_consumed = num_blocks * RESAMPLE_16KHZ_SAMPLES_IN; 1787 memmove(input, input + samples_consumed, (*num_samples_in - samples_consumed) * sizeof(*input)); 1788 *num_samples_in -= samples_consumed; 1789 *num_samples_out = RESAMPLE_16KHZ_SAMPLES_OUT * num_blocks; 1790 } 1791 1792 1793 AudioHardware::DownSampler::DownSampler(uint32_t outSampleRate, 1794 uint32_t channelCount, 1795 uint32_t frameCount, 1796 AudioHardware::BufferProvider* provider) 1797 : mStatus(NO_INIT), mProvider(provider), mSampleRate(outSampleRate), 1798 mChannelCount(channelCount), mFrameCount(frameCount), 1799 mInLeft(NULL), mInRight(NULL), mTmpLeft(NULL), mTmpRight(NULL), 1800 mTmp2Left(NULL), mTmp2Right(NULL), mOutLeft(NULL), mOutRight(NULL) 1801 1802 { 1803 LOGV("AudioHardware::DownSampler() cstor %p SR %d channels %d frames %d", 1804 this, mSampleRate, mChannelCount, mFrameCount); 1805 1806 if (mSampleRate != 8000 && mSampleRate != 11025 && mSampleRate != 16000 && 1807 mSampleRate != 22050) { 1808 LOGW("AudioHardware::DownSampler cstor: bad sampling rate: %d", mSampleRate); 1809 return; 1810 } 1811 1812 mInLeft = new int16_t[mFrameCount]; 1813 mInRight = new int16_t[mFrameCount]; 1814 mTmpLeft = new int16_t[mFrameCount]; 1815 mTmpRight = new int16_t[mFrameCount]; 1816 mTmp2Left = new int16_t[mFrameCount]; 1817 mTmp2Right = new int16_t[mFrameCount]; 1818 mOutLeft = new int16_t[mFrameCount]; 1819 mOutRight = new int16_t[mFrameCount]; 1820 1821 mStatus = NO_ERROR; 1822 } 1823 1824 AudioHardware::DownSampler::~DownSampler() 1825 { 1826 if (mInLeft) delete[] mInLeft; 1827 if (mInRight) delete[] mInRight; 1828 if (mTmpLeft) delete[] mTmpLeft; 1829 if (mTmpRight) delete[] mTmpRight; 1830 if (mTmp2Left) delete[] mTmp2Left; 1831 if (mTmp2Right) delete[] mTmp2Right; 1832 if (mOutLeft) delete[] mOutLeft; 1833 if (mOutRight) delete[] mOutRight; 1834 } 1835 1836 void AudioHardware::DownSampler::reset() 1837 { 1838 mInInBuf = 0; 1839 mInTmpBuf = 0; 1840 mInTmp2Buf = 0; 1841 mOutBufPos = 0; 1842 mInOutBuf = 0; 1843 } 1844 1845 1846 int AudioHardware::DownSampler::resample(int16_t* out, size_t *outFrameCount) 1847 { 1848 if (mStatus != NO_ERROR) { 1849 return mStatus; 1850 } 1851 1852 if (out == NULL || outFrameCount == NULL) { 1853 return BAD_VALUE; 1854 } 1855 1856 int16_t *outLeft = mTmp2Left; 1857 int16_t *outRight = mTmp2Left; 1858 if (mSampleRate == 22050) { 1859 outLeft = mTmpLeft; 1860 outRight = mTmpRight; 1861 } else if (mSampleRate == 8000){ 1862 outLeft = mOutLeft; 1863 outRight = mOutRight; 1864 } 1865 1866 int outFrames = 0; 1867 int remaingFrames = *outFrameCount; 1868 1869 if (mInOutBuf) { 1870 int frames = (remaingFrames > mInOutBuf) ? mInOutBuf : remaingFrames; 1871 1872 for (int i = 0; i < frames; ++i) { 1873 out[i] = outLeft[mOutBufPos + i]; 1874 } 1875 if (mChannelCount == 2) { 1876 for (int i = 0; i < frames; ++i) { 1877 out[i * 2] = outLeft[mOutBufPos + i]; 1878 out[i * 2 + 1] = outRight[mOutBufPos + i]; 1879 } 1880 } 1881 remaingFrames -= frames; 1882 mInOutBuf -= frames; 1883 mOutBufPos += frames; 1884 outFrames += frames; 1885 } 1886 1887 while (remaingFrames) { 1888 LOGW_IF((mInOutBuf != 0), "mInOutBuf should be 0 here"); 1889 1890 AudioHardware::BufferProvider::Buffer buf; 1891 buf.frameCount = mFrameCount - mInInBuf; 1892 int ret = mProvider->getNextBuffer(&buf); 1893 if (buf.raw == NULL) { 1894 *outFrameCount = outFrames; 1895 return ret; 1896 } 1897 1898 for (size_t i = 0; i < buf.frameCount; ++i) { 1899 mInLeft[i + mInInBuf] = buf.i16[i]; 1900 } 1901 if (mChannelCount == 2) { 1902 for (size_t i = 0; i < buf.frameCount; ++i) { 1903 mInLeft[i + mInInBuf] = buf.i16[i * 2]; 1904 mInRight[i + mInInBuf] = buf.i16[i * 2 + 1]; 1905 } 1906 } 1907 mInInBuf += buf.frameCount; 1908 mProvider->releaseBuffer(&buf); 1909 1910 /* 44010 -> 22050 */ 1911 { 1912 int samples_in_left = mInInBuf; 1913 int samples_out_left; 1914 resample_2_1(mInLeft, mTmpLeft + mInTmpBuf, &samples_in_left, &samples_out_left); 1915 1916 if (mChannelCount == 2) { 1917 int samples_in_right = mInInBuf; 1918 int samples_out_right; 1919 resample_2_1(mInRight, mTmpRight + mInTmpBuf, &samples_in_right, &samples_out_right); 1920 } 1921 1922 mInInBuf = samples_in_left; 1923 mInTmpBuf += samples_out_left; 1924 mInOutBuf = samples_out_left; 1925 } 1926 1927 if (mSampleRate == 11025 || mSampleRate == 8000) { 1928 /* 22050 - > 11025 */ 1929 int samples_in_left = mInTmpBuf; 1930 int samples_out_left; 1931 resample_2_1(mTmpLeft, mTmp2Left + mInTmp2Buf, &samples_in_left, &samples_out_left); 1932 1933 if (mChannelCount == 2) { 1934 int samples_in_right = mInTmpBuf; 1935 int samples_out_right; 1936 resample_2_1(mTmpRight, mTmp2Right + mInTmp2Buf, &samples_in_right, &samples_out_right); 1937 } 1938 1939 1940 mInTmpBuf = samples_in_left; 1941 mInTmp2Buf += samples_out_left; 1942 mInOutBuf = samples_out_left; 1943 1944 if (mSampleRate == 8000) { 1945 /* 11025 -> 8000*/ 1946 int samples_in_left = mInTmp2Buf; 1947 int samples_out_left; 1948 resample_441_320(mTmp2Left, mOutLeft, &samples_in_left, &samples_out_left); 1949 1950 if (mChannelCount == 2) { 1951 int samples_in_right = mInTmp2Buf; 1952 int samples_out_right; 1953 resample_441_320(mTmp2Right, mOutRight, &samples_in_right, &samples_out_right); 1954 } 1955 1956 mInTmp2Buf = samples_in_left; 1957 mInOutBuf = samples_out_left; 1958 } else { 1959 mInTmp2Buf = 0; 1960 } 1961 1962 } else if (mSampleRate == 16000) { 1963 /* 22050 -> 16000*/ 1964 int samples_in_left = mInTmpBuf; 1965 int samples_out_left; 1966 resample_441_320(mTmpLeft, mTmp2Left, &samples_in_left, &samples_out_left); 1967 1968 if (mChannelCount == 2) { 1969 int samples_in_right = mInTmpBuf; 1970 int samples_out_right; 1971 resample_441_320(mTmpRight, mTmp2Right, &samples_in_right, &samples_out_right); 1972 } 1973 1974 mInTmpBuf = samples_in_left; 1975 mInOutBuf = samples_out_left; 1976 } else { 1977 mInTmpBuf = 0; 1978 } 1979 1980 int frames = (remaingFrames > mInOutBuf) ? mInOutBuf : remaingFrames; 1981 1982 for (int i = 0; i < frames; ++i) { 1983 out[outFrames + i] = outLeft[i]; 1984 } 1985 if (mChannelCount == 2) { 1986 for (int i = 0; i < frames; ++i) { 1987 out[(outFrames + i) * 2] = outLeft[i]; 1988 out[(outFrames + i) * 2 + 1] = outRight[i]; 1989 } 1990 } 1991 remaingFrames -= frames; 1992 outFrames += frames; 1993 mOutBufPos = frames; 1994 mInOutBuf -= frames; 1995 } 1996 1997 return 0; 1998 } 1999 2000 2001 2002 2003 2004 2005 2006 //------------------------------------------------------------------------------ 2007 // Factory 2008 //------------------------------------------------------------------------------ 2009 2010 extern "C" AudioHardwareInterface* createAudioHardware(void) { 2011 return new AudioHardware(); 2012 } 2013 2014 }; // namespace android 2015
