media/libmedia/AudioTrack.cpp - platform/frameworks/base - Gitiles

 /* //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
	/* //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