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