NuPlayerDriver.cpp revision fb74cf332eaa01e23c45d2d5566e963d177d69ae 
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                mPositionUs -= ALooper::GetNowUs() - mPauseStartedTimeUs;
275            }
276            break;
277        }
278
279        default:
280            return INVALID_OPERATION;
281    }
282
283    mState = STATE_RUNNING;
284    mPauseStartedTimeUs = -1;
285
286    return OK;
287}
288
289status_t NuPlayerDriver::stop() {
290    Mutex::Autolock autoLock(mLock);
291
292    switch (mState) {
293        case STATE_RUNNING:
294            mPlayer->pause();
295            // fall through
296
297        case STATE_PAUSED:
298            mState = STATE_STOPPED;
299            notifyListener_l(MEDIA_STOPPED);
300            break;
301
302        case STATE_PREPARED:
303        case STATE_STOPPED:
304        case STATE_STOPPED_AND_PREPARING:
305        case STATE_STOPPED_AND_PREPARED:
306            mState = STATE_STOPPED;
307            break;
308
309        default:
310            return INVALID_OPERATION;
311    }
312    setPauseStartedTimeIfNeeded();
313
314    return OK;
315}
316
317status_t NuPlayerDriver::pause() {
318    Mutex::Autolock autoLock(mLock);
319
320    switch (mState) {
321        case STATE_PAUSED:
322        case STATE_PREPARED:
323            return OK;
324
325        case STATE_RUNNING:
326            setPauseStartedTimeIfNeeded();
327            mState = STATE_PAUSED;
328            notifyListener_l(MEDIA_PAUSED);
329            mPlayer->pause();
330            break;
331
332        default:
333            return INVALID_OPERATION;
334    }
335
336    return OK;
337}
338
339bool NuPlayerDriver::isPlaying() {
340    return mState == STATE_RUNNING && !mAtEOS;
341}
342
343status_t NuPlayerDriver::seekTo(int msec) {
344    Mutex::Autolock autoLock(mLock);
345
346    int64_t seekTimeUs = msec * 1000ll;
347
348    switch (mState) {
349        case STATE_PREPARED:
350        {
351            int curpos = 0;
352            if (mPositionUs > 0) {
353                curpos = (mPositionUs + 500ll) / 1000;
354            }
355            if (curpos == msec) {
356                // nothing to do, and doing something anyway could result in deadlock (b/15323063)
357                break;
358            }
359            mStartupSeekTimeUs = seekTimeUs;
360            // pretend that the seek completed. It will actually happen when starting playback.
361            // TODO: actually perform the seek here, so the player is ready to go at the new
362            // location
363            notifySeekComplete_l();
364            break;
365        }
366
367        case STATE_RUNNING:
368        case STATE_PAUSED:
369        {
370            mAtEOS = false;
371            // seeks can take a while, so we essentially paused
372            notifyListener_l(MEDIA_PAUSED);
373            mPlayer->seekToAsync(seekTimeUs);
374            break;
375        }
376
377        default:
378            return INVALID_OPERATION;
379    }
380
381    mPositionUs = seekTimeUs;
382    mNotifyTimeRealUs = -1;
383    return OK;
384}
385
386status_t NuPlayerDriver::getCurrentPosition(int *msec) {
387    Mutex::Autolock autoLock(mLock);
388
389    if (mPositionUs < 0) {
390        *msec = 0;
391    } else if (mNotifyTimeRealUs == -1) {
392        *msec = mPositionUs / 1000;
393    } else {
394        int64_t nowUs =
395                (isPlaying() ?  ALooper::GetNowUs() : mPauseStartedTimeUs);
396        *msec = (mPositionUs + nowUs - mNotifyTimeRealUs + 500ll) / 1000;
397    }
398
399    return OK;
400}
401
402status_t NuPlayerDriver::getDuration(int *msec) {
403    Mutex::Autolock autoLock(mLock);
404
405    if (mDurationUs < 0) {
406        return UNKNOWN_ERROR;
407    }
408
409    *msec = (mDurationUs + 500ll) / 1000;
410
411    return OK;
412}
413
414status_t NuPlayerDriver::reset() {
415    Mutex::Autolock autoLock(mLock);
416
417    switch (mState) {
418        case STATE_IDLE:
419            return OK;
420
421        case STATE_SET_DATASOURCE_PENDING:
422        case STATE_RESET_IN_PROGRESS:
423            return INVALID_OPERATION;
424
425        case STATE_PREPARING:
426        {
427            CHECK(mIsAsyncPrepare);
428
429            notifyListener_l(MEDIA_PREPARED);
430            break;
431        }
432
433        default:
434            break;
435    }
436
437    if (mState != STATE_STOPPED) {
438        notifyListener_l(MEDIA_STOPPED);
439    }
440
441    mState = STATE_RESET_IN_PROGRESS;
442    mPlayer->resetAsync();
443
444    while (mState == STATE_RESET_IN_PROGRESS) {
445        mCondition.wait(mLock);
446    }
447
448    mDurationUs = -1;
449    mPositionUs = -1;
450    mStartupSeekTimeUs = -1;
451    mLooping = false;
452
453    return OK;
454}
455
456status_t NuPlayerDriver::setLooping(int loop) {
457    mLooping = loop != 0;
458    return OK;
459}
460
461player_type NuPlayerDriver::playerType() {
462    return NU_PLAYER;
463}
464
465status_t NuPlayerDriver::invoke(const Parcel &request, Parcel *reply) {
466    if (reply == NULL) {
467        ALOGE("reply is a NULL pointer");
468        return BAD_VALUE;
469    }
470
471    int32_t methodId;
472    status_t ret = request.readInt32(&methodId);
473    if (ret != OK) {
474        ALOGE("Failed to retrieve the requested method to invoke");
475        return ret;
476    }
477
478    switch (methodId) {
479        case INVOKE_ID_SET_VIDEO_SCALING_MODE:
480        {
481            int mode = request.readInt32();
482            return mPlayer->setVideoScalingMode(mode);
483        }
484
485        case INVOKE_ID_GET_TRACK_INFO:
486        {
487            return mPlayer->getTrackInfo(reply);
488        }
489
490        case INVOKE_ID_SELECT_TRACK:
491        {
492            int trackIndex = request.readInt32();
493            return mPlayer->selectTrack(trackIndex, true /* select */);
494        }
495
496        case INVOKE_ID_UNSELECT_TRACK:
497        {
498            int trackIndex = request.readInt32();
499            return mPlayer->selectTrack(trackIndex, false /* select */);
500        }
501
502        case INVOKE_ID_GET_SELECTED_TRACK:
503        {
504            int32_t type = request.readInt32();
505            return mPlayer->getSelectedTrack(type, reply);
506        }
507
508        default:
509        {
510            return INVALID_OPERATION;
511        }
512    }
513}
514
515void NuPlayerDriver::setAudioSink(const sp<AudioSink> &audioSink) {
516    mPlayer->setAudioSink(audioSink);
517    mAudioSink = audioSink;
518}
519
520status_t NuPlayerDriver::setParameter(
521        int /* key */, const Parcel & /* request */) {
522    return INVALID_OPERATION;
523}
524
525status_t NuPlayerDriver::getParameter(int /* key */, Parcel * /* reply */) {
526    return INVALID_OPERATION;
527}
528
529status_t NuPlayerDriver::getMetadata(
530        const media::Metadata::Filter& /* ids */, Parcel *records) {
531    Mutex::Autolock autoLock(mLock);
532
533    using media::Metadata;
534
535    Metadata meta(records);
536
537    meta.appendBool(
538            Metadata::kPauseAvailable,
539            mPlayerFlags & NuPlayer::Source::FLAG_CAN_PAUSE);
540
541    meta.appendBool(
542            Metadata::kSeekBackwardAvailable,
543            mPlayerFlags & NuPlayer::Source::FLAG_CAN_SEEK_BACKWARD);
544
545    meta.appendBool(
546            Metadata::kSeekForwardAvailable,
547            mPlayerFlags & NuPlayer::Source::FLAG_CAN_SEEK_FORWARD);
548
549    meta.appendBool(
550            Metadata::kSeekAvailable,
551            mPlayerFlags & NuPlayer::Source::FLAG_CAN_SEEK);
552
553    return OK;
554}
555
556void NuPlayerDriver::notifyResetComplete() {
557    Mutex::Autolock autoLock(mLock);
558
559    CHECK_EQ(mState, STATE_RESET_IN_PROGRESS);
560    mState = STATE_IDLE;
561    mCondition.broadcast();
562}
563
564void NuPlayerDriver::notifySetSurfaceComplete() {
565    Mutex::Autolock autoLock(mLock);
566
567    CHECK(mSetSurfaceInProgress);
568    mSetSurfaceInProgress = false;
569
570    mCondition.broadcast();
571}
572
573void NuPlayerDriver::notifyDuration(int64_t durationUs) {
574    Mutex::Autolock autoLock(mLock);
575    mDurationUs = durationUs;
576}
577
578void NuPlayerDriver::notifyPosition(int64_t positionUs) {
579    Mutex::Autolock autoLock(mLock);
580    if (isPlaying()) {
581        mPositionUs = positionUs;
582        mNotifyTimeRealUs = ALooper::GetNowUs();
583    }
584}
585
586void NuPlayerDriver::notifySeekComplete() {
587    Mutex::Autolock autoLock(mLock);
588    notifySeekComplete_l();
589}
590
591void NuPlayerDriver::notifySeekComplete_l() {
592    bool wasSeeking = true;
593    if (mState == STATE_STOPPED_AND_PREPARING) {
594        wasSeeking = false;
595        mState = STATE_STOPPED_AND_PREPARED;
596        mCondition.broadcast();
597        if (!mIsAsyncPrepare) {
598            // if we are preparing synchronously, no need to notify listener
599            return;
600        }
601    } else if (mState == STATE_STOPPED) {
602        // no need to notify listener
603        return;
604    }
605    notifyListener_l(wasSeeking ? MEDIA_SEEK_COMPLETE : MEDIA_PREPARED);
606}
607
608void NuPlayerDriver::notifyFrameStats(
609        int64_t numFramesTotal, int64_t numFramesDropped) {
610    Mutex::Autolock autoLock(mLock);
611    mNumFramesTotal = numFramesTotal;
612    mNumFramesDropped = numFramesDropped;
613}
614
615status_t NuPlayerDriver::dump(
616        int fd, const Vector<String16> & /* args */) const {
617    Mutex::Autolock autoLock(mLock);
618
619    FILE *out = fdopen(dup(fd), "w");
620
621    fprintf(out, " NuPlayer\n");
622    fprintf(out, "  numFramesTotal(%" PRId64 "), numFramesDropped(%" PRId64 "), "
623                 "percentageDropped(%.2f)\n",
624                 mNumFramesTotal,
625                 mNumFramesDropped,
626                 mNumFramesTotal == 0
627                    ? 0.0 : (double)mNumFramesDropped / mNumFramesTotal);
628
629    fclose(out);
630    out = NULL;
631
632    return OK;
633}
634
635void NuPlayerDriver::notifyListener(
636        int msg, int ext1, int ext2, const Parcel *in) {
637    Mutex::Autolock autoLock(mLock);
638    notifyListener_l(msg, ext1, ext2, in);
639}
640
641void NuPlayerDriver::notifyListener_l(
642        int msg, int ext1, int ext2, const Parcel *in) {
643    switch (msg) {
644        case MEDIA_PLAYBACK_COMPLETE:
645        {
646            if (mState != STATE_RESET_IN_PROGRESS) {
647                if (mLooping || (mAutoLoop
648                        && (mAudioSink == NULL || mAudioSink->realtime()))) {
649                    mPlayer->seekToAsync(0);
650                    break;
651                }
652
653                mPlayer->pause();
654                mState = STATE_PAUSED;
655            }
656            // fall through
657        }
658
659        case MEDIA_ERROR:
660        {
661            mAtEOS = true;
662            setPauseStartedTimeIfNeeded();
663            break;
664        }
665
666        default:
667            break;
668    }
669
670    mLock.unlock();
671    sendEvent(msg, ext1, ext2, in);
672    mLock.lock();
673}
674
675void NuPlayerDriver::notifySetDataSourceCompleted(status_t err) {
676    Mutex::Autolock autoLock(mLock);
677
678    CHECK_EQ(mState, STATE_SET_DATASOURCE_PENDING);
679
680    mAsyncResult = err;
681    mState = (err == OK) ? STATE_UNPREPARED : STATE_IDLE;
682    mCondition.broadcast();
683}
684
685void NuPlayerDriver::notifyPrepareCompleted(status_t err) {
686    Mutex::Autolock autoLock(mLock);
687
688    if (mState != STATE_PREPARING) {
689        // We were preparing asynchronously when the client called
690        // reset(), we sent a premature "prepared" notification and
691        // then initiated the reset. This notification is stale.
692        CHECK(mState == STATE_RESET_IN_PROGRESS || mState == STATE_IDLE);
693        return;
694    }
695
696    CHECK_EQ(mState, STATE_PREPARING);
697
698    mAsyncResult = err;
699
700    if (err == OK) {
701        // update state before notifying client, so that if client calls back into NuPlayerDriver
702        // in response, NuPlayerDriver has the right state
703        mState = STATE_PREPARED;
704        if (mIsAsyncPrepare) {
705            notifyListener_l(MEDIA_PREPARED);
706        }
707    } else {
708        mState = STATE_UNPREPARED;
709        if (mIsAsyncPrepare) {
710            notifyListener_l(MEDIA_ERROR, MEDIA_ERROR_UNKNOWN, err);
711        }
712    }
713
714    sp<MetaData> meta = mPlayer->getFileMeta();
715    int32_t loop;
716    if (meta != NULL
717            && meta->findInt32(kKeyAutoLoop, &loop) && loop != 0) {
718        mAutoLoop = true;
719    }
720
721    mCondition.broadcast();
722}
723
724void NuPlayerDriver::notifyFlagsChanged(uint32_t flags) {
725    Mutex::Autolock autoLock(mLock);
726
727    mPlayerFlags = flags;
728}
729
730void NuPlayerDriver::setPauseStartedTimeIfNeeded() {
731    if (mPauseStartedTimeUs == -1) {
732        mPauseStartedTimeUs = ALooper::GetNowUs();
733    }
734}
735
736}  // namespace android
737