NuPlayerDriver.cpp revision 2070254f241f52cadb69bc2323f56df72704f1ca 
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 <utils/Log.h>
20
21#include "NuPlayerDriver.h"
22
23#include "NuPlayer.h"
24#include "NuPlayerSource.h"
25
26#include <media/stagefright/foundation/ADebug.h>
27#include <media/stagefright/foundation/ALooper.h>
28#include <media/stagefright/MetaData.h>
29
30namespace android {
31
32NuPlayerDriver::NuPlayerDriver()
33    : mState(STATE_IDLE),
34      mIsAsyncPrepare(false),
35      mAsyncResult(UNKNOWN_ERROR),
36      mSetSurfaceInProgress(false),
37      mDurationUs(-1),
38      mPositionUs(-1),
39      mNumFramesTotal(0),
40      mNumFramesDropped(0),
41      mLooper(new ALooper),
42      mPlayerFlags(0),
43      mAtEOS(false),
44      mStartupSeekTimeUs(-1) {
45    mLooper->setName("NuPlayerDriver Looper");
46
47    mLooper->start(
48            false, /* runOnCallingThread */
49            true,  /* canCallJava */
50            PRIORITY_AUDIO);
51
52    mPlayer = new NuPlayer;
53    mLooper->registerHandler(mPlayer);
54
55    mPlayer->setDriver(this);
56}
57
58NuPlayerDriver::~NuPlayerDriver() {
59    mLooper->stop();
60}
61
62status_t NuPlayerDriver::initCheck() {
63    return OK;
64}
65
66status_t NuPlayerDriver::setUID(uid_t uid) {
67    mPlayer->setUID(uid);
68
69    return OK;
70}
71
72status_t NuPlayerDriver::setDataSource(
73        const char *url, const KeyedVector<String8, String8> *headers) {
74    Mutex::Autolock autoLock(mLock);
75
76    if (mState != STATE_IDLE) {
77        return INVALID_OPERATION;
78    }
79
80    mState = STATE_SET_DATASOURCE_PENDING;
81
82    mPlayer->setDataSourceAsync(url, headers);
83
84    while (mState == STATE_SET_DATASOURCE_PENDING) {
85        mCondition.wait(mLock);
86    }
87
88    return mAsyncResult;
89}
90
91status_t NuPlayerDriver::setDataSource(int fd, int64_t offset, int64_t length) {
92    Mutex::Autolock autoLock(mLock);
93
94    if (mState != STATE_IDLE) {
95        return INVALID_OPERATION;
96    }
97
98    mState = STATE_SET_DATASOURCE_PENDING;
99
100    mPlayer->setDataSourceAsync(fd, offset, length);
101
102    while (mState == STATE_SET_DATASOURCE_PENDING) {
103        mCondition.wait(mLock);
104    }
105
106    return mAsyncResult;
107}
108
109status_t NuPlayerDriver::setDataSource(const sp<IStreamSource> &source) {
110    Mutex::Autolock autoLock(mLock);
111
112    if (mState != STATE_IDLE) {
113        return INVALID_OPERATION;
114    }
115
116    mState = STATE_SET_DATASOURCE_PENDING;
117
118    mPlayer->setDataSourceAsync(source);
119
120    while (mState == STATE_SET_DATASOURCE_PENDING) {
121        mCondition.wait(mLock);
122    }
123
124    return mAsyncResult;
125}
126
127status_t NuPlayerDriver::setVideoSurfaceTexture(
128        const sp<IGraphicBufferProducer> &bufferProducer) {
129    Mutex::Autolock autoLock(mLock);
130
131    if (mSetSurfaceInProgress) {
132        return INVALID_OPERATION;
133    }
134
135    switch (mState) {
136        case STATE_SET_DATASOURCE_PENDING:
137        case STATE_RESET_IN_PROGRESS:
138            return INVALID_OPERATION;
139
140        default:
141            break;
142    }
143
144    mSetSurfaceInProgress = true;
145
146    mPlayer->setVideoSurfaceTextureAsync(bufferProducer);
147
148    while (mSetSurfaceInProgress) {
149        mCondition.wait(mLock);
150    }
151
152    return OK;
153}
154
155status_t NuPlayerDriver::prepare() {
156    Mutex::Autolock autoLock(mLock);
157    return prepare_l();
158}
159
160status_t NuPlayerDriver::prepare_l() {
161    switch (mState) {
162        case STATE_UNPREPARED:
163            mState = STATE_PREPARING;
164
165            // Make sure we're not posting any notifications, success or
166            // failure information is only communicated through our result
167            // code.
168            mIsAsyncPrepare = false;
169            mPlayer->prepareAsync();
170            while (mState == STATE_PREPARING) {
171                mCondition.wait(mLock);
172            }
173            return (mState == STATE_PREPARED) ? OK : UNKNOWN_ERROR;
174        default:
175            return INVALID_OPERATION;
176    };
177}
178
179status_t NuPlayerDriver::prepareAsync() {
180    Mutex::Autolock autoLock(mLock);
181
182    switch (mState) {
183        case STATE_UNPREPARED:
184            mState = STATE_PREPARING;
185            mIsAsyncPrepare = true;
186            mPlayer->prepareAsync();
187            return OK;
188        default:
189            return INVALID_OPERATION;
190    };
191}
192
193status_t NuPlayerDriver::start() {
194    Mutex::Autolock autoLock(mLock);
195
196    switch (mState) {
197        case STATE_UNPREPARED:
198        {
199            status_t err = prepare_l();
200
201            if (err != OK) {
202                return err;
203            }
204
205            CHECK_EQ(mState, STATE_PREPARED);
206
207            // fall through
208        }
209
210        case STATE_PREPARED:
211        {
212            mAtEOS = false;
213            mPlayer->start();
214
215            if (mStartupSeekTimeUs >= 0) {
216                if (mStartupSeekTimeUs == 0) {
217                    notifySeekComplete();
218                } else {
219                    mPlayer->seekToAsync(mStartupSeekTimeUs);
220                }
221
222                mStartupSeekTimeUs = -1;
223            }
224            break;
225        }
226
227        case STATE_RUNNING:
228            break;
229
230        case STATE_PAUSED:
231        {
232            mPlayer->resume();
233            break;
234        }
235
236        default:
237            return INVALID_OPERATION;
238    }
239
240    mState = STATE_RUNNING;
241
242    return OK;
243}
244
245status_t NuPlayerDriver::stop() {
246    return pause();
247}
248
249status_t NuPlayerDriver::pause() {
250    Mutex::Autolock autoLock(mLock);
251
252    switch (mState) {
253        case STATE_PAUSED:
254        case STATE_PREPARED:
255            return OK;
256
257        case STATE_RUNNING:
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            mStartupSeekTimeUs = seekTimeUs;
283            break;
284        }
285
286        case STATE_RUNNING:
287        case STATE_PAUSED:
288        {
289            mAtEOS = false;
290            mPlayer->seekToAsync(seekTimeUs);
291            break;
292        }
293
294        default:
295            return INVALID_OPERATION;
296    }
297
298    return OK;
299}
300
301status_t NuPlayerDriver::getCurrentPosition(int *msec) {
302    Mutex::Autolock autoLock(mLock);
303
304    if (mPositionUs < 0) {
305        *msec = 0;
306    } else {
307        *msec = (mPositionUs + 500ll) / 1000;
308    }
309
310    return OK;
311}
312
313status_t NuPlayerDriver::getDuration(int *msec) {
314    Mutex::Autolock autoLock(mLock);
315
316    if (mDurationUs < 0) {
317        return UNKNOWN_ERROR;
318    }
319
320    *msec = (mDurationUs + 500ll) / 1000;
321
322    return OK;
323}
324
325status_t NuPlayerDriver::reset() {
326    Mutex::Autolock autoLock(mLock);
327
328    switch (mState) {
329        case STATE_IDLE:
330            return OK;
331
332        case STATE_SET_DATASOURCE_PENDING:
333        case STATE_RESET_IN_PROGRESS:
334            return INVALID_OPERATION;
335
336        default:
337            break;
338    }
339
340    mState = STATE_RESET_IN_PROGRESS;
341    mPlayer->resetAsync();
342
343    while (mState == STATE_RESET_IN_PROGRESS) {
344        mCondition.wait(mLock);
345    }
346
347    mDurationUs = -1;
348    mPositionUs = -1;
349    mStartupSeekTimeUs = -1;
350
351    return OK;
352}
353
354status_t NuPlayerDriver::setLooping(int loop) {
355    return INVALID_OPERATION;
356}
357
358player_type NuPlayerDriver::playerType() {
359    return NU_PLAYER;
360}
361
362status_t NuPlayerDriver::invoke(const Parcel &request, Parcel *reply) {
363    if (reply == NULL) {
364        ALOGE("reply is a NULL pointer");
365        return BAD_VALUE;
366    }
367
368    int32_t methodId;
369    status_t ret = request.readInt32(&methodId);
370    if (ret != OK) {
371        ALOGE("Failed to retrieve the requested method to invoke");
372        return ret;
373    }
374
375    switch (methodId) {
376        case INVOKE_ID_SET_VIDEO_SCALING_MODE:
377        {
378            int mode = request.readInt32();
379            return mPlayer->setVideoScalingMode(mode);
380        }
381
382        default:
383        {
384            return INVALID_OPERATION;
385        }
386    }
387}
388
389void NuPlayerDriver::setAudioSink(const sp<AudioSink> &audioSink) {
390    mPlayer->setAudioSink(audioSink);
391}
392
393status_t NuPlayerDriver::setParameter(int key, const Parcel &request) {
394    return INVALID_OPERATION;
395}
396
397status_t NuPlayerDriver::getParameter(int key, Parcel *reply) {
398    return INVALID_OPERATION;
399}
400
401status_t NuPlayerDriver::getMetadata(
402        const media::Metadata::Filter& ids, Parcel *records) {
403    Mutex::Autolock autoLock(mLock);
404
405    using media::Metadata;
406
407    Metadata meta(records);
408
409    meta.appendBool(
410            Metadata::kPauseAvailable,
411            mPlayerFlags & NuPlayer::Source::FLAG_CAN_PAUSE);
412
413    meta.appendBool(
414            Metadata::kSeekBackwardAvailable,
415            mPlayerFlags & NuPlayer::Source::FLAG_CAN_SEEK_BACKWARD);
416
417    meta.appendBool(
418            Metadata::kSeekForwardAvailable,
419            mPlayerFlags & NuPlayer::Source::FLAG_CAN_SEEK_FORWARD);
420
421    meta.appendBool(
422            Metadata::kSeekAvailable,
423            mPlayerFlags & NuPlayer::Source::FLAG_CAN_SEEK);
424
425    return OK;
426}
427
428void NuPlayerDriver::notifyResetComplete() {
429    Mutex::Autolock autoLock(mLock);
430
431    CHECK_EQ(mState, STATE_RESET_IN_PROGRESS);
432    mState = STATE_IDLE;
433    mCondition.broadcast();
434}
435
436void NuPlayerDriver::notifySetSurfaceComplete() {
437    Mutex::Autolock autoLock(mLock);
438
439    CHECK(mSetSurfaceInProgress);
440    mSetSurfaceInProgress = false;
441
442    mCondition.broadcast();
443}
444
445void NuPlayerDriver::notifyDuration(int64_t durationUs) {
446    Mutex::Autolock autoLock(mLock);
447    mDurationUs = durationUs;
448}
449
450void NuPlayerDriver::notifyPosition(int64_t positionUs) {
451    Mutex::Autolock autoLock(mLock);
452    mPositionUs = positionUs;
453}
454
455void NuPlayerDriver::notifySeekComplete() {
456    notifyListener(MEDIA_SEEK_COMPLETE);
457}
458
459void NuPlayerDriver::notifyFrameStats(
460        int64_t numFramesTotal, int64_t numFramesDropped) {
461    Mutex::Autolock autoLock(mLock);
462    mNumFramesTotal = numFramesTotal;
463    mNumFramesDropped = numFramesDropped;
464}
465
466status_t NuPlayerDriver::dump(int fd, const Vector<String16> &args) const {
467    Mutex::Autolock autoLock(mLock);
468
469    FILE *out = fdopen(dup(fd), "w");
470
471    fprintf(out, " NuPlayer\n");
472    fprintf(out, "  numFramesTotal(%lld), numFramesDropped(%lld), "
473                 "percentageDropped(%.2f)\n",
474                 mNumFramesTotal,
475                 mNumFramesDropped,
476                 mNumFramesTotal == 0
477                    ? 0.0 : (double)mNumFramesDropped / mNumFramesTotal);
478
479    fclose(out);
480    out = NULL;
481
482    return OK;
483}
484
485void NuPlayerDriver::notifyListener(int msg, int ext1, int ext2) {
486    if (msg == MEDIA_PLAYBACK_COMPLETE || msg == MEDIA_ERROR) {
487        mAtEOS = true;
488    }
489
490    sendEvent(msg, ext1, ext2);
491}
492
493void NuPlayerDriver::notifySetDataSourceCompleted(status_t err) {
494    Mutex::Autolock autoLock(mLock);
495
496    CHECK_EQ(mState, STATE_SET_DATASOURCE_PENDING);
497
498    mAsyncResult = err;
499    mState = (err == OK) ? STATE_UNPREPARED : STATE_IDLE;
500    mCondition.broadcast();
501}
502
503void NuPlayerDriver::notifyPrepareCompleted(status_t err) {
504    Mutex::Autolock autoLock(mLock);
505
506    CHECK_EQ(mState, STATE_PREPARING);
507
508    mAsyncResult = err;
509
510    if (err == OK) {
511        if (mIsAsyncPrepare) {
512            notifyListener(MEDIA_PREPARED);
513        }
514        mState = STATE_PREPARED;
515    } else {
516        if (mIsAsyncPrepare) {
517            notifyListener(MEDIA_ERROR, MEDIA_ERROR_UNKNOWN, err);
518        }
519        mState = STATE_UNPREPARED;
520    }
521
522    mCondition.broadcast();
523}
524
525void NuPlayerDriver::notifyFlagsChanged(uint32_t flags) {
526    Mutex::Autolock autoLock(mLock);
527
528    mPlayerFlags = flags;
529}
530
531}  // namespace android
532