1/*
2 * Copyright (C) 2011 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17//#define USE_LOG SLAndroidLogLevel_Verbose
18
19#include "sles_allinclusive.h"
20
21#include <media/stagefright/foundation/ADebug.h>
22#include <sys/stat.h>
23#include <inttypes.h>
24
25namespace android {
26
27//--------------------------------------------------------------------------------------------------
28GenericPlayer::GenericPlayer(const AudioPlayback_Parameters* params) :
29        mDataLocatorType(kDataLocatorNone),
30        mNotifyClient(NULL),
31        mNotifyUser(NULL),
32        mStateFlags(0),
33        mPlaybackParams(*params),
34        mDurationMsec(ANDROID_UNKNOWN_TIME),
35        mPlaybackRatePermille(1000),
36        mCacheStatus(kStatusEmpty),
37        mCacheFill(0),
38        mLastNotifiedCacheFill(0),
39        mCacheFillNotifThreshold(100),
40        mEventFlags(0),
41        mMarkerPositionMs(ANDROID_UNKNOWN_TIME),
42        mPositionUpdatePeriodMs(1000), // per spec
43        mOneShotGeneration(0),
44        mDeliveredNewPosMs(ANDROID_UNKNOWN_TIME),
45        mObservedPositionMs(ANDROID_UNKNOWN_TIME)
46{
47    SL_LOGD("GenericPlayer::GenericPlayer()");
48
49    mLooper = new android::ALooper();
50
51    // Post-construction accesses need to be protected by mSettingsLock
52    mAndroidAudioLevels.mFinalVolume[0] = 1.0f;
53    mAndroidAudioLevels.mFinalVolume[1] = 1.0f;
54}
55
56
57GenericPlayer::~GenericPlayer() {
58    SL_LOGV("GenericPlayer::~GenericPlayer()");
59
60    resetDataLocator();
61}
62
63
64void GenericPlayer::init(const notif_cbf_t cbf, void* notifUser) {
65    SL_LOGD("GenericPlayer::init()");
66
67    {
68        android::Mutex::Autolock autoLock(mNotifyClientLock);
69        mNotifyClient = cbf;
70        mNotifyUser = notifUser;
71    }
72
73    mLooper->registerHandler(this);
74    mLooper->start(false /*runOnCallingThread*/, false /*canCallJava*/, PRIORITY_DEFAULT);
75}
76
77
78void GenericPlayer::preDestroy() {
79    SL_LOGD("GenericPlayer::preDestroy()");
80    {
81        android::Mutex::Autolock autoLock(mNotifyClientLock);
82        mNotifyClient = NULL;
83        mNotifyUser = NULL;
84    }
85
86    mLooper->stop();
87    mLooper->unregisterHandler(id());
88}
89
90
91void GenericPlayer::setDataSource(const char *uri) {
92    SL_LOGV("GenericPlayer::setDataSource(uri=%s)", uri);
93    resetDataLocator();
94
95    mDataLocator.uriRef = uri;
96
97    mDataLocatorType = kDataLocatorUri;
98}
99
100
101void GenericPlayer::setDataSource(int fd, int64_t offset, int64_t length, bool closeAfterUse) {
102    SL_LOGV("GenericPlayer::setDataSource(fd=%d, offset=%lld, length=%lld, closeAfterUse=%s)", fd,
103            offset, length, closeAfterUse ? "true" : "false");
104    resetDataLocator();
105
106    mDataLocator.fdi.fd = fd;
107
108    struct stat sb;
109    int ret = fstat(fd, &sb);
110    if (ret != 0) {
111        SL_LOGE("GenericPlayer::setDataSource: fstat(%d) failed: %d, %s", fd, ret, strerror(errno));
112        return;
113    }
114
115    if (offset >= sb.st_size) {
116        SL_LOGE("SfPlayer::setDataSource: invalid offset");
117        return;
118    }
119    mDataLocator.fdi.offset = offset;
120
121    if (PLAYER_FD_FIND_FILE_SIZE == length) {
122        mDataLocator.fdi.length = sb.st_size;
123    } else if (offset + length > sb.st_size) {
124        mDataLocator.fdi.length = sb.st_size - offset;
125    } else {
126        mDataLocator.fdi.length = length;
127    }
128
129    mDataLocator.fdi.mCloseAfterUse = closeAfterUse;
130
131    mDataLocatorType = kDataLocatorFd;
132}
133
134
135void GenericPlayer::prepare() {
136    SL_LOGD("GenericPlayer::prepare()");
137    // do not attempt prepare more than once
138    if (!(mStateFlags & (kFlagPrepared | kFlagPreparedUnsuccessfully))) {
139        sp<AMessage> msg = new AMessage(kWhatPrepare, this);
140        msg->post();
141    }
142}
143
144
145void GenericPlayer::play() {
146    SL_LOGD("GenericPlayer::play()");
147    sp<AMessage> msg = new AMessage(kWhatPlay, this);
148    msg->post();
149}
150
151
152void GenericPlayer::pause() {
153    SL_LOGD("GenericPlayer::pause()");
154    sp<AMessage> msg = new AMessage(kWhatPause, this);
155    msg->post();
156}
157
158
159void GenericPlayer::stop() {
160    SL_LOGD("GenericPlayer::stop()");
161    (new AMessage(kWhatPause, this))->post();
162
163    // after a stop, playback should resume from the start.
164    seek(0);
165}
166
167
168void GenericPlayer::seek(int64_t timeMsec) {
169    SL_LOGV("GenericPlayer::seek %lld", timeMsec);
170    if (timeMsec < 0 && timeMsec != ANDROID_UNKNOWN_TIME) {
171        SL_LOGE("GenericPlayer::seek error, can't seek to negative time %" PRId64 "ms", timeMsec);
172        return;
173    }
174    sp<AMessage> msg = new AMessage(kWhatSeek, this);
175    msg->setInt64(WHATPARAM_SEEK_SEEKTIME_MS, timeMsec);
176    msg->post();
177}
178
179
180void GenericPlayer::loop(bool loop) {
181    SL_LOGV("GenericPlayer::loop %s", loop ? "true" : "false");
182    sp<AMessage> msg = new AMessage(kWhatLoop, this);
183    msg->setInt32(WHATPARAM_LOOP_LOOPING, (int32_t)loop);
184    msg->post();
185}
186
187
188void GenericPlayer::setBufferingUpdateThreshold(int16_t thresholdPercent) {
189    SL_LOGV("GenericPlayer::setBufferingUpdateThreshold %d", thresholdPercent);
190    sp<AMessage> msg = new AMessage(kWhatBuffUpdateThres, this);
191    msg->setInt32(WHATPARAM_BUFFERING_UPDATETHRESHOLD_PERCENT, (int32_t)thresholdPercent);
192    msg->post();
193}
194
195
196//--------------------------------------------------
197void GenericPlayer::getDurationMsec(int* msec) {
198    Mutex::Autolock _l(mSettingsLock);
199    *msec = mDurationMsec;
200}
201
202//--------------------------------------------------
203void GenericPlayer::setVolume(float leftVol, float rightVol)
204{
205    {
206        Mutex::Autolock _l(mSettingsLock);
207        mAndroidAudioLevels.mFinalVolume[0] = leftVol;
208        mAndroidAudioLevels.mFinalVolume[1] = rightVol;
209    }
210    // send a message for the volume to be updated by the object which implements the volume
211    (new AMessage(kWhatVolumeUpdate, this))->post();
212}
213
214
215//--------------------------------------------------
216void GenericPlayer::attachAuxEffect(int32_t effectId)
217{
218    SL_LOGV("GenericPlayer::attachAuxEffect(id=%d)", effectId);
219    sp<AMessage> msg = new AMessage(kWhatAttachAuxEffect, this);
220    msg->setInt32(WHATPARAM_ATTACHAUXEFFECT, effectId);
221    msg->post();
222}
223
224
225//--------------------------------------------------
226void GenericPlayer::setAuxEffectSendLevel(float level)
227{
228    SL_LOGV("GenericPlayer::setAuxEffectSendLevel(level=%g)", level);
229    sp<AMessage> msg = new AMessage(kWhatSetAuxEffectSendLevel, this);
230    msg->setFloat(WHATPARAM_SETAUXEFFECTSENDLEVEL, level);
231    msg->post();
232}
233
234
235//--------------------------------------------------
236void GenericPlayer::setPlaybackRate(int32_t ratePermille) {
237    SL_LOGV("GenericPlayer::setPlaybackRate(ratePermille=%d)", ratePermille);
238    {
239        Mutex::Autolock _l(mSettingsLock);
240        mPlaybackRatePermille = (int16_t)ratePermille;
241    }
242}
243
244//--------------------------------------------------
245// Call after changing any of the IPlay settings related to SL_PLAYEVENT_*
246void GenericPlayer::setPlayEvents(int32_t eventFlags, int32_t markerPositionMs,
247        int32_t positionUpdatePeriodMs)
248{
249    // Normalize ms that are within the valid unsigned range, but not in the int32_t range
250    if (markerPositionMs < 0) {
251        markerPositionMs = ANDROID_UNKNOWN_TIME;
252    }
253    if (positionUpdatePeriodMs < 0) {
254        positionUpdatePeriodMs = ANDROID_UNKNOWN_TIME;
255    }
256    // markers are delivered accurately, but new position updates are limited to every 100 ms
257    if (positionUpdatePeriodMs < 100) {
258        positionUpdatePeriodMs = 100;
259    }
260    sp<AMessage> msg = new AMessage(kWhatSetPlayEvents, this);
261    msg->setInt32(WHATPARAM_SETPLAYEVENTS_FLAGS, eventFlags);
262    msg->setInt32(WHATPARAM_SETPLAYEVENTS_MARKER, markerPositionMs);
263    msg->setInt32(WHATPARAM_SETPLAYEVENTS_UPDATE, positionUpdatePeriodMs);
264    msg->post();
265}
266
267
268//--------------------------------------------------
269/*
270 * post-condition: mDataLocatorType == kDataLocatorNone
271 *
272 */
273void GenericPlayer::resetDataLocator() {
274    SL_LOGV("GenericPlayer::resetDataLocator()");
275    if (mDataLocatorType == kDataLocatorFd && mDataLocator.fdi.mCloseAfterUse) {
276        (void) ::close(mDataLocator.fdi.fd);
277        // would be redundant, as we're about to invalidate the union mDataLocator
278        //mDataLocator.fdi.fd = -1;
279        //mDataLocator.fdi.mCloseAfterUse = false;
280    }
281    mDataLocatorType = kDataLocatorNone;
282}
283
284
285void GenericPlayer::notify(const char* event, int data, bool async) {
286    SL_LOGV("GenericPlayer::notify(event=%s, data=%d, async=%s)", event, data,
287            async ? "true" : "false");
288    sp<AMessage> msg = new AMessage(kWhatNotif, this);
289    msg->setInt32(event, (int32_t)data);
290    if (async) {
291        msg->post();
292    } else {
293        onNotify(msg);
294    }
295}
296
297
298void GenericPlayer::notify(const char* event, int data1, int data2, bool async) {
299    SL_LOGV("GenericPlayer::notify(event=%s, data1=%d, data2=%d, async=%s)", event, data1, data2,
300            async ? "true" : "false");
301    sp<AMessage> msg = new AMessage(kWhatNotif, this);
302    msg->setRect(event, 0, 0, (int32_t)data1, (int32_t)data2);
303    if (async) {
304        msg->post();
305    } else {
306        onNotify(msg);
307    }
308}
309
310
311//--------------------------------------------------
312// AHandler implementation
313void GenericPlayer::onMessageReceived(const sp<AMessage> &msg) {
314    SL_LOGV("GenericPlayer::onMessageReceived()");
315    switch (msg->what()) {
316        case kWhatPrepare:
317            SL_LOGV("kWhatPrepare");
318            onPrepare();
319            break;
320
321        case kWhatNotif:
322            SL_LOGV("kWhatNotif");
323            onNotify(msg);
324            break;
325
326        case kWhatPlay:
327            SL_LOGV("kWhatPlay");
328            onPlay();
329            break;
330
331        case kWhatPause:
332            SL_LOGV("kWhatPause");
333            onPause();
334            break;
335
336        case kWhatSeek:
337            SL_LOGV("kWhatSeek");
338            onSeek(msg);
339            break;
340
341        case kWhatLoop:
342            SL_LOGV("kWhatLoop");
343            onLoop(msg);
344            break;
345
346        case kWhatVolumeUpdate:
347            SL_LOGV("kWhatVolumeUpdate");
348            onVolumeUpdate();
349            break;
350
351        case kWhatSeekComplete:
352            SL_LOGV("kWhatSeekComplete");
353            onSeekComplete();
354            break;
355
356        case kWhatBufferingUpdate:
357            SL_LOGV("kWhatBufferingUpdate");
358            onBufferingUpdate(msg);
359            break;
360
361        case kWhatBuffUpdateThres:
362            SL_LOGV("kWhatBuffUpdateThres");
363            onSetBufferingUpdateThreshold(msg);
364            break;
365
366        case kWhatAttachAuxEffect:
367            SL_LOGV("kWhatAttachAuxEffect");
368            onAttachAuxEffect(msg);
369            break;
370
371        case kWhatSetAuxEffectSendLevel:
372            SL_LOGV("kWhatSetAuxEffectSendLevel");
373            onSetAuxEffectSendLevel(msg);
374            break;
375
376        case kWhatSetPlayEvents:
377            SL_LOGV("kWhatSetPlayEvents");
378            onSetPlayEvents(msg);
379            break;
380
381        case kWhatOneShot:
382            SL_LOGV("kWhatOneShot");
383            onOneShot(msg);
384            break;
385
386        default:
387            SL_LOGE("GenericPlayer::onMessageReceived unknown message %d", msg->what());
388            TRESPASS();
389    }
390}
391
392
393//--------------------------------------------------
394// Event handlers
395//  it is strictly verboten to call those methods outside of the event loop
396
397void GenericPlayer::onPrepare() {
398    SL_LOGV("GenericPlayer::onPrepare()");
399    // Subclass is responsible for indicating whether prepare was successful or unsuccessful
400    // by updating mStateFlags accordingly.  It must set exactly one of these two flags.
401    assert(!(mStateFlags & kFlagPrepared) != !(mStateFlags & kFlagPreparedUnsuccessfully));
402    notify(PLAYEREVENT_PREPARED, mStateFlags & kFlagPrepared ? PLAYER_SUCCESS : PLAYER_FAILURE,
403            true /*async*/);
404    SL_LOGD("GenericPlayer::onPrepare() done, mStateFlags=0x%x", mStateFlags);
405}
406
407
408void GenericPlayer::onNotify(const sp<AMessage> &msg) {
409    SL_LOGV("GenericPlayer::onNotify()");
410    notif_cbf_t notifClient;
411    void*       notifUser;
412    {
413        android::Mutex::Autolock autoLock(mNotifyClientLock);
414        if (NULL == mNotifyClient) {
415            return;
416        } else {
417            notifClient = mNotifyClient;
418            notifUser   = mNotifyUser;
419        }
420    }
421
422    int32_t val1, val2;
423    if (msg->findInt32(PLAYEREVENT_PREFETCHSTATUSCHANGE, &val1)) {
424        SL_LOGV("GenericPlayer notifying %s = %d", PLAYEREVENT_PREFETCHSTATUSCHANGE, val1);
425        notifClient(kEventPrefetchStatusChange, val1, 0, notifUser);
426    // There is exactly one notification per message, hence "else if" instead of "if"
427    } else if (msg->findInt32(PLAYEREVENT_PREFETCHFILLLEVELUPDATE, &val1)) {
428        SL_LOGV("GenericPlayer notifying %s = %d", PLAYEREVENT_PREFETCHFILLLEVELUPDATE, val1);
429        notifClient(kEventPrefetchFillLevelUpdate, val1, 0, notifUser);
430    } else if (msg->findInt32(PLAYEREVENT_ENDOFSTREAM, &val1)) {
431        SL_LOGV("GenericPlayer notifying %s = %d", PLAYEREVENT_ENDOFSTREAM, val1);
432        notifClient(kEventEndOfStream, val1, 0, notifUser);
433    } else if (msg->findInt32(PLAYEREVENT_PREPARED, &val1)) {
434        SL_LOGV("GenericPlayer notifying %s = %d", PLAYEREVENT_PREPARED, val1);
435        notifClient(kEventPrepared, val1, 0, notifUser);
436    } else if (msg->findInt32(PLAYEREVENT_CHANNEL_COUNT, &val1)) {
437        SL_LOGV("GenericPlayer notifying %s = %d", PLAYEREVENT_CHANNEL_COUNT, val1);
438        notifClient(kEventChannelCount, val1, 0, notifUser);
439    } else if (msg->findRect(PLAYEREVENT_VIDEO_SIZE_UPDATE, &val1, &val2, &val1, &val2)) {
440        SL_LOGV("GenericPlayer notifying %s = %d, %d", PLAYEREVENT_VIDEO_SIZE_UPDATE, val1, val2);
441        notifClient(kEventHasVideoSize, val1, val2, notifUser);
442    } else if (msg->findInt32(PLAYEREVENT_PLAY, &val1)) {
443        SL_LOGV("GenericPlayer notifying %s = %d", PLAYEREVENT_PLAY, val1);
444        notifClient(kEventPlay, val1, 0, notifUser);
445    } else if (msg->findInt32(PLAYEREVENT_ERRORAFTERPREPARE, &val1)) {
446        SL_LOGV("GenericPlayer notifying %s = %d", PLAYEREVENT_ERRORAFTERPREPARE, val1);
447        notifClient(kEventErrorAfterPrepare, val1, 0, notifUser);
448    } else {
449        SL_LOGV("GenericPlayer notifying unknown");
450    }
451}
452
453
454void GenericPlayer::onPlay() {
455    SL_LOGD("GenericPlayer::onPlay()");
456    if ((mStateFlags & (kFlagPrepared | kFlagPlaying)) == kFlagPrepared) {
457        SL_LOGD("starting player");
458        mStateFlags |= kFlagPlaying;
459        updateOneShot();
460    }
461}
462
463
464void GenericPlayer::onPause() {
465    SL_LOGD("GenericPlayer::onPause()");
466    if (!(~mStateFlags & (kFlagPrepared | kFlagPlaying))) {
467        SL_LOGV("pausing player");
468        mStateFlags &= ~kFlagPlaying;
469        updateOneShot();
470    }
471}
472
473
474void GenericPlayer::onSeek(const sp<AMessage> &msg) {
475    SL_LOGV("GenericPlayer::onSeek");
476}
477
478
479void GenericPlayer::onLoop(const sp<AMessage> &msg) {
480    SL_LOGV("GenericPlayer::onLoop");
481}
482
483
484void GenericPlayer::onVolumeUpdate() {
485    SL_LOGV("GenericPlayer::onVolumeUpdate");
486}
487
488
489void GenericPlayer::onSeekComplete() {
490    SL_LOGD("GenericPlayer::onSeekComplete()");
491    mStateFlags &= ~kFlagSeeking;
492    // avoid spurious or lost events caused by seeking past a marker
493    mDeliveredNewPosMs = ANDROID_UNKNOWN_TIME;
494    mObservedPositionMs = ANDROID_UNKNOWN_TIME;
495    updateOneShot();
496}
497
498
499void GenericPlayer::onBufferingUpdate(const sp<AMessage> &msg) {
500    SL_LOGV("GenericPlayer::onBufferingUpdate");
501}
502
503
504void GenericPlayer::onSetBufferingUpdateThreshold(const sp<AMessage> &msg) {
505    SL_LOGV("GenericPlayer::onSetBufferingUpdateThreshold");
506    int32_t thresholdPercent = 0;
507    if (msg->findInt32(WHATPARAM_BUFFERING_UPDATETHRESHOLD_PERCENT, &thresholdPercent)) {
508        Mutex::Autolock _l(mSettingsLock);
509        mCacheFillNotifThreshold = (int16_t)thresholdPercent;
510    }
511}
512
513
514void GenericPlayer::onAttachAuxEffect(const sp<AMessage> &msg) {
515    SL_LOGV("GenericPlayer::onAttachAuxEffect()");
516}
517
518
519void GenericPlayer::onSetAuxEffectSendLevel(const sp<AMessage> &msg) {
520    SL_LOGV("GenericPlayer::onSetAuxEffectSendLevel()");
521}
522
523
524void GenericPlayer::onSetPlayEvents(const sp<AMessage> &msg) {
525    SL_LOGV("GenericPlayer::onSetPlayEvents()");
526    int32_t eventFlags, markerPositionMs, positionUpdatePeriodMs;
527    if (msg->findInt32(WHATPARAM_SETPLAYEVENTS_FLAGS, &eventFlags) &&
528            msg->findInt32(WHATPARAM_SETPLAYEVENTS_MARKER, &markerPositionMs) &&
529            msg->findInt32(WHATPARAM_SETPLAYEVENTS_UPDATE, &positionUpdatePeriodMs)) {
530        mEventFlags = eventFlags;
531        mMarkerPositionMs = markerPositionMs;
532        mPositionUpdatePeriodMs = positionUpdatePeriodMs;
533        updateOneShot();
534    }
535}
536
537
538void GenericPlayer::onOneShot(const sp<AMessage> &msg) {
539    SL_LOGV("GenericPlayer::onOneShot()");
540    int32_t generation;
541    if (msg->findInt32(WHATPARAM_ONESHOT_GENERATION, &generation)) {
542        if (generation != mOneShotGeneration) {
543            SL_LOGV("GenericPlayer::onOneShot() generation %d cancelled; latest is %d",
544                    generation, mOneShotGeneration);
545            return;
546        }
547        updateOneShot();
548    }
549}
550
551
552//-------------------------------------------------
553void GenericPlayer::notifyStatus() {
554    SL_LOGV("GenericPlayer::notifyStatus");
555    notify(PLAYEREVENT_PREFETCHSTATUSCHANGE, (int32_t)mCacheStatus, true /*async*/);
556}
557
558
559void GenericPlayer::notifyCacheFill() {
560    SL_LOGV("GenericPlayer::notifyCacheFill");
561    mLastNotifiedCacheFill = mCacheFill;
562    notify(PLAYEREVENT_PREFETCHFILLLEVELUPDATE, (int32_t)mLastNotifiedCacheFill, true/*async*/);
563}
564
565
566void GenericPlayer::seekComplete() {
567    SL_LOGV("GenericPlayer::seekComplete");
568    sp<AMessage> msg = new AMessage(kWhatSeekComplete, this);
569    msg->post();
570}
571
572
573void GenericPlayer::bufferingUpdate(int16_t fillLevelPerMille) {
574    SL_LOGV("GenericPlayer::bufferingUpdate");
575    sp<AMessage> msg = new AMessage(kWhatBufferingUpdate, this);
576    msg->setInt32(WHATPARAM_BUFFERING_UPDATE, fillLevelPerMille);
577    msg->post();
578}
579
580
581// For the meaning of positionMs, see comment in declaration at android_GenericPlayer.h
582void GenericPlayer::updateOneShot(int positionMs)
583{
584    SL_LOGV("GenericPlayer::updateOneShot");
585
586    // nop until prepared
587    if (!(mStateFlags & kFlagPrepared)) {
588        return;
589    }
590
591    // cancel any pending one-shot(s)
592    ++mOneShotGeneration;
593
594    // don't restart one-shot if player is paused or stopped
595    if (!(mStateFlags & kFlagPlaying)) {
596        return;
597    }
598
599    // get current player position in milliseconds
600    if (positionMs < 0) {
601        positionMs = ANDROID_UNKNOWN_TIME;
602    }
603    if (positionMs == ANDROID_UNKNOWN_TIME) {
604        getPositionMsec(&positionMs);
605        // normalize it
606        if (positionMs < 0) {
607            positionMs = ANDROID_UNKNOWN_TIME;
608        }
609        if (ANDROID_UNKNOWN_TIME == positionMs) {
610            // getPositionMsec is not working for some reason, give up
611            //ALOGV("Does anyone really know what time it is?");
612            return;
613        }
614    }
615
616    // if we observe the player position going backwards, even without without a seek, then recover
617    if (mObservedPositionMs != ANDROID_UNKNOWN_TIME && positionMs < mObservedPositionMs) {
618        mDeliveredNewPosMs = ANDROID_UNKNOWN_TIME;
619        mObservedPositionMs = positionMs;
620    }
621
622    // delayUs is the expected delay between current position and marker;
623    // the default is infinity in case there are no upcoming marker(s)
624    int64_t delayUs = -1;
625
626    // is there a marker?
627    if ((mEventFlags & SL_PLAYEVENT_HEADATMARKER) && (mMarkerPositionMs != ANDROID_UNKNOWN_TIME)) {
628        // check to see if we have observed the position passing through the marker
629        if (mObservedPositionMs <= mMarkerPositionMs && mMarkerPositionMs <= positionMs) {
630            notify(PLAYEREVENT_PLAY, (int32_t) SL_PLAYEVENT_HEADATMARKER, true /*async*/);
631        } else if (positionMs < mMarkerPositionMs) {
632            delayUs = (mMarkerPositionMs - positionMs) * 1000LL;
633        }
634    }
635
636    // are periodic position updates needed?
637    if ((mEventFlags & SL_PLAYEVENT_HEADATNEWPOS) &&
638            (mPositionUpdatePeriodMs != ANDROID_UNKNOWN_TIME)) {
639        // check to see if we have observed the position passing through a virtual marker, where the
640        // virtual marker is at the previously delivered new position plus position update period
641        int32_t virtualMarkerMs;
642        if (mDeliveredNewPosMs != ANDROID_UNKNOWN_TIME) {
643            virtualMarkerMs = mDeliveredNewPosMs + mPositionUpdatePeriodMs;
644        } else if (mObservedPositionMs != ANDROID_UNKNOWN_TIME) {
645            virtualMarkerMs = mObservedPositionMs + mPositionUpdatePeriodMs;
646            // pretend there has been an update in the past
647            mDeliveredNewPosMs = mObservedPositionMs;
648        } else {
649            virtualMarkerMs = positionMs + mPositionUpdatePeriodMs;
650            // pretend there has been an update in the past
651            mDeliveredNewPosMs = positionMs;
652        }
653        // nextVirtualMarkerMs will be set to the position of the next upcoming virtual marker
654        int32_t nextVirtualMarkerMs;
655        if (mObservedPositionMs <= virtualMarkerMs && virtualMarkerMs <= positionMs) {
656            // we did pass through the virtual marker, now compute the next virtual marker
657            mDeliveredNewPosMs = virtualMarkerMs;
658            nextVirtualMarkerMs = virtualMarkerMs + mPositionUpdatePeriodMs;
659            // re-synchronize if we missed an update
660            if (nextVirtualMarkerMs <= positionMs) {
661                SL_LOGW("Missed SL_PLAYEVENT_HEADATNEWPOS for position %d; current position %d",
662                        nextVirtualMarkerMs, positionMs);
663                // try to catch up by setting next goal to current position plus update period
664                mDeliveredNewPosMs = positionMs;
665                nextVirtualMarkerMs = positionMs + mPositionUpdatePeriodMs;
666            }
667            notify(PLAYEREVENT_PLAY, (int32_t) SL_PLAYEVENT_HEADATNEWPOS, true /*async*/);
668        } else {
669            // we did not pass through the virtual marker yet, so use same marker again
670            nextVirtualMarkerMs = virtualMarkerMs;
671        }
672        // note that if arithmetic overflow occurred, nextVirtualMarkerMs will be negative
673        if (positionMs < nextVirtualMarkerMs) {
674            int64_t trialDelayUs;
675            trialDelayUs = (nextVirtualMarkerMs - positionMs) * 1000LL;
676            if (trialDelayUs > 0 && (delayUs == -1 || trialDelayUs < delayUs)) {
677                delayUs = trialDelayUs;
678            }
679        }
680    }
681
682    // we have a new observed position
683    mObservedPositionMs = positionMs;
684
685    if (mPlaybackRatePermille == 0) {
686        // playback is frozen, no update expected (and no division by zero below)
687        return;
688    }
689
690    // post the new one-shot message if needed
691    if (advancesPositionInRealTime() && delayUs >= 0) {
692        // scale delay according to playback rate (reported positions won't change, but reported
693        // time will advance slower or faster depending on rate)
694        {
695            Mutex::Autolock _l(mSettingsLock);
696            delayUs =  delayUs * 1000 / mPlaybackRatePermille;
697        }
698
699        // 20 ms min delay to avoid near busy waiting
700        if (delayUs < 20000LL) {
701            delayUs = 20000LL;
702        }
703        // 1 minute max delay avoids indefinite memory leaks caused by cancelled one-shots
704        if (delayUs > 60000000LL) {
705            delayUs = 60000000LL;
706        }
707        //SL_LOGI("delayUs = %lld", delayUs);
708        sp<AMessage> msg = new AMessage(kWhatOneShot, this);
709        msg->setInt32(WHATPARAM_ONESHOT_GENERATION, mOneShotGeneration);
710        msg->post(delayUs);
711    }
712
713}
714
715} // namespace android
716