NuPlayerDriver.cpp revision 09e0c3646362d29c78bc26c8b23b7a753c412e6c 
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//#define LOG_NDEBUG 0
18#define LOG_TAG "NuPlayerDriver"
19#include <inttypes.h>
20#include <utils/Log.h>
21
22#include "NuPlayerDriver.h"
23
24#include "NuPlayer.h"
25#include "NuPlayerSource.h"
26
27#include <media/stagefright/foundation/ADebug.h>
28#include <media/stagefright/foundation/ALooper.h>
29#include <media/stagefright/MetaData.h>
30
31namespace android {
32
33NuPlayerDriver::NuPlayerDriver()
34    : mState(STATE_IDLE),
35      mIsAsyncPrepare(false),
36      mAsyncResult(UNKNOWN_ERROR),
37      mSetSurfaceInProgress(false),
38      mDurationUs(-1),
39      mPositionUs(-1),
40      mNotifyTimeRealUs(-1),
41      mPauseStartedTimeUs(-1),
42      mNumFramesTotal(0),
43      mNumFramesDropped(0),
44      mLooper(new ALooper),
45      mPlayerFlags(0),
46      mAtEOS(false),
47      mLooping(false),
48      mStartupSeekTimeUs(-1) {
49    mLooper->setName("NuPlayerDriver Looper");
50
51    mLooper->start(
52            false, /* runOnCallingThread */
53            true,  /* canCallJava */
54            PRIORITY_AUDIO);
55
56    mPlayer = new NuPlayer;
57    mLooper->registerHandler(mPlayer);
58
59    mPlayer->setDriver(this);
60}
61
62NuPlayerDriver::~NuPlayerDriver() {
63    mLooper->stop();
64}
65
66status_t NuPlayerDriver::initCheck() {
67    return OK;
68}
69
70status_t NuPlayerDriver::setUID(uid_t uid) {
71    mPlayer->setUID(uid);
72
73    return OK;
74}
75
76status_t NuPlayerDriver::setDataSource(
77        const sp<IMediaHTTPService> &httpService,
78        const char *url,
79        const KeyedVector<String8, String8> *headers) {
80    Mutex::Autolock autoLock(mLock);
81
82    ALOGV("setDataSource: url=%s", url);
83    if (mState != STATE_IDLE) {
84        return INVALID_OPERATION;
85    }
86
87    mState = STATE_SET_DATASOURCE_PENDING;
88
89    mPlayer->setDataSourceAsync(httpService, url, headers);
90
91    while (mState == STATE_SET_DATASOURCE_PENDING) {
92        mCondition.wait(mLock);
93    }
94
95    return mAsyncResult;
96}
97
98status_t NuPlayerDriver::setDataSource(int fd, int64_t offset, int64_t length) {
99    Mutex::Autolock autoLock(mLock);
100
101    ALOGV("setDataSource: fd=%d", fd);
102    if (mState != STATE_IDLE) {
103        return INVALID_OPERATION;
104    }
105
106    mState = STATE_SET_DATASOURCE_PENDING;
107
108    mPlayer->setDataSourceAsync(fd, offset, length);
109
110    while (mState == STATE_SET_DATASOURCE_PENDING) {
111        mCondition.wait(mLock);
112    }
113
114    return mAsyncResult;
115}
116
117status_t NuPlayerDriver::setDataSource(const sp<IStreamSource> &source) {
118    Mutex::Autolock autoLock(mLock);
119
120    ALOGV("setDataSource: stream source");
121    if (mState != STATE_IDLE) {
122        return INVALID_OPERATION;
123    }
124
125    mState = STATE_SET_DATASOURCE_PENDING;
126
127    mPlayer->setDataSourceAsync(source);
128
129    while (mState == STATE_SET_DATASOURCE_PENDING) {
130        mCondition.wait(mLock);
131    }
132
133    return mAsyncResult;
134}
135
136status_t NuPlayerDriver::setVideoSurfaceTexture(
137        const sp<IGraphicBufferProducer> &bufferProducer) {
138    Mutex::Autolock autoLock(mLock);
139
140    if (mSetSurfaceInProgress) {
141        return INVALID_OPERATION;
142    }
143
144    switch (mState) {
145        case STATE_SET_DATASOURCE_PENDING:
146        case STATE_RESET_IN_PROGRESS:
147            return INVALID_OPERATION;
148
149        default:
150            break;
151    }
152
153    mSetSurfaceInProgress = true;
154
155    mPlayer->setVideoSurfaceTextureAsync(bufferProducer);
156
157    while (mSetSurfaceInProgress) {
158        mCondition.wait(mLock);
159    }
160
161    return OK;
162}
163
164status_t NuPlayerDriver::prepare() {
165    Mutex::Autolock autoLock(mLock);
166    return prepare_l();
167}
168
169status_t NuPlayerDriver::prepare_l() {
170    switch (mState) {
171        case STATE_UNPREPARED:
172            mState = STATE_PREPARING;
173
174            // Make sure we're not posting any notifications, success or
175            // failure information is only communicated through our result
176            // code.
177            mIsAsyncPrepare = false;
178            mPlayer->prepareAsync();
179            while (mState == STATE_PREPARING) {
180                mCondition.wait(mLock);
181            }
182            return (mState == STATE_PREPARED) ? OK : UNKNOWN_ERROR;
183        case STATE_STOPPED:
184            // this is really just paused. handle as seek to start
185            mAtEOS = false;
186            mState = STATE_STOPPED_AND_PREPARING;
187            mIsAsyncPrepare = false;
188            mPlayer->seekToAsync(0);
189            while (mState == STATE_STOPPED_AND_PREPARING) {
190                mCondition.wait(mLock);
191            }
192            return (mState == STATE_STOPPED_AND_PREPARED) ? OK : UNKNOWN_ERROR;
193        default:
194            return INVALID_OPERATION;
195    };
196}
197
198status_t NuPlayerDriver::prepareAsync() {
199    Mutex::Autolock autoLock(mLock);
200
201    switch (mState) {
202        case STATE_UNPREPARED:
203            mState = STATE_PREPARING;
204            mIsAsyncPrepare = true;
205            mPlayer->prepareAsync();
206            return OK;
207        case STATE_STOPPED:
208            // this is really just paused. handle as seek to start
209            mAtEOS = false;
210            mState = STATE_STOPPED_AND_PREPARING;
211            mIsAsyncPrepare = true;
212            mPlayer->seekToAsync(0);
213            return OK;
214        default:
215            return INVALID_OPERATION;
216    };
217}
218
219status_t NuPlayerDriver::start() {
220    Mutex::Autolock autoLock(mLock);
221
222    switch (mState) {
223        case STATE_UNPREPARED:
224        {
225            status_t err = prepare_l();
226
227            if (err != OK) {
228                return err;
229            }
230
231            CHECK_EQ(mState, STATE_PREPARED);
232
233            // fall through
234        }
235
236        case STATE_PREPARED:
237        {
238            mAtEOS = false;
239            mPlayer->start();
240
241            if (mStartupSeekTimeUs >= 0) {
242                if (mStartupSeekTimeUs == 0) {
243                    notifySeekComplete_l();
244                } else {
245                    mPlayer->seekToAsync(mStartupSeekTimeUs);
246                }
247
248                mStartupSeekTimeUs = -1;
249            }
250            break;
251        }
252
253        case STATE_RUNNING:
254        {
255            if (mAtEOS) {
256                mPlayer->seekToAsync(0);
257                mAtEOS = false;
258                mPositionUs = -1;
259            }
260            break;
261        }
262
263        case STATE_PAUSED:
264        case STATE_STOPPED_AND_PREPARED:
265        {
266            if (mAtEOS) {
267                mPlayer->seekToAsync(0);
268                mAtEOS = false;
269                mPlayer->resume();
270                mPositionUs = -1;
271            } else {
272                mPlayer->resume();
273                if (mNotifyTimeRealUs != -1) {
274                    // Pause time must be set if here by setPauseStartedTimeIfNeeded().
275                    //CHECK(mPauseStartedTimeUs != -1);
276
277                    // if no seek occurs, adjust our notify time so that getCurrentPosition()
278                    // is continuous if read immediately after calling start().
279                    mNotifyTimeRealUs += ALooper::GetNowUs() - mPauseStartedTimeUs;
280                }
281            }
282            break;
283        }
284
285        default:
286            return INVALID_OPERATION;
287    }
288
289    mState = STATE_RUNNING;
290    mPauseStartedTimeUs = -1;
291
292    return OK;
293}
294
295status_t NuPlayerDriver::stop() {
296    Mutex::Autolock autoLock(mLock);
297
298    switch (mState) {
299        case STATE_RUNNING:
300            mPlayer->pause();
301            // fall through
302
303        case STATE_PAUSED:
304            mState = STATE_STOPPED;
305            notifyListener_l(MEDIA_STOPPED);
306            break;
307
308        case STATE_PREPARED:
309        case STATE_STOPPED:
310        case STATE_STOPPED_AND_PREPARING:
311        case STATE_STOPPED_AND_PREPARED:
312            mState = STATE_STOPPED;
313            break;
314
315        default:
316            return INVALID_OPERATION;
317    }
318    setPauseStartedTimeIfNeeded();
319
320    return OK;
321}
322
323status_t NuPlayerDriver::pause() {
324    Mutex::Autolock autoLock(mLock);
325
326    switch (mState) {
327        case STATE_PAUSED:
328        case STATE_PREPARED:
329            return OK;
330
331        case STATE_RUNNING:
332            setPauseStartedTimeIfNeeded();
333            mState = STATE_PAUSED;
334            notifyListener_l(MEDIA_PAUSED);
335            mPlayer->pause();
336            break;
337
338        default:
339            return INVALID_OPERATION;
340    }
341
342    return OK;
343}
344
345bool NuPlayerDriver::isPlaying() {
346    return mState == STATE_RUNNING && !mAtEOS;
347}
348
349status_t NuPlayerDriver::seekTo(int msec) {
350    Mutex::Autolock autoLock(mLock);
351
352    int64_t seekTimeUs = msec * 1000ll;
353
354    switch (mState) {
355        case STATE_PREPARED:
356        {
357            mStartupSeekTimeUs = seekTimeUs;
358            // pretend that the seek completed. It will actually happen when starting playback.
359            // TODO: actually perform the seek here, so the player is ready to go at the new
360            // location
361            notifySeekComplete_l();
362            break;
363        }
364
365        case STATE_RUNNING:
366        case STATE_PAUSED:
367        {
368            mAtEOS = false;
369            // seeks can take a while, so we essentially paused
370            notifyListener_l(MEDIA_PAUSED);
371            mPlayer->seekToAsync(seekTimeUs);
372            break;
373        }
374
375        default:
376            return INVALID_OPERATION;
377    }
378
379    mPositionUs = seekTimeUs;
380    mNotifyTimeRealUs = -1;
381    return OK;
382}
383
384status_t NuPlayerDriver::getCurrentPosition(int *msec) {
385    Mutex::Autolock autoLock(mLock);
386
387    if (mPositionUs < 0) {
388        // mPositionUs is the media time.
389        // It is negative under these cases
390        // (1) == -1 after reset, or very first playback, no stream notification yet.
391        // (2) == -1 start after end of stream, no stream notification yet.
392        // (3) == large negative # after ~292,471 years of continuous playback.
393
394        //CHECK_EQ(mPositionUs, -1);
395        *msec = 0;
396    } else if (mNotifyTimeRealUs == -1) {
397        // A seek has occurred just occurred, no stream notification yet.
398        // mPositionUs (>= 0) is the new media position.
399        *msec = mPositionUs / 1000;
400    } else {
401        // mPosition must be valid (i.e. >= 0) by the first check above.
402        // We're either playing or have pause time set: mPauseStartedTimeUs is >= 0
403        //LOG_ALWAYS_FATAL_IF(
404        //        !isPlaying() && mPauseStartedTimeUs < 0,
405        //        "Player in non-playing mState(%d) and mPauseStartedTimeUs(%lld) < 0",
406        //        mState, (long long)mPauseStartedTimeUs);
407        ALOG_ASSERT(mNotifyTimeRealUs >= 0);
408        int64_t nowUs =
409                (isPlaying() ?  ALooper::GetNowUs() : mPauseStartedTimeUs);
410        *msec = (mPositionUs + nowUs - mNotifyTimeRealUs + 500ll) / 1000;
411        // It is possible for *msec to be negative if the media position is > 596 hours.
412        // but we turn on this checking in NDEBUG == 0 mode.
413        ALOG_ASSERT(*msec >= 0);
414        ALOGV("getCurrentPosition nowUs(%lld)", (long long)nowUs);
415    }
416    ALOGV("getCurrentPosition returning(%d) mPositionUs(%lld) mNotifyRealTimeUs(%lld)",
417            *msec, (long long)mPositionUs, (long long)mNotifyTimeRealUs);
418    return OK;
419}
420
421status_t NuPlayerDriver::getDuration(int *msec) {
422    Mutex::Autolock autoLock(mLock);
423
424    if (mDurationUs < 0) {
425        return UNKNOWN_ERROR;
426    }
427
428    *msec = (mDurationUs + 500ll) / 1000;
429
430    return OK;
431}
432
433status_t NuPlayerDriver::reset() {
434    Mutex::Autolock autoLock(mLock);
435
436    switch (mState) {
437        case STATE_IDLE:
438            return OK;
439
440        case STATE_SET_DATASOURCE_PENDING:
441        case STATE_RESET_IN_PROGRESS:
442            return INVALID_OPERATION;
443
444        case STATE_PREPARING:
445        {
446            CHECK(mIsAsyncPrepare);
447
448            notifyListener_l(MEDIA_PREPARED);
449            break;
450        }
451
452        default:
453            break;
454    }
455
456    if (mState != STATE_STOPPED) {
457        notifyListener_l(MEDIA_STOPPED);
458    }
459
460    mState = STATE_RESET_IN_PROGRESS;
461    mPlayer->resetAsync();
462
463    while (mState == STATE_RESET_IN_PROGRESS) {
464        mCondition.wait(mLock);
465    }
466
467    mDurationUs = -1;
468    mPositionUs = -1;
469    mStartupSeekTimeUs = -1;
470    mLooping = false;
471
472    return OK;
473}
474
475status_t NuPlayerDriver::setLooping(int loop) {
476    mLooping = loop != 0;
477    return OK;
478}
479
480player_type NuPlayerDriver::playerType() {
481    return NU_PLAYER;
482}
483
484status_t NuPlayerDriver::invoke(const Parcel &request, Parcel *reply) {
485    if (reply == NULL) {
486        ALOGE("reply is a NULL pointer");
487        return BAD_VALUE;
488    }
489
490    int32_t methodId;
491    status_t ret = request.readInt32(&methodId);
492    if (ret != OK) {
493        ALOGE("Failed to retrieve the requested method to invoke");
494        return ret;
495    }
496
497    switch (methodId) {
498        case INVOKE_ID_SET_VIDEO_SCALING_MODE:
499        {
500            int mode = request.readInt32();
501            return mPlayer->setVideoScalingMode(mode);
502        }
503
504        case INVOKE_ID_GET_TRACK_INFO:
505        {
506            return mPlayer->getTrackInfo(reply);
507        }
508
509        case INVOKE_ID_SELECT_TRACK:
510        {
511            int trackIndex = request.readInt32();
512            return mPlayer->selectTrack(trackIndex, true /* select */);
513        }
514
515        case INVOKE_ID_UNSELECT_TRACK:
516        {
517            int trackIndex = request.readInt32();
518            return mPlayer->selectTrack(trackIndex, false /* select */);
519        }
520
521        case INVOKE_ID_GET_SELECTED_TRACK:
522        {
523            int32_t type = request.readInt32();
524            return mPlayer->getSelectedTrack(type, reply);
525        }
526
527        default:
528        {
529            return INVALID_OPERATION;
530        }
531    }
532}
533
534void NuPlayerDriver::setAudioSink(const sp<AudioSink> &audioSink) {
535    mPlayer->setAudioSink(audioSink);
536}
537
538status_t NuPlayerDriver::setParameter(
539        int /* key */, const Parcel & /* request */) {
540    return INVALID_OPERATION;
541}
542
543status_t NuPlayerDriver::getParameter(int /* key */, Parcel * /* reply */) {
544    return INVALID_OPERATION;
545}
546
547status_t NuPlayerDriver::getMetadata(
548        const media::Metadata::Filter& /* ids */, Parcel *records) {
549    Mutex::Autolock autoLock(mLock);
550
551    using media::Metadata;
552
553    Metadata meta(records);
554
555    meta.appendBool(
556            Metadata::kPauseAvailable,
557            mPlayerFlags & NuPlayer::Source::FLAG_CAN_PAUSE);
558
559    meta.appendBool(
560            Metadata::kSeekBackwardAvailable,
561            mPlayerFlags & NuPlayer::Source::FLAG_CAN_SEEK_BACKWARD);
562
563    meta.appendBool(
564            Metadata::kSeekForwardAvailable,
565            mPlayerFlags & NuPlayer::Source::FLAG_CAN_SEEK_FORWARD);
566
567    meta.appendBool(
568            Metadata::kSeekAvailable,
569            mPlayerFlags & NuPlayer::Source::FLAG_CAN_SEEK);
570
571    return OK;
572}
573
574void NuPlayerDriver::notifyResetComplete() {
575    Mutex::Autolock autoLock(mLock);
576
577    CHECK_EQ(mState, STATE_RESET_IN_PROGRESS);
578    mState = STATE_IDLE;
579    mCondition.broadcast();
580}
581
582void NuPlayerDriver::notifySetSurfaceComplete() {
583    Mutex::Autolock autoLock(mLock);
584
585    CHECK(mSetSurfaceInProgress);
586    mSetSurfaceInProgress = false;
587
588    mCondition.broadcast();
589}
590
591void NuPlayerDriver::notifyDuration(int64_t durationUs) {
592    Mutex::Autolock autoLock(mLock);
593    mDurationUs = durationUs;
594}
595
596void NuPlayerDriver::notifyPosition(int64_t positionUs) {
597    Mutex::Autolock autoLock(mLock);
598    if (isPlaying()) {
599        mPositionUs = positionUs;
600        mNotifyTimeRealUs = ALooper::GetNowUs();
601    }
602}
603
604void NuPlayerDriver::notifySeekComplete() {
605    Mutex::Autolock autoLock(mLock);
606    notifySeekComplete_l();
607}
608
609void NuPlayerDriver::notifySeekComplete_l() {
610    bool wasSeeking = true;
611    if (mState == STATE_STOPPED_AND_PREPARING) {
612        wasSeeking = false;
613        mState = STATE_STOPPED_AND_PREPARED;
614        mCondition.broadcast();
615        if (!mIsAsyncPrepare) {
616            // if we are preparing synchronously, no need to notify listener
617            return;
618        }
619    } else if (mState == STATE_STOPPED) {
620        // no need to notify listener
621        return;
622    }
623    notifyListener_l(wasSeeking ? MEDIA_SEEK_COMPLETE : MEDIA_PREPARED);
624}
625
626void NuPlayerDriver::notifyFrameStats(
627        int64_t numFramesTotal, int64_t numFramesDropped) {
628    Mutex::Autolock autoLock(mLock);
629    mNumFramesTotal = numFramesTotal;
630    mNumFramesDropped = numFramesDropped;
631}
632
633status_t NuPlayerDriver::dump(
634        int fd, const Vector<String16> & /* args */) const {
635    Mutex::Autolock autoLock(mLock);
636
637    FILE *out = fdopen(dup(fd), "w");
638
639    fprintf(out, " NuPlayer\n");
640    fprintf(out, "  numFramesTotal(%" PRId64 "), numFramesDropped(%" PRId64 "), "
641                 "percentageDropped(%.2f)\n",
642                 mNumFramesTotal,
643                 mNumFramesDropped,
644                 mNumFramesTotal == 0
645                    ? 0.0 : (double)mNumFramesDropped / mNumFramesTotal);
646
647    fclose(out);
648    out = NULL;
649
650    return OK;
651}
652
653void NuPlayerDriver::notifyListener(
654        int msg, int ext1, int ext2, const Parcel *in) {
655    Mutex::Autolock autoLock(mLock);
656    notifyListener_l(msg, ext1, ext2, in);
657}
658
659void NuPlayerDriver::notifyListener_l(
660        int msg, int ext1, int ext2, const Parcel *in) {
661    switch (msg) {
662        case MEDIA_PLAYBACK_COMPLETE:
663        {
664            if (mState != STATE_RESET_IN_PROGRESS) {
665                if (mLooping) {
666                    mPlayer->seekToAsync(0);
667                    break;
668                }
669
670                mPlayer->pause();
671                mState = STATE_PAUSED;
672            }
673            // fall through
674        }
675
676        case MEDIA_ERROR:
677        {
678            mAtEOS = true;
679            setPauseStartedTimeIfNeeded();
680            break;
681        }
682
683        default:
684            break;
685    }
686
687    mLock.unlock();
688    sendEvent(msg, ext1, ext2, in);
689    mLock.lock();
690}
691
692void NuPlayerDriver::notifySetDataSourceCompleted(status_t err) {
693    Mutex::Autolock autoLock(mLock);
694
695    CHECK_EQ(mState, STATE_SET_DATASOURCE_PENDING);
696
697    mAsyncResult = err;
698    mState = (err == OK) ? STATE_UNPREPARED : STATE_IDLE;
699    mCondition.broadcast();
700}
701
702void NuPlayerDriver::notifyPrepareCompleted(status_t err) {
703    Mutex::Autolock autoLock(mLock);
704
705    if (mState != STATE_PREPARING) {
706        // We were preparing asynchronously when the client called
707        // reset(), we sent a premature "prepared" notification and
708        // then initiated the reset. This notification is stale.
709        CHECK(mState == STATE_RESET_IN_PROGRESS || mState == STATE_IDLE);
710        return;
711    }
712
713    CHECK_EQ(mState, STATE_PREPARING);
714
715    mAsyncResult = err;
716
717    if (err == OK) {
718        // update state before notifying client, so that if client calls back into NuPlayerDriver
719        // in response, NuPlayerDriver has the right state
720        mState = STATE_PREPARED;
721        if (mIsAsyncPrepare) {
722            notifyListener_l(MEDIA_PREPARED);
723        }
724    } else {
725        mState = STATE_UNPREPARED;
726        if (mIsAsyncPrepare) {
727            notifyListener_l(MEDIA_ERROR, MEDIA_ERROR_UNKNOWN, err);
728        }
729    }
730
731    mCondition.broadcast();
732}
733
734void NuPlayerDriver::notifyFlagsChanged(uint32_t flags) {
735    Mutex::Autolock autoLock(mLock);
736
737    mPlayerFlags = flags;
738}
739
740void NuPlayerDriver::setPauseStartedTimeIfNeeded() {
741    if (mPauseStartedTimeUs == -1) {
742        mPauseStartedTimeUs = ALooper::GetNowUs();
743    }
744}
745
746}  // namespace android
747