AudioTrack.cpp revision 05632a5fa4b88ca474294887fc92a9fcdf0e2352 
1/* frameworks/base/media/libmedia/AudioTrack.cpp
2**
3** Copyright 2007, The Android Open Source Project
4**
5** Licensed under the Apache License, Version 2.0 (the "License");
6** you may not use this file except in compliance with the License.
7** You may obtain a copy of the License at
8**
9**     http://www.apache.org/licenses/LICENSE-2.0
10**
11** Unless required by applicable law or agreed to in writing, software
12** distributed under the License is distributed on an "AS IS" BASIS,
13** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14** See the License for the specific language governing permissions and
15** limitations under the License.
16*/
17
18
19//#define LOG_NDEBUG 0
20#define LOG_TAG "AudioTrack"
21
22#include <stdint.h>
23#include <sys/types.h>
24#include <limits.h>
25
26#include <sched.h>
27#include <sys/resource.h>
28
29#include <private/media/AudioTrackShared.h>
30
31#include <media/AudioSystem.h>
32#include <media/AudioTrack.h>
33
34#include <utils/Log.h>
35#include <binder/Parcel.h>
36#include <binder/IPCThreadState.h>
37#include <utils/Timers.h>
38#include <utils/Atomic.h>
39
40#include <cutils/bitops.h>
41#include <cutils/compiler.h>
42
43#include <system/audio.h>
44#include <system/audio_policy.h>
45
46namespace android {
47// ---------------------------------------------------------------------------
48
49// static
50status_t AudioTrack::getMinFrameCount(
51        int* frameCount,
52        int streamType,
53        uint32_t sampleRate)
54{
55    int afSampleRate;
56    if (AudioSystem::getOutputSamplingRate(&afSampleRate, streamType) != NO_ERROR) {
57        return NO_INIT;
58    }
59    int afFrameCount;
60    if (AudioSystem::getOutputFrameCount(&afFrameCount, streamType) != NO_ERROR) {
61        return NO_INIT;
62    }
63    uint32_t afLatency;
64    if (AudioSystem::getOutputLatency(&afLatency, streamType) != NO_ERROR) {
65        return NO_INIT;
66    }
67
68    // Ensure that buffer depth covers at least audio hardware latency
69    uint32_t minBufCount = afLatency / ((1000 * afFrameCount) / afSampleRate);
70    if (minBufCount < 2) minBufCount = 2;
71
72    *frameCount = (sampleRate == 0) ? afFrameCount * minBufCount :
73              afFrameCount * minBufCount * sampleRate / afSampleRate;
74    return NO_ERROR;
75}
76
77// ---------------------------------------------------------------------------
78
79AudioTrack::AudioTrack()
80    : mStatus(NO_INIT),
81      mPreviousPriority(ANDROID_PRIORITY_NORMAL), mPreviousSchedulingGroup(ANDROID_TGROUP_DEFAULT)
82{
83}
84
85AudioTrack::AudioTrack(
86        int streamType,
87        uint32_t sampleRate,
88        audio_format_t format,
89        int channelMask,
90        int frameCount,
91        uint32_t flags,
92        callback_t cbf,
93        void* user,
94        int notificationFrames,
95        int sessionId)
96    : mStatus(NO_INIT),
97      mPreviousPriority(ANDROID_PRIORITY_NORMAL), mPreviousSchedulingGroup(ANDROID_TGROUP_DEFAULT)
98{
99    mStatus = set(streamType, sampleRate, format, channelMask,
100            frameCount, flags, cbf, user, notificationFrames,
101            0, false, sessionId);
102}
103
104AudioTrack::AudioTrack(
105        int streamType,
106        uint32_t sampleRate,
107        audio_format_t format,
108        int channelMask,
109        const sp<IMemory>& sharedBuffer,
110        uint32_t flags,
111        callback_t cbf,
112        void* user,
113        int notificationFrames,
114        int sessionId)
115    : mStatus(NO_INIT),
116      mPreviousPriority(ANDROID_PRIORITY_NORMAL), mPreviousSchedulingGroup(ANDROID_TGROUP_DEFAULT)
117{
118    mStatus = set(streamType, sampleRate, format, channelMask,
119            0, flags, cbf, user, notificationFrames,
120            sharedBuffer, false, sessionId);
121}
122
123AudioTrack::~AudioTrack()
124{
125    ALOGV_IF(mSharedBuffer != 0, "Destructor sharedBuffer: %p", mSharedBuffer->pointer());
126
127    if (mStatus == NO_ERROR) {
128        // Make sure that callback function exits in the case where
129        // it is looping on buffer full condition in obtainBuffer().
130        // Otherwise the callback thread will never exit.
131        stop();
132        if (mAudioTrackThread != 0) {
133            mAudioTrackThread->requestExitAndWait();
134            mAudioTrackThread.clear();
135        }
136        mAudioTrack.clear();
137        IPCThreadState::self()->flushCommands();
138        AudioSystem::releaseAudioSessionId(mSessionId);
139    }
140}
141
142status_t AudioTrack::set(
143        int streamType,
144        uint32_t sampleRate,
145        audio_format_t format,
146        int channelMask,
147        int frameCount,
148        uint32_t flags,
149        callback_t cbf,
150        void* user,
151        int notificationFrames,
152        const sp<IMemory>& sharedBuffer,
153        bool threadCanCallJava,
154        int sessionId)
155{
156
157    ALOGV_IF(sharedBuffer != 0, "sharedBuffer: %p, size: %d", sharedBuffer->pointer(), sharedBuffer->size());
158
159    AutoMutex lock(mLock);
160    if (mAudioTrack != 0) {
161        ALOGE("Track already in use");
162        return INVALID_OPERATION;
163    }
164
165    int afSampleRate;
166    if (AudioSystem::getOutputSamplingRate(&afSampleRate, streamType) != NO_ERROR) {
167        return NO_INIT;
168    }
169    uint32_t afLatency;
170    if (AudioSystem::getOutputLatency(&afLatency, streamType) != NO_ERROR) {
171        return NO_INIT;
172    }
173
174    // handle default values first.
175    if (streamType == AUDIO_STREAM_DEFAULT) {
176        streamType = AUDIO_STREAM_MUSIC;
177    }
178    if (sampleRate == 0) {
179        sampleRate = afSampleRate;
180    }
181    // these below should probably come from the audioFlinger too...
182    if (format == AUDIO_FORMAT_DEFAULT) {
183        format = AUDIO_FORMAT_PCM_16_BIT;
184    }
185    if (channelMask == 0) {
186        channelMask = AUDIO_CHANNEL_OUT_STEREO;
187    }
188
189    // validate parameters
190    if (!audio_is_valid_format(format)) {
191        ALOGE("Invalid format");
192        return BAD_VALUE;
193    }
194
195    // force direct flag if format is not linear PCM
196    if (!audio_is_linear_pcm(format)) {
197        flags |= AUDIO_POLICY_OUTPUT_FLAG_DIRECT;
198    }
199
200    if (!audio_is_output_channel(channelMask)) {
201        ALOGE("Invalid channel mask");
202        return BAD_VALUE;
203    }
204    uint32_t channelCount = popcount(channelMask);
205
206    audio_io_handle_t output = AudioSystem::getOutput(
207                                    (audio_stream_type_t)streamType,
208                                    sampleRate, format, channelMask,
209                                    (audio_policy_output_flags_t)flags);
210
211    if (output == 0) {
212        ALOGE("Could not get audio output for stream type %d", streamType);
213        return BAD_VALUE;
214    }
215
216    mVolume[LEFT] = 1.0f;
217    mVolume[RIGHT] = 1.0f;
218    mSendLevel = 0.0f;
219    mFrameCount = frameCount;
220    mNotificationFramesReq = notificationFrames;
221    mSessionId = sessionId;
222    mAuxEffectId = 0;
223
224    // create the IAudioTrack
225    status_t status = createTrack_l(streamType,
226                                  sampleRate,
227                                  format,
228                                  (uint32_t)channelMask,
229                                  frameCount,
230                                  flags,
231                                  sharedBuffer,
232                                  output,
233                                  true);
234
235    if (status != NO_ERROR) {
236        return status;
237    }
238
239    if (cbf != 0) {
240        mAudioTrackThread = new AudioTrackThread(*this, threadCanCallJava);
241    }
242
243    mStatus = NO_ERROR;
244
245    mStreamType = streamType;
246    mFormat = format;
247    mChannelMask = (uint32_t)channelMask;
248    mChannelCount = channelCount;
249    mSharedBuffer = sharedBuffer;
250    mMuted = false;
251    mActive = false;
252    mCbf = cbf;
253    mUserData = user;
254    mLoopCount = 0;
255    mMarkerPosition = 0;
256    mMarkerReached = false;
257    mNewPosition = 0;
258    mUpdatePeriod = 0;
259    mFlushed = false;
260    mFlags = flags;
261    AudioSystem::acquireAudioSessionId(mSessionId);
262    mRestoreStatus = NO_ERROR;
263    return NO_ERROR;
264}
265
266status_t AudioTrack::initCheck() const
267{
268    return mStatus;
269}
270
271// -------------------------------------------------------------------------
272
273uint32_t AudioTrack::latency() const
274{
275    return mLatency;
276}
277
278int AudioTrack::streamType() const
279{
280    return mStreamType;
281}
282
283audio_format_t AudioTrack::format() const
284{
285    return mFormat;
286}
287
288int AudioTrack::channelCount() const
289{
290    return mChannelCount;
291}
292
293uint32_t AudioTrack::frameCount() const
294{
295    return mCblk->frameCount;
296}
297
298int AudioTrack::frameSize() const
299{
300    if (audio_is_linear_pcm(mFormat)) {
301        return channelCount()*audio_bytes_per_sample(mFormat);
302    } else {
303        return sizeof(uint8_t);
304    }
305}
306
307sp<IMemory>& AudioTrack::sharedBuffer()
308{
309    return mSharedBuffer;
310}
311
312// -------------------------------------------------------------------------
313
314void AudioTrack::start()
315{
316    sp<AudioTrackThread> t = mAudioTrackThread;
317    status_t status = NO_ERROR;
318
319    ALOGV("start %p", this);
320    if (t != 0) {
321        if (t->exitPending()) {
322            if (t->requestExitAndWait() == WOULD_BLOCK) {
323                ALOGE("AudioTrack::start called from thread");
324                return;
325            }
326        }
327        t->mLock.lock();
328     }
329
330    AutoMutex lock(mLock);
331    // acquire a strong reference on the IMemory and IAudioTrack so that they cannot be destroyed
332    // while we are accessing the cblk
333    sp <IAudioTrack> audioTrack = mAudioTrack;
334    sp <IMemory> iMem = mCblkMemory;
335    audio_track_cblk_t* cblk = mCblk;
336
337    if (!mActive) {
338        mFlushed = false;
339        mActive = true;
340        mNewPosition = cblk->server + mUpdatePeriod;
341        cblk->lock.lock();
342        cblk->bufferTimeoutMs = MAX_STARTUP_TIMEOUT_MS;
343        cblk->waitTimeMs = 0;
344        android_atomic_and(~CBLK_DISABLED_ON, &cblk->flags);
345        if (t != 0) {
346            t->run("AudioTrackThread", ANDROID_PRIORITY_AUDIO);
347        } else {
348            mPreviousPriority = getpriority(PRIO_PROCESS, 0);
349            mPreviousSchedulingGroup = androidGetThreadSchedulingGroup(0);
350            androidSetThreadPriority(0, ANDROID_PRIORITY_AUDIO);
351        }
352
353        ALOGV("start %p before lock cblk %p", this, mCblk);
354        if (!(cblk->flags & CBLK_INVALID_MSK)) {
355            cblk->lock.unlock();
356            status = mAudioTrack->start();
357            cblk->lock.lock();
358            if (status == DEAD_OBJECT) {
359                android_atomic_or(CBLK_INVALID_ON, &cblk->flags);
360            }
361        }
362        if (cblk->flags & CBLK_INVALID_MSK) {
363            status = restoreTrack_l(cblk, true);
364        }
365        cblk->lock.unlock();
366        if (status != NO_ERROR) {
367            ALOGV("start() failed");
368            mActive = false;
369            if (t != 0) {
370                t->requestExit();
371            } else {
372                setpriority(PRIO_PROCESS, 0, mPreviousPriority);
373                androidSetThreadSchedulingGroup(0, mPreviousSchedulingGroup);
374            }
375        }
376    }
377
378    if (t != 0) {
379        t->mLock.unlock();
380    }
381}
382
383void AudioTrack::stop()
384{
385    sp<AudioTrackThread> t = mAudioTrackThread;
386
387    ALOGV("stop %p", this);
388    if (t != 0) {
389        t->mLock.lock();
390    }
391
392    AutoMutex lock(mLock);
393    if (mActive) {
394        mActive = false;
395        mCblk->cv.signal();
396        mAudioTrack->stop();
397        // Cancel loops (If we are in the middle of a loop, playback
398        // would not stop until loopCount reaches 0).
399        setLoop_l(0, 0, 0);
400        // the playback head position will reset to 0, so if a marker is set, we need
401        // to activate it again
402        mMarkerReached = false;
403        // Force flush if a shared buffer is used otherwise audioflinger
404        // will not stop before end of buffer is reached.
405        if (mSharedBuffer != 0) {
406            flush_l();
407        }
408        if (t != 0) {
409            t->requestExit();
410        } else {
411            setpriority(PRIO_PROCESS, 0, mPreviousPriority);
412            androidSetThreadSchedulingGroup(0, mPreviousSchedulingGroup);
413        }
414    }
415
416    if (t != 0) {
417        t->mLock.unlock();
418    }
419}
420
421bool AudioTrack::stopped() const
422{
423    AutoMutex lock(mLock);
424    return stopped_l();
425}
426
427void AudioTrack::flush()
428{
429    AutoMutex lock(mLock);
430    flush_l();
431}
432
433// must be called with mLock held
434void AudioTrack::flush_l()
435{
436    ALOGV("flush");
437
438    // clear playback marker and periodic update counter
439    mMarkerPosition = 0;
440    mMarkerReached = false;
441    mUpdatePeriod = 0;
442
443    if (!mActive) {
444        mFlushed = true;
445        mAudioTrack->flush();
446        // Release AudioTrack callback thread in case it was waiting for new buffers
447        // in AudioTrack::obtainBuffer()
448        mCblk->cv.signal();
449    }
450}
451
452void AudioTrack::pause()
453{
454    ALOGV("pause");
455    AutoMutex lock(mLock);
456    if (mActive) {
457        mActive = false;
458        mAudioTrack->pause();
459    }
460}
461
462void AudioTrack::mute(bool e)
463{
464    mAudioTrack->mute(e);
465    mMuted = e;
466}
467
468bool AudioTrack::muted() const
469{
470    return mMuted;
471}
472
473status_t AudioTrack::setVolume(float left, float right)
474{
475    if (left < 0.0f || left > 1.0f || right < 0.0f || right > 1.0f) {
476        return BAD_VALUE;
477    }
478
479    AutoMutex lock(mLock);
480    mVolume[LEFT] = left;
481    mVolume[RIGHT] = right;
482
483    // write must be atomic
484    mCblk->volumeLR = (uint32_t(uint16_t(right * 0x1000)) << 16) | uint16_t(left * 0x1000);
485
486    return NO_ERROR;
487}
488
489void AudioTrack::getVolume(float* left, float* right)
490{
491    if (left != NULL) {
492        *left  = mVolume[LEFT];
493    }
494    if (right != NULL) {
495        *right = mVolume[RIGHT];
496    }
497}
498
499status_t AudioTrack::setAuxEffectSendLevel(float level)
500{
501    ALOGV("setAuxEffectSendLevel(%f)", level);
502    if (level < 0.0f || level > 1.0f) {
503        return BAD_VALUE;
504    }
505    AutoMutex lock(mLock);
506
507    mSendLevel = level;
508
509    mCblk->setSendLevel(level);
510
511    return NO_ERROR;
512}
513
514void AudioTrack::getAuxEffectSendLevel(float* level)
515{
516    if (level != NULL) {
517        *level  = mSendLevel;
518    }
519}
520
521status_t AudioTrack::setSampleRate(int rate)
522{
523    int afSamplingRate;
524
525    if (AudioSystem::getOutputSamplingRate(&afSamplingRate, mStreamType) != NO_ERROR) {
526        return NO_INIT;
527    }
528    // Resampler implementation limits input sampling rate to 2 x output sampling rate.
529    if (rate <= 0 || rate > afSamplingRate*2 ) return BAD_VALUE;
530
531    AutoMutex lock(mLock);
532    mCblk->sampleRate = rate;
533    return NO_ERROR;
534}
535
536uint32_t AudioTrack::getSampleRate()
537{
538    AutoMutex lock(mLock);
539    return mCblk->sampleRate;
540}
541
542status_t AudioTrack::setLoop(uint32_t loopStart, uint32_t loopEnd, int loopCount)
543{
544    AutoMutex lock(mLock);
545    return setLoop_l(loopStart, loopEnd, loopCount);
546}
547
548// must be called with mLock held
549status_t AudioTrack::setLoop_l(uint32_t loopStart, uint32_t loopEnd, int loopCount)
550{
551    audio_track_cblk_t* cblk = mCblk;
552
553    Mutex::Autolock _l(cblk->lock);
554
555    if (loopCount == 0) {
556        cblk->loopStart = UINT_MAX;
557        cblk->loopEnd = UINT_MAX;
558        cblk->loopCount = 0;
559        mLoopCount = 0;
560        return NO_ERROR;
561    }
562
563    if (loopStart >= loopEnd ||
564        loopEnd - loopStart > cblk->frameCount ||
565        cblk->server > loopStart) {
566        ALOGE("setLoop invalid value: loopStart %d, loopEnd %d, loopCount %d, framecount %d, user %d", loopStart, loopEnd, loopCount, cblk->frameCount, cblk->user);
567        return BAD_VALUE;
568    }
569
570    if ((mSharedBuffer != 0) && (loopEnd > cblk->frameCount)) {
571        ALOGE("setLoop invalid value: loop markers beyond data: loopStart %d, loopEnd %d, framecount %d",
572            loopStart, loopEnd, cblk->frameCount);
573        return BAD_VALUE;
574    }
575
576    cblk->loopStart = loopStart;
577    cblk->loopEnd = loopEnd;
578    cblk->loopCount = loopCount;
579    mLoopCount = loopCount;
580
581    return NO_ERROR;
582}
583
584status_t AudioTrack::getLoop(uint32_t *loopStart, uint32_t *loopEnd, int *loopCount)
585{
586    AutoMutex lock(mLock);
587    if (loopStart != 0) {
588        *loopStart = mCblk->loopStart;
589    }
590    if (loopEnd != 0) {
591        *loopEnd = mCblk->loopEnd;
592    }
593    if (loopCount != 0) {
594        if (mCblk->loopCount < 0) {
595            *loopCount = -1;
596        } else {
597            *loopCount = mCblk->loopCount;
598        }
599    }
600
601    return NO_ERROR;
602}
603
604status_t AudioTrack::setMarkerPosition(uint32_t marker)
605{
606    if (mCbf == 0) return INVALID_OPERATION;
607
608    mMarkerPosition = marker;
609    mMarkerReached = false;
610
611    return NO_ERROR;
612}
613
614status_t AudioTrack::getMarkerPosition(uint32_t *marker)
615{
616    if (marker == 0) return BAD_VALUE;
617
618    *marker = mMarkerPosition;
619
620    return NO_ERROR;
621}
622
623status_t AudioTrack::setPositionUpdatePeriod(uint32_t updatePeriod)
624{
625    if (mCbf == 0) return INVALID_OPERATION;
626
627    uint32_t curPosition;
628    getPosition(&curPosition);
629    mNewPosition = curPosition + updatePeriod;
630    mUpdatePeriod = updatePeriod;
631
632    return NO_ERROR;
633}
634
635status_t AudioTrack::getPositionUpdatePeriod(uint32_t *updatePeriod)
636{
637    if (updatePeriod == 0) return BAD_VALUE;
638
639    *updatePeriod = mUpdatePeriod;
640
641    return NO_ERROR;
642}
643
644status_t AudioTrack::setPosition(uint32_t position)
645{
646    AutoMutex lock(mLock);
647
648    if (!stopped_l()) return INVALID_OPERATION;
649
650    Mutex::Autolock _l(mCblk->lock);
651
652    if (position > mCblk->user) return BAD_VALUE;
653
654    mCblk->server = position;
655    android_atomic_or(CBLK_FORCEREADY_ON, &mCblk->flags);
656
657    return NO_ERROR;
658}
659
660status_t AudioTrack::getPosition(uint32_t *position)
661{
662    if (position == 0) return BAD_VALUE;
663    AutoMutex lock(mLock);
664    *position = mFlushed ? 0 : mCblk->server;
665
666    return NO_ERROR;
667}
668
669status_t AudioTrack::reload()
670{
671    AutoMutex lock(mLock);
672
673    if (!stopped_l()) return INVALID_OPERATION;
674
675    flush_l();
676
677    mCblk->stepUser(mCblk->frameCount);
678
679    return NO_ERROR;
680}
681
682audio_io_handle_t AudioTrack::getOutput()
683{
684    AutoMutex lock(mLock);
685    return getOutput_l();
686}
687
688// must be called with mLock held
689audio_io_handle_t AudioTrack::getOutput_l()
690{
691    return AudioSystem::getOutput((audio_stream_type_t)mStreamType,
692            mCblk->sampleRate, mFormat, mChannelMask, (audio_policy_output_flags_t)mFlags);
693}
694
695int AudioTrack::getSessionId()
696{
697    return mSessionId;
698}
699
700status_t AudioTrack::attachAuxEffect(int effectId)
701{
702    ALOGV("attachAuxEffect(%d)", effectId);
703    status_t status = mAudioTrack->attachAuxEffect(effectId);
704    if (status == NO_ERROR) {
705        mAuxEffectId = effectId;
706    }
707    return status;
708}
709
710// -------------------------------------------------------------------------
711
712// must be called with mLock held
713status_t AudioTrack::createTrack_l(
714        int streamType,
715        uint32_t sampleRate,
716        audio_format_t format,
717        uint32_t channelMask,
718        int frameCount,
719        uint32_t flags,
720        const sp<IMemory>& sharedBuffer,
721        audio_io_handle_t output,
722        bool enforceFrameCount)
723{
724    status_t status;
725    const sp<IAudioFlinger>& audioFlinger = AudioSystem::get_audio_flinger();
726    if (audioFlinger == 0) {
727       ALOGE("Could not get audioflinger");
728       return NO_INIT;
729    }
730
731    int afSampleRate;
732    if (AudioSystem::getOutputSamplingRate(&afSampleRate, streamType) != NO_ERROR) {
733        return NO_INIT;
734    }
735    int afFrameCount;
736    if (AudioSystem::getOutputFrameCount(&afFrameCount, streamType) != NO_ERROR) {
737        return NO_INIT;
738    }
739    uint32_t afLatency;
740    if (AudioSystem::getOutputLatency(&afLatency, streamType) != NO_ERROR) {
741        return NO_INIT;
742    }
743
744    mNotificationFramesAct = mNotificationFramesReq;
745    if (!audio_is_linear_pcm(format)) {
746        if (sharedBuffer != 0) {
747            frameCount = sharedBuffer->size();
748        }
749    } else {
750        // Ensure that buffer depth covers at least audio hardware latency
751        uint32_t minBufCount = afLatency / ((1000 * afFrameCount)/afSampleRate);
752        if (minBufCount < 2) minBufCount = 2;
753
754        int minFrameCount = (afFrameCount*sampleRate*minBufCount)/afSampleRate;
755
756        if (sharedBuffer == 0) {
757            if (frameCount == 0) {
758                frameCount = minFrameCount;
759            }
760            if (mNotificationFramesAct == 0) {
761                mNotificationFramesAct = frameCount/2;
762            }
763            // Make sure that application is notified with sufficient margin
764            // before underrun
765            if (mNotificationFramesAct > (uint32_t)frameCount/2) {
766                mNotificationFramesAct = frameCount/2;
767            }
768            if (frameCount < minFrameCount) {
769                if (enforceFrameCount) {
770                    ALOGE("Invalid buffer size: minFrameCount %d, frameCount %d", minFrameCount, frameCount);
771                    return BAD_VALUE;
772                } else {
773                    frameCount = minFrameCount;
774                }
775            }
776        } else {
777            // Ensure that buffer alignment matches channelcount
778            int channelCount = popcount(channelMask);
779            if (((uint32_t)sharedBuffer->pointer() & (channelCount | 1)) != 0) {
780                ALOGE("Invalid buffer alignement: address %p, channelCount %d", sharedBuffer->pointer(), channelCount);
781                return BAD_VALUE;
782            }
783            frameCount = sharedBuffer->size()/channelCount/sizeof(int16_t);
784        }
785    }
786
787    sp<IAudioTrack> track = audioFlinger->createTrack(getpid(),
788                                                      streamType,
789                                                      sampleRate,
790                                                      format,
791                                                      channelMask,
792                                                      frameCount,
793                                                      ((uint16_t)flags) << 16,
794                                                      sharedBuffer,
795                                                      output,
796                                                      &mSessionId,
797                                                      &status);
798
799    if (track == 0) {
800        ALOGE("AudioFlinger could not create track, status: %d", status);
801        return status;
802    }
803    sp<IMemory> cblk = track->getCblk();
804    if (cblk == 0) {
805        ALOGE("Could not get control block");
806        return NO_INIT;
807    }
808    mAudioTrack = track;
809    mCblkMemory = cblk;
810    mCblk = static_cast<audio_track_cblk_t*>(cblk->pointer());
811    android_atomic_or(CBLK_DIRECTION_OUT, &mCblk->flags);
812    if (sharedBuffer == 0) {
813        mCblk->buffers = (char*)mCblk + sizeof(audio_track_cblk_t);
814    } else {
815        mCblk->buffers = sharedBuffer->pointer();
816         // Force buffer full condition as data is already present in shared memory
817        mCblk->stepUser(mCblk->frameCount);
818    }
819
820    mCblk->volumeLR = (uint32_t(uint16_t(mVolume[RIGHT] * 0x1000)) << 16) | uint16_t(mVolume[LEFT] * 0x1000);
821    mCblk->setSendLevel(mSendLevel);
822    mAudioTrack->attachAuxEffect(mAuxEffectId);
823    mCblk->bufferTimeoutMs = MAX_STARTUP_TIMEOUT_MS;
824    mCblk->waitTimeMs = 0;
825    mRemainingFrames = mNotificationFramesAct;
826    mLatency = afLatency + (1000*mCblk->frameCount) / sampleRate;
827    return NO_ERROR;
828}
829
830status_t AudioTrack::obtainBuffer(Buffer* audioBuffer, int32_t waitCount)
831{
832    AutoMutex lock(mLock);
833    bool active;
834    status_t result = NO_ERROR;
835    audio_track_cblk_t* cblk = mCblk;
836    uint32_t framesReq = audioBuffer->frameCount;
837    uint32_t waitTimeMs = (waitCount < 0) ? cblk->bufferTimeoutMs : WAIT_PERIOD_MS;
838
839    audioBuffer->frameCount  = 0;
840    audioBuffer->size = 0;
841
842    uint32_t framesAvail = cblk->framesAvailable();
843
844    cblk->lock.lock();
845    if (cblk->flags & CBLK_INVALID_MSK) {
846        goto create_new_track;
847    }
848    cblk->lock.unlock();
849
850    if (framesAvail == 0) {
851        cblk->lock.lock();
852        goto start_loop_here;
853        while (framesAvail == 0) {
854            active = mActive;
855            if (CC_UNLIKELY(!active)) {
856                ALOGV("Not active and NO_MORE_BUFFERS");
857                cblk->lock.unlock();
858                return NO_MORE_BUFFERS;
859            }
860            if (CC_UNLIKELY(!waitCount)) {
861                cblk->lock.unlock();
862                return WOULD_BLOCK;
863            }
864            if (!(cblk->flags & CBLK_INVALID_MSK)) {
865                mLock.unlock();
866                result = cblk->cv.waitRelative(cblk->lock, milliseconds(waitTimeMs));
867                cblk->lock.unlock();
868                mLock.lock();
869                if (!mActive) {
870                    return status_t(STOPPED);
871                }
872                cblk->lock.lock();
873            }
874
875            if (cblk->flags & CBLK_INVALID_MSK) {
876                goto create_new_track;
877            }
878            if (CC_UNLIKELY(result != NO_ERROR)) {
879                cblk->waitTimeMs += waitTimeMs;
880                if (cblk->waitTimeMs >= cblk->bufferTimeoutMs) {
881                    // timing out when a loop has been set and we have already written upto loop end
882                    // is a normal condition: no need to wake AudioFlinger up.
883                    if (cblk->user < cblk->loopEnd) {
884                        ALOGW(   "obtainBuffer timed out (is the CPU pegged?) %p "
885                                "user=%08x, server=%08x", this, cblk->user, cblk->server);
886                        //unlock cblk mutex before calling mAudioTrack->start() (see issue #1617140)
887                        cblk->lock.unlock();
888                        result = mAudioTrack->start();
889                        cblk->lock.lock();
890                        if (result == DEAD_OBJECT) {
891                            android_atomic_or(CBLK_INVALID_ON, &cblk->flags);
892create_new_track:
893                            result = restoreTrack_l(cblk, false);
894                        }
895                        if (result != NO_ERROR) {
896                            ALOGW("obtainBuffer create Track error %d", result);
897                            cblk->lock.unlock();
898                            return result;
899                        }
900                    }
901                    cblk->waitTimeMs = 0;
902                }
903
904                if (--waitCount == 0) {
905                    cblk->lock.unlock();
906                    return TIMED_OUT;
907                }
908            }
909            // read the server count again
910        start_loop_here:
911            framesAvail = cblk->framesAvailable_l();
912        }
913        cblk->lock.unlock();
914    }
915
916    // restart track if it was disabled by audioflinger due to previous underrun
917    if (mActive && (cblk->flags & CBLK_DISABLED_MSK)) {
918        android_atomic_and(~CBLK_DISABLED_ON, &cblk->flags);
919        ALOGW("obtainBuffer() track %p disabled, restarting", this);
920        mAudioTrack->start();
921    }
922
923    cblk->waitTimeMs = 0;
924
925    if (framesReq > framesAvail) {
926        framesReq = framesAvail;
927    }
928
929    uint32_t u = cblk->user;
930    uint32_t bufferEnd = cblk->userBase + cblk->frameCount;
931
932    if (u + framesReq > bufferEnd) {
933        framesReq = bufferEnd - u;
934    }
935
936    audioBuffer->flags = mMuted ? Buffer::MUTE : 0;
937    audioBuffer->channelCount = mChannelCount;
938    audioBuffer->frameCount = framesReq;
939    audioBuffer->size = framesReq * cblk->frameSize;
940    if (audio_is_linear_pcm(mFormat)) {
941        audioBuffer->format = AUDIO_FORMAT_PCM_16_BIT;
942    } else {
943        audioBuffer->format = mFormat;
944    }
945    audioBuffer->raw = (int8_t *)cblk->buffer(u);
946    active = mActive;
947    return active ? status_t(NO_ERROR) : status_t(STOPPED);
948}
949
950void AudioTrack::releaseBuffer(Buffer* audioBuffer)
951{
952    AutoMutex lock(mLock);
953    mCblk->stepUser(audioBuffer->frameCount);
954}
955
956// -------------------------------------------------------------------------
957
958ssize_t AudioTrack::write(const void* buffer, size_t userSize)
959{
960
961    if (mSharedBuffer != 0) return INVALID_OPERATION;
962
963    if (ssize_t(userSize) < 0) {
964        // sanity-check. user is most-likely passing an error code.
965        ALOGE("AudioTrack::write(buffer=%p, size=%u (%d)",
966                buffer, userSize, userSize);
967        return BAD_VALUE;
968    }
969
970    ALOGV("write %p: %d bytes, mActive=%d", this, userSize, mActive);
971
972    // acquire a strong reference on the IMemory and IAudioTrack so that they cannot be destroyed
973    // while we are accessing the cblk
974    mLock.lock();
975    sp <IAudioTrack> audioTrack = mAudioTrack;
976    sp <IMemory> iMem = mCblkMemory;
977    mLock.unlock();
978
979    ssize_t written = 0;
980    const int8_t *src = (const int8_t *)buffer;
981    Buffer audioBuffer;
982    size_t frameSz = (size_t)frameSize();
983
984    do {
985        audioBuffer.frameCount = userSize/frameSz;
986
987        // Calling obtainBuffer() with a negative wait count causes
988        // an (almost) infinite wait time.
989        status_t err = obtainBuffer(&audioBuffer, -1);
990        if (err < 0) {
991            // out of buffers, return #bytes written
992            if (err == status_t(NO_MORE_BUFFERS))
993                break;
994            return ssize_t(err);
995        }
996
997        size_t toWrite;
998
999        if (mFormat == AUDIO_FORMAT_PCM_8_BIT && !(mFlags & AUDIO_POLICY_OUTPUT_FLAG_DIRECT)) {
1000            // Divide capacity by 2 to take expansion into account
1001            toWrite = audioBuffer.size>>1;
1002            // 8 to 16 bit conversion
1003            int count = toWrite;
1004            int16_t *dst = (int16_t *)(audioBuffer.i8);
1005            while(count--) {
1006                *dst++ = (int16_t)(*src++^0x80) << 8;
1007            }
1008        } else {
1009            toWrite = audioBuffer.size;
1010            memcpy(audioBuffer.i8, src, toWrite);
1011            src += toWrite;
1012        }
1013        userSize -= toWrite;
1014        written += toWrite;
1015
1016        releaseBuffer(&audioBuffer);
1017    } while (userSize >= frameSz);
1018
1019    return written;
1020}
1021
1022// -------------------------------------------------------------------------
1023
1024bool AudioTrack::processAudioBuffer(const sp<AudioTrackThread>& thread)
1025{
1026    Buffer audioBuffer;
1027    uint32_t frames;
1028    size_t writtenSize;
1029
1030    mLock.lock();
1031    // acquire a strong reference on the IMemory and IAudioTrack so that they cannot be destroyed
1032    // while we are accessing the cblk
1033    sp <IAudioTrack> audioTrack = mAudioTrack;
1034    sp <IMemory> iMem = mCblkMemory;
1035    audio_track_cblk_t* cblk = mCblk;
1036    bool active = mActive;
1037    mLock.unlock();
1038
1039    // Manage underrun callback
1040    if (active && (cblk->framesAvailable() == cblk->frameCount)) {
1041        ALOGV("Underrun user: %x, server: %x, flags %04x", cblk->user, cblk->server, cblk->flags);
1042        if (!(android_atomic_or(CBLK_UNDERRUN_ON, &cblk->flags) & CBLK_UNDERRUN_MSK)) {
1043            mCbf(EVENT_UNDERRUN, mUserData, 0);
1044            if (cblk->server == cblk->frameCount) {
1045                mCbf(EVENT_BUFFER_END, mUserData, 0);
1046            }
1047            if (mSharedBuffer != 0) return false;
1048        }
1049    }
1050
1051    // Manage loop end callback
1052    while (mLoopCount > cblk->loopCount) {
1053        int loopCount = -1;
1054        mLoopCount--;
1055        if (mLoopCount >= 0) loopCount = mLoopCount;
1056
1057        mCbf(EVENT_LOOP_END, mUserData, (void *)&loopCount);
1058    }
1059
1060    // Manage marker callback
1061    if (!mMarkerReached && (mMarkerPosition > 0)) {
1062        if (cblk->server >= mMarkerPosition) {
1063            mCbf(EVENT_MARKER, mUserData, (void *)&mMarkerPosition);
1064            mMarkerReached = true;
1065        }
1066    }
1067
1068    // Manage new position callback
1069    if (mUpdatePeriod > 0) {
1070        while (cblk->server >= mNewPosition) {
1071            mCbf(EVENT_NEW_POS, mUserData, (void *)&mNewPosition);
1072            mNewPosition += mUpdatePeriod;
1073        }
1074    }
1075
1076    // If Shared buffer is used, no data is requested from client.
1077    if (mSharedBuffer != 0) {
1078        frames = 0;
1079    } else {
1080        frames = mRemainingFrames;
1081    }
1082
1083    int32_t waitCount = -1;
1084    if (mUpdatePeriod || (!mMarkerReached && mMarkerPosition) || mLoopCount) {
1085        waitCount = 1;
1086    }
1087
1088    do {
1089
1090        audioBuffer.frameCount = frames;
1091
1092        // Calling obtainBuffer() with a wait count of 1
1093        // limits wait time to WAIT_PERIOD_MS. This prevents from being
1094        // stuck here not being able to handle timed events (position, markers, loops).
1095        status_t err = obtainBuffer(&audioBuffer, waitCount);
1096        if (err < NO_ERROR) {
1097            if (err != TIMED_OUT) {
1098                ALOGE_IF(err != status_t(NO_MORE_BUFFERS), "Error obtaining an audio buffer, giving up.");
1099                return false;
1100            }
1101            break;
1102        }
1103        if (err == status_t(STOPPED)) return false;
1104
1105        // Divide buffer size by 2 to take into account the expansion
1106        // due to 8 to 16 bit conversion: the callback must fill only half
1107        // of the destination buffer
1108        if (mFormat == AUDIO_FORMAT_PCM_8_BIT && !(mFlags & AUDIO_POLICY_OUTPUT_FLAG_DIRECT)) {
1109            audioBuffer.size >>= 1;
1110        }
1111
1112        size_t reqSize = audioBuffer.size;
1113        mCbf(EVENT_MORE_DATA, mUserData, &audioBuffer);
1114        writtenSize = audioBuffer.size;
1115
1116        // Sanity check on returned size
1117        if (ssize_t(writtenSize) <= 0) {
1118            // The callback is done filling buffers
1119            // Keep this thread going to handle timed events and
1120            // still try to get more data in intervals of WAIT_PERIOD_MS
1121            // but don't just loop and block the CPU, so wait
1122            usleep(WAIT_PERIOD_MS*1000);
1123            break;
1124        }
1125        if (writtenSize > reqSize) writtenSize = reqSize;
1126
1127        if (mFormat == AUDIO_FORMAT_PCM_8_BIT && !(mFlags & AUDIO_POLICY_OUTPUT_FLAG_DIRECT)) {
1128            // 8 to 16 bit conversion
1129            const int8_t *src = audioBuffer.i8 + writtenSize-1;
1130            int count = writtenSize;
1131            int16_t *dst = audioBuffer.i16 + writtenSize-1;
1132            while(count--) {
1133                *dst-- = (int16_t)(*src--^0x80) << 8;
1134            }
1135            writtenSize <<= 1;
1136        }
1137
1138        audioBuffer.size = writtenSize;
1139        // NOTE: mCblk->frameSize is not equal to AudioTrack::frameSize() for
1140        // 8 bit PCM data: in this case,  mCblk->frameSize is based on a sampel size of
1141        // 16 bit.
1142        audioBuffer.frameCount = writtenSize/mCblk->frameSize;
1143
1144        frames -= audioBuffer.frameCount;
1145
1146        releaseBuffer(&audioBuffer);
1147    }
1148    while (frames);
1149
1150    if (frames == 0) {
1151        mRemainingFrames = mNotificationFramesAct;
1152    } else {
1153        mRemainingFrames = frames;
1154    }
1155    return true;
1156}
1157
1158// must be called with mLock and cblk.lock held. Callers must also hold strong references on
1159// the IAudioTrack and IMemory in case they are recreated here.
1160// If the IAudioTrack is successfully restored, the cblk pointer is updated
1161status_t AudioTrack::restoreTrack_l(audio_track_cblk_t*& cblk, bool fromStart)
1162{
1163    status_t result;
1164
1165    if (!(android_atomic_or(CBLK_RESTORING_ON, &cblk->flags) & CBLK_RESTORING_MSK)) {
1166        ALOGW("dead IAudioTrack, creating a new one from %s TID %d",
1167             fromStart ? "start()" : "obtainBuffer()", gettid());
1168
1169        // signal old cblk condition so that other threads waiting for available buffers stop
1170        // waiting now
1171        cblk->cv.broadcast();
1172        cblk->lock.unlock();
1173
1174        // refresh the audio configuration cache in this process to make sure we get new
1175        // output parameters in getOutput_l() and createTrack_l()
1176        AudioSystem::clearAudioConfigCache();
1177
1178        // if the new IAudioTrack is created, createTrack_l() will modify the
1179        // following member variables: mAudioTrack, mCblkMemory and mCblk.
1180        // It will also delete the strong references on previous IAudioTrack and IMemory
1181        result = createTrack_l(mStreamType,
1182                               cblk->sampleRate,
1183                               mFormat,
1184                               mChannelMask,
1185                               mFrameCount,
1186                               mFlags,
1187                               mSharedBuffer,
1188                               getOutput_l(),
1189                               false);
1190
1191        if (result == NO_ERROR) {
1192            uint32_t user = cblk->user;
1193            uint32_t server = cblk->server;
1194            // restore write index and set other indexes to reflect empty buffer status
1195            mCblk->user = user;
1196            mCblk->server = user;
1197            mCblk->userBase = user;
1198            mCblk->serverBase = user;
1199            // restore loop: this is not guaranteed to succeed if new frame count is not
1200            // compatible with loop length
1201            setLoop_l(cblk->loopStart, cblk->loopEnd, cblk->loopCount);
1202            if (!fromStart) {
1203                mCblk->bufferTimeoutMs = MAX_RUN_TIMEOUT_MS;
1204                // Make sure that a client relying on callback events indicating underrun or
1205                // the actual amount of audio frames played (e.g SoundPool) receives them.
1206                if (mSharedBuffer == 0) {
1207                    uint32_t frames = 0;
1208                    if (user > server) {
1209                        frames = ((user - server) > mCblk->frameCount) ?
1210                                mCblk->frameCount : (user - server);
1211                        memset(mCblk->buffers, 0, frames * mCblk->frameSize);
1212                    }
1213                    // restart playback even if buffer is not completely filled.
1214                    android_atomic_or(CBLK_FORCEREADY_ON, &mCblk->flags);
1215                    // stepUser() clears CBLK_UNDERRUN_ON flag enabling underrun callbacks to
1216                    // the client
1217                    mCblk->stepUser(frames);
1218                }
1219            }
1220            if (mActive) {
1221                result = mAudioTrack->start();
1222                ALOGW_IF(result != NO_ERROR, "restoreTrack_l() start() failed status %d", result);
1223            }
1224            if (fromStart && result == NO_ERROR) {
1225                mNewPosition = mCblk->server + mUpdatePeriod;
1226            }
1227        }
1228        if (result != NO_ERROR) {
1229            android_atomic_and(~CBLK_RESTORING_ON, &cblk->flags);
1230            ALOGW_IF(result != NO_ERROR, "restoreTrack_l() failed status %d", result);
1231        }
1232        mRestoreStatus = result;
1233        // signal old cblk condition for other threads waiting for restore completion
1234        android_atomic_or(CBLK_RESTORED_ON, &cblk->flags);
1235        cblk->cv.broadcast();
1236    } else {
1237        if (!(cblk->flags & CBLK_RESTORED_MSK)) {
1238            ALOGW("dead IAudioTrack, waiting for a new one TID %d", gettid());
1239            mLock.unlock();
1240            result = cblk->cv.waitRelative(cblk->lock, milliseconds(RESTORE_TIMEOUT_MS));
1241            if (result == NO_ERROR) {
1242                result = mRestoreStatus;
1243            }
1244            cblk->lock.unlock();
1245            mLock.lock();
1246        } else {
1247            ALOGW("dead IAudioTrack, already restored TID %d", gettid());
1248            result = mRestoreStatus;
1249            cblk->lock.unlock();
1250        }
1251    }
1252    ALOGV("restoreTrack_l() status %d mActive %d cblk %p, old cblk %p flags %08x old flags %08x",
1253         result, mActive, mCblk, cblk, mCblk->flags, cblk->flags);
1254
1255    if (result == NO_ERROR) {
1256        // from now on we switch to the newly created cblk
1257        cblk = mCblk;
1258    }
1259    cblk->lock.lock();
1260
1261    ALOGW_IF(result != NO_ERROR, "restoreTrack_l() error %d TID %d", result, gettid());
1262
1263    return result;
1264}
1265
1266status_t AudioTrack::dump(int fd, const Vector<String16>& args) const
1267{
1268
1269    const size_t SIZE = 256;
1270    char buffer[SIZE];
1271    String8 result;
1272
1273    result.append(" AudioTrack::dump\n");
1274    snprintf(buffer, 255, "  stream type(%d), left - right volume(%f, %f)\n", mStreamType, mVolume[0], mVolume[1]);
1275    result.append(buffer);
1276    snprintf(buffer, 255, "  format(%d), channel count(%d), frame count(%d)\n", mFormat, mChannelCount, mCblk->frameCount);
1277    result.append(buffer);
1278    snprintf(buffer, 255, "  sample rate(%d), status(%d), muted(%d)\n", (mCblk == 0) ? 0 : mCblk->sampleRate, mStatus, mMuted);
1279    result.append(buffer);
1280    snprintf(buffer, 255, "  active(%d), latency (%d)\n", mActive, mLatency);
1281    result.append(buffer);
1282    ::write(fd, result.string(), result.size());
1283    return NO_ERROR;
1284}
1285
1286// =========================================================================
1287
1288AudioTrack::AudioTrackThread::AudioTrackThread(AudioTrack& receiver, bool bCanCallJava)
1289    : Thread(bCanCallJava), mReceiver(receiver)
1290{
1291}
1292
1293bool AudioTrack::AudioTrackThread::threadLoop()
1294{
1295    return mReceiver.processAudioBuffer(this);
1296}
1297
1298status_t AudioTrack::AudioTrackThread::readyToRun()
1299{
1300    return NO_ERROR;
1301}
1302
1303void AudioTrack::AudioTrackThread::onFirstRef()
1304{
1305}
1306
1307// =========================================================================
1308
1309
1310audio_track_cblk_t::audio_track_cblk_t()
1311    : lock(Mutex::SHARED), cv(Condition::SHARED), user(0), server(0),
1312    userBase(0), serverBase(0), buffers(0), frameCount(0),
1313    loopStart(UINT_MAX), loopEnd(UINT_MAX), loopCount(0), volumeLR(0),
1314    mSendLevel(0), flags(0)
1315{
1316}
1317
1318uint32_t audio_track_cblk_t::stepUser(uint32_t frameCount)
1319{
1320    uint32_t u = user;
1321
1322    u += frameCount;
1323    // Ensure that user is never ahead of server for AudioRecord
1324    if (flags & CBLK_DIRECTION_MSK) {
1325        // If stepServer() has been called once, switch to normal obtainBuffer() timeout period
1326        if (bufferTimeoutMs == MAX_STARTUP_TIMEOUT_MS-1) {
1327            bufferTimeoutMs = MAX_RUN_TIMEOUT_MS;
1328        }
1329    } else if (u > server) {
1330        ALOGW("stepServer occurred after track reset");
1331        u = server;
1332    }
1333
1334    if (u >= userBase + this->frameCount) {
1335        userBase += this->frameCount;
1336    }
1337
1338    user = u;
1339
1340    // Clear flow control error condition as new data has been written/read to/from buffer.
1341    if (flags & CBLK_UNDERRUN_MSK) {
1342        android_atomic_and(~CBLK_UNDERRUN_MSK, &flags);
1343    }
1344
1345    return u;
1346}
1347
1348bool audio_track_cblk_t::stepServer(uint32_t frameCount)
1349{
1350    if (!tryLock()) {
1351        ALOGW("stepServer() could not lock cblk");
1352        return false;
1353    }
1354
1355    uint32_t s = server;
1356
1357    s += frameCount;
1358    if (flags & CBLK_DIRECTION_MSK) {
1359        // Mark that we have read the first buffer so that next time stepUser() is called
1360        // we switch to normal obtainBuffer() timeout period
1361        if (bufferTimeoutMs == MAX_STARTUP_TIMEOUT_MS) {
1362            bufferTimeoutMs = MAX_STARTUP_TIMEOUT_MS - 1;
1363        }
1364        // It is possible that we receive a flush()
1365        // while the mixer is processing a block: in this case,
1366        // stepServer() is called After the flush() has reset u & s and
1367        // we have s > u
1368        if (s > user) {
1369            ALOGW("stepServer occurred after track reset");
1370            s = user;
1371        }
1372    }
1373
1374    if (s >= loopEnd) {
1375        ALOGW_IF(s > loopEnd, "stepServer: s %u > loopEnd %u", s, loopEnd);
1376        s = loopStart;
1377        if (--loopCount == 0) {
1378            loopEnd = UINT_MAX;
1379            loopStart = UINT_MAX;
1380        }
1381    }
1382    if (s >= serverBase + this->frameCount) {
1383        serverBase += this->frameCount;
1384    }
1385
1386    server = s;
1387
1388    if (!(flags & CBLK_INVALID_MSK)) {
1389        cv.signal();
1390    }
1391    lock.unlock();
1392    return true;
1393}
1394
1395void* audio_track_cblk_t::buffer(uint32_t offset) const
1396{
1397    return (int8_t *)buffers + (offset - userBase) * frameSize;
1398}
1399
1400uint32_t audio_track_cblk_t::framesAvailable()
1401{
1402    Mutex::Autolock _l(lock);
1403    return framesAvailable_l();
1404}
1405
1406uint32_t audio_track_cblk_t::framesAvailable_l()
1407{
1408    uint32_t u = user;
1409    uint32_t s = server;
1410
1411    if (flags & CBLK_DIRECTION_MSK) {
1412        uint32_t limit = (s < loopStart) ? s : loopStart;
1413        return limit + frameCount - u;
1414    } else {
1415        return frameCount + u - s;
1416    }
1417}
1418
1419uint32_t audio_track_cblk_t::framesReady()
1420{
1421    uint32_t u = user;
1422    uint32_t s = server;
1423
1424    if (flags & CBLK_DIRECTION_MSK) {
1425        if (u < loopEnd) {
1426            return u - s;
1427        } else {
1428            // do not block on mutex shared with client on AudioFlinger side
1429            if (!tryLock()) {
1430                ALOGW("framesReady() could not lock cblk");
1431                return 0;
1432            }
1433            uint32_t frames = UINT_MAX;
1434            if (loopCount >= 0) {
1435                frames = (loopEnd - loopStart)*loopCount + u - s;
1436            }
1437            lock.unlock();
1438            return frames;
1439        }
1440    } else {
1441        return s - u;
1442    }
1443}
1444
1445bool audio_track_cblk_t::tryLock()
1446{
1447    // the code below simulates lock-with-timeout
1448    // we MUST do this to protect the AudioFlinger server
1449    // as this lock is shared with the client.
1450    status_t err;
1451
1452    err = lock.tryLock();
1453    if (err == -EBUSY) { // just wait a bit
1454        usleep(1000);
1455        err = lock.tryLock();
1456    }
1457    if (err != NO_ERROR) {
1458        // probably, the client just died.
1459        return false;
1460    }
1461    return true;
1462}
1463
1464// -------------------------------------------------------------------------
1465
1466}; // namespace android
1467