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