NuPlayerDriver.cpp revision 09062bfafa335d15f5b52c29778e60482dfb3f33 
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        default:
182            return INVALID_OPERATION;
183    };
184}
185
186status_t NuPlayerDriver::prepareAsync() {
187    Mutex::Autolock autoLock(mLock);
188
189    switch (mState) {
190        case STATE_UNPREPARED:
191            mState = STATE_PREPARING;
192            mIsAsyncPrepare = true;
193            mPlayer->prepareAsync();
194            return OK;
195        default:
196            return INVALID_OPERATION;
197    };
198}
199
200status_t NuPlayerDriver::start() {
201    Mutex::Autolock autoLock(mLock);
202
203    switch (mState) {
204        case STATE_UNPREPARED:
205        {
206            status_t err = prepare_l();
207
208            if (err != OK) {
209                return err;
210            }
211
212            CHECK_EQ(mState, STATE_PREPARED);
213
214            // fall through
215        }
216
217        case STATE_PREPARED:
218        {
219            mAtEOS = false;
220            mPlayer->start();
221
222            if (mStartupSeekTimeUs >= 0) {
223                if (mStartupSeekTimeUs == 0) {
224                    notifySeekComplete();
225                } else {
226                    mPlayer->seekToAsync(mStartupSeekTimeUs);
227                }
228
229                mStartupSeekTimeUs = -1;
230            }
231            break;
232        }
233
234        case STATE_RUNNING:
235            break;
236
237        case STATE_PAUSED:
238        {
239            if (mAtEOS) {
240                mPlayer->seekToAsync(0);
241            }
242            mPlayer->resume();
243            break;
244        }
245
246        default:
247            return INVALID_OPERATION;
248    }
249
250    mState = STATE_RUNNING;
251
252    return OK;
253}
254
255status_t NuPlayerDriver::stop() {
256    return pause();
257}
258
259status_t NuPlayerDriver::pause() {
260    Mutex::Autolock autoLock(mLock);
261
262    switch (mState) {
263        case STATE_PAUSED:
264        case STATE_PREPARED:
265            return OK;
266
267        case STATE_RUNNING:
268            notifyListener(MEDIA_PAUSED);
269            mPlayer->pause();
270            break;
271
272        default:
273            return INVALID_OPERATION;
274    }
275
276    mState = STATE_PAUSED;
277
278    return OK;
279}
280
281bool NuPlayerDriver::isPlaying() {
282    return mState == STATE_RUNNING && !mAtEOS;
283}
284
285status_t NuPlayerDriver::seekTo(int msec) {
286    Mutex::Autolock autoLock(mLock);
287
288    int64_t seekTimeUs = msec * 1000ll;
289
290    switch (mState) {
291        case STATE_PREPARED:
292        {
293            int curpos = 0;
294            if (mPositionUs > 0) {
295                curpos = (mPositionUs + 500ll) / 1000;
296            }
297            if (curpos == msec) {
298                // nothing to do, and doing something anyway could result in deadlock (b/15323063)
299                break;
300            }
301            mStartupSeekTimeUs = seekTimeUs;
302            // pretend that the seek completed. It will actually happen when starting playback.
303            // TODO: actually perform the seek here, so the player is ready to go at the new
304            // location
305            notifySeekComplete();
306            break;
307        }
308
309        case STATE_RUNNING:
310        case STATE_PAUSED:
311        {
312            mAtEOS = false;
313            // seeks can take a while, so we essentially paused
314            notifyListener(MEDIA_PAUSED);
315            mPlayer->seekToAsync(seekTimeUs);
316            break;
317        }
318
319        default:
320            return INVALID_OPERATION;
321    }
322
323    return OK;
324}
325
326status_t NuPlayerDriver::getCurrentPosition(int *msec) {
327    Mutex::Autolock autoLock(mLock);
328
329    if (mPositionUs < 0) {
330        *msec = 0;
331    } else {
332        *msec = (mPositionUs + 500ll) / 1000;
333    }
334
335    return OK;
336}
337
338status_t NuPlayerDriver::getDuration(int *msec) {
339    Mutex::Autolock autoLock(mLock);
340
341    if (mDurationUs < 0) {
342        return UNKNOWN_ERROR;
343    }
344
345    *msec = (mDurationUs + 500ll) / 1000;
346
347    return OK;
348}
349
350status_t NuPlayerDriver::reset() {
351    Mutex::Autolock autoLock(mLock);
352
353    switch (mState) {
354        case STATE_IDLE:
355            return OK;
356
357        case STATE_SET_DATASOURCE_PENDING:
358        case STATE_RESET_IN_PROGRESS:
359            return INVALID_OPERATION;
360
361        case STATE_PREPARING:
362        {
363            CHECK(mIsAsyncPrepare);
364
365            notifyListener(MEDIA_PREPARED);
366            break;
367        }
368
369        default:
370            break;
371    }
372
373    notifyListener(MEDIA_STOPPED);
374
375    mState = STATE_RESET_IN_PROGRESS;
376    mPlayer->resetAsync();
377
378    while (mState == STATE_RESET_IN_PROGRESS) {
379        mCondition.wait(mLock);
380    }
381
382    mDurationUs = -1;
383    mPositionUs = -1;
384    mStartupSeekTimeUs = -1;
385    mLooping = false;
386
387    return OK;
388}
389
390status_t NuPlayerDriver::setLooping(int loop) {
391    mLooping = loop != 0;
392    return OK;
393}
394
395player_type NuPlayerDriver::playerType() {
396    return NU_PLAYER;
397}
398
399status_t NuPlayerDriver::invoke(const Parcel &request, Parcel *reply) {
400    if (reply == NULL) {
401        ALOGE("reply is a NULL pointer");
402        return BAD_VALUE;
403    }
404
405    int32_t methodId;
406    status_t ret = request.readInt32(&methodId);
407    if (ret != OK) {
408        ALOGE("Failed to retrieve the requested method to invoke");
409        return ret;
410    }
411
412    switch (methodId) {
413        case INVOKE_ID_SET_VIDEO_SCALING_MODE:
414        {
415            int mode = request.readInt32();
416            return mPlayer->setVideoScalingMode(mode);
417        }
418
419        case INVOKE_ID_GET_TRACK_INFO:
420        {
421            return mPlayer->getTrackInfo(reply);
422        }
423
424        case INVOKE_ID_SELECT_TRACK:
425        {
426            int trackIndex = request.readInt32();
427            return mPlayer->selectTrack(trackIndex, true /* select */);
428        }
429
430        case INVOKE_ID_UNSELECT_TRACK:
431        {
432            int trackIndex = request.readInt32();
433            return mPlayer->selectTrack(trackIndex, false /* select */);
434        }
435
436        case INVOKE_ID_GET_SELECTED_TRACK:
437        {
438            int32_t type = request.readInt32();
439            return mPlayer->getSelectedTrack(type, reply);
440        }
441
442        default:
443        {
444            return INVALID_OPERATION;
445        }
446    }
447}
448
449void NuPlayerDriver::setAudioSink(const sp<AudioSink> &audioSink) {
450    mPlayer->setAudioSink(audioSink);
451}
452
453status_t NuPlayerDriver::setParameter(
454        int /* key */, const Parcel & /* request */) {
455    return INVALID_OPERATION;
456}
457
458status_t NuPlayerDriver::getParameter(int /* key */, Parcel * /* reply */) {
459    return INVALID_OPERATION;
460}
461
462status_t NuPlayerDriver::getMetadata(
463        const media::Metadata::Filter& /* ids */, Parcel *records) {
464    Mutex::Autolock autoLock(mLock);
465
466    using media::Metadata;
467
468    Metadata meta(records);
469
470    meta.appendBool(
471            Metadata::kPauseAvailable,
472            mPlayerFlags & NuPlayer::Source::FLAG_CAN_PAUSE);
473
474    meta.appendBool(
475            Metadata::kSeekBackwardAvailable,
476            mPlayerFlags & NuPlayer::Source::FLAG_CAN_SEEK_BACKWARD);
477
478    meta.appendBool(
479            Metadata::kSeekForwardAvailable,
480            mPlayerFlags & NuPlayer::Source::FLAG_CAN_SEEK_FORWARD);
481
482    meta.appendBool(
483            Metadata::kSeekAvailable,
484            mPlayerFlags & NuPlayer::Source::FLAG_CAN_SEEK);
485
486    return OK;
487}
488
489void NuPlayerDriver::notifyResetComplete() {
490    Mutex::Autolock autoLock(mLock);
491
492    CHECK_EQ(mState, STATE_RESET_IN_PROGRESS);
493    mState = STATE_IDLE;
494    mCondition.broadcast();
495}
496
497void NuPlayerDriver::notifySetSurfaceComplete() {
498    Mutex::Autolock autoLock(mLock);
499
500    CHECK(mSetSurfaceInProgress);
501    mSetSurfaceInProgress = false;
502
503    mCondition.broadcast();
504}
505
506void NuPlayerDriver::notifyDuration(int64_t durationUs) {
507    Mutex::Autolock autoLock(mLock);
508    mDurationUs = durationUs;
509}
510
511void NuPlayerDriver::notifyPosition(int64_t positionUs) {
512    Mutex::Autolock autoLock(mLock);
513    mPositionUs = positionUs;
514}
515
516void NuPlayerDriver::notifySeekComplete() {
517    notifyListener(MEDIA_SEEK_COMPLETE);
518}
519
520void NuPlayerDriver::notifyFrameStats(
521        int64_t numFramesTotal, int64_t numFramesDropped) {
522    Mutex::Autolock autoLock(mLock);
523    mNumFramesTotal = numFramesTotal;
524    mNumFramesDropped = numFramesDropped;
525}
526
527status_t NuPlayerDriver::dump(
528        int fd, const Vector<String16> & /* args */) const {
529    Mutex::Autolock autoLock(mLock);
530
531    FILE *out = fdopen(dup(fd), "w");
532
533    fprintf(out, " NuPlayer\n");
534    fprintf(out, "  numFramesTotal(%" PRId64 "), numFramesDropped(%" PRId64 "), "
535                 "percentageDropped(%.2f)\n",
536                 mNumFramesTotal,
537                 mNumFramesDropped,
538                 mNumFramesTotal == 0
539                    ? 0.0 : (double)mNumFramesDropped / mNumFramesTotal);
540
541    fclose(out);
542    out = NULL;
543
544    return OK;
545}
546
547void NuPlayerDriver::notifyListener(
548        int msg, int ext1, int ext2, const Parcel *in) {
549    switch (msg) {
550        case MEDIA_PLAYBACK_COMPLETE:
551        {
552            if (mLooping) {
553                mPlayer->seekToAsync(0);
554                break;
555            } else {
556                mState = STATE_PAUSED;
557            }
558            // fall through
559        }
560
561        case MEDIA_ERROR:
562        {
563            mAtEOS = true;
564            break;
565        }
566
567        default:
568            break;
569    }
570
571    sendEvent(msg, ext1, ext2, in);
572}
573
574void NuPlayerDriver::notifySetDataSourceCompleted(status_t err) {
575    Mutex::Autolock autoLock(mLock);
576
577    CHECK_EQ(mState, STATE_SET_DATASOURCE_PENDING);
578
579    mAsyncResult = err;
580    mState = (err == OK) ? STATE_UNPREPARED : STATE_IDLE;
581    mCondition.broadcast();
582}
583
584void NuPlayerDriver::notifyPrepareCompleted(status_t err) {
585    Mutex::Autolock autoLock(mLock);
586
587    if (mState != STATE_PREPARING) {
588        // We were preparing asynchronously when the client called
589        // reset(), we sent a premature "prepared" notification and
590        // then initiated the reset. This notification is stale.
591        CHECK(mState == STATE_RESET_IN_PROGRESS || mState == STATE_IDLE);
592        return;
593    }
594
595    CHECK_EQ(mState, STATE_PREPARING);
596
597    mAsyncResult = err;
598
599    if (err == OK) {
600        if (mIsAsyncPrepare) {
601            notifyListener(MEDIA_PREPARED);
602        }
603        mState = STATE_PREPARED;
604    } else {
605        if (mIsAsyncPrepare) {
606            notifyListener(MEDIA_ERROR, MEDIA_ERROR_UNKNOWN, err);
607        }
608        mState = STATE_UNPREPARED;
609    }
610
611    mCondition.broadcast();
612}
613
614void NuPlayerDriver::notifyFlagsChanged(uint32_t flags) {
615    Mutex::Autolock autoLock(mLock);
616
617    mPlayerFlags = flags;
618}
619
620}  // namespace android
621