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