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