NuPlayerDriver.cpp revision 9b80c2bdb205bc143104f54d0743b6eedd67b14e 
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
25#include <media/stagefright/foundation/ADebug.h>
26#include <media/stagefright/foundation/ALooper.h>
27
28namespace android {
29
30NuPlayerDriver::NuPlayerDriver()
31    : mResetInProgress(false),
32      mDurationUs(-1),
33      mPositionUs(-1),
34      mLooper(new ALooper),
35      mState(UNINITIALIZED),
36      mStartupSeekTimeUs(-1) {
37    mLooper->setName("NuPlayerDriver Looper");
38
39    mLooper->start(
40            false, /* runOnCallingThread */
41            true,  /* canCallJava */
42            PRIORITY_AUDIO);
43
44    mPlayer = new NuPlayer;
45    mLooper->registerHandler(mPlayer);
46
47    mPlayer->setDriver(this);
48}
49
50NuPlayerDriver::~NuPlayerDriver() {
51    mLooper->stop();
52}
53
54status_t NuPlayerDriver::initCheck() {
55    return OK;
56}
57
58status_t NuPlayerDriver::setUID(uid_t uid) {
59    mPlayer->setUID(uid);
60
61    return OK;
62}
63
64status_t NuPlayerDriver::setDataSource(
65        const char *url, const KeyedVector<String8, String8> *headers) {
66    CHECK_EQ((int)mState, (int)UNINITIALIZED);
67
68    mPlayer->setDataSource(url, headers);
69
70    mState = STOPPED;
71
72    return OK;
73}
74
75status_t NuPlayerDriver::setDataSource(int fd, int64_t offset, int64_t length) {
76    return INVALID_OPERATION;
77}
78
79status_t NuPlayerDriver::setDataSource(const sp<IStreamSource> &source) {
80    CHECK_EQ((int)mState, (int)UNINITIALIZED);
81
82    mPlayer->setDataSource(source);
83
84    mState = STOPPED;
85
86    return OK;
87}
88
89status_t NuPlayerDriver::setVideoSurface(const sp<Surface> &surface) {
90    mPlayer->setVideoSurface(surface);
91
92    return OK;
93}
94
95status_t NuPlayerDriver::setVideoSurfaceTexture(
96        const sp<ISurfaceTexture> &surfaceTexture) {
97    mPlayer->setVideoSurfaceTexture(surfaceTexture);
98
99    return OK;
100}
101
102status_t NuPlayerDriver::prepare() {
103    return OK;
104}
105
106status_t NuPlayerDriver::prepareAsync() {
107    sendEvent(MEDIA_PREPARED);
108
109    return OK;
110}
111
112status_t NuPlayerDriver::start() {
113    switch (mState) {
114        case UNINITIALIZED:
115            return INVALID_OPERATION;
116        case STOPPED:
117        {
118            mPlayer->start();
119
120            if (mStartupSeekTimeUs >= 0) {
121                mPlayer->seekToAsync(mStartupSeekTimeUs);
122                mStartupSeekTimeUs = -1;
123            }
124            break;
125        }
126        case PLAYING:
127            return OK;
128        default:
129        {
130            CHECK_EQ((int)mState, (int)PAUSED);
131
132            mPlayer->resume();
133            break;
134        }
135    }
136
137    mState = PLAYING;
138
139    return OK;
140}
141
142status_t NuPlayerDriver::stop() {
143    return pause();
144}
145
146status_t NuPlayerDriver::pause() {
147    switch (mState) {
148        case UNINITIALIZED:
149            return INVALID_OPERATION;
150        case STOPPED:
151            return OK;
152        case PLAYING:
153            mPlayer->pause();
154            break;
155        default:
156        {
157            CHECK_EQ((int)mState, (int)PAUSED);
158            return OK;
159        }
160    }
161
162    mState = PAUSED;
163
164    return OK;
165}
166
167bool NuPlayerDriver::isPlaying() {
168    return mState == PLAYING;
169}
170
171status_t NuPlayerDriver::seekTo(int msec) {
172    int64_t seekTimeUs = msec * 1000ll;
173
174    switch (mState) {
175        case UNINITIALIZED:
176            return INVALID_OPERATION;
177        case STOPPED:
178        {
179            mStartupSeekTimeUs = seekTimeUs;
180            break;
181        }
182        case PLAYING:
183        case PAUSED:
184        {
185            mPlayer->seekToAsync(seekTimeUs);
186            break;
187        }
188
189        default:
190            TRESPASS();
191            break;
192    }
193
194    return OK;
195}
196
197status_t NuPlayerDriver::getCurrentPosition(int *msec) {
198    Mutex::Autolock autoLock(mLock);
199
200    if (mPositionUs < 0) {
201        *msec = 0;
202    } else {
203        *msec = (mPositionUs + 500ll) / 1000;
204    }
205
206    return OK;
207}
208
209status_t NuPlayerDriver::getDuration(int *msec) {
210    Mutex::Autolock autoLock(mLock);
211
212    if (mDurationUs < 0) {
213        *msec = 0;
214    } else {
215        *msec = (mDurationUs + 500ll) / 1000;
216    }
217
218    return OK;
219}
220
221status_t NuPlayerDriver::reset() {
222    Mutex::Autolock autoLock(mLock);
223    mResetInProgress = true;
224
225    mPlayer->resetAsync();
226
227    while (mResetInProgress) {
228        mCondition.wait(mLock);
229    }
230
231    mDurationUs = -1;
232    mPositionUs = -1;
233    mState = UNINITIALIZED;
234    mStartupSeekTimeUs = -1;
235
236    return OK;
237}
238
239status_t NuPlayerDriver::setLooping(int loop) {
240    return INVALID_OPERATION;
241}
242
243player_type NuPlayerDriver::playerType() {
244    return NU_PLAYER;
245}
246
247status_t NuPlayerDriver::invoke(const Parcel &request, Parcel *reply) {
248    return INVALID_OPERATION;
249}
250
251void NuPlayerDriver::setAudioSink(const sp<AudioSink> &audioSink) {
252    mPlayer->setAudioSink(audioSink);
253}
254
255status_t NuPlayerDriver::setParameter(int key, const Parcel &request) {
256    return INVALID_OPERATION;
257}
258
259status_t NuPlayerDriver::getParameter(int key, Parcel *reply) {
260    return INVALID_OPERATION;
261}
262
263status_t NuPlayerDriver::getMetadata(
264        const media::Metadata::Filter& ids, Parcel *records) {
265    return INVALID_OPERATION;
266}
267
268void NuPlayerDriver::notifyResetComplete() {
269    Mutex::Autolock autoLock(mLock);
270    CHECK(mResetInProgress);
271    mResetInProgress = false;
272    mCondition.broadcast();
273}
274
275void NuPlayerDriver::notifyDuration(int64_t durationUs) {
276    Mutex::Autolock autoLock(mLock);
277    mDurationUs = durationUs;
278}
279
280void NuPlayerDriver::notifyPosition(int64_t positionUs) {
281    Mutex::Autolock autoLock(mLock);
282    mPositionUs = positionUs;
283}
284
285void NuPlayerDriver::notifySeekComplete() {
286    sendEvent(MEDIA_SEEK_COMPLETE);
287}
288
289}  // namespace android
290