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