NuPlayerDriver.cpp revision 8b67ce7210caa4f119a687e9b0946b339db08265 
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/foundation/AUtils.h>
30#include <media/stagefright/MetaData.h>
31#include <media/stagefright/Utils.h>
32
33namespace android {
34
35NuPlayerDriver::NuPlayerDriver()
36    : mState(STATE_IDLE),
37      mIsAsyncPrepare(false),
38      mAsyncResult(UNKNOWN_ERROR),
39      mSetSurfaceInProgress(false),
40      mDurationUs(-1),
41      mPositionUs(-1),
42      mSeekInProgress(false),
43      mLooper(new ALooper),
44      mPlayerFlags(0),
45      mAtEOS(false),
46      mLooping(false),
47      mAutoLoop(false),
48      mStartupSeekTimeUs(-1) {
49    ALOGV("NuPlayerDriver(%p)", this);
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    ALOGV("~NuPlayerDriver(%p)", this);
65    mLooper->stop();
66}
67
68status_t NuPlayerDriver::initCheck() {
69    return OK;
70}
71
72status_t NuPlayerDriver::setUID(uid_t uid) {
73    mPlayer->setUID(uid);
74
75    return OK;
76}
77
78status_t NuPlayerDriver::setDataSource(
79        const sp<IMediaHTTPService> &httpService,
80        const char *url,
81        const KeyedVector<String8, String8> *headers) {
82    ALOGV("setDataSource(%p) url(%s)", this, uriDebugString(url, false).c_str());
83    Mutex::Autolock autoLock(mLock);
84
85    if (mState != STATE_IDLE) {
86        return INVALID_OPERATION;
87    }
88
89    mState = STATE_SET_DATASOURCE_PENDING;
90
91    mPlayer->setDataSourceAsync(httpService, url, headers);
92
93    while (mState == STATE_SET_DATASOURCE_PENDING) {
94        mCondition.wait(mLock);
95    }
96
97    return mAsyncResult;
98}
99
100status_t NuPlayerDriver::setDataSource(int fd, int64_t offset, int64_t length) {
101    ALOGV("setDataSource(%p) file(%d)", this, fd);
102    Mutex::Autolock autoLock(mLock);
103
104    if (mState != STATE_IDLE) {
105        return INVALID_OPERATION;
106    }
107
108    mState = STATE_SET_DATASOURCE_PENDING;
109
110    mPlayer->setDataSourceAsync(fd, offset, length);
111
112    while (mState == STATE_SET_DATASOURCE_PENDING) {
113        mCondition.wait(mLock);
114    }
115
116    return mAsyncResult;
117}
118
119status_t NuPlayerDriver::setDataSource(const sp<IStreamSource> &source) {
120    ALOGV("setDataSource(%p) stream source", this);
121    Mutex::Autolock autoLock(mLock);
122
123    if (mState != STATE_IDLE) {
124        return INVALID_OPERATION;
125    }
126
127    mState = STATE_SET_DATASOURCE_PENDING;
128
129    mPlayer->setDataSourceAsync(source);
130
131    while (mState == STATE_SET_DATASOURCE_PENDING) {
132        mCondition.wait(mLock);
133    }
134
135    return mAsyncResult;
136}
137
138status_t NuPlayerDriver::setVideoSurfaceTexture(
139        const sp<IGraphicBufferProducer> &bufferProducer) {
140    ALOGV("setVideoSurfaceTexture(%p)", this);
141    Mutex::Autolock autoLock(mLock);
142
143    if (mSetSurfaceInProgress) {
144        return INVALID_OPERATION;
145    }
146
147    switch (mState) {
148        case STATE_SET_DATASOURCE_PENDING:
149        case STATE_RESET_IN_PROGRESS:
150            return INVALID_OPERATION;
151
152        default:
153            break;
154    }
155
156    mSetSurfaceInProgress = true;
157
158    mPlayer->setVideoSurfaceTextureAsync(bufferProducer);
159
160    while (mSetSurfaceInProgress) {
161        mCondition.wait(mLock);
162    }
163
164    return OK;
165}
166
167status_t NuPlayerDriver::prepare() {
168    ALOGV("prepare(%p)", this);
169    Mutex::Autolock autoLock(mLock);
170    return prepare_l();
171}
172
173status_t NuPlayerDriver::prepare_l() {
174    switch (mState) {
175        case STATE_UNPREPARED:
176            mState = STATE_PREPARING;
177
178            // Make sure we're not posting any notifications, success or
179            // failure information is only communicated through our result
180            // code.
181            mIsAsyncPrepare = false;
182            mPlayer->prepareAsync();
183            while (mState == STATE_PREPARING) {
184                mCondition.wait(mLock);
185            }
186            return (mState == STATE_PREPARED) ? OK : UNKNOWN_ERROR;
187        case STATE_STOPPED:
188            // this is really just paused. handle as seek to start
189            mAtEOS = false;
190            mState = STATE_STOPPED_AND_PREPARING;
191            mIsAsyncPrepare = false;
192            mPlayer->seekToAsync(0, true /* needNotify */);
193            while (mState == STATE_STOPPED_AND_PREPARING) {
194                mCondition.wait(mLock);
195            }
196            return (mState == STATE_STOPPED_AND_PREPARED) ? OK : UNKNOWN_ERROR;
197        default:
198            return INVALID_OPERATION;
199    };
200}
201
202status_t NuPlayerDriver::prepareAsync() {
203    ALOGV("prepareAsync(%p)", this);
204    Mutex::Autolock autoLock(mLock);
205
206    switch (mState) {
207        case STATE_UNPREPARED:
208            mState = STATE_PREPARING;
209            mIsAsyncPrepare = true;
210            mPlayer->prepareAsync();
211            return OK;
212        case STATE_STOPPED:
213            // this is really just paused. handle as seek to start
214            mAtEOS = false;
215            mState = STATE_STOPPED_AND_PREPARING;
216            mIsAsyncPrepare = true;
217            mPlayer->seekToAsync(0, true /* needNotify */);
218            return OK;
219        default:
220            return INVALID_OPERATION;
221    };
222}
223
224status_t NuPlayerDriver::start() {
225    ALOGD("start(%p)", this);
226    Mutex::Autolock autoLock(mLock);
227
228    switch (mState) {
229        case STATE_UNPREPARED:
230        {
231            status_t err = prepare_l();
232
233            if (err != OK) {
234                return err;
235            }
236
237            CHECK_EQ(mState, STATE_PREPARED);
238
239            // fall through
240        }
241
242        case STATE_PREPARED:
243        {
244            mAtEOS = false;
245            mPlayer->start();
246
247            if (mStartupSeekTimeUs >= 0) {
248                if (mStartupSeekTimeUs > 0) {
249                    mPlayer->seekToAsync(mStartupSeekTimeUs);
250                }
251
252                mStartupSeekTimeUs = -1;
253            }
254            break;
255        }
256
257        case STATE_RUNNING:
258        {
259            if (mAtEOS) {
260                mPlayer->seekToAsync(0);
261                mAtEOS = false;
262                mPositionUs = -1;
263            }
264            break;
265        }
266
267        case STATE_PAUSED:
268        case STATE_STOPPED_AND_PREPARED:
269        {
270            if (mAtEOS) {
271                mPlayer->seekToAsync(0);
272                mAtEOS = false;
273                mPlayer->resume();
274                mPositionUs = -1;
275            } else {
276                mPlayer->resume();
277            }
278            break;
279        }
280
281        default:
282            return INVALID_OPERATION;
283    }
284
285    mState = STATE_RUNNING;
286
287    return OK;
288}
289
290status_t NuPlayerDriver::stop() {
291    ALOGD("stop(%p)", this);
292    Mutex::Autolock autoLock(mLock);
293
294    switch (mState) {
295        case STATE_RUNNING:
296            mPlayer->pause();
297            // fall through
298
299        case STATE_PAUSED:
300            mState = STATE_STOPPED;
301            notifyListener_l(MEDIA_STOPPED);
302            break;
303
304        case STATE_PREPARED:
305        case STATE_STOPPED:
306        case STATE_STOPPED_AND_PREPARING:
307        case STATE_STOPPED_AND_PREPARED:
308            mState = STATE_STOPPED;
309            break;
310
311        default:
312            return INVALID_OPERATION;
313    }
314
315    return OK;
316}
317
318status_t NuPlayerDriver::pause() {
319    // The NuPlayerRenderer may get flushed if pause for long enough, e.g. the pause timeout tear
320    // down for audio offload mode. If that happens, the NuPlayerRenderer will no longer know the
321    // current position. So similar to seekTo, update |mPositionUs| to the pause position by calling
322    // getCurrentPosition here.
323    int msec;
324    getCurrentPosition(&msec);
325
326    Mutex::Autolock autoLock(mLock);
327
328    switch (mState) {
329        case STATE_PAUSED:
330        case STATE_PREPARED:
331            return OK;
332
333        case STATE_RUNNING:
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    ALOGD("seekTo(%p) %d ms", this, msec);
352    Mutex::Autolock autoLock(mLock);
353
354    int64_t seekTimeUs = msec * 1000ll;
355
356    switch (mState) {
357        case STATE_PREPARED:
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            mSeekInProgress = true;
372            // seeks can take a while, so we essentially paused
373            notifyListener_l(MEDIA_PAUSED);
374            mPlayer->seekToAsync(seekTimeUs, true /* needNotify */);
375            break;
376        }
377
378        default:
379            return INVALID_OPERATION;
380    }
381
382    mPositionUs = seekTimeUs;
383    return OK;
384}
385
386status_t NuPlayerDriver::getCurrentPosition(int *msec) {
387    int64_t tempUs = 0;
388    status_t ret = mPlayer->getCurrentPosition(&tempUs);
389
390    Mutex::Autolock autoLock(mLock);
391    // We need to check mSeekInProgress here because mPlayer->seekToAsync is an async call, which
392    // means getCurrentPosition can be called before seek is completed. Iow, renderer may return a
393    // position value that's different the seek to position.
394    if (ret != OK || mSeekInProgress) {
395        tempUs = (mPositionUs <= 0) ? 0 : mPositionUs;
396    } else {
397        mPositionUs = tempUs;
398    }
399    *msec = (int)divRound(tempUs, (int64_t)(1000));
400    return OK;
401}
402
403status_t NuPlayerDriver::getDuration(int *msec) {
404    Mutex::Autolock autoLock(mLock);
405
406    if (mDurationUs < 0) {
407        return UNKNOWN_ERROR;
408    }
409
410    *msec = (mDurationUs + 500ll) / 1000;
411
412    return OK;
413}
414
415status_t NuPlayerDriver::reset() {
416    ALOGD("reset(%p)", this);
417    Mutex::Autolock autoLock(mLock);
418
419    switch (mState) {
420        case STATE_IDLE:
421            return OK;
422
423        case STATE_SET_DATASOURCE_PENDING:
424        case STATE_RESET_IN_PROGRESS:
425            return INVALID_OPERATION;
426
427        case STATE_PREPARING:
428        {
429            CHECK(mIsAsyncPrepare);
430
431            notifyListener_l(MEDIA_PREPARED);
432            break;
433        }
434
435        default:
436            break;
437    }
438
439    if (mState != STATE_STOPPED) {
440        notifyListener_l(MEDIA_STOPPED);
441    }
442
443    mState = STATE_RESET_IN_PROGRESS;
444    mPlayer->resetAsync();
445
446    while (mState == STATE_RESET_IN_PROGRESS) {
447        mCondition.wait(mLock);
448    }
449
450    mDurationUs = -1;
451    mPositionUs = -1;
452    mStartupSeekTimeUs = -1;
453    mLooping = false;
454
455    return OK;
456}
457
458status_t NuPlayerDriver::setLooping(int loop) {
459    mLooping = loop != 0;
460    return OK;
461}
462
463player_type NuPlayerDriver::playerType() {
464    return NU_PLAYER;
465}
466
467status_t NuPlayerDriver::invoke(const Parcel &request, Parcel *reply) {
468    if (reply == NULL) {
469        ALOGE("reply is a NULL pointer");
470        return BAD_VALUE;
471    }
472
473    int32_t methodId;
474    status_t ret = request.readInt32(&methodId);
475    if (ret != OK) {
476        ALOGE("Failed to retrieve the requested method to invoke");
477        return ret;
478    }
479
480    switch (methodId) {
481        case INVOKE_ID_SET_VIDEO_SCALING_MODE:
482        {
483            int mode = request.readInt32();
484            return mPlayer->setVideoScalingMode(mode);
485        }
486
487        case INVOKE_ID_GET_TRACK_INFO:
488        {
489            return mPlayer->getTrackInfo(reply);
490        }
491
492        case INVOKE_ID_SELECT_TRACK:
493        {
494            int trackIndex = request.readInt32();
495            return mPlayer->selectTrack(trackIndex, true /* select */);
496        }
497
498        case INVOKE_ID_UNSELECT_TRACK:
499        {
500            int trackIndex = request.readInt32();
501            return mPlayer->selectTrack(trackIndex, false /* select */);
502        }
503
504        case INVOKE_ID_GET_SELECTED_TRACK:
505        {
506            int32_t type = request.readInt32();
507            return mPlayer->getSelectedTrack(type, reply);
508        }
509
510        default:
511        {
512            return INVALID_OPERATION;
513        }
514    }
515}
516
517void NuPlayerDriver::setAudioSink(const sp<AudioSink> &audioSink) {
518    mPlayer->setAudioSink(audioSink);
519    mAudioSink = audioSink;
520}
521
522status_t NuPlayerDriver::setParameter(
523        int /* key */, const Parcel & /* request */) {
524    return INVALID_OPERATION;
525}
526
527status_t NuPlayerDriver::getParameter(int /* key */, Parcel * /* reply */) {
528    return INVALID_OPERATION;
529}
530
531status_t NuPlayerDriver::getMetadata(
532        const media::Metadata::Filter& /* ids */, Parcel *records) {
533    Mutex::Autolock autoLock(mLock);
534
535    using media::Metadata;
536
537    Metadata meta(records);
538
539    meta.appendBool(
540            Metadata::kPauseAvailable,
541            mPlayerFlags & NuPlayer::Source::FLAG_CAN_PAUSE);
542
543    meta.appendBool(
544            Metadata::kSeekBackwardAvailable,
545            mPlayerFlags & NuPlayer::Source::FLAG_CAN_SEEK_BACKWARD);
546
547    meta.appendBool(
548            Metadata::kSeekForwardAvailable,
549            mPlayerFlags & NuPlayer::Source::FLAG_CAN_SEEK_FORWARD);
550
551    meta.appendBool(
552            Metadata::kSeekAvailable,
553            mPlayerFlags & NuPlayer::Source::FLAG_CAN_SEEK);
554
555    return OK;
556}
557
558void NuPlayerDriver::notifyResetComplete() {
559    ALOGD("notifyResetComplete(%p)", this);
560    Mutex::Autolock autoLock(mLock);
561
562    CHECK_EQ(mState, STATE_RESET_IN_PROGRESS);
563    mState = STATE_IDLE;
564    mCondition.broadcast();
565}
566
567void NuPlayerDriver::notifySetSurfaceComplete() {
568    ALOGV("notifySetSurfaceComplete(%p)", this);
569    Mutex::Autolock autoLock(mLock);
570
571    CHECK(mSetSurfaceInProgress);
572    mSetSurfaceInProgress = false;
573
574    mCondition.broadcast();
575}
576
577void NuPlayerDriver::notifyDuration(int64_t durationUs) {
578    Mutex::Autolock autoLock(mLock);
579    mDurationUs = durationUs;
580}
581
582void NuPlayerDriver::notifySeekComplete() {
583    ALOGV("notifySeekComplete(%p)", this);
584    Mutex::Autolock autoLock(mLock);
585    mSeekInProgress = false;
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
606status_t NuPlayerDriver::dump(
607        int fd, const Vector<String16> & /* args */) const {
608    int64_t numFramesTotal;
609    int64_t numFramesDropped;
610    mPlayer->getStats(&numFramesTotal, &numFramesDropped);
611
612    FILE *out = fdopen(dup(fd), "w");
613
614    fprintf(out, " NuPlayer\n");
615    fprintf(out, "  numFramesTotal(%" PRId64 "), numFramesDropped(%" PRId64 "), "
616                 "percentageDropped(%.2f)\n",
617                 numFramesTotal,
618                 numFramesDropped,
619                 numFramesTotal == 0
620                    ? 0.0 : (double)numFramesDropped / numFramesTotal);
621
622    fclose(out);
623    out = NULL;
624
625    return OK;
626}
627
628void NuPlayerDriver::notifyListener(
629        int msg, int ext1, int ext2, const Parcel *in) {
630    Mutex::Autolock autoLock(mLock);
631    notifyListener_l(msg, ext1, ext2, in);
632}
633
634void NuPlayerDriver::notifyListener_l(
635        int msg, int ext1, int ext2, const Parcel *in) {
636    switch (msg) {
637        case MEDIA_PLAYBACK_COMPLETE:
638        {
639            if (mState != STATE_RESET_IN_PROGRESS) {
640                if (mLooping || (mAutoLoop
641                        && (mAudioSink == NULL || mAudioSink->realtime()))) {
642                    mPlayer->seekToAsync(0);
643                    break;
644                }
645
646                mPlayer->pause();
647                mState = STATE_PAUSED;
648            }
649            // fall through
650        }
651
652        case MEDIA_ERROR:
653        {
654            mAtEOS = true;
655            break;
656        }
657
658        default:
659            break;
660    }
661
662    mLock.unlock();
663    sendEvent(msg, ext1, ext2, in);
664    mLock.lock();
665}
666
667void NuPlayerDriver::notifySetDataSourceCompleted(status_t err) {
668    Mutex::Autolock autoLock(mLock);
669
670    CHECK_EQ(mState, STATE_SET_DATASOURCE_PENDING);
671
672    mAsyncResult = err;
673    mState = (err == OK) ? STATE_UNPREPARED : STATE_IDLE;
674    mCondition.broadcast();
675}
676
677void NuPlayerDriver::notifyPrepareCompleted(status_t err) {
678    Mutex::Autolock autoLock(mLock);
679
680    if (mState != STATE_PREPARING) {
681        // We were preparing asynchronously when the client called
682        // reset(), we sent a premature "prepared" notification and
683        // then initiated the reset. This notification is stale.
684        CHECK(mState == STATE_RESET_IN_PROGRESS || mState == STATE_IDLE);
685        return;
686    }
687
688    CHECK_EQ(mState, STATE_PREPARING);
689
690    mAsyncResult = err;
691
692    if (err == OK) {
693        // update state before notifying client, so that if client calls back into NuPlayerDriver
694        // in response, NuPlayerDriver has the right state
695        mState = STATE_PREPARED;
696        if (mIsAsyncPrepare) {
697            notifyListener_l(MEDIA_PREPARED);
698        }
699    } else {
700        mState = STATE_UNPREPARED;
701        if (mIsAsyncPrepare) {
702            notifyListener_l(MEDIA_ERROR, MEDIA_ERROR_UNKNOWN, err);
703        }
704    }
705
706    sp<MetaData> meta = mPlayer->getFileMeta();
707    int32_t loop;
708    if (meta != NULL
709            && meta->findInt32(kKeyAutoLoop, &loop) && loop != 0) {
710        mAutoLoop = true;
711    }
712
713    mCondition.broadcast();
714}
715
716void NuPlayerDriver::notifyFlagsChanged(uint32_t flags) {
717    Mutex::Autolock autoLock(mLock);
718
719    mPlayerFlags = flags;
720}
721
722}  // namespace android
723