AudioRecord.cpp revision 58f30210ea540b6ce5aa6a46330cd3499483cb97
1/* 2** 3** Copyright 2008, The Android Open Source Project 4** 5** Licensed under the Apache License, Version 2.0 (the "License"); 6** you may not use this file except in compliance with the License. 7** You may obtain a copy of the License at 8** 9** http://www.apache.org/licenses/LICENSE-2.0 10** 11** Unless required by applicable law or agreed to in writing, software 12** distributed under the License is distributed on an "AS IS" BASIS, 13** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14** See the License for the specific language governing permissions and 15** limitations under the License. 16*/ 17 18//#define LOG_NDEBUG 0 19#define LOG_TAG "AudioRecord" 20 21#include <stdint.h> 22#include <sys/types.h> 23 24#include <sched.h> 25#include <sys/resource.h> 26 27#include <private/media/AudioTrackShared.h> 28 29#include <media/AudioSystem.h> 30#include <media/AudioRecord.h> 31#include <media/mediarecorder.h> 32 33#include <binder/IServiceManager.h> 34#include <utils/Log.h> 35#include <binder/Parcel.h> 36#include <binder/IPCThreadState.h> 37#include <utils/Timers.h> 38#include <utils/Atomic.h> 39 40#include <system/audio.h> 41#include <cutils/bitops.h> 42#include <cutils/compiler.h> 43 44namespace android { 45// --------------------------------------------------------------------------- 46 47// static 48status_t AudioRecord::getMinFrameCount( 49 int* frameCount, 50 uint32_t sampleRate, 51 audio_format_t format, 52 int channelCount) 53{ 54 size_t size = 0; 55 if (AudioSystem::getInputBufferSize(sampleRate, format, channelCount, &size) 56 != NO_ERROR) { 57 ALOGE("AudioSystem could not query the input buffer size."); 58 return NO_INIT; 59 } 60 61 if (size == 0) { 62 ALOGE("Unsupported configuration: sampleRate %d, format %d, channelCount %d", 63 sampleRate, format, channelCount); 64 return BAD_VALUE; 65 } 66 67 // We double the size of input buffer for ping pong use of record buffer. 68 size <<= 1; 69 70 if (audio_is_linear_pcm(format)) { 71 size /= channelCount * audio_bytes_per_sample(format); 72 } 73 74 *frameCount = size; 75 return NO_ERROR; 76} 77 78// --------------------------------------------------------------------------- 79 80AudioRecord::AudioRecord() 81 : mStatus(NO_INIT), mSessionId(0), 82 mPreviousPriority(ANDROID_PRIORITY_NORMAL), mPreviousSchedulingGroup(ANDROID_TGROUP_DEFAULT) 83{ 84} 85 86AudioRecord::AudioRecord( 87 int inputSource, 88 uint32_t sampleRate, 89 audio_format_t format, 90 uint32_t channelMask, 91 int frameCount, 92 uint32_t flags, 93 callback_t cbf, 94 void* user, 95 int notificationFrames, 96 int sessionId) 97 : mStatus(NO_INIT), mSessionId(0), 98 mPreviousPriority(ANDROID_PRIORITY_NORMAL), mPreviousSchedulingGroup(ANDROID_TGROUP_DEFAULT) 99{ 100 mStatus = set(inputSource, sampleRate, format, channelMask, 101 frameCount, flags, cbf, user, notificationFrames, sessionId); 102} 103 104AudioRecord::~AudioRecord() 105{ 106 if (mStatus == NO_ERROR) { 107 // Make sure that callback function exits in the case where 108 // it is looping on buffer empty condition in obtainBuffer(). 109 // Otherwise the callback thread will never exit. 110 stop(); 111 if (mClientRecordThread != 0) { 112 mClientRecordThread->requestExitAndWait(); 113 mClientRecordThread.clear(); 114 } 115 mAudioRecord.clear(); 116 IPCThreadState::self()->flushCommands(); 117 AudioSystem::releaseAudioSessionId(mSessionId); 118 } 119} 120 121status_t AudioRecord::set( 122 int inputSource, 123 uint32_t sampleRate, 124 audio_format_t format, 125 uint32_t channelMask, 126 int frameCount, 127 uint32_t flags, 128 callback_t cbf, 129 void* user, 130 int notificationFrames, 131 bool threadCanCallJava, 132 int sessionId) 133{ 134 135 ALOGV("set(): sampleRate %d, channelMask %d, frameCount %d",sampleRate, channelMask, frameCount); 136 137 AutoMutex lock(mLock); 138 139 if (mAudioRecord != 0) { 140 return INVALID_OPERATION; 141 } 142 143 if (inputSource == AUDIO_SOURCE_DEFAULT) { 144 inputSource = AUDIO_SOURCE_MIC; 145 } 146 147 if (sampleRate == 0) { 148 sampleRate = DEFAULT_SAMPLE_RATE; 149 } 150 // these below should probably come from the audioFlinger too... 151 if (format == AUDIO_FORMAT_DEFAULT) { 152 format = AUDIO_FORMAT_PCM_16_BIT; 153 } 154 // validate parameters 155 if (!audio_is_valid_format(format)) { 156 ALOGE("Invalid format"); 157 return BAD_VALUE; 158 } 159 160 if (!audio_is_input_channel(channelMask)) { 161 return BAD_VALUE; 162 } 163 164 int channelCount = popcount(channelMask); 165 166 if (sessionId == 0 ) { 167 mSessionId = AudioSystem::newAudioSessionId(); 168 } else { 169 mSessionId = sessionId; 170 } 171 ALOGV("set(): mSessionId %d", mSessionId); 172 173 audio_io_handle_t input = AudioSystem::getInput(inputSource, 174 sampleRate, 175 format, 176 channelMask, 177 (audio_in_acoustics_t)flags, 178 mSessionId); 179 if (input == 0) { 180 ALOGE("Could not get audio input for record source %d", inputSource); 181 return BAD_VALUE; 182 } 183 184 // validate framecount 185 int minFrameCount = 0; 186 status_t status = getMinFrameCount(&minFrameCount, sampleRate, format, channelCount); 187 if (status != NO_ERROR) { 188 return status; 189 } 190 ALOGV("AudioRecord::set() minFrameCount = %d", minFrameCount); 191 192 if (frameCount == 0) { 193 frameCount = minFrameCount; 194 } else if (frameCount < minFrameCount) { 195 return BAD_VALUE; 196 } 197 198 if (notificationFrames == 0) { 199 notificationFrames = frameCount/2; 200 } 201 202 // create the IAudioRecord 203 status = openRecord_l(sampleRate, format, channelMask, 204 frameCount, flags, input); 205 if (status != NO_ERROR) { 206 return status; 207 } 208 209 if (cbf != 0) { 210 mClientRecordThread = new ClientRecordThread(*this, threadCanCallJava); 211 } 212 213 mStatus = NO_ERROR; 214 215 mFormat = format; 216 // Update buffer size in case it has been limited by AudioFlinger during track creation 217 mFrameCount = mCblk->frameCount; 218 mChannelCount = (uint8_t)channelCount; 219 mChannelMask = channelMask; 220 mActive = 0; 221 mCbf = cbf; 222 mNotificationFrames = notificationFrames; 223 mRemainingFrames = notificationFrames; 224 mUserData = user; 225 // TODO: add audio hardware input latency here 226 mLatency = (1000*mFrameCount) / sampleRate; 227 mMarkerPosition = 0; 228 mMarkerReached = false; 229 mNewPosition = 0; 230 mUpdatePeriod = 0; 231 mInputSource = (uint8_t)inputSource; 232 mFlags = flags; 233 mInput = input; 234 AudioSystem::acquireAudioSessionId(mSessionId); 235 236 return NO_ERROR; 237} 238 239status_t AudioRecord::initCheck() const 240{ 241 return mStatus; 242} 243 244// ------------------------------------------------------------------------- 245 246uint32_t AudioRecord::latency() const 247{ 248 return mLatency; 249} 250 251audio_format_t AudioRecord::format() const 252{ 253 return mFormat; 254} 255 256int AudioRecord::channelCount() const 257{ 258 return mChannelCount; 259} 260 261uint32_t AudioRecord::frameCount() const 262{ 263 return mFrameCount; 264} 265 266size_t AudioRecord::frameSize() const 267{ 268 if (audio_is_linear_pcm(mFormat)) { 269 return channelCount()*audio_bytes_per_sample(mFormat); 270 } else { 271 return sizeof(uint8_t); 272 } 273} 274 275int AudioRecord::inputSource() const 276{ 277 return (int)mInputSource; 278} 279 280// ------------------------------------------------------------------------- 281 282status_t AudioRecord::start() 283{ 284 status_t ret = NO_ERROR; 285 sp<ClientRecordThread> t = mClientRecordThread; 286 287 ALOGV("start"); 288 289 if (t != 0) { 290 if (t->exitPending()) { 291 if (t->requestExitAndWait() == WOULD_BLOCK) { 292 ALOGE("AudioRecord::start called from thread"); 293 return WOULD_BLOCK; 294 } 295 } 296 t->mLock.lock(); 297 } 298 299 AutoMutex lock(mLock); 300 // acquire a strong reference on the IAudioRecord and IMemory so that they cannot be destroyed 301 // while we are accessing the cblk 302 sp <IAudioRecord> audioRecord = mAudioRecord; 303 sp <IMemory> iMem = mCblkMemory; 304 audio_track_cblk_t* cblk = mCblk; 305 if (mActive == 0) { 306 mActive = 1; 307 308 cblk->lock.lock(); 309 if (!(cblk->flags & CBLK_INVALID_MSK)) { 310 cblk->lock.unlock(); 311 ret = mAudioRecord->start(); 312 cblk->lock.lock(); 313 if (ret == DEAD_OBJECT) { 314 android_atomic_or(CBLK_INVALID_ON, &cblk->flags); 315 } 316 } 317 if (cblk->flags & CBLK_INVALID_MSK) { 318 ret = restoreRecord_l(cblk); 319 } 320 cblk->lock.unlock(); 321 if (ret == NO_ERROR) { 322 mNewPosition = cblk->user + mUpdatePeriod; 323 cblk->bufferTimeoutMs = MAX_RUN_TIMEOUT_MS; 324 cblk->waitTimeMs = 0; 325 if (t != 0) { 326 t->run("ClientRecordThread", ANDROID_PRIORITY_AUDIO); 327 } else { 328 mPreviousPriority = getpriority(PRIO_PROCESS, 0); 329 mPreviousSchedulingGroup = androidGetThreadSchedulingGroup(0); 330 androidSetThreadPriority(0, ANDROID_PRIORITY_AUDIO); 331 } 332 } else { 333 mActive = 0; 334 } 335 } 336 337 if (t != 0) { 338 t->mLock.unlock(); 339 } 340 341 return ret; 342} 343 344status_t AudioRecord::stop() 345{ 346 sp<ClientRecordThread> t = mClientRecordThread; 347 348 ALOGV("stop"); 349 350 if (t != 0) { 351 t->mLock.lock(); 352 } 353 354 AutoMutex lock(mLock); 355 if (mActive == 1) { 356 mActive = 0; 357 mCblk->cv.signal(); 358 mAudioRecord->stop(); 359 // the record head position will reset to 0, so if a marker is set, we need 360 // to activate it again 361 mMarkerReached = false; 362 if (t != 0) { 363 t->requestExit(); 364 } else { 365 setpriority(PRIO_PROCESS, 0, mPreviousPriority); 366 androidSetThreadSchedulingGroup(0, mPreviousSchedulingGroup); 367 } 368 } 369 370 if (t != 0) { 371 t->mLock.unlock(); 372 } 373 374 return NO_ERROR; 375} 376 377bool AudioRecord::stopped() const 378{ 379 return !mActive; 380} 381 382uint32_t AudioRecord::getSampleRate() 383{ 384 AutoMutex lock(mLock); 385 return mCblk->sampleRate; 386} 387 388status_t AudioRecord::setMarkerPosition(uint32_t marker) 389{ 390 if (mCbf == 0) return INVALID_OPERATION; 391 392 mMarkerPosition = marker; 393 mMarkerReached = false; 394 395 return NO_ERROR; 396} 397 398status_t AudioRecord::getMarkerPosition(uint32_t *marker) 399{ 400 if (marker == 0) return BAD_VALUE; 401 402 *marker = mMarkerPosition; 403 404 return NO_ERROR; 405} 406 407status_t AudioRecord::setPositionUpdatePeriod(uint32_t updatePeriod) 408{ 409 if (mCbf == 0) return INVALID_OPERATION; 410 411 uint32_t curPosition; 412 getPosition(&curPosition); 413 mNewPosition = curPosition + updatePeriod; 414 mUpdatePeriod = updatePeriod; 415 416 return NO_ERROR; 417} 418 419status_t AudioRecord::getPositionUpdatePeriod(uint32_t *updatePeriod) 420{ 421 if (updatePeriod == 0) return BAD_VALUE; 422 423 *updatePeriod = mUpdatePeriod; 424 425 return NO_ERROR; 426} 427 428status_t AudioRecord::getPosition(uint32_t *position) 429{ 430 if (position == 0) return BAD_VALUE; 431 432 AutoMutex lock(mLock); 433 *position = mCblk->user; 434 435 return NO_ERROR; 436} 437 438unsigned int AudioRecord::getInputFramesLost() 439{ 440 if (mActive) 441 return AudioSystem::getInputFramesLost(mInput); 442 else 443 return 0; 444} 445 446// ------------------------------------------------------------------------- 447 448// must be called with mLock held 449status_t AudioRecord::openRecord_l( 450 uint32_t sampleRate, 451 audio_format_t format, 452 uint32_t channelMask, 453 int frameCount, 454 uint32_t flags, 455 audio_io_handle_t input) 456{ 457 status_t status; 458 const sp<IAudioFlinger>& audioFlinger = AudioSystem::get_audio_flinger(); 459 if (audioFlinger == 0) { 460 return NO_INIT; 461 } 462 463 sp<IAudioRecord> record = audioFlinger->openRecord(getpid(), input, 464 sampleRate, format, 465 channelMask, 466 frameCount, 467 ((uint16_t)flags) << 16, 468 &mSessionId, 469 &status); 470 471 if (record == 0) { 472 ALOGE("AudioFlinger could not create record track, status: %d", status); 473 return status; 474 } 475 sp<IMemory> cblk = record->getCblk(); 476 if (cblk == 0) { 477 ALOGE("Could not get control block"); 478 return NO_INIT; 479 } 480 mAudioRecord.clear(); 481 mAudioRecord = record; 482 mCblkMemory.clear(); 483 mCblkMemory = cblk; 484 mCblk = static_cast<audio_track_cblk_t*>(cblk->pointer()); 485 mCblk->buffers = (char*)mCblk + sizeof(audio_track_cblk_t); 486 android_atomic_and(~CBLK_DIRECTION_MSK, &mCblk->flags); 487 mCblk->bufferTimeoutMs = MAX_RUN_TIMEOUT_MS; 488 mCblk->waitTimeMs = 0; 489 return NO_ERROR; 490} 491 492status_t AudioRecord::obtainBuffer(Buffer* audioBuffer, int32_t waitCount) 493{ 494 AutoMutex lock(mLock); 495 int active; 496 status_t result = NO_ERROR; 497 audio_track_cblk_t* cblk = mCblk; 498 uint32_t framesReq = audioBuffer->frameCount; 499 uint32_t waitTimeMs = (waitCount < 0) ? cblk->bufferTimeoutMs : WAIT_PERIOD_MS; 500 501 audioBuffer->frameCount = 0; 502 audioBuffer->size = 0; 503 504 uint32_t framesReady = cblk->framesReady(); 505 506 if (framesReady == 0) { 507 cblk->lock.lock(); 508 goto start_loop_here; 509 while (framesReady == 0) { 510 active = mActive; 511 if (CC_UNLIKELY(!active)) { 512 cblk->lock.unlock(); 513 return NO_MORE_BUFFERS; 514 } 515 if (CC_UNLIKELY(!waitCount)) { 516 cblk->lock.unlock(); 517 return WOULD_BLOCK; 518 } 519 if (!(cblk->flags & CBLK_INVALID_MSK)) { 520 mLock.unlock(); 521 result = cblk->cv.waitRelative(cblk->lock, milliseconds(waitTimeMs)); 522 cblk->lock.unlock(); 523 mLock.lock(); 524 if (mActive == 0) { 525 return status_t(STOPPED); 526 } 527 cblk->lock.lock(); 528 } 529 if (cblk->flags & CBLK_INVALID_MSK) { 530 goto create_new_record; 531 } 532 if (CC_UNLIKELY(result != NO_ERROR)) { 533 cblk->waitTimeMs += waitTimeMs; 534 if (cblk->waitTimeMs >= cblk->bufferTimeoutMs) { 535 ALOGW( "obtainBuffer timed out (is the CPU pegged?) " 536 "user=%08x, server=%08x", cblk->user, cblk->server); 537 cblk->lock.unlock(); 538 result = mAudioRecord->start(); 539 cblk->lock.lock(); 540 if (result == DEAD_OBJECT) { 541 android_atomic_or(CBLK_INVALID_ON, &cblk->flags); 542create_new_record: 543 result = AudioRecord::restoreRecord_l(cblk); 544 } 545 if (result != NO_ERROR) { 546 ALOGW("obtainBuffer create Track error %d", result); 547 cblk->lock.unlock(); 548 return result; 549 } 550 cblk->waitTimeMs = 0; 551 } 552 if (--waitCount == 0) { 553 cblk->lock.unlock(); 554 return TIMED_OUT; 555 } 556 } 557 // read the server count again 558 start_loop_here: 559 framesReady = cblk->framesReady(); 560 } 561 cblk->lock.unlock(); 562 } 563 564 cblk->waitTimeMs = 0; 565 566 if (framesReq > framesReady) { 567 framesReq = framesReady; 568 } 569 570 uint32_t u = cblk->user; 571 uint32_t bufferEnd = cblk->userBase + cblk->frameCount; 572 573 if (u + framesReq > bufferEnd) { 574 framesReq = bufferEnd - u; 575 } 576 577 audioBuffer->flags = 0; 578 audioBuffer->channelCount= mChannelCount; 579 audioBuffer->format = mFormat; 580 audioBuffer->frameCount = framesReq; 581 audioBuffer->size = framesReq*cblk->frameSize; 582 audioBuffer->raw = (int8_t*)cblk->buffer(u); 583 active = mActive; 584 return active ? status_t(NO_ERROR) : status_t(STOPPED); 585} 586 587void AudioRecord::releaseBuffer(Buffer* audioBuffer) 588{ 589 AutoMutex lock(mLock); 590 mCblk->stepUser(audioBuffer->frameCount); 591} 592 593audio_io_handle_t AudioRecord::getInput() 594{ 595 AutoMutex lock(mLock); 596 return mInput; 597} 598 599// must be called with mLock held 600audio_io_handle_t AudioRecord::getInput_l() 601{ 602 mInput = AudioSystem::getInput(mInputSource, 603 mCblk->sampleRate, 604 mFormat, 605 mChannelMask, 606 (audio_in_acoustics_t)mFlags, 607 mSessionId); 608 return mInput; 609} 610 611int AudioRecord::getSessionId() 612{ 613 return mSessionId; 614} 615 616// ------------------------------------------------------------------------- 617 618ssize_t AudioRecord::read(void* buffer, size_t userSize) 619{ 620 ssize_t read = 0; 621 Buffer audioBuffer; 622 int8_t *dst = static_cast<int8_t*>(buffer); 623 624 if (ssize_t(userSize) < 0) { 625 // sanity-check. user is most-likely passing an error code. 626 ALOGE("AudioRecord::read(buffer=%p, size=%u (%d)", 627 buffer, userSize, userSize); 628 return BAD_VALUE; 629 } 630 631 mLock.lock(); 632 // acquire a strong reference on the IAudioRecord and IMemory so that they cannot be destroyed 633 // while we are accessing the cblk 634 sp <IAudioRecord> audioRecord = mAudioRecord; 635 sp <IMemory> iMem = mCblkMemory; 636 mLock.unlock(); 637 638 do { 639 640 audioBuffer.frameCount = userSize/frameSize(); 641 642 // By using a wait count corresponding to twice the timeout period in 643 // obtainBuffer() we give a chance to recover once for a read timeout 644 // (if media_server crashed for instance) before returning a length of 645 // 0 bytes read to the client 646 status_t err = obtainBuffer(&audioBuffer, ((2 * MAX_RUN_TIMEOUT_MS) / WAIT_PERIOD_MS)); 647 if (err < 0) { 648 // out of buffers, return #bytes written 649 if (err == status_t(NO_MORE_BUFFERS)) 650 break; 651 if (err == status_t(TIMED_OUT)) 652 err = 0; 653 return ssize_t(err); 654 } 655 656 size_t bytesRead = audioBuffer.size; 657 memcpy(dst, audioBuffer.i8, bytesRead); 658 659 dst += bytesRead; 660 userSize -= bytesRead; 661 read += bytesRead; 662 663 releaseBuffer(&audioBuffer); 664 } while (userSize); 665 666 return read; 667} 668 669// ------------------------------------------------------------------------- 670 671bool AudioRecord::processAudioBuffer(const sp<ClientRecordThread>& thread) 672{ 673 Buffer audioBuffer; 674 uint32_t frames = mRemainingFrames; 675 size_t readSize; 676 677 mLock.lock(); 678 // acquire a strong reference on the IAudioRecord and IMemory so that they cannot be destroyed 679 // while we are accessing the cblk 680 sp <IAudioRecord> audioRecord = mAudioRecord; 681 sp <IMemory> iMem = mCblkMemory; 682 audio_track_cblk_t* cblk = mCblk; 683 mLock.unlock(); 684 685 // Manage marker callback 686 if (!mMarkerReached && (mMarkerPosition > 0)) { 687 if (cblk->user >= mMarkerPosition) { 688 mCbf(EVENT_MARKER, mUserData, (void *)&mMarkerPosition); 689 mMarkerReached = true; 690 } 691 } 692 693 // Manage new position callback 694 if (mUpdatePeriod > 0) { 695 while (cblk->user >= mNewPosition) { 696 mCbf(EVENT_NEW_POS, mUserData, (void *)&mNewPosition); 697 mNewPosition += mUpdatePeriod; 698 } 699 } 700 701 do { 702 audioBuffer.frameCount = frames; 703 // Calling obtainBuffer() with a wait count of 1 704 // limits wait time to WAIT_PERIOD_MS. This prevents from being 705 // stuck here not being able to handle timed events (position, markers). 706 status_t err = obtainBuffer(&audioBuffer, 1); 707 if (err < NO_ERROR) { 708 if (err != TIMED_OUT) { 709 ALOGE_IF(err != status_t(NO_MORE_BUFFERS), "Error obtaining an audio buffer, giving up."); 710 return false; 711 } 712 break; 713 } 714 if (err == status_t(STOPPED)) return false; 715 716 size_t reqSize = audioBuffer.size; 717 mCbf(EVENT_MORE_DATA, mUserData, &audioBuffer); 718 readSize = audioBuffer.size; 719 720 // Sanity check on returned size 721 if (ssize_t(readSize) <= 0) { 722 // The callback is done filling buffers 723 // Keep this thread going to handle timed events and 724 // still try to get more data in intervals of WAIT_PERIOD_MS 725 // but don't just loop and block the CPU, so wait 726 usleep(WAIT_PERIOD_MS*1000); 727 break; 728 } 729 if (readSize > reqSize) readSize = reqSize; 730 731 audioBuffer.size = readSize; 732 audioBuffer.frameCount = readSize/frameSize(); 733 frames -= audioBuffer.frameCount; 734 735 releaseBuffer(&audioBuffer); 736 737 } while (frames); 738 739 740 // Manage overrun callback 741 if (mActive && (cblk->framesAvailable() == 0)) { 742 ALOGV("Overrun user: %x, server: %x, flags %04x", cblk->user, cblk->server, cblk->flags); 743 if (!(android_atomic_or(CBLK_UNDERRUN_ON, &cblk->flags) & CBLK_UNDERRUN_MSK)) { 744 mCbf(EVENT_OVERRUN, mUserData, 0); 745 } 746 } 747 748 if (frames == 0) { 749 mRemainingFrames = mNotificationFrames; 750 } else { 751 mRemainingFrames = frames; 752 } 753 return true; 754} 755 756// must be called with mLock and cblk.lock held. Callers must also hold strong references on 757// the IAudioRecord and IMemory in case they are recreated here. 758// If the IAudioRecord is successfully restored, the cblk pointer is updated 759status_t AudioRecord::restoreRecord_l(audio_track_cblk_t*& cblk) 760{ 761 status_t result; 762 763 if (!(android_atomic_or(CBLK_RESTORING_ON, &cblk->flags) & CBLK_RESTORING_MSK)) { 764 ALOGW("dead IAudioRecord, creating a new one"); 765 // signal old cblk condition so that other threads waiting for available buffers stop 766 // waiting now 767 cblk->cv.broadcast(); 768 cblk->lock.unlock(); 769 770 // if the new IAudioRecord is created, openRecord_l() will modify the 771 // following member variables: mAudioRecord, mCblkMemory and mCblk. 772 // It will also delete the strong references on previous IAudioRecord and IMemory 773 result = openRecord_l(cblk->sampleRate, mFormat, mChannelMask, 774 mFrameCount, mFlags, getInput_l()); 775 if (result == NO_ERROR) { 776 result = mAudioRecord->start(); 777 } 778 if (result != NO_ERROR) { 779 mActive = false; 780 } 781 782 // signal old cblk condition for other threads waiting for restore completion 783 android_atomic_or(CBLK_RESTORED_ON, &cblk->flags); 784 cblk->cv.broadcast(); 785 } else { 786 if (!(cblk->flags & CBLK_RESTORED_MSK)) { 787 ALOGW("dead IAudioRecord, waiting for a new one to be created"); 788 mLock.unlock(); 789 result = cblk->cv.waitRelative(cblk->lock, milliseconds(RESTORE_TIMEOUT_MS)); 790 cblk->lock.unlock(); 791 mLock.lock(); 792 } else { 793 ALOGW("dead IAudioRecord, already restored"); 794 result = NO_ERROR; 795 cblk->lock.unlock(); 796 } 797 if (result != NO_ERROR || mActive == 0) { 798 result = status_t(STOPPED); 799 } 800 } 801 ALOGV("restoreRecord_l() status %d mActive %d cblk %p, old cblk %p flags %08x old flags %08x", 802 result, mActive, mCblk, cblk, mCblk->flags, cblk->flags); 803 804 if (result == NO_ERROR) { 805 // from now on we switch to the newly created cblk 806 cblk = mCblk; 807 } 808 cblk->lock.lock(); 809 810 ALOGW_IF(result != NO_ERROR, "restoreRecord_l() error %d", result); 811 812 return result; 813} 814 815// ========================================================================= 816 817AudioRecord::ClientRecordThread::ClientRecordThread(AudioRecord& receiver, bool bCanCallJava) 818 : Thread(bCanCallJava), mReceiver(receiver) 819{ 820} 821 822bool AudioRecord::ClientRecordThread::threadLoop() 823{ 824 return mReceiver.processAudioBuffer(this); 825} 826 827// ------------------------------------------------------------------------- 828 829}; // namespace android 830 831