1 /* 2 * Copyright (C) 2007 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 //#define LOG_NDEBUG 0 18 #define LOG_TAG "SoundPool" 19 #include <utils/Log.h> 20 21 //#define USE_SHARED_MEM_BUFFER 22 23 // XXX needed for timing latency 24 #include <utils/Timers.h> 25 26 #include <sys/resource.h> 27 #include <media/AudioTrack.h> 28 #include <media/mediaplayer.h> 29 30 #include "SoundPool.h" 31 #include "SoundPoolThread.h" 32 33 namespace android 34 { 35 36 int kDefaultBufferCount = 4; 37 uint32_t kMaxSampleRate = 48000; 38 uint32_t kDefaultSampleRate = 44100; 39 uint32_t kDefaultFrameCount = 1200; 40 41 SoundPool::SoundPool(int maxChannels, int streamType, int srcQuality) 42 { 43 LOGV("SoundPool constructor: maxChannels=%d, streamType=%d, srcQuality=%d", 44 maxChannels, streamType, srcQuality); 45 46 // check limits 47 mMaxChannels = maxChannels; 48 if (mMaxChannels < 1) { 49 mMaxChannels = 1; 50 } 51 else if (mMaxChannels > 32) { 52 mMaxChannels = 32; 53 } 54 LOGW_IF(maxChannels != mMaxChannels, "App requested %d channels", maxChannels); 55 56 mQuit = false; 57 mDecodeThread = 0; 58 mStreamType = streamType; 59 mSrcQuality = srcQuality; 60 mAllocated = 0; 61 mNextSampleID = 0; 62 mNextChannelID = 0; 63 64 mCallback = 0; 65 mUserData = 0; 66 67 mChannelPool = new SoundChannel[mMaxChannels]; 68 for (int i = 0; i < mMaxChannels; ++i) { 69 mChannelPool[i].init(this); 70 mChannels.push_back(&mChannelPool[i]); 71 } 72 73 // start decode thread 74 startThreads(); 75 } 76 77 SoundPool::~SoundPool() 78 { 79 LOGV("SoundPool destructor"); 80 mDecodeThread->quit(); 81 quit(); 82 83 Mutex::Autolock lock(&mLock); 84 mChannels.clear(); 85 if (mChannelPool) 86 delete [] mChannelPool; 87 88 // clean up samples 89 LOGV("clear samples"); 90 mSamples.clear(); 91 92 if (mDecodeThread) 93 delete mDecodeThread; 94 } 95 96 void SoundPool::addToRestartList(SoundChannel* channel) 97 { 98 Mutex::Autolock lock(&mRestartLock); 99 mRestart.push_back(channel); 100 mCondition.signal(); 101 } 102 103 int SoundPool::beginThread(void* arg) 104 { 105 SoundPool* p = (SoundPool*)arg; 106 return p->run(); 107 } 108 109 int SoundPool::run() 110 { 111 mRestartLock.lock(); 112 while (!mQuit) { 113 mCondition.wait(mRestartLock); 114 LOGV("awake"); 115 if (mQuit) break; 116 117 while (!mRestart.empty()) { 118 SoundChannel* channel; 119 LOGV("Getting channel from list"); 120 List<SoundChannel*>::iterator iter = mRestart.begin(); 121 channel = *iter; 122 mRestart.erase(iter); 123 if (channel) channel->nextEvent(); 124 if (mQuit) break; 125 } 126 } 127 128 mRestart.clear(); 129 mCondition.signal(); 130 mRestartLock.unlock(); 131 LOGV("goodbye"); 132 return 0; 133 } 134 135 void SoundPool::quit() 136 { 137 mRestartLock.lock(); 138 mQuit = true; 139 mCondition.signal(); 140 mCondition.wait(mRestartLock); 141 LOGV("return from quit"); 142 mRestartLock.unlock(); 143 } 144 145 bool SoundPool::startThreads() 146 { 147 createThreadEtc(beginThread, this, "SoundPool"); 148 if (mDecodeThread == NULL) 149 mDecodeThread = new SoundPoolThread(this); 150 return mDecodeThread != NULL; 151 } 152 153 SoundChannel* SoundPool::findChannel(int channelID) 154 { 155 for (int i = 0; i < mMaxChannels; ++i) { 156 if (mChannelPool[i].channelID() == channelID) { 157 return &mChannelPool[i]; 158 } 159 } 160 return NULL; 161 } 162 163 SoundChannel* SoundPool::findNextChannel(int channelID) 164 { 165 for (int i = 0; i < mMaxChannels; ++i) { 166 if (mChannelPool[i].nextChannelID() == channelID) { 167 return &mChannelPool[i]; 168 } 169 } 170 return NULL; 171 } 172 173 int SoundPool::load(const char* path, int priority) 174 { 175 LOGV("load: path=%s, priority=%d", path, priority); 176 Mutex::Autolock lock(&mLock); 177 sp<Sample> sample = new Sample(++mNextSampleID, path); 178 mSamples.add(sample->sampleID(), sample); 179 doLoad(sample); 180 return sample->sampleID(); 181 } 182 183 int SoundPool::load(int fd, int64_t offset, int64_t length, int priority) 184 { 185 LOGV("load: fd=%d, offset=%lld, length=%lld, priority=%d", 186 fd, offset, length, priority); 187 Mutex::Autolock lock(&mLock); 188 sp<Sample> sample = new Sample(++mNextSampleID, fd, offset, length); 189 mSamples.add(sample->sampleID(), sample); 190 doLoad(sample); 191 return sample->sampleID(); 192 } 193 194 void SoundPool::doLoad(sp<Sample>& sample) 195 { 196 LOGV("doLoad: loading sample sampleID=%d", sample->sampleID()); 197 sample->startLoad(); 198 mDecodeThread->loadSample(sample->sampleID()); 199 } 200 201 bool SoundPool::unload(int sampleID) 202 { 203 LOGV("unload: sampleID=%d", sampleID); 204 Mutex::Autolock lock(&mLock); 205 return mSamples.removeItem(sampleID); 206 } 207 208 int SoundPool::play(int sampleID, float leftVolume, float rightVolume, 209 int priority, int loop, float rate) 210 { 211 LOGV("sampleID=%d, leftVolume=%f, rightVolume=%f, priority=%d, loop=%d, rate=%f", 212 sampleID, leftVolume, rightVolume, priority, loop, rate); 213 sp<Sample> sample; 214 SoundChannel* channel; 215 int channelID; 216 217 // scope for lock 218 { 219 Mutex::Autolock lock(&mLock); 220 221 // is sample ready? 222 sample = findSample(sampleID); 223 if ((sample == 0) || (sample->state() != Sample::READY)) { 224 LOGW(" sample %d not READY", sampleID); 225 return 0; 226 } 227 228 dump(); 229 230 // allocate a channel 231 channel = allocateChannel(priority); 232 233 // no channel allocated - return 0 234 if (!channel) { 235 LOGV("No channel allocated"); 236 return 0; 237 } 238 239 channelID = ++mNextChannelID; 240 } 241 242 LOGV("channel state = %d", channel->state()); 243 channel->play(sample, channelID, leftVolume, rightVolume, priority, loop, rate); 244 return channelID; 245 } 246 247 SoundChannel* SoundPool::allocateChannel(int priority) 248 { 249 List<SoundChannel*>::iterator iter; 250 SoundChannel* channel = NULL; 251 252 // allocate a channel 253 if (!mChannels.empty()) { 254 iter = mChannels.begin(); 255 if (priority >= (*iter)->priority()) { 256 channel = *iter; 257 mChannels.erase(iter); 258 LOGV("Allocated active channel"); 259 } 260 } 261 262 // update priority and put it back in the list 263 if (channel) { 264 channel->setPriority(priority); 265 for (iter = mChannels.begin(); iter != mChannels.end(); ++iter) { 266 if (priority < (*iter)->priority()) { 267 break; 268 } 269 } 270 mChannels.insert(iter, channel); 271 } 272 return channel; 273 } 274 275 // move a channel from its current position to the front of the list 276 void SoundPool::moveToFront(SoundChannel* channel) 277 { 278 for (List<SoundChannel*>::iterator iter = mChannels.begin(); iter != mChannels.end(); ++iter) { 279 if (*iter == channel) { 280 mChannels.erase(iter); 281 mChannels.push_front(channel); 282 break; 283 } 284 } 285 } 286 287 void SoundPool::pause(int channelID) 288 { 289 LOGV("pause(%d)", channelID); 290 Mutex::Autolock lock(&mLock); 291 SoundChannel* channel = findChannel(channelID); 292 if (channel) { 293 channel->pause(); 294 } 295 } 296 297 void SoundPool::autoPause() 298 { 299 LOGV("autoPause()"); 300 Mutex::Autolock lock(&mLock); 301 for (int i = 0; i < mMaxChannels; ++i) { 302 SoundChannel* channel = &mChannelPool[i]; 303 channel->autoPause(); 304 } 305 } 306 307 void SoundPool::resume(int channelID) 308 { 309 LOGV("resume(%d)", channelID); 310 Mutex::Autolock lock(&mLock); 311 SoundChannel* channel = findChannel(channelID); 312 if (channel) { 313 channel->resume(); 314 } 315 } 316 317 void SoundPool::autoResume() 318 { 319 LOGV("autoResume()"); 320 Mutex::Autolock lock(&mLock); 321 for (int i = 0; i < mMaxChannels; ++i) { 322 SoundChannel* channel = &mChannelPool[i]; 323 channel->autoResume(); 324 } 325 } 326 327 void SoundPool::stop(int channelID) 328 { 329 LOGV("stop(%d)", channelID); 330 Mutex::Autolock lock(&mLock); 331 SoundChannel* channel = findChannel(channelID); 332 if (channel) { 333 channel->stop(); 334 } else { 335 channel = findNextChannel(channelID); 336 if (channel) 337 channel->clearNextEvent(); 338 } 339 } 340 341 void SoundPool::setVolume(int channelID, float leftVolume, float rightVolume) 342 { 343 Mutex::Autolock lock(&mLock); 344 SoundChannel* channel = findChannel(channelID); 345 if (channel) { 346 channel->setVolume(leftVolume, rightVolume); 347 } 348 } 349 350 void SoundPool::setPriority(int channelID, int priority) 351 { 352 LOGV("setPriority(%d, %d)", channelID, priority); 353 Mutex::Autolock lock(&mLock); 354 SoundChannel* channel = findChannel(channelID); 355 if (channel) { 356 channel->setPriority(priority); 357 } 358 } 359 360 void SoundPool::setLoop(int channelID, int loop) 361 { 362 LOGV("setLoop(%d, %d)", channelID, loop); 363 Mutex::Autolock lock(&mLock); 364 SoundChannel* channel = findChannel(channelID); 365 if (channel) { 366 channel->setLoop(loop); 367 } 368 } 369 370 void SoundPool::setRate(int channelID, float rate) 371 { 372 LOGV("setRate(%d, %f)", channelID, rate); 373 Mutex::Autolock lock(&mLock); 374 SoundChannel* channel = findChannel(channelID); 375 if (channel) { 376 channel->setRate(rate); 377 } 378 } 379 380 // call with lock held 381 void SoundPool::done(SoundChannel* channel) 382 { 383 LOGV("done(%d)", channel->channelID()); 384 385 // if "stolen", play next event 386 if (channel->nextChannelID() != 0) { 387 LOGV("add to restart list"); 388 addToRestartList(channel); 389 } 390 391 // return to idle state 392 else { 393 LOGV("move to front"); 394 moveToFront(channel); 395 } 396 } 397 398 void SoundPool::setCallback(SoundPoolCallback* callback, void* user) 399 { 400 Mutex::Autolock lock(&mCallbackLock); 401 mCallback = callback; 402 mUserData = user; 403 } 404 405 void SoundPool::notify(SoundPoolEvent event) 406 { 407 Mutex::Autolock lock(&mCallbackLock); 408 if (mCallback != NULL) { 409 mCallback(event, this, mUserData); 410 } 411 } 412 413 void SoundPool::dump() 414 { 415 for (int i = 0; i < mMaxChannels; ++i) { 416 mChannelPool[i].dump(); 417 } 418 } 419 420 421 Sample::Sample(int sampleID, const char* url) 422 { 423 init(); 424 mSampleID = sampleID; 425 mUrl = strdup(url); 426 LOGV("create sampleID=%d, url=%s", mSampleID, mUrl); 427 } 428 429 Sample::Sample(int sampleID, int fd, int64_t offset, int64_t length) 430 { 431 init(); 432 mSampleID = sampleID; 433 mFd = dup(fd); 434 mOffset = offset; 435 mLength = length; 436 LOGV("create sampleID=%d, fd=%d, offset=%lld, length=%lld", mSampleID, mFd, mLength, mOffset); 437 } 438 439 void Sample::init() 440 { 441 mData = 0; 442 mSize = 0; 443 mRefCount = 0; 444 mSampleID = 0; 445 mState = UNLOADED; 446 mFd = -1; 447 mOffset = 0; 448 mLength = 0; 449 mUrl = 0; 450 } 451 452 Sample::~Sample() 453 { 454 LOGV("Sample::destructor sampleID=%d, fd=%d", mSampleID, mFd); 455 if (mFd > 0) { 456 LOGV("close(%d)", mFd); 457 ::close(mFd); 458 } 459 mData.clear(); 460 delete mUrl; 461 } 462 463 status_t Sample::doLoad() 464 { 465 uint32_t sampleRate; 466 int numChannels; 467 int format; 468 sp<IMemory> p; 469 LOGV("Start decode"); 470 if (mUrl) { 471 p = MediaPlayer::decode(mUrl, &sampleRate, &numChannels, &format); 472 } else { 473 p = MediaPlayer::decode(mFd, mOffset, mLength, &sampleRate, &numChannels, &format); 474 LOGV("close(%d)", mFd); 475 ::close(mFd); 476 mFd = -1; 477 } 478 if (p == 0) { 479 LOGE("Unable to load sample: %s", mUrl); 480 return -1; 481 } 482 LOGV("pointer = %p, size = %u, sampleRate = %u, numChannels = %d", 483 p->pointer(), p->size(), sampleRate, numChannels); 484 485 if (sampleRate > kMaxSampleRate) { 486 LOGE("Sample rate (%u) out of range", sampleRate); 487 return - 1; 488 } 489 490 if ((numChannels < 1) || (numChannels > 2)) { 491 LOGE("Sample channel count (%d) out of range", numChannels); 492 return - 1; 493 } 494 495 //_dumpBuffer(p->pointer(), p->size()); 496 uint8_t* q = static_cast<uint8_t*>(p->pointer()) + p->size() - 10; 497 //_dumpBuffer(q, 10, 10, false); 498 499 mData = p; 500 mSize = p->size(); 501 mSampleRate = sampleRate; 502 mNumChannels = numChannels; 503 mFormat = format; 504 mState = READY; 505 return 0; 506 } 507 508 509 void SoundChannel::init(SoundPool* soundPool) 510 { 511 mSoundPool = soundPool; 512 } 513 514 void SoundChannel::play(const sp<Sample>& sample, int nextChannelID, float leftVolume, 515 float rightVolume, int priority, int loop, float rate) 516 { 517 AudioTrack* oldTrack; 518 519 LOGV("play %p: sampleID=%d, channelID=%d, leftVolume=%f, rightVolume=%f, priority=%d, loop=%d, rate=%f", 520 this, sample->sampleID(), nextChannelID, leftVolume, rightVolume, priority, loop, rate); 521 522 // if not idle, this voice is being stolen 523 if (mState != IDLE) { 524 LOGV("channel %d stolen - event queued for channel %d", channelID(), nextChannelID); 525 mNextEvent.set(sample, nextChannelID, leftVolume, rightVolume, priority, loop, rate); 526 stop(); 527 return; 528 } 529 530 // initialize track 531 int afFrameCount; 532 int afSampleRate; 533 int streamType = mSoundPool->streamType(); 534 if (AudioSystem::getOutputFrameCount(&afFrameCount, streamType) != NO_ERROR) { 535 afFrameCount = kDefaultFrameCount; 536 } 537 if (AudioSystem::getOutputSamplingRate(&afSampleRate, streamType) != NO_ERROR) { 538 afSampleRate = kDefaultSampleRate; 539 } 540 int numChannels = sample->numChannels(); 541 uint32_t sampleRate = uint32_t(float(sample->sampleRate()) * rate + 0.5); 542 uint32_t totalFrames = (kDefaultBufferCount * afFrameCount * sampleRate) / afSampleRate; 543 uint32_t bufferFrames = (totalFrames + (kDefaultBufferCount - 1)) / kDefaultBufferCount; 544 uint32_t frameCount = 0; 545 546 if (loop) { 547 frameCount = sample->size()/numChannels/((sample->format() == AudioSystem::PCM_16_BIT) ? sizeof(int16_t) : sizeof(uint8_t)); 548 } 549 550 #ifndef USE_SHARED_MEM_BUFFER 551 // Ensure minimum audio buffer size in case of short looped sample 552 if(frameCount < totalFrames) { 553 frameCount = totalFrames; 554 } 555 #endif 556 557 AudioTrack* newTrack; 558 559 // mToggle toggles each time a track is started on a given channel. 560 // The toggle is concatenated with the SoundChannel address and passed to AudioTrack 561 // as callback user data. This enables the detection of callbacks received from the old 562 // audio track while the new one is being started and avoids processing them with 563 // wrong audio audio buffer size (mAudioBufferSize) 564 unsigned long toggle = mToggle ^ 1; 565 void *userData = (void *)((unsigned long)this | toggle); 566 uint32_t channels = (numChannels == 2) ? AudioSystem::CHANNEL_OUT_STEREO : AudioSystem::CHANNEL_OUT_MONO; 567 568 #ifdef USE_SHARED_MEM_BUFFER 569 newTrack = new AudioTrack(streamType, sampleRate, sample->format(), 570 channels, sample->getIMemory(), 0, callback, userData); 571 #else 572 newTrack = new AudioTrack(streamType, sampleRate, sample->format(), 573 channels, frameCount, 0, callback, userData, bufferFrames); 574 #endif 575 if (newTrack->initCheck() != NO_ERROR) { 576 LOGE("Error creating AudioTrack"); 577 delete newTrack; 578 return; 579 } 580 LOGV("setVolume %p", newTrack); 581 newTrack->setVolume(leftVolume, rightVolume); 582 newTrack->setLoop(0, frameCount, loop); 583 584 { 585 Mutex::Autolock lock(&mLock); 586 // From now on, AudioTrack callbacks recevieved with previous toggle value will be ignored. 587 mToggle = toggle; 588 oldTrack = mAudioTrack; 589 mAudioTrack = newTrack; 590 mPos = 0; 591 mSample = sample; 592 mChannelID = nextChannelID; 593 mPriority = priority; 594 mLoop = loop; 595 mLeftVolume = leftVolume; 596 mRightVolume = rightVolume; 597 mNumChannels = numChannels; 598 mRate = rate; 599 clearNextEvent(); 600 mState = PLAYING; 601 mAudioTrack->start(); 602 mAudioBufferSize = newTrack->frameCount()*newTrack->frameSize(); 603 } 604 605 LOGV("delete oldTrack %p", oldTrack); 606 delete oldTrack; 607 } 608 609 void SoundChannel::nextEvent() 610 { 611 sp<Sample> sample; 612 int nextChannelID; 613 float leftVolume; 614 float rightVolume; 615 int priority; 616 int loop; 617 float rate; 618 619 // check for valid event 620 { 621 Mutex::Autolock lock(&mLock); 622 nextChannelID = mNextEvent.channelID(); 623 if (nextChannelID == 0) { 624 LOGV("stolen channel has no event"); 625 return; 626 } 627 628 sample = mNextEvent.sample(); 629 leftVolume = mNextEvent.leftVolume(); 630 rightVolume = mNextEvent.rightVolume(); 631 priority = mNextEvent.priority(); 632 loop = mNextEvent.loop(); 633 rate = mNextEvent.rate(); 634 } 635 636 LOGV("Starting stolen channel %d -> %d", channelID(), nextChannelID); 637 play(sample, nextChannelID, leftVolume, rightVolume, priority, loop, rate); 638 } 639 640 void SoundChannel::callback(int event, void* user, void *info) 641 { 642 unsigned long toggle = (unsigned long)user & 1; 643 SoundChannel* channel = static_cast<SoundChannel*>((void *)((unsigned long)user & ~1)); 644 645 if (channel->mToggle != toggle) { 646 LOGV("callback with wrong toggle"); 647 return; 648 } 649 channel->process(event, info); 650 } 651 652 void SoundChannel::process(int event, void *info) 653 { 654 //LOGV("process(%d)", mChannelID); 655 sp<Sample> sample = mSample; 656 657 // LOGV("SoundChannel::process event %d", event); 658 659 if (event == AudioTrack::EVENT_MORE_DATA) { 660 AudioTrack::Buffer* b = static_cast<AudioTrack::Buffer *>(info); 661 662 // check for stop state 663 if (b->size == 0) return; 664 665 if (sample != 0) { 666 // fill buffer 667 uint8_t* q = (uint8_t*) b->i8; 668 size_t count = 0; 669 670 if (mPos < (int)sample->size()) { 671 uint8_t* p = sample->data() + mPos; 672 count = sample->size() - mPos; 673 if (count > b->size) { 674 count = b->size; 675 } 676 memcpy(q, p, count); 677 LOGV("fill: q=%p, p=%p, mPos=%u, b->size=%u, count=%d", q, p, mPos, b->size, count); 678 } else if (mPos < mAudioBufferSize) { 679 count = mAudioBufferSize - mPos; 680 if (count > b->size) { 681 count = b->size; 682 } 683 memset(q, 0, count); 684 LOGV("fill extra: q=%p, mPos=%u, b->size=%u, count=%d", q, mPos, b->size, count); 685 } 686 687 mPos += count; 688 b->size = count; 689 //LOGV("buffer=%p, [0]=%d", b->i16, b->i16[0]); 690 } 691 } else if (event == AudioTrack::EVENT_UNDERRUN) { 692 LOGV("stopping track"); 693 stop(); 694 } else if (event == AudioTrack::EVENT_LOOP_END) { 695 LOGV("End loop: %d", *(int *)info); 696 } 697 } 698 699 700 // call with lock held 701 void SoundChannel::stop_l() 702 { 703 if (mState != IDLE) { 704 setVolume_l(0, 0); 705 LOGV("stop"); 706 mAudioTrack->stop(); 707 mSample.clear(); 708 mState = IDLE; 709 mPriority = IDLE_PRIORITY; 710 } 711 } 712 713 void SoundChannel::stop() 714 { 715 { 716 Mutex::Autolock lock(&mLock); 717 stop_l(); 718 } 719 mSoundPool->done(this); 720 } 721 722 //FIXME: Pause is a little broken right now 723 void SoundChannel::pause() 724 { 725 Mutex::Autolock lock(&mLock); 726 if (mState == PLAYING) { 727 LOGV("pause track"); 728 mState = PAUSED; 729 mAudioTrack->pause(); 730 } 731 } 732 733 void SoundChannel::autoPause() 734 { 735 Mutex::Autolock lock(&mLock); 736 if (mState == PLAYING) { 737 LOGV("pause track"); 738 mState = PAUSED; 739 mAutoPaused = true; 740 mAudioTrack->pause(); 741 } 742 } 743 744 void SoundChannel::resume() 745 { 746 Mutex::Autolock lock(&mLock); 747 if (mState == PAUSED) { 748 LOGV("resume track"); 749 mState = PLAYING; 750 mAutoPaused = false; 751 mAudioTrack->start(); 752 } 753 } 754 755 void SoundChannel::autoResume() 756 { 757 Mutex::Autolock lock(&mLock); 758 if (mAutoPaused && (mState == PAUSED)) { 759 LOGV("resume track"); 760 mState = PLAYING; 761 mAutoPaused = false; 762 mAudioTrack->start(); 763 } 764 } 765 766 void SoundChannel::setRate(float rate) 767 { 768 Mutex::Autolock lock(&mLock); 769 if (mAudioTrack != 0 && mSample.get() != 0) { 770 uint32_t sampleRate = uint32_t(float(mSample->sampleRate()) * rate + 0.5); 771 mAudioTrack->setSampleRate(sampleRate); 772 mRate = rate; 773 } 774 } 775 776 // call with lock held 777 void SoundChannel::setVolume_l(float leftVolume, float rightVolume) 778 { 779 mLeftVolume = leftVolume; 780 mRightVolume = rightVolume; 781 if (mAudioTrack != 0) mAudioTrack->setVolume(leftVolume, rightVolume); 782 } 783 784 void SoundChannel::setVolume(float leftVolume, float rightVolume) 785 { 786 Mutex::Autolock lock(&mLock); 787 setVolume_l(leftVolume, rightVolume); 788 } 789 790 void SoundChannel::setLoop(int loop) 791 { 792 Mutex::Autolock lock(&mLock); 793 if (mAudioTrack != 0 && mSample.get() != 0) { 794 mAudioTrack->setLoop(0, mSample->size()/mNumChannels/((mSample->format() == AudioSystem::PCM_16_BIT) ? sizeof(int16_t) : sizeof(uint8_t)), loop); 795 mLoop = loop; 796 } 797 } 798 799 SoundChannel::~SoundChannel() 800 { 801 LOGV("SoundChannel destructor"); 802 if (mAudioTrack) { 803 LOGV("stop track"); 804 mAudioTrack->stop(); 805 delete mAudioTrack; 806 } 807 clearNextEvent(); 808 mSample.clear(); 809 } 810 811 void SoundChannel::dump() 812 { 813 LOGV("mState = %d mChannelID=%d, mNumChannels=%d, mPos = %d, mPriority=%d, mLoop=%d", 814 mState, mChannelID, mNumChannels, mPos, mPriority, mLoop); 815 } 816 817 void SoundEvent::set(const sp<Sample>& sample, int channelID, float leftVolume, 818 float rightVolume, int priority, int loop, float rate) 819 { 820 mSample =sample; 821 mChannelID = channelID; 822 mLeftVolume = leftVolume; 823 mRightVolume = rightVolume; 824 mPriority = priority; 825 mLoop = loop; 826 mRate =rate; 827 } 828 829 } // end namespace android 830