NuPlayerDriver.cpp revision 4b75b86785d674b98dade17cd197b912d87cd279 
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      mNumFramesTotal(0),
41      mNumFramesDropped(0),
42      mLooper(new ALooper),
43      mPlayerFlags(0),
44      mAtEOS(false),
45      mLooping(false),
46      mStartupSeekTimeUs(-1) {
47    mLooper->setName("NuPlayerDriver Looper");
48
49    mLooper->start(
50            false, /* runOnCallingThread */
51            true,  /* canCallJava */
52            PRIORITY_AUDIO);
53
54    mPlayer = new NuPlayer;
55    mLooper->registerHandler(mPlayer);
56
57    mPlayer->setDriver(this);
58}
59
60NuPlayerDriver::~NuPlayerDriver() {
61    mLooper->stop();
62}
63
64status_t NuPlayerDriver::initCheck() {
65    return OK;
66}
67
68status_t NuPlayerDriver::setUID(uid_t uid) {
69    mPlayer->setUID(uid);
70
71    return OK;
72}
73
74status_t NuPlayerDriver::setDataSource(
75        const sp<IMediaHTTPService> &httpService,
76        const char *url,
77        const KeyedVector<String8, String8> *headers) {
78    Mutex::Autolock autoLock(mLock);
79
80    ALOGV("setDataSource: url=%s", url);
81    if (mState != STATE_IDLE) {
82        return INVALID_OPERATION;
83    }
84
85    mState = STATE_SET_DATASOURCE_PENDING;
86
87    mPlayer->setDataSourceAsync(httpService, url, headers);
88
89    while (mState == STATE_SET_DATASOURCE_PENDING) {
90        mCondition.wait(mLock);
91    }
92
93    return mAsyncResult;
94}
95
96status_t NuPlayerDriver::setDataSource(int fd, int64_t offset, int64_t length) {
97    Mutex::Autolock autoLock(mLock);
98
99    ALOGV("setDataSource: fd=%d", fd);
100    if (mState != STATE_IDLE) {
101        return INVALID_OPERATION;
102    }
103
104    mState = STATE_SET_DATASOURCE_PENDING;
105
106    mPlayer->setDataSourceAsync(fd, offset, length);
107
108    while (mState == STATE_SET_DATASOURCE_PENDING) {
109        mCondition.wait(mLock);
110    }
111
112    return mAsyncResult;
113}
114
115status_t NuPlayerDriver::setDataSource(const sp<IStreamSource> &source) {
116    Mutex::Autolock autoLock(mLock);
117
118    ALOGV("setDataSource: stream source");
119    if (mState != STATE_IDLE) {
120        return INVALID_OPERATION;
121    }
122
123    mState = STATE_SET_DATASOURCE_PENDING;
124
125    mPlayer->setDataSourceAsync(source);
126
127    while (mState == STATE_SET_DATASOURCE_PENDING) {
128        mCondition.wait(mLock);
129    }
130
131    return mAsyncResult;
132}
133
134status_t NuPlayerDriver::setVideoSurfaceTexture(
135        const sp<IGraphicBufferProducer> &bufferProducer) {
136    Mutex::Autolock autoLock(mLock);
137
138    if (mSetSurfaceInProgress) {
139        return INVALID_OPERATION;
140    }
141
142    switch (mState) {
143        case STATE_SET_DATASOURCE_PENDING:
144        case STATE_RESET_IN_PROGRESS:
145            return INVALID_OPERATION;
146
147        default:
148            break;
149    }
150
151    mSetSurfaceInProgress = true;
152
153    mPlayer->setVideoSurfaceTextureAsync(bufferProducer);
154
155    while (mSetSurfaceInProgress) {
156        mCondition.wait(mLock);
157    }
158
159    return OK;
160}
161
162status_t NuPlayerDriver::prepare() {
163    Mutex::Autolock autoLock(mLock);
164    return prepare_l();
165}
166
167status_t NuPlayerDriver::prepare_l() {
168    switch (mState) {
169        case STATE_UNPREPARED:
170            mState = STATE_PREPARING;
171
172            // Make sure we're not posting any notifications, success or
173            // failure information is only communicated through our result
174            // code.
175            mIsAsyncPrepare = false;
176            mPlayer->prepareAsync();
177            while (mState == STATE_PREPARING) {
178                mCondition.wait(mLock);
179            }
180            return (mState == STATE_PREPARED) ? OK : UNKNOWN_ERROR;
181        case STATE_STOPPED:
182            // this is really just paused. handle as seek to start
183            mAtEOS = false;
184            mState = STATE_STOPPED_AND_PREPARING;
185            mIsAsyncPrepare = false;
186            mPlayer->seekToAsync(0);
187            while (mState == STATE_STOPPED_AND_PREPARING) {
188                mCondition.wait(mLock);
189            }
190            return (mState == STATE_STOPPED_AND_PREPARED) ? OK : UNKNOWN_ERROR;
191        default:
192            return INVALID_OPERATION;
193    };
194}
195
196status_t NuPlayerDriver::prepareAsync() {
197    Mutex::Autolock autoLock(mLock);
198
199    switch (mState) {
200        case STATE_UNPREPARED:
201            mState = STATE_PREPARING;
202            mIsAsyncPrepare = true;
203            mPlayer->prepareAsync();
204            return OK;
205        case STATE_STOPPED:
206            // this is really just paused. handle as seek to start
207            mAtEOS = false;
208            mState = STATE_STOPPED_AND_PREPARING;
209            mIsAsyncPrepare = true;
210            mPlayer->seekToAsync(0);
211            return OK;
212        default:
213            return INVALID_OPERATION;
214    };
215}
216
217status_t NuPlayerDriver::start() {
218    Mutex::Autolock autoLock(mLock);
219
220    switch (mState) {
221        case STATE_UNPREPARED:
222        {
223            status_t err = prepare_l();
224
225            if (err != OK) {
226                return err;
227            }
228
229            CHECK_EQ(mState, STATE_PREPARED);
230
231            // fall through
232        }
233
234        case STATE_PREPARED:
235        {
236            mAtEOS = false;
237            mPlayer->start();
238
239            if (mStartupSeekTimeUs >= 0) {
240                if (mStartupSeekTimeUs == 0) {
241                    notifySeekComplete();
242                } else {
243                    mPlayer->seekToAsync(mStartupSeekTimeUs);
244                }
245
246                mStartupSeekTimeUs = -1;
247            }
248            break;
249        }
250
251        case STATE_RUNNING:
252            break;
253
254        case STATE_PAUSED:
255        case STATE_STOPPED_AND_PREPARED:
256        {
257            mPlayer->resume();
258            break;
259        }
260
261        default:
262            return INVALID_OPERATION;
263    }
264
265    mState = STATE_RUNNING;
266
267    return OK;
268}
269
270status_t NuPlayerDriver::stop() {
271    Mutex::Autolock autoLock(mLock);
272
273    switch (mState) {
274        case STATE_RUNNING:
275            mPlayer->pause();
276            // fall through
277
278        case STATE_PAUSED:
279            notifyListener(MEDIA_STOPPED);
280            // fall through
281
282        case STATE_PREPARED:
283        case STATE_STOPPED:
284        case STATE_STOPPED_AND_PREPARING:
285        case STATE_STOPPED_AND_PREPARED:
286            mState = STATE_STOPPED;
287            break;
288
289        default:
290            return INVALID_OPERATION;
291    }
292
293    return OK;
294}
295
296status_t NuPlayerDriver::pause() {
297    Mutex::Autolock autoLock(mLock);
298
299    switch (mState) {
300        case STATE_PAUSED:
301        case STATE_PREPARED:
302            return OK;
303
304        case STATE_RUNNING:
305            notifyListener(MEDIA_PAUSED);
306            mPlayer->pause();
307            break;
308
309        default:
310            return INVALID_OPERATION;
311    }
312
313    mState = STATE_PAUSED;
314
315    return OK;
316}
317
318bool NuPlayerDriver::isPlaying() {
319    return mState == STATE_RUNNING && !mAtEOS;
320}
321
322status_t NuPlayerDriver::seekTo(int msec) {
323    Mutex::Autolock autoLock(mLock);
324
325    int64_t seekTimeUs = msec * 1000ll;
326
327    switch (mState) {
328        case STATE_PREPARED:
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();
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::notifySetSurfaceComplete() {
529    Mutex::Autolock autoLock(mLock);
530
531    CHECK(mSetSurfaceInProgress);
532    mSetSurfaceInProgress = false;
533
534    mCondition.broadcast();
535}
536
537void NuPlayerDriver::notifyDuration(int64_t durationUs) {
538    Mutex::Autolock autoLock(mLock);
539    mDurationUs = durationUs;
540}
541
542void NuPlayerDriver::notifyPosition(int64_t positionUs) {
543    Mutex::Autolock autoLock(mLock);
544    mPositionUs = positionUs;
545}
546
547void NuPlayerDriver::notifySeekComplete() {
548    bool wasSeeking = true;
549    {
550        Mutex::Autolock autoLock(mLock);
551        if (mState == STATE_STOPPED_AND_PREPARING) {
552            wasSeeking = false;
553            mState = STATE_STOPPED_AND_PREPARED;
554            mCondition.broadcast();
555            if (!mIsAsyncPrepare) {
556                // if we are preparing synchronously, no need to notify listener
557                return;
558            }
559        } else if (mState == STATE_STOPPED) {
560            // no need to notify listener
561            return;
562        }
563    }
564    notifyListener(wasSeeking ? MEDIA_SEEK_COMPLETE : MEDIA_PREPARED);
565}
566
567void NuPlayerDriver::notifyFrameStats(
568        int64_t numFramesTotal, int64_t numFramesDropped) {
569    Mutex::Autolock autoLock(mLock);
570    mNumFramesTotal = numFramesTotal;
571    mNumFramesDropped = numFramesDropped;
572}
573
574status_t NuPlayerDriver::dump(
575        int fd, const Vector<String16> & /* args */) const {
576    Mutex::Autolock autoLock(mLock);
577
578    FILE *out = fdopen(dup(fd), "w");
579
580    fprintf(out, " NuPlayer\n");
581    fprintf(out, "  numFramesTotal(%" PRId64 "), numFramesDropped(%" PRId64 "), "
582                 "percentageDropped(%.2f)\n",
583                 mNumFramesTotal,
584                 mNumFramesDropped,
585                 mNumFramesTotal == 0
586                    ? 0.0 : (double)mNumFramesDropped / mNumFramesTotal);
587
588    fclose(out);
589    out = NULL;
590
591    return OK;
592}
593
594void NuPlayerDriver::notifyListener(
595        int msg, int ext1, int ext2, const Parcel *in) {
596    switch (msg) {
597        case MEDIA_PLAYBACK_COMPLETE:
598        {
599            if (mLooping) {
600                mPlayer->seekToAsync(0);
601                break;
602            }
603            // fall through
604        }
605
606        case MEDIA_ERROR:
607        {
608            mAtEOS = true;
609            break;
610        }
611
612        default:
613            break;
614    }
615
616    sendEvent(msg, ext1, ext2, in);
617}
618
619void NuPlayerDriver::notifySetDataSourceCompleted(status_t err) {
620    Mutex::Autolock autoLock(mLock);
621
622    CHECK_EQ(mState, STATE_SET_DATASOURCE_PENDING);
623
624    mAsyncResult = err;
625    mState = (err == OK) ? STATE_UNPREPARED : STATE_IDLE;
626    mCondition.broadcast();
627}
628
629void NuPlayerDriver::notifyPrepareCompleted(status_t err) {
630    Mutex::Autolock autoLock(mLock);
631
632    if (mState != STATE_PREPARING) {
633        // We were preparing asynchronously when the client called
634        // reset(), we sent a premature "prepared" notification and
635        // then initiated the reset. This notification is stale.
636        CHECK(mState == STATE_RESET_IN_PROGRESS || mState == STATE_IDLE);
637        return;
638    }
639
640    CHECK_EQ(mState, STATE_PREPARING);
641
642    mAsyncResult = err;
643
644    if (err == OK) {
645        if (mIsAsyncPrepare) {
646            notifyListener(MEDIA_PREPARED);
647        }
648        mState = STATE_PREPARED;
649    } else {
650        if (mIsAsyncPrepare) {
651            notifyListener(MEDIA_ERROR, MEDIA_ERROR_UNKNOWN, err);
652        }
653        mState = STATE_UNPREPARED;
654    }
655
656    mCondition.broadcast();
657}
658
659void NuPlayerDriver::notifyFlagsChanged(uint32_t flags) {
660    Mutex::Autolock autoLock(mLock);
661
662    mPlayerFlags = flags;
663}
664
665}  // namespace android
666