1/*
2 * Copyright (C) 2010 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/* Play implementation */
18
19#include "sles_allinclusive.h"
20
21
22static SLresult IPlay_SetPlayState(SLPlayItf self, SLuint32 state)
23{
24    SL_ENTER_INTERFACE
25
26    switch (state) {
27    case SL_PLAYSTATE_STOPPED:
28    case SL_PLAYSTATE_PAUSED:
29    case SL_PLAYSTATE_PLAYING:
30        {
31        IPlay *thiz = (IPlay *) self;
32        unsigned attr = ATTR_NONE;
33        result = SL_RESULT_SUCCESS;
34#ifdef USE_OUTPUTMIXEXT
35        CAudioPlayer *audioPlayer = (SL_OBJECTID_AUDIOPLAYER == InterfaceToObjectID(thiz)) ?
36            (CAudioPlayer *) thiz->mThis : NULL;
37#endif
38        interface_lock_exclusive(thiz);
39        SLuint32 oldState = thiz->mState;
40        if (state != oldState) {
41#ifdef USE_OUTPUTMIXEXT
42          for (;; interface_cond_wait(thiz)) {
43
44            // We are comparing the old state (left) vs. new state (right).
45            // Note that the old state is 3 bits wide, but new state is only 2 bits wide.
46            // That is why the old state is on the left and new state is on the right.
47            switch ((oldState << 2) | state) {
48
49            case (SL_PLAYSTATE_STOPPED  << 2) | SL_PLAYSTATE_STOPPED:
50            case (SL_PLAYSTATE_PAUSED   << 2) | SL_PLAYSTATE_PAUSED:
51            case (SL_PLAYSTATE_PLAYING  << 2) | SL_PLAYSTATE_PLAYING:
52               // no-op, and unreachable due to earlier "if (state != oldState)"
53                break;
54
55            case (SL_PLAYSTATE_STOPPED  << 2) | SL_PLAYSTATE_PLAYING:
56            case (SL_PLAYSTATE_PAUSED   << 2) | SL_PLAYSTATE_PLAYING:
57                attr = ATTR_PLAY_STATE;
58                // set enqueue attribute if queue is non-empty and state becomes PLAYING
59                if ((NULL != audioPlayer) && (audioPlayer->mBufferQueue.mFront !=
60                    audioPlayer->mBufferQueue.mRear)) {
61                    // note that USE_OUTPUTMIXEXT does not support ATTR_ABQ_ENQUEUE
62                    attr |= ATTR_BQ_ENQUEUE;
63                }
64                // fall through
65
66            case (SL_PLAYSTATE_STOPPED  << 2) | SL_PLAYSTATE_PAUSED:
67            case (SL_PLAYSTATE_PLAYING  << 2) | SL_PLAYSTATE_PAUSED:
68                // easy
69                thiz->mState = state;
70                break;
71
72            case (SL_PLAYSTATE_STOPPING << 2) | SL_PLAYSTATE_STOPPED:
73                // either spurious wakeup, or someone else requested same transition
74                continue;
75
76            case (SL_PLAYSTATE_STOPPING << 2) | SL_PLAYSTATE_PAUSED:
77            case (SL_PLAYSTATE_STOPPING << 2) | SL_PLAYSTATE_PLAYING:
78                // wait for other guy to finish his transition, then retry ours
79                continue;
80
81            case (SL_PLAYSTATE_PAUSED   << 2) | SL_PLAYSTATE_STOPPED:
82            case (SL_PLAYSTATE_PLAYING  << 2) | SL_PLAYSTATE_STOPPED:
83                // tell mixer to stop, then wait for mixer to acknowledge the request to stop
84                thiz->mState = SL_PLAYSTATE_STOPPING;
85                continue;
86
87            default:
88                // unexpected state
89                assert(SL_BOOLEAN_FALSE);
90                result = SL_RESULT_INTERNAL_ERROR;
91                break;
92
93            }
94
95            break;
96          }
97#else
98          // Here life looks easy for an Android, but there are other troubles in play land
99          thiz->mState = state;
100          attr = ATTR_PLAY_STATE;
101          // no need to set ATTR_BQ_ENQUEUE or ATTR_ABQ_ENQUEUE
102#endif
103        }
104        // SL_LOGD("set play state %d", state);
105        interface_unlock_exclusive_attributes(thiz, attr);
106        }
107        break;
108    default:
109        result = SL_RESULT_PARAMETER_INVALID;
110        break;
111    }
112
113    SL_LEAVE_INTERFACE
114}
115
116
117static SLresult IPlay_GetPlayState(SLPlayItf self, SLuint32 *pState)
118{
119    SL_ENTER_INTERFACE
120
121    if (NULL == pState) {
122        result = SL_RESULT_PARAMETER_INVALID;
123    } else {
124        IPlay *thiz = (IPlay *) self;
125        interface_lock_shared(thiz);
126        SLuint32 state = thiz->mState;
127        interface_unlock_shared(thiz);
128        result = SL_RESULT_SUCCESS;
129#ifdef USE_OUTPUTMIXEXT
130        switch (state) {
131        case SL_PLAYSTATE_STOPPED:  // as is
132        case SL_PLAYSTATE_PAUSED:
133        case SL_PLAYSTATE_PLAYING:
134            break;
135        case SL_PLAYSTATE_STOPPING: // these states require re-mapping
136            state = SL_PLAYSTATE_STOPPED;
137            break;
138        default:                    // impossible
139            assert(SL_BOOLEAN_FALSE);
140            state = SL_PLAYSTATE_STOPPED;
141            result = SL_RESULT_INTERNAL_ERROR;
142            break;
143        }
144#endif
145        *pState = state;
146    }
147
148    SL_LEAVE_INTERFACE
149}
150
151
152static SLresult IPlay_GetDuration(SLPlayItf self, SLmillisecond *pMsec)
153{
154    SL_ENTER_INTERFACE
155
156    if (NULL == pMsec) {
157        result = SL_RESULT_PARAMETER_INVALID;
158    } else {
159        result = SL_RESULT_SUCCESS;
160        IPlay *thiz = (IPlay *) self;
161        // even though this is a getter, it can modify state due to caching
162        interface_lock_exclusive(thiz);
163        SLmillisecond duration = thiz->mDuration;
164#ifdef ANDROID
165        if (SL_TIME_UNKNOWN == duration) {
166            SLmillisecond temp;
167            switch (InterfaceToObjectID(thiz)) {
168            case SL_OBJECTID_AUDIOPLAYER:
169                result = android_audioPlayer_getDuration(thiz, &temp);
170                break;
171            case XA_OBJECTID_MEDIAPLAYER:
172                result = android_Player_getDuration(thiz, &temp);
173                break;
174            default:
175                result = SL_RESULT_FEATURE_UNSUPPORTED;
176                break;
177            }
178            if (SL_RESULT_SUCCESS == result) {
179                duration = temp;
180                thiz->mDuration = duration;
181            }
182        }
183#else
184        // will be set by containing AudioPlayer or MidiPlayer object at Realize, if known,
185        // otherwise the duration will be updated each time a new maximum position is detected
186#endif
187        interface_unlock_exclusive(thiz);
188        *pMsec = duration;
189    }
190
191    SL_LEAVE_INTERFACE
192}
193
194
195static SLresult IPlay_GetPosition(SLPlayItf self, SLmillisecond *pMsec)
196{
197    SL_ENTER_INTERFACE
198
199    if (NULL == pMsec) {
200        result = SL_RESULT_PARAMETER_INVALID;
201    } else {
202        IPlay *thiz = (IPlay *) self;
203        SLmillisecond position;
204        interface_lock_shared(thiz);
205#ifdef ANDROID
206        // Android does not use the mPosition field for audio and media players
207        //  and doesn't cache the position
208        switch (IObjectToObjectID((thiz)->mThis)) {
209          case SL_OBJECTID_AUDIOPLAYER:
210            android_audioPlayer_getPosition(thiz, &position);
211            break;
212          case XA_OBJECTID_MEDIAPLAYER:
213            android_Player_getPosition(thiz, &position);
214            break;
215          default:
216            // we shouldn'be here
217            assert(SL_BOOLEAN_FALSE);
218        }
219#else
220        // on other platforms we depend on periodic updates to the current position
221        position = thiz->mPosition;
222        // if a seek is pending, then lie about current position so the seek appears synchronous
223        if (SL_OBJECTID_AUDIOPLAYER == InterfaceToObjectID(thiz)) {
224            CAudioPlayer *audioPlayer = (CAudioPlayer *) thiz->mThis;
225            SLmillisecond pos = audioPlayer->mSeek.mPos;
226            if (SL_TIME_UNKNOWN != pos) {
227                position = pos;
228            }
229        }
230#endif
231        interface_unlock_shared(thiz);
232        *pMsec = position;
233        result = SL_RESULT_SUCCESS;
234    }
235
236    SL_LEAVE_INTERFACE
237}
238
239
240static SLresult IPlay_RegisterCallback(SLPlayItf self, slPlayCallback callback, void *pContext)
241{
242    SL_ENTER_INTERFACE
243
244    IPlay *thiz = (IPlay *) self;
245    interface_lock_exclusive(thiz);
246    thiz->mCallback = callback;
247    thiz->mContext = pContext;
248    // omits _attributes b/c noone cares deeply enough about these fields to need quick notification
249    interface_unlock_exclusive(thiz);
250    result = SL_RESULT_SUCCESS;
251
252    SL_LEAVE_INTERFACE
253}
254
255
256static SLresult IPlay_SetCallbackEventsMask(SLPlayItf self, SLuint32 eventFlags)
257{
258    SL_ENTER_INTERFACE
259
260    if (eventFlags & ~(SL_PLAYEVENT_HEADATEND | SL_PLAYEVENT_HEADATMARKER |
261            SL_PLAYEVENT_HEADATNEWPOS | SL_PLAYEVENT_HEADMOVING | SL_PLAYEVENT_HEADSTALLED)) {
262        result = SL_RESULT_PARAMETER_INVALID;
263    } else {
264        IPlay *thiz = (IPlay *) self;
265        interface_lock_exclusive(thiz);
266        if (thiz->mEventFlags != eventFlags) {
267#ifdef USE_OUTPUTMIXEXT
268            // enabling the "head at new position" play event will postpone the next update event
269            if (!(thiz->mEventFlags & SL_PLAYEVENT_HEADATNEWPOS) &&
270                    (eventFlags & SL_PLAYEVENT_HEADATNEWPOS)) {
271                thiz->mFramesSincePositionUpdate = 0;
272            }
273#endif
274            thiz->mEventFlags = eventFlags;
275            interface_unlock_exclusive_attributes(thiz, ATTR_TRANSPORT);
276        } else {
277            interface_unlock_exclusive(thiz);
278        }
279        result = SL_RESULT_SUCCESS;
280    }
281
282    SL_LEAVE_INTERFACE
283}
284
285
286static SLresult IPlay_GetCallbackEventsMask(SLPlayItf self, SLuint32 *pEventFlags)
287{
288    SL_ENTER_INTERFACE
289
290    if (NULL == pEventFlags) {
291        result = SL_RESULT_PARAMETER_INVALID;
292    } else {
293        IPlay *thiz = (IPlay *) self;
294        interface_lock_shared(thiz);
295        SLuint32 eventFlags = thiz->mEventFlags;
296        interface_unlock_shared(thiz);
297        *pEventFlags = eventFlags;
298        result = SL_RESULT_SUCCESS;
299    }
300
301    SL_LEAVE_INTERFACE
302}
303
304
305static SLresult IPlay_SetMarkerPosition(SLPlayItf self, SLmillisecond mSec)
306{
307    SL_ENTER_INTERFACE
308
309    if (SL_TIME_UNKNOWN == mSec) {
310        result = SL_RESULT_PARAMETER_INVALID;
311    } else {
312        IPlay *thiz = (IPlay *) self;
313        bool significant = false;
314        interface_lock_exclusive(thiz);
315        if (thiz->mMarkerPosition != mSec) {
316            thiz->mMarkerPosition = mSec;
317            if (thiz->mEventFlags & SL_PLAYEVENT_HEADATMARKER) {
318                significant = true;
319            }
320        }
321        if (significant) {
322            interface_unlock_exclusive_attributes(thiz, ATTR_TRANSPORT);
323        } else {
324            interface_unlock_exclusive(thiz);
325        }
326        result = SL_RESULT_SUCCESS;
327    }
328
329    SL_LEAVE_INTERFACE
330}
331
332
333static SLresult IPlay_ClearMarkerPosition(SLPlayItf self)
334{
335    SL_ENTER_INTERFACE
336
337    IPlay *thiz = (IPlay *) self;
338    bool significant = false;
339    interface_lock_exclusive(thiz);
340    // clearing the marker position is equivalent to setting the marker to SL_TIME_UNKNOWN
341    if (thiz->mMarkerPosition != SL_TIME_UNKNOWN) {
342        thiz->mMarkerPosition = SL_TIME_UNKNOWN;
343        if (thiz->mEventFlags & SL_PLAYEVENT_HEADATMARKER) {
344            significant = true;
345        }
346    }
347    if (significant) {
348        interface_unlock_exclusive_attributes(thiz, ATTR_TRANSPORT);
349    } else {
350        interface_unlock_exclusive(thiz);
351    }
352    result = SL_RESULT_SUCCESS;
353
354    SL_LEAVE_INTERFACE
355}
356
357
358static SLresult IPlay_GetMarkerPosition(SLPlayItf self, SLmillisecond *pMsec)
359{
360    SL_ENTER_INTERFACE
361
362    if (NULL == pMsec) {
363        result = SL_RESULT_PARAMETER_INVALID;
364    } else {
365        IPlay *thiz = (IPlay *) self;
366        interface_lock_shared(thiz);
367        SLmillisecond markerPosition = thiz->mMarkerPosition;
368        interface_unlock_shared(thiz);
369        *pMsec = markerPosition;
370        if (SL_TIME_UNKNOWN == markerPosition) {
371            result = SL_RESULT_PRECONDITIONS_VIOLATED;
372        } else {
373            result = SL_RESULT_SUCCESS;
374        }
375    }
376
377    SL_LEAVE_INTERFACE
378}
379
380
381static SLresult IPlay_SetPositionUpdatePeriod(SLPlayItf self, SLmillisecond mSec)
382{
383    SL_ENTER_INTERFACE
384
385    if (0 == mSec) {
386        result = SL_RESULT_PARAMETER_INVALID;
387    } else {
388        IPlay *thiz = (IPlay *) self;
389        bool significant = false;
390        interface_lock_exclusive(thiz);
391        if (thiz->mPositionUpdatePeriod != mSec) {
392            thiz->mPositionUpdatePeriod = mSec;
393#ifdef USE_OUTPUTMIXEXT
394            if (SL_OBJECTID_AUDIOPLAYER == InterfaceToObjectID(thiz)) {
395                CAudioPlayer *audioPlayer = (CAudioPlayer *) thiz->mThis;
396                SLuint32 frameUpdatePeriod = ((long long) mSec *
397                    (long long) audioPlayer->mSampleRateMilliHz) / 1000000LL;
398                if (0 == frameUpdatePeriod) {
399                    frameUpdatePeriod = ~0;
400                }
401                thiz->mFrameUpdatePeriod = frameUpdatePeriod;
402                // setting a new update period postpones the next callback
403                thiz->mFramesSincePositionUpdate = 0;
404            }
405#endif
406            if (thiz->mEventFlags & SL_PLAYEVENT_HEADATNEWPOS) {
407                significant = true;
408            }
409        }
410        if (significant) {
411            interface_unlock_exclusive_attributes(thiz, ATTR_TRANSPORT);
412        } else {
413            interface_unlock_exclusive(thiz);
414        }
415        result = SL_RESULT_SUCCESS;
416    }
417
418    SL_LEAVE_INTERFACE
419}
420
421
422static SLresult IPlay_GetPositionUpdatePeriod(SLPlayItf self, SLmillisecond *pMsec)
423{
424    SL_ENTER_INTERFACE
425
426    if (NULL == pMsec) {
427        result = SL_RESULT_PARAMETER_INVALID;
428    } else {
429        IPlay *thiz = (IPlay *) self;
430        interface_lock_shared(thiz);
431        SLmillisecond positionUpdatePeriod = thiz->mPositionUpdatePeriod;
432        interface_unlock_shared(thiz);
433        *pMsec = positionUpdatePeriod;
434        result = SL_RESULT_SUCCESS;
435    }
436
437    SL_LEAVE_INTERFACE
438}
439
440
441static const struct SLPlayItf_ IPlay_Itf = {
442    IPlay_SetPlayState,
443    IPlay_GetPlayState,
444    IPlay_GetDuration,
445    IPlay_GetPosition,
446    IPlay_RegisterCallback,
447    IPlay_SetCallbackEventsMask,
448    IPlay_GetCallbackEventsMask,
449    IPlay_SetMarkerPosition,
450    IPlay_ClearMarkerPosition,
451    IPlay_GetMarkerPosition,
452    IPlay_SetPositionUpdatePeriod,
453    IPlay_GetPositionUpdatePeriod
454};
455
456void IPlay_init(void *self)
457{
458    IPlay *thiz = (IPlay *) self;
459    thiz->mItf = &IPlay_Itf;
460    thiz->mState = SL_PLAYSTATE_STOPPED;
461    thiz->mDuration = SL_TIME_UNKNOWN;  // will be set by containing player object
462    thiz->mPosition = (SLmillisecond) 0;
463    thiz->mCallback = NULL;
464    thiz->mContext = NULL;
465    thiz->mEventFlags = 0;
466    thiz->mMarkerPosition = SL_TIME_UNKNOWN;
467    thiz->mPositionUpdatePeriod = 1000; // per spec
468#ifdef USE_OUTPUTMIXEXT
469    thiz->mFrameUpdatePeriod = 0;   // because we don't know the sample rate yet
470    thiz->mLastSeekPosition = 0;
471    thiz->mFramesSinceLastSeek = 0;
472    thiz->mFramesSincePositionUpdate = 0;
473#endif
474}
475