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