| /* //device/extlibs/pv/android/AudioTrack.cpp |
| ** |
| ** Copyright 2007, The Android Open Source Project |
| ** |
| ** Licensed under the Apache License, Version 2.0 (the "License"); |
| ** you may not use this file except in compliance with the License. |
| ** You may obtain a copy of the License at |
| ** |
| ** http://www.apache.org/licenses/LICENSE-2.0 |
| ** |
| ** Unless required by applicable law or agreed to in writing, software |
| ** distributed under the License is distributed on an "AS IS" BASIS, |
| ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| ** See the License for the specific language governing permissions and |
| ** limitations under the License. |
| */ |
| |
| |
| //#define LOG_NDEBUG 0 |
| #define LOG_TAG "AudioTrack" |
| |
| #include <stdint.h> |
| #include <sys/types.h> |
| |
| #include <sched.h> |
| #include <sys/resource.h> |
| |
| #include <private/media/AudioTrackShared.h> |
| |
| #include <media/AudioSystem.h> |
| #include <media/AudioTrack.h> |
| |
| #include <utils/Log.h> |
| #include <utils/MemoryDealer.h> |
| #include <utils/Parcel.h> |
| #include <utils/IPCThreadState.h> |
| #include <utils/Timers.h> |
| #include <cutils/atomic.h> |
| |
| #define LIKELY( exp ) (__builtin_expect( (exp) != 0, true )) |
| #define UNLIKELY( exp ) (__builtin_expect( (exp) != 0, false )) |
| |
| namespace android { |
| |
| // --------------------------------------------------------------------------- |
| |
| static volatile size_t gFrameCount = 0; |
| |
| size_t AudioTrack::frameCount() |
| { |
| if (gFrameCount) return gFrameCount; |
| const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger(); |
| if (af == 0) return PERMISSION_DENIED; |
| gFrameCount = af->frameCount(); |
| return gFrameCount; |
| } |
| |
| // --------------------------------------------------------------------------- |
| |
| AudioTrack::AudioTrack() |
| : mStatus(NO_INIT) |
| { |
| } |
| |
| AudioTrack::AudioTrack( |
| int streamType, |
| uint32_t sampleRate, |
| int format, |
| int channelCount, |
| int bufferCount, |
| uint32_t flags, |
| callback_t cbf, void* user) |
| : mStatus(NO_INIT) |
| { |
| mStatus = set(streamType, sampleRate, format, channelCount, |
| bufferCount, flags, cbf, user); |
| } |
| |
| AudioTrack::~AudioTrack() |
| { |
| if (mStatus == NO_ERROR) { |
| if (mPosition) { |
| releaseBuffer(&mAudioBuffer); |
| } |
| // obtainBuffer() will give up with an error |
| mAudioTrack->stop(); |
| if (mAudioTrackThread != 0) { |
| mAudioTrackThread->requestExitAndWait(); |
| mAudioTrackThread.clear(); |
| } |
| mAudioTrack.clear(); |
| IPCThreadState::self()->flushCommands(); |
| } |
| } |
| |
| status_t AudioTrack::set( |
| int streamType, |
| uint32_t sampleRate, |
| int format, |
| int channelCount, |
| int bufferCount, |
| uint32_t flags, |
| callback_t cbf, void* user) |
| { |
| |
| if (mAudioFlinger != 0) { |
| LOGE("Track already in use"); |
| return INVALID_OPERATION; |
| } |
| |
| const sp<IAudioFlinger>& audioFlinger = AudioSystem::get_audio_flinger(); |
| if (audioFlinger == 0) { |
| LOGE("Could not get audioflinger"); |
| return NO_INIT; |
| } |
| |
| // handle default values first. |
| if (streamType == DEFAULT) { |
| streamType = MUSIC; |
| } |
| if (sampleRate == 0) { |
| sampleRate = audioFlinger->sampleRate(); |
| } |
| // these below should probably come from the audioFlinger too... |
| if (format == 0) { |
| format = AudioSystem::PCM_16_BIT; |
| } |
| if (channelCount == 0) { |
| channelCount = 2; |
| } |
| if (bufferCount == 0) { |
| bufferCount = 2; |
| } |
| |
| // validate parameters |
| if (format != AudioSystem::PCM_16_BIT) { |
| LOGE("Invalid format"); |
| return BAD_VALUE; |
| } |
| if (channelCount != 1 && channelCount != 2) { |
| LOGE("Invalid channel number"); |
| return BAD_VALUE; |
| } |
| if (bufferCount < 2) { |
| LOGE("Invalid buffer count"); |
| return BAD_VALUE; |
| } |
| |
| // create the track |
| sp<IAudioTrack> track = audioFlinger->createTrack(getpid(), |
| streamType, sampleRate, format, channelCount, bufferCount, flags); |
| if (track == 0) { |
| LOGE("AudioFlinger could not create track"); |
| return NO_INIT; |
| } |
| sp<IMemory> cblk = track->getCblk(); |
| if (cblk == 0) { |
| LOGE("Could not get control block"); |
| return NO_INIT; |
| } |
| if (cbf != 0) { |
| mAudioTrackThread = new AudioTrackThread(*this); |
| if (mAudioTrackThread == 0) { |
| LOGE("Could not create callback thread"); |
| return NO_INIT; |
| } |
| } |
| |
| mStatus = NO_ERROR; |
| |
| mAudioFlinger = audioFlinger; |
| mAudioTrack = track; |
| mCblkMemory = cblk; |
| mCblk = static_cast<audio_track_cblk_t*>(cblk->pointer()); |
| mCblk->buffers = (char*)mCblk + sizeof(audio_track_cblk_t); |
| mCblk->volume[0] = mCblk->volume[1] = 0x1000; |
| mVolume[LEFT] = 1.0f; |
| mVolume[RIGHT] = 1.0f; |
| mSampleRate = sampleRate; |
| mFrameCount = audioFlinger->frameCount(); |
| mStreamType = streamType; |
| mFormat = format; |
| mBufferCount = bufferCount; |
| mChannelCount = channelCount; |
| mMuted = false; |
| mActive = 0; |
| mReserved = 0; |
| mCbf = cbf; |
| mUserData = user; |
| mLatency = seconds(mFrameCount) / mSampleRate; |
| mPosition = 0; |
| return NO_ERROR; |
| } |
| |
| status_t AudioTrack::initCheck() const |
| { |
| return mStatus; |
| } |
| |
| // ------------------------------------------------------------------------- |
| |
| nsecs_t AudioTrack::latency() const |
| { |
| return mLatency; |
| } |
| |
| int AudioTrack::streamType() const |
| { |
| return mStreamType; |
| } |
| |
| uint32_t AudioTrack::sampleRate() const |
| { |
| return mSampleRate; |
| } |
| |
| int AudioTrack::format() const |
| { |
| return mFormat; |
| } |
| |
| int AudioTrack::channelCount() const |
| { |
| return mChannelCount; |
| } |
| |
| int AudioTrack::bufferCount() const |
| { |
| return mBufferCount; |
| } |
| |
| // ------------------------------------------------------------------------- |
| |
| void AudioTrack::start() |
| { |
| sp<AudioTrackThread> t = mAudioTrackThread; |
| |
| LOGV("start"); |
| if (t != 0) { |
| if (t->exitPending()) { |
| if (t->requestExitAndWait() == WOULD_BLOCK) { |
| LOGE("AudioTrack::start called from thread"); |
| return; |
| } |
| } |
| t->mLock.lock(); |
| } |
| |
| if (android_atomic_or(1, &mActive) == 0) { |
| if (t != 0) { |
| t->run("AudioTrackThread", THREAD_PRIORITY_AUDIO_CLIENT); |
| } else { |
| setpriority(PRIO_PROCESS, 0, THREAD_PRIORITY_AUDIO_CLIENT); |
| } |
| mAudioTrack->start(); |
| } |
| |
| if (t != 0) { |
| t->mLock.unlock(); |
| } |
| } |
| |
| void AudioTrack::stop() |
| { |
| sp<AudioTrackThread> t = mAudioTrackThread; |
| |
| LOGV("stop"); |
| if (t != 0) { |
| t->mLock.lock(); |
| } |
| |
| if (android_atomic_and(~1, &mActive) == 1) { |
| if (mPosition) { |
| releaseBuffer(&mAudioBuffer); |
| } |
| mAudioTrack->stop(); |
| if (t != 0) { |
| t->requestExit(); |
| } else { |
| setpriority(PRIO_PROCESS, 0, ANDROID_PRIORITY_NORMAL); |
| } |
| } |
| |
| if (t != 0) { |
| t->mLock.unlock(); |
| } |
| } |
| |
| bool AudioTrack::stopped() const |
| { |
| return !mActive; |
| } |
| |
| void AudioTrack::flush() |
| { |
| LOGV("flush"); |
| if (!mActive) { |
| mCblk->lock.lock(); |
| mAudioTrack->flush(); |
| // Release AudioTrack callback thread in case it was waiting for new buffers |
| // in AudioTrack::obtainBuffer() |
| mCblk->cv.signal(); |
| mCblk->lock.unlock(); |
| } |
| } |
| |
| void AudioTrack::pause() |
| { |
| LOGV("pause"); |
| if (android_atomic_and(~1, &mActive) == 1) { |
| mActive = 0; |
| mAudioTrack->pause(); |
| } |
| } |
| |
| void AudioTrack::mute(bool e) |
| { |
| mAudioTrack->mute(e); |
| mMuted = e; |
| } |
| |
| bool AudioTrack::muted() const |
| { |
| return mMuted; |
| } |
| |
| void AudioTrack::setVolume(float left, float right) |
| { |
| mVolume[LEFT] = left; |
| mVolume[RIGHT] = right; |
| |
| // write must be atomic |
| mCblk->volumeLR = (int32_t(int16_t(left * 0x1000)) << 16) | int16_t(right * 0x1000); |
| } |
| |
| void AudioTrack::getVolume(float* left, float* right) |
| { |
| *left = mVolume[LEFT]; |
| *right = mVolume[RIGHT]; |
| } |
| |
| void AudioTrack::setSampleRate(int rate) |
| { |
| if (rate > MAX_SAMPLE_RATE) rate = MAX_SAMPLE_RATE; |
| mCblk->sampleRate = rate; |
| } |
| |
| uint32_t AudioTrack::getSampleRate() |
| { |
| return uint32_t(mCblk->sampleRate); |
| } |
| |
| // ------------------------------------------------------------------------- |
| |
| status_t AudioTrack::obtainBuffer(Buffer* audioBuffer, bool blocking) |
| { |
| int active; |
| int timeout = 0; |
| status_t result; |
| audio_track_cblk_t* cblk = mCblk; |
| |
| uint32_t u = cblk->user; |
| uint32_t u_seq = u & audio_track_cblk_t::SEQUENCE_MASK; |
| uint32_t u_buf = u & audio_track_cblk_t::BUFFER_MASK; |
| |
| uint32_t s = cblk->server; |
| uint32_t s_seq = s & audio_track_cblk_t::SEQUENCE_MASK; |
| uint32_t s_buf = s & audio_track_cblk_t::BUFFER_MASK; |
| |
| LOGW_IF(u_seq < s_seq, "user doesn't fill buffers fast enough"); |
| |
| if (u_seq > s_seq && u_buf == s_buf) { |
| Mutex::Autolock _l(cblk->lock); |
| goto start_loop_here; |
| while (u_seq > s_seq && u_buf == s_buf) { |
| active = mActive; |
| if (UNLIKELY(!active)) { |
| LOGV("Not active and NO_MORE_BUFFERS"); |
| return NO_MORE_BUFFERS; |
| } |
| if (UNLIKELY(!blocking)) |
| return WOULD_BLOCK; |
| timeout = 0; |
| result = cblk->cv.waitRelative(cblk->lock, seconds(1)); |
| if (__builtin_expect(result!=NO_ERROR, false)) { |
| LOGW( "obtainBuffer timed out (is the CPU pegged?) " |
| "user=%08x, server=%08x", u, s); |
| mAudioTrack->start(); // FIXME: Wake up audioflinger |
| timeout = 1; |
| } |
| // Read user count in case a flush has reset while we where waiting on cv. |
| u = cblk->user; |
| u_seq = u & audio_track_cblk_t::SEQUENCE_MASK; |
| u_buf = u & audio_track_cblk_t::BUFFER_MASK; |
| |
| // read the server count again |
| start_loop_here: |
| s = cblk->server; |
| s_seq = s & audio_track_cblk_t::SEQUENCE_MASK; |
| s_buf = s & audio_track_cblk_t::BUFFER_MASK; |
| } |
| } |
| |
| LOGW_IF(timeout, |
| "*** SERIOUS WARNING *** obtainBuffer() timed out " |
| "but didn't need to be locked. We recovered, but " |
| "this shouldn't happen (user=%08x, server=%08x)", u, s); |
| |
| audioBuffer->flags = mMuted ? Buffer::MUTE : 0; |
| audioBuffer->channelCount= mChannelCount; |
| audioBuffer->format = mFormat; |
| audioBuffer->frameCount = mFrameCount; |
| audioBuffer->size = cblk->size; |
| audioBuffer->raw = (int8_t *)cblk->buffer(u_buf); |
| active = mActive; |
| return active ? status_t(NO_ERROR) : status_t(STOPPED); |
| } |
| |
| void AudioTrack::releaseBuffer(Buffer* audioBuffer) |
| { |
| // next buffer... |
| if (UNLIKELY(mPosition)) { |
| // clean the remaining part of the buffer |
| size_t capacity = mAudioBuffer.size - mPosition; |
| memset(mAudioBuffer.i8 + mPosition, 0, capacity); |
| mPosition = 0; |
| } |
| audio_track_cblk_t* cblk = mCblk; |
| cblk->stepUser(mBufferCount); |
| } |
| |
| // ------------------------------------------------------------------------- |
| |
| ssize_t AudioTrack::write(const void* buffer, size_t userSize) |
| { |
| if (ssize_t(userSize) < 0) { |
| // sanity-check. user is most-likely passing an error code. |
| LOGE("AudioTrack::write(buffer=%p, size=%u (%d)", |
| buffer, userSize, userSize); |
| return BAD_VALUE; |
| } |
| |
| LOGV("write %d bytes, mActive=%d", userSize, mActive); |
| ssize_t written = 0; |
| do { |
| if (mPosition == 0) { |
| status_t err = obtainBuffer(&mAudioBuffer, true); |
| if (err < 0) { |
| // out of buffers, return #bytes written |
| if (err == status_t(NO_MORE_BUFFERS)) |
| break; |
| return ssize_t(err); |
| } |
| } |
| |
| size_t capacity = mAudioBuffer.size - mPosition; |
| size_t toWrite = userSize < capacity ? userSize : capacity; |
| |
| memcpy(mAudioBuffer.i8 + mPosition, buffer, toWrite); |
| buffer = static_cast<const int8_t*>(buffer) + toWrite; |
| mPosition += toWrite; |
| userSize -= toWrite; |
| capacity -= toWrite; |
| written += toWrite; |
| |
| if (capacity == 0) { |
| mPosition = 0; |
| releaseBuffer(&mAudioBuffer); |
| } |
| } while (userSize); |
| |
| return written; |
| } |
| |
| // ------------------------------------------------------------------------- |
| |
| bool AudioTrack::processAudioBuffer(const sp<AudioTrackThread>& thread) |
| { |
| Buffer audioBuffer; |
| |
| status_t err = obtainBuffer(&audioBuffer, true); |
| if (err < NO_ERROR) { |
| LOGE("Error obtaining an audio buffer, giving up."); |
| return false; |
| } |
| if (err == status_t(STOPPED)) return false; |
| mCbf(mUserData, audioBuffer); |
| releaseBuffer(&audioBuffer); |
| |
| return true; |
| } |
| |
| status_t AudioTrack::dump(int fd, const Vector<String16>& args) const |
| { |
| |
| const size_t SIZE = 256; |
| char buffer[SIZE]; |
| String8 result; |
| |
| result.append(" AudioTrack::dump\n"); |
| snprintf(buffer, 255, " stream type(%d), left - right volume(%f, %f)\n", mStreamType, mVolume[0], mVolume[1]); |
| result.append(buffer); |
| snprintf(buffer, 255, " format(%d), channel count(%d), frame count(%d), buffer count(%d)\n", mFormat, mChannelCount, mFrameCount, mBufferCount); |
| result.append(buffer); |
| snprintf(buffer, 255, " sample rate(%d), status(%d), muted(%d), reserved(%d)\n", mSampleRate, mStatus, mMuted, mReserved); |
| result.append(buffer); |
| snprintf(buffer, 255, " active(%d), latency (%lld), position(%d)\n", mActive, mLatency, mPosition); |
| result.append(buffer); |
| ::write(fd, result.string(), result.size()); |
| return NO_ERROR; |
| } |
| |
| // ========================================================================= |
| |
| AudioTrack::AudioTrackThread::AudioTrackThread(AudioTrack& receiver) |
| : Thread(false), mReceiver(receiver) |
| { |
| } |
| |
| bool AudioTrack::AudioTrackThread::threadLoop() |
| { |
| return mReceiver.processAudioBuffer(this); |
| } |
| |
| status_t AudioTrack::AudioTrackThread::readyToRun() |
| { |
| return NO_ERROR; |
| } |
| |
| void AudioTrack::AudioTrackThread::onFirstRef() |
| { |
| } |
| |
| // ========================================================================= |
| |
| audio_track_cblk_t::audio_track_cblk_t() |
| : user(0), server(0), volumeLR(0), buffers(0), size(0) |
| { |
| } |
| |
| uint32_t audio_track_cblk_t::stepUser(int bufferCount) |
| { |
| uint32_t u = this->user; |
| uint32_t u_seq = u & audio_track_cblk_t::SEQUENCE_MASK; |
| uint32_t u_buf = u & audio_track_cblk_t::BUFFER_MASK; |
| if (++u_buf >= uint32_t(bufferCount)) { |
| u_seq += 0x100; |
| u_buf = 0; |
| } |
| u = u_seq | u_buf; |
| this->user = u; |
| return u; |
| } |
| |
| bool audio_track_cblk_t::stepServer(int bufferCount) |
| { |
| // the code below simulates lock-with-timeout |
| // we MUST do this to protect the AudioFlinger server |
| // as this lock is shared with the client. |
| status_t err; |
| |
| err = lock.tryLock(); |
| if (err == -EBUSY) { // just wait a bit |
| usleep(1000); |
| err = lock.tryLock(); |
| } |
| if (err != NO_ERROR) { |
| // probably, the client just died. |
| return false; |
| } |
| |
| uint32_t s = this->server; |
| uint32_t s_seq = s & audio_track_cblk_t::SEQUENCE_MASK; |
| uint32_t s_buf = s & audio_track_cblk_t::BUFFER_MASK; |
| s_buf++; |
| if (s_buf >= uint32_t(bufferCount)) { |
| s_seq += 0x100; |
| s_buf = 0; |
| } |
| s = s_seq | s_buf; |
| |
| this->server = s; |
| cv.signal(); |
| lock.unlock(); |
| return true; |
| } |
| |
| void* audio_track_cblk_t::buffer(int id) const |
| { |
| return (char*)this->buffers + id * this->size; |
| } |
| |
| // ------------------------------------------------------------------------- |
| |
| }; // namespace android |
| |