NuPlayerDriver.cpp revision e427abf1ea252ff305fc33aacdd2e83cf34891b5 
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                    mPlayer->seekToAsync(mStartupSeekTimeUs);
245                }
246
247                mStartupSeekTimeUs = -1;
248            }
249            break;
250        }
251
252        case STATE_RUNNING:
253        {
254            if (mAtEOS) {
255                mPlayer->seekToAsync(0);
256                mAtEOS = false;
257                mPositionUs = -1;
258            }
259            break;
260        }
261
262        case STATE_PAUSED:
263        case STATE_STOPPED_AND_PREPARED:
264        {
265            if (mAtEOS) {
266                mPlayer->seekToAsync(0);
267                mAtEOS = false;
268                mPlayer->resume();
269                mPositionUs = -1;
270            } else {
271                mPlayer->resume();
272                if (mNotifyTimeRealUs != -1) {
273                    // Pause time must be set if here by setPauseStartedTimeIfNeeded().
274                    //CHECK(mPauseStartedTimeUs != -1);
275
276                    // if no seek occurs, adjust our notify time so that getCurrentPosition()
277                    // is continuous if read immediately after calling start().
278                    mNotifyTimeRealUs += ALooper::GetNowUs() - mPauseStartedTimeUs;
279                }
280            }
281            break;
282        }
283
284        default:
285            return INVALID_OPERATION;
286    }
287
288    mState = STATE_RUNNING;
289    mPauseStartedTimeUs = -1;
290
291    return OK;
292}
293
294status_t NuPlayerDriver::stop() {
295    Mutex::Autolock autoLock(mLock);
296
297    switch (mState) {
298        case STATE_RUNNING:
299            mPlayer->pause();
300            // fall through
301
302        case STATE_PAUSED:
303            mState = STATE_STOPPED;
304            notifyListener_l(MEDIA_STOPPED);
305            break;
306
307        case STATE_PREPARED:
308        case STATE_STOPPED:
309        case STATE_STOPPED_AND_PREPARING:
310        case STATE_STOPPED_AND_PREPARED:
311            mState = STATE_STOPPED;
312            break;
313
314        default:
315            return INVALID_OPERATION;
316    }
317    setPauseStartedTimeIfNeeded();
318
319    return OK;
320}
321
322status_t NuPlayerDriver::pause() {
323    Mutex::Autolock autoLock(mLock);
324
325    switch (mState) {
326        case STATE_PAUSED:
327        case STATE_PREPARED:
328            return OK;
329
330        case STATE_RUNNING:
331            setPauseStartedTimeIfNeeded();
332            mState = STATE_PAUSED;
333            notifyListener_l(MEDIA_PAUSED);
334            mPlayer->pause();
335            break;
336
337        default:
338            return INVALID_OPERATION;
339    }
340
341    return OK;
342}
343
344bool NuPlayerDriver::isPlaying() {
345    return mState == STATE_RUNNING && !mAtEOS;
346}
347
348status_t NuPlayerDriver::seekTo(int msec) {
349    Mutex::Autolock autoLock(mLock);
350
351    int64_t seekTimeUs = msec * 1000ll;
352
353    switch (mState) {
354        case STATE_PREPARED:
355        {
356            mStartupSeekTimeUs = seekTimeUs;
357            // pretend that the seek completed. It will actually happen when starting playback.
358            // TODO: actually perform the seek here, so the player is ready to go at the new
359            // location
360            notifySeekComplete_l();
361            break;
362        }
363
364        case STATE_RUNNING:
365        case STATE_PAUSED:
366        {
367            mAtEOS = false;
368            // seeks can take a while, so we essentially paused
369            notifyListener_l(MEDIA_PAUSED);
370            mPlayer->seekToAsync(seekTimeUs, true /* needNotify */);
371            break;
372        }
373
374        default:
375            return INVALID_OPERATION;
376    }
377
378    mPositionUs = seekTimeUs;
379    mNotifyTimeRealUs = -1;
380    return OK;
381}
382
383status_t NuPlayerDriver::getCurrentPosition(int *msec) {
384    Mutex::Autolock autoLock(mLock);
385
386    if (mPositionUs < 0) {
387        // mPositionUs is the media time.
388        // It is negative under these cases
389        // (1) == -1 after reset, or very first playback, no stream notification yet.
390        // (2) == -1 start after end of stream, no stream notification yet.
391        // (3) == large negative # after ~292,471 years of continuous playback.
392
393        //CHECK_EQ(mPositionUs, -1);
394        *msec = 0;
395    } else if (mNotifyTimeRealUs == -1) {
396        // A seek has occurred just occurred, no stream notification yet.
397        // mPositionUs (>= 0) is the new media position.
398        *msec = mPositionUs / 1000;
399    } else {
400        // mPosition must be valid (i.e. >= 0) by the first check above.
401        // We're either playing or have pause time set: mPauseStartedTimeUs is >= 0
402        //LOG_ALWAYS_FATAL_IF(
403        //        !isPlaying() && mPauseStartedTimeUs < 0,
404        //        "Player in non-playing mState(%d) and mPauseStartedTimeUs(%lld) < 0",
405        //        mState, (long long)mPauseStartedTimeUs);
406        ALOG_ASSERT(mNotifyTimeRealUs >= 0);
407        int64_t nowUs =
408                (isPlaying() ?  ALooper::GetNowUs() : mPauseStartedTimeUs);
409        *msec = (mPositionUs + nowUs - mNotifyTimeRealUs + 500ll) / 1000;
410        // It is possible for *msec to be negative if the media position is > 596 hours.
411        // but we turn on this checking in NDEBUG == 0 mode.
412        ALOG_ASSERT(*msec >= 0);
413        ALOGV("getCurrentPosition nowUs(%lld)", (long long)nowUs);
414    }
415    ALOGV("getCurrentPosition returning(%d) mPositionUs(%lld) mNotifyRealTimeUs(%lld)",
416            *msec, (long long)mPositionUs, (long long)mNotifyTimeRealUs);
417    return OK;
418}
419
420status_t NuPlayerDriver::getDuration(int *msec) {
421    Mutex::Autolock autoLock(mLock);
422
423    if (mDurationUs < 0) {
424        return UNKNOWN_ERROR;
425    }
426
427    *msec = (mDurationUs + 500ll) / 1000;
428
429    return OK;
430}
431
432status_t NuPlayerDriver::reset() {
433    Mutex::Autolock autoLock(mLock);
434
435    switch (mState) {
436        case STATE_IDLE:
437            return OK;
438
439        case STATE_SET_DATASOURCE_PENDING:
440        case STATE_RESET_IN_PROGRESS:
441            return INVALID_OPERATION;
442
443        case STATE_PREPARING:
444        {
445            CHECK(mIsAsyncPrepare);
446
447            notifyListener_l(MEDIA_PREPARED);
448            break;
449        }
450
451        default:
452            break;
453    }
454
455    if (mState != STATE_STOPPED) {
456        notifyListener_l(MEDIA_STOPPED);
457    }
458
459    mState = STATE_RESET_IN_PROGRESS;
460    mPlayer->resetAsync();
461
462    while (mState == STATE_RESET_IN_PROGRESS) {
463        mCondition.wait(mLock);
464    }
465
466    mDurationUs = -1;
467    mPositionUs = -1;
468    mStartupSeekTimeUs = -1;
469    mLooping = false;
470
471    return OK;
472}
473
474status_t NuPlayerDriver::setLooping(int loop) {
475    mLooping = loop != 0;
476    return OK;
477}
478
479player_type NuPlayerDriver::playerType() {
480    return NU_PLAYER;
481}
482
483status_t NuPlayerDriver::invoke(const Parcel &request, Parcel *reply) {
484    if (reply == NULL) {
485        ALOGE("reply is a NULL pointer");
486        return BAD_VALUE;
487    }
488
489    int32_t methodId;
490    status_t ret = request.readInt32(&methodId);
491    if (ret != OK) {
492        ALOGE("Failed to retrieve the requested method to invoke");
493        return ret;
494    }
495
496    switch (methodId) {
497        case INVOKE_ID_SET_VIDEO_SCALING_MODE:
498        {
499            int mode = request.readInt32();
500            return mPlayer->setVideoScalingMode(mode);
501        }
502
503        case INVOKE_ID_GET_TRACK_INFO:
504        {
505            return mPlayer->getTrackInfo(reply);
506        }
507
508        case INVOKE_ID_SELECT_TRACK:
509        {
510            int trackIndex = request.readInt32();
511            return mPlayer->selectTrack(trackIndex, true /* select */);
512        }
513
514        case INVOKE_ID_UNSELECT_TRACK:
515        {
516            int trackIndex = request.readInt32();
517            return mPlayer->selectTrack(trackIndex, false /* select */);
518        }
519
520        case INVOKE_ID_GET_SELECTED_TRACK:
521        {
522            int32_t type = request.readInt32();
523            return mPlayer->getSelectedTrack(type, reply);
524        }
525
526        default:
527        {
528            return INVALID_OPERATION;
529        }
530    }
531}
532
533void NuPlayerDriver::setAudioSink(const sp<AudioSink> &audioSink) {
534    mPlayer->setAudioSink(audioSink);
535    mAudioSink = 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 || (mAutoLoop
666                        && (mAudioSink == NULL || mAudioSink->realtime()))) {
667                    mPlayer->seekToAsync(0);
668                    break;
669                }
670
671                mPlayer->pause();
672                mState = STATE_PAUSED;
673            }
674            // fall through
675        }
676
677        case MEDIA_ERROR:
678        {
679            mAtEOS = true;
680            setPauseStartedTimeIfNeeded();
681            break;
682        }
683
684        default:
685            break;
686    }
687
688    mLock.unlock();
689    sendEvent(msg, ext1, ext2, in);
690    mLock.lock();
691}
692
693void NuPlayerDriver::notifySetDataSourceCompleted(status_t err) {
694    Mutex::Autolock autoLock(mLock);
695
696    CHECK_EQ(mState, STATE_SET_DATASOURCE_PENDING);
697
698    mAsyncResult = err;
699    mState = (err == OK) ? STATE_UNPREPARED : STATE_IDLE;
700    mCondition.broadcast();
701}
702
703void NuPlayerDriver::notifyPrepareCompleted(status_t err) {
704    Mutex::Autolock autoLock(mLock);
705
706    if (mState != STATE_PREPARING) {
707        // We were preparing asynchronously when the client called
708        // reset(), we sent a premature "prepared" notification and
709        // then initiated the reset. This notification is stale.
710        CHECK(mState == STATE_RESET_IN_PROGRESS || mState == STATE_IDLE);
711        return;
712    }
713
714    CHECK_EQ(mState, STATE_PREPARING);
715
716    mAsyncResult = err;
717
718    if (err == OK) {
719        // update state before notifying client, so that if client calls back into NuPlayerDriver
720        // in response, NuPlayerDriver has the right state
721        mState = STATE_PREPARED;
722        if (mIsAsyncPrepare) {
723            notifyListener_l(MEDIA_PREPARED);
724        }
725    } else {
726        mState = STATE_UNPREPARED;
727        if (mIsAsyncPrepare) {
728            notifyListener_l(MEDIA_ERROR, MEDIA_ERROR_UNKNOWN, err);
729        }
730    }
731
732    sp<MetaData> meta = mPlayer->getFileMeta();
733    int32_t loop;
734    if (meta != NULL
735            && meta->findInt32(kKeyAutoLoop, &loop) && loop != 0) {
736        mAutoLoop = true;
737    }
738
739    mCondition.broadcast();
740}
741
742void NuPlayerDriver::notifyFlagsChanged(uint32_t flags) {
743    Mutex::Autolock autoLock(mLock);
744
745    mPlayerFlags = flags;
746}
747
748void NuPlayerDriver::setPauseStartedTimeIfNeeded() {
749    if (mPauseStartedTimeUs == -1) {
750        mPauseStartedTimeUs = ALooper::GetNowUs();
751    }
752}
753
754}  // namespace android
755