frameworks/base/media/jni/soundpool/SoundPool.cpp

   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