blob: 6a803132379f7573de2c2a364b13437b30bf6dee [file] [log] [blame]
Andreas Huberf9334412010-12-15 15:17:42 -08001/*
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"
Kévin PETIT377b2ec2014-02-03 12:35:36 +000019#include <inttypes.h>
Andreas Huberf9334412010-12-15 15:17:42 -080020#include <utils/Log.h>
21
22#include "NuPlayerDriver.h"
23
24#include "NuPlayer.h"
Andreas Huber9575c962013-02-05 13:59:56 -080025#include "NuPlayerSource.h"
Andreas Huberf9334412010-12-15 15:17:42 -080026
Andreas Huber1aef2112011-01-04 14:01:29 -080027#include <media/stagefright/foundation/ADebug.h>
Andreas Huberf9334412010-12-15 15:17:42 -080028#include <media/stagefright/foundation/ALooper.h>
Ronghua Wua73d9e02014-10-08 15:13:29 -070029#include <media/stagefright/foundation/AUtils.h>
Andreas Huber9575c962013-02-05 13:59:56 -080030#include <media/stagefright/MetaData.h>
Andy Hung2abde2c2014-09-30 14:40:32 -070031#include <media/stagefright/Utils.h>
Andreas Huberf9334412010-12-15 15:17:42 -080032
33namespace android {
34
35NuPlayerDriver::NuPlayerDriver()
Andreas Huber9575c962013-02-05 13:59:56 -080036 : mState(STATE_IDLE),
Andreas Huberec0c5972013-02-05 14:47:13 -080037 mIsAsyncPrepare(false),
Andreas Huber9575c962013-02-05 13:59:56 -080038 mAsyncResult(UNKNOWN_ERROR),
Chong Zhang13d6faa2014-08-22 15:35:28 -070039 mSetSurfaceInProgress(false),
Andreas Huber43c3e6c2011-01-05 12:17:08 -080040 mDurationUs(-1),
41 mPositionUs(-1),
Ronghua Wua73d9e02014-10-08 15:13:29 -070042 mSeekInProgress(false),
Andreas Huber1aef2112011-01-04 14:01:29 -080043 mLooper(new ALooper),
Andreas Huber9575c962013-02-05 13:59:56 -080044 mPlayerFlags(0),
Andreas Hubera4af2142011-10-26 15:23:31 -070045 mAtEOS(false),
Lajos Molnara2e14302014-07-31 12:07:58 -070046 mLooping(false),
Marco Nelissenf0b72b52014-09-16 15:43:44 -070047 mAutoLoop(false),
Andreas Huber43c3e6c2011-01-05 12:17:08 -080048 mStartupSeekTimeUs(-1) {
Andy Hung2abde2c2014-09-30 14:40:32 -070049 ALOGV("NuPlayerDriver(%p)", this);
Andreas Huberf9334412010-12-15 15:17:42 -080050 mLooper->setName("NuPlayerDriver Looper");
51
52 mLooper->start(
53 false, /* runOnCallingThread */
54 true, /* canCallJava */
55 PRIORITY_AUDIO);
56
57 mPlayer = new NuPlayer;
58 mLooper->registerHandler(mPlayer);
59
Andreas Huber43c3e6c2011-01-05 12:17:08 -080060 mPlayer->setDriver(this);
Andreas Huberf9334412010-12-15 15:17:42 -080061}
62
63NuPlayerDriver::~NuPlayerDriver() {
Andy Hung2abde2c2014-09-30 14:40:32 -070064 ALOGV("~NuPlayerDriver(%p)", this);
Andreas Huberf9334412010-12-15 15:17:42 -080065 mLooper->stop();
66}
67
68status_t NuPlayerDriver::initCheck() {
69 return OK;
70}
71
Andreas Huber9b80c2b2011-06-30 15:47:02 -070072status_t NuPlayerDriver::setUID(uid_t uid) {
73 mPlayer->setUID(uid);
74
75 return OK;
76}
77
Andreas Huberf9334412010-12-15 15:17:42 -080078status_t NuPlayerDriver::setDataSource(
Andreas Huber1b86fe02014-01-29 11:13:26 -080079 const sp<IMediaHTTPService> &httpService,
80 const char *url,
81 const KeyedVector<String8, String8> *headers) {
Andy Hung2abde2c2014-09-30 14:40:32 -070082 ALOGV("setDataSource(%p) url(%s)", this, uriDebugString(url, false).c_str());
Andreas Huber9575c962013-02-05 13:59:56 -080083 Mutex::Autolock autoLock(mLock);
Andreas Huber43c3e6c2011-01-05 12:17:08 -080084
Andreas Huber9575c962013-02-05 13:59:56 -080085 if (mState != STATE_IDLE) {
86 return INVALID_OPERATION;
87 }
Andreas Huber5bc087c2010-12-23 10:27:40 -080088
Andreas Huber9575c962013-02-05 13:59:56 -080089 mState = STATE_SET_DATASOURCE_PENDING;
Andreas Huber43c3e6c2011-01-05 12:17:08 -080090
Andreas Huber1b86fe02014-01-29 11:13:26 -080091 mPlayer->setDataSourceAsync(httpService, url, headers);
Andreas Huber9575c962013-02-05 13:59:56 -080092
93 while (mState == STATE_SET_DATASOURCE_PENDING) {
94 mCondition.wait(mLock);
95 }
96
97 return mAsyncResult;
Andreas Huberf9334412010-12-15 15:17:42 -080098}
99
100status_t NuPlayerDriver::setDataSource(int fd, int64_t offset, int64_t length) {
Andy Hung2abde2c2014-09-30 14:40:32 -0700101 ALOGV("setDataSource(%p) file(%d)", this, fd);
Andreas Huber9575c962013-02-05 13:59:56 -0800102 Mutex::Autolock autoLock(mLock);
Andreas Huberafed0e12011-09-20 15:39:58 -0700103
Andreas Huber9575c962013-02-05 13:59:56 -0800104 if (mState != STATE_IDLE) {
105 return INVALID_OPERATION;
106 }
Andreas Huberafed0e12011-09-20 15:39:58 -0700107
Andreas Huber9575c962013-02-05 13:59:56 -0800108 mState = STATE_SET_DATASOURCE_PENDING;
Andreas Huberafed0e12011-09-20 15:39:58 -0700109
Andreas Huber9575c962013-02-05 13:59:56 -0800110 mPlayer->setDataSourceAsync(fd, offset, length);
111
112 while (mState == STATE_SET_DATASOURCE_PENDING) {
113 mCondition.wait(mLock);
114 }
115
116 return mAsyncResult;
Andreas Huberf9334412010-12-15 15:17:42 -0800117}
118
119status_t NuPlayerDriver::setDataSource(const sp<IStreamSource> &source) {
Andy Hung2abde2c2014-09-30 14:40:32 -0700120 ALOGV("setDataSource(%p) stream source", this);
Andreas Huber9575c962013-02-05 13:59:56 -0800121 Mutex::Autolock autoLock(mLock);
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800122
Andreas Huber9575c962013-02-05 13:59:56 -0800123 if (mState != STATE_IDLE) {
124 return INVALID_OPERATION;
125 }
Andreas Huberf9334412010-12-15 15:17:42 -0800126
Andreas Huber9575c962013-02-05 13:59:56 -0800127 mState = STATE_SET_DATASOURCE_PENDING;
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800128
Andreas Huber9575c962013-02-05 13:59:56 -0800129 mPlayer->setDataSourceAsync(source);
130
131 while (mState == STATE_SET_DATASOURCE_PENDING) {
132 mCondition.wait(mLock);
133 }
134
135 return mAsyncResult;
Andreas Huberf9334412010-12-15 15:17:42 -0800136}
137
Glenn Kasten11731182011-02-08 17:26:17 -0800138status_t NuPlayerDriver::setVideoSurfaceTexture(
Andy McFadden8ba01022012-12-18 09:46:54 -0800139 const sp<IGraphicBufferProducer> &bufferProducer) {
Andy Hung2abde2c2014-09-30 14:40:32 -0700140 ALOGV("setVideoSurfaceTexture(%p)", this);
Andreas Huber57a339c2012-12-03 11:18:00 -0800141 Mutex::Autolock autoLock(mLock);
142
Chong Zhang13d6faa2014-08-22 15:35:28 -0700143 if (mSetSurfaceInProgress) {
144 return INVALID_OPERATION;
145 }
146
Andreas Huber9575c962013-02-05 13:59:56 -0800147 switch (mState) {
148 case STATE_SET_DATASOURCE_PENDING:
149 case STATE_RESET_IN_PROGRESS:
150 return INVALID_OPERATION;
151
152 default:
153 break;
154 }
155
Chong Zhang13d6faa2014-08-22 15:35:28 -0700156 mSetSurfaceInProgress = true;
157
Andy McFadden8ba01022012-12-18 09:46:54 -0800158 mPlayer->setVideoSurfaceTextureAsync(bufferProducer);
Andreas Huber57a339c2012-12-03 11:18:00 -0800159
Chong Zhang13d6faa2014-08-22 15:35:28 -0700160 while (mSetSurfaceInProgress) {
161 mCondition.wait(mLock);
162 }
163
Glenn Kasten11731182011-02-08 17:26:17 -0800164 return OK;
165}
166
Andreas Huberf9334412010-12-15 15:17:42 -0800167status_t NuPlayerDriver::prepare() {
Andy Hung2abde2c2014-09-30 14:40:32 -0700168 ALOGV("prepare(%p)", this);
Andreas Huber9575c962013-02-05 13:59:56 -0800169 Mutex::Autolock autoLock(mLock);
170 return prepare_l();
171}
172
173status_t NuPlayerDriver::prepare_l() {
174 switch (mState) {
175 case STATE_UNPREPARED:
176 mState = STATE_PREPARING;
Andreas Huberec0c5972013-02-05 14:47:13 -0800177
178 // Make sure we're not posting any notifications, success or
179 // failure information is only communicated through our result
180 // code.
181 mIsAsyncPrepare = false;
Andreas Huber9575c962013-02-05 13:59:56 -0800182 mPlayer->prepareAsync();
183 while (mState == STATE_PREPARING) {
184 mCondition.wait(mLock);
185 }
186 return (mState == STATE_PREPARED) ? OK : UNKNOWN_ERROR;
Lajos Molnar4b75b862013-08-15 15:59:19 -0700187 case STATE_STOPPED:
188 // this is really just paused. handle as seek to start
189 mAtEOS = false;
190 mState = STATE_STOPPED_AND_PREPARING;
191 mIsAsyncPrepare = false;
192 mPlayer->seekToAsync(0);
193 while (mState == STATE_STOPPED_AND_PREPARING) {
194 mCondition.wait(mLock);
195 }
196 return (mState == STATE_STOPPED_AND_PREPARED) ? OK : UNKNOWN_ERROR;
Andreas Huber9575c962013-02-05 13:59:56 -0800197 default:
198 return INVALID_OPERATION;
199 };
Andreas Huberf9334412010-12-15 15:17:42 -0800200}
201
202status_t NuPlayerDriver::prepareAsync() {
Andy Hung2abde2c2014-09-30 14:40:32 -0700203 ALOGV("prepareAsync(%p)", this);
Andreas Huber9575c962013-02-05 13:59:56 -0800204 Mutex::Autolock autoLock(mLock);
Andreas Huberafed0e12011-09-20 15:39:58 -0700205
Andreas Huber9575c962013-02-05 13:59:56 -0800206 switch (mState) {
207 case STATE_UNPREPARED:
208 mState = STATE_PREPARING;
Andreas Huberec0c5972013-02-05 14:47:13 -0800209 mIsAsyncPrepare = true;
Andreas Huber9575c962013-02-05 13:59:56 -0800210 mPlayer->prepareAsync();
211 return OK;
Lajos Molnar4b75b862013-08-15 15:59:19 -0700212 case STATE_STOPPED:
213 // this is really just paused. handle as seek to start
214 mAtEOS = false;
215 mState = STATE_STOPPED_AND_PREPARING;
216 mIsAsyncPrepare = true;
217 mPlayer->seekToAsync(0);
218 return OK;
Andreas Huber9575c962013-02-05 13:59:56 -0800219 default:
220 return INVALID_OPERATION;
221 };
Andreas Huberf9334412010-12-15 15:17:42 -0800222}
223
224status_t NuPlayerDriver::start() {
Andy Hung2abde2c2014-09-30 14:40:32 -0700225 ALOGD("start(%p)", this);
Andreas Huber9575c962013-02-05 13:59:56 -0800226 Mutex::Autolock autoLock(mLock);
227
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800228 switch (mState) {
Andreas Huber9575c962013-02-05 13:59:56 -0800229 case STATE_UNPREPARED:
230 {
231 status_t err = prepare_l();
232
233 if (err != OK) {
234 return err;
235 }
236
237 CHECK_EQ(mState, STATE_PREPARED);
238
239 // fall through
240 }
241
242 case STATE_PREPARED:
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800243 {
Andreas Hubera4af2142011-10-26 15:23:31 -0700244 mAtEOS = false;
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800245 mPlayer->start();
246
247 if (mStartupSeekTimeUs >= 0) {
Wei Jiae427abf2014-09-22 15:21:11 -0700248 if (mStartupSeekTimeUs > 0) {
Andreas Huber2048d0c2011-07-15 16:25:41 -0700249 mPlayer->seekToAsync(mStartupSeekTimeUs);
250 }
251
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800252 mStartupSeekTimeUs = -1;
253 }
254 break;
255 }
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800256
Andreas Huber9575c962013-02-05 13:59:56 -0800257 case STATE_RUNNING:
Wei Jia05601952014-08-20 18:21:11 -0700258 {
259 if (mAtEOS) {
260 mPlayer->seekToAsync(0);
261 mAtEOS = false;
262 mPositionUs = -1;
263 }
Andreas Huber9575c962013-02-05 13:59:56 -0800264 break;
Wei Jia05601952014-08-20 18:21:11 -0700265 }
Andreas Huber9575c962013-02-05 13:59:56 -0800266
267 case STATE_PAUSED:
Lajos Molnar4b75b862013-08-15 15:59:19 -0700268 case STATE_STOPPED_AND_PREPARED:
Andreas Huber9575c962013-02-05 13:59:56 -0800269 {
Robert Shih6e9f6b42014-09-16 17:07:22 -0700270 if (mAtEOS) {
271 mPlayer->seekToAsync(0);
272 mAtEOS = false;
273 mPlayer->resume();
274 mPositionUs = -1;
275 } else {
276 mPlayer->resume();
Robert Shih6e9f6b42014-09-16 17:07:22 -0700277 }
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800278 break;
279 }
Andreas Huber9575c962013-02-05 13:59:56 -0800280
281 default:
282 return INVALID_OPERATION;
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800283 }
284
Andreas Huber9575c962013-02-05 13:59:56 -0800285 mState = STATE_RUNNING;
Andreas Huberf9334412010-12-15 15:17:42 -0800286
287 return OK;
288}
289
290status_t NuPlayerDriver::stop() {
Andy Hung2abde2c2014-09-30 14:40:32 -0700291 ALOGD("stop(%p)", this);
Lajos Molnar4b75b862013-08-15 15:59:19 -0700292 Mutex::Autolock autoLock(mLock);
293
294 switch (mState) {
295 case STATE_RUNNING:
296 mPlayer->pause();
297 // fall through
298
299 case STATE_PAUSED:
Marco Nelissen2a79c322014-08-26 13:57:32 -0700300 mState = STATE_STOPPED;
Wei Jia05601952014-08-20 18:21:11 -0700301 notifyListener_l(MEDIA_STOPPED);
Marco Nelissen2a79c322014-08-26 13:57:32 -0700302 break;
Lajos Molnar4b75b862013-08-15 15:59:19 -0700303
304 case STATE_PREPARED:
305 case STATE_STOPPED:
306 case STATE_STOPPED_AND_PREPARING:
307 case STATE_STOPPED_AND_PREPARED:
308 mState = STATE_STOPPED;
309 break;
310
311 default:
312 return INVALID_OPERATION;
313 }
314
315 return OK;
Andreas Huberf9334412010-12-15 15:17:42 -0800316}
317
318status_t NuPlayerDriver::pause() {
Andreas Huber9575c962013-02-05 13:59:56 -0800319 Mutex::Autolock autoLock(mLock);
320
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800321 switch (mState) {
Andreas Huber9575c962013-02-05 13:59:56 -0800322 case STATE_PAUSED:
323 case STATE_PREPARED:
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800324 return OK;
Andreas Huber9575c962013-02-05 13:59:56 -0800325
326 case STATE_RUNNING:
Marco Nelissen2a79c322014-08-26 13:57:32 -0700327 mState = STATE_PAUSED;
Wei Jia05601952014-08-20 18:21:11 -0700328 notifyListener_l(MEDIA_PAUSED);
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800329 mPlayer->pause();
330 break;
Andreas Huber9575c962013-02-05 13:59:56 -0800331
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800332 default:
Andreas Huber9575c962013-02-05 13:59:56 -0800333 return INVALID_OPERATION;
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800334 }
335
Andreas Huberf9334412010-12-15 15:17:42 -0800336 return OK;
337}
338
339bool NuPlayerDriver::isPlaying() {
Andreas Huber9575c962013-02-05 13:59:56 -0800340 return mState == STATE_RUNNING && !mAtEOS;
Andreas Huberf9334412010-12-15 15:17:42 -0800341}
342
343status_t NuPlayerDriver::seekTo(int msec) {
Andy Hung2abde2c2014-09-30 14:40:32 -0700344 ALOGD("seekTo(%p) %d ms", this, msec);
Andreas Huber9575c962013-02-05 13:59:56 -0800345 Mutex::Autolock autoLock(mLock);
346
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800347 int64_t seekTimeUs = msec * 1000ll;
348
349 switch (mState) {
Andreas Huber9575c962013-02-05 13:59:56 -0800350 case STATE_PREPARED:
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800351 {
352 mStartupSeekTimeUs = seekTimeUs;
Marco Nelissendd114d12014-05-28 15:23:14 -0700353 // pretend that the seek completed. It will actually happen when starting playback.
354 // TODO: actually perform the seek here, so the player is ready to go at the new
355 // location
Marco Nelisseneb645a02014-08-20 09:44:44 -0700356 notifySeekComplete_l();
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800357 break;
358 }
Andreas Huber9575c962013-02-05 13:59:56 -0800359
360 case STATE_RUNNING:
361 case STATE_PAUSED:
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800362 {
Andreas Hubera4af2142011-10-26 15:23:31 -0700363 mAtEOS = false;
Ronghua Wua73d9e02014-10-08 15:13:29 -0700364 mSeekInProgress = true;
Lajos Molnarcbaffcf2013-08-14 18:30:38 -0700365 // seeks can take a while, so we essentially paused
Wei Jia05601952014-08-20 18:21:11 -0700366 notifyListener_l(MEDIA_PAUSED);
Wei Jiae427abf2014-09-22 15:21:11 -0700367 mPlayer->seekToAsync(seekTimeUs, true /* needNotify */);
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800368 break;
369 }
370
371 default:
Andreas Huber9575c962013-02-05 13:59:56 -0800372 return INVALID_OPERATION;
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800373 }
374
Wei Jia05601952014-08-20 18:21:11 -0700375 mPositionUs = seekTimeUs;
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800376 return OK;
Andreas Huberf9334412010-12-15 15:17:42 -0800377}
378
379status_t NuPlayerDriver::getCurrentPosition(int *msec) {
Ronghua Wua73d9e02014-10-08 15:13:29 -0700380 int64_t tempUs = 0;
381 status_t ret = mPlayer->getCurrentPosition(&tempUs);
382
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800383 Mutex::Autolock autoLock(mLock);
Ronghua Wua73d9e02014-10-08 15:13:29 -0700384 // We need to check mSeekInProgress here because mPlayer->seekToAsync is an async call, which
385 // means getCurrentPosition can be called before seek is completed. Iow, renderer may return a
386 // position value that's different the seek to position.
387 if (ret != OK || mSeekInProgress) {
388 tempUs = (mPositionUs <= 0) ? 0 : mPositionUs;
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800389 } else {
Ronghua Wua73d9e02014-10-08 15:13:29 -0700390 mPositionUs = tempUs;
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800391 }
Ronghua Wua73d9e02014-10-08 15:13:29 -0700392 *msec = (int)divRound(tempUs, (int64_t)(1000));
Andreas Huber5bc087c2010-12-23 10:27:40 -0800393 return OK;
Andreas Huberf9334412010-12-15 15:17:42 -0800394}
395
396status_t NuPlayerDriver::getDuration(int *msec) {
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800397 Mutex::Autolock autoLock(mLock);
398
399 if (mDurationUs < 0) {
Andreas Huberd85929f2013-04-11 11:07:55 -0700400 return UNKNOWN_ERROR;
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800401 }
Andreas Huber5bc087c2010-12-23 10:27:40 -0800402
Andreas Huberd85929f2013-04-11 11:07:55 -0700403 *msec = (mDurationUs + 500ll) / 1000;
404
Andreas Huber5bc087c2010-12-23 10:27:40 -0800405 return OK;
Andreas Huberf9334412010-12-15 15:17:42 -0800406}
407
408status_t NuPlayerDriver::reset() {
Andy Hung2abde2c2014-09-30 14:40:32 -0700409 ALOGD("reset(%p)", this);
Andreas Huber1aef2112011-01-04 14:01:29 -0800410 Mutex::Autolock autoLock(mLock);
Andreas Huber1aef2112011-01-04 14:01:29 -0800411
Andreas Huber9575c962013-02-05 13:59:56 -0800412 switch (mState) {
413 case STATE_IDLE:
414 return OK;
415
416 case STATE_SET_DATASOURCE_PENDING:
417 case STATE_RESET_IN_PROGRESS:
418 return INVALID_OPERATION;
419
Andreas Huberb5f28d42013-04-25 15:11:19 -0700420 case STATE_PREPARING:
421 {
422 CHECK(mIsAsyncPrepare);
423
Wei Jia05601952014-08-20 18:21:11 -0700424 notifyListener_l(MEDIA_PREPARED);
Andreas Huberb5f28d42013-04-25 15:11:19 -0700425 break;
426 }
427
Andreas Huber9575c962013-02-05 13:59:56 -0800428 default:
429 break;
430 }
431
Lajos Molnar4b75b862013-08-15 15:59:19 -0700432 if (mState != STATE_STOPPED) {
Wei Jia05601952014-08-20 18:21:11 -0700433 notifyListener_l(MEDIA_STOPPED);
Lajos Molnar4b75b862013-08-15 15:59:19 -0700434 }
Lajos Molnarcbaffcf2013-08-14 18:30:38 -0700435
Andreas Huber9575c962013-02-05 13:59:56 -0800436 mState = STATE_RESET_IN_PROGRESS;
Andreas Huber1aef2112011-01-04 14:01:29 -0800437 mPlayer->resetAsync();
438
Andreas Huber9575c962013-02-05 13:59:56 -0800439 while (mState == STATE_RESET_IN_PROGRESS) {
Andreas Huber1aef2112011-01-04 14:01:29 -0800440 mCondition.wait(mLock);
441 }
442
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800443 mDurationUs = -1;
444 mPositionUs = -1;
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800445 mStartupSeekTimeUs = -1;
Lajos Molnara2e14302014-07-31 12:07:58 -0700446 mLooping = false;
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800447
Andreas Huberf9334412010-12-15 15:17:42 -0800448 return OK;
449}
450
Lajos Molnara2e14302014-07-31 12:07:58 -0700451status_t NuPlayerDriver::setLooping(int loop) {
452 mLooping = loop != 0;
453 return OK;
Andreas Huberf9334412010-12-15 15:17:42 -0800454}
455
456player_type NuPlayerDriver::playerType() {
457 return NU_PLAYER;
458}
459
460status_t NuPlayerDriver::invoke(const Parcel &request, Parcel *reply) {
James Dong0d268a32012-08-31 12:18:27 -0700461 if (reply == NULL) {
462 ALOGE("reply is a NULL pointer");
463 return BAD_VALUE;
464 }
465
466 int32_t methodId;
467 status_t ret = request.readInt32(&methodId);
468 if (ret != OK) {
469 ALOGE("Failed to retrieve the requested method to invoke");
470 return ret;
471 }
472
473 switch (methodId) {
474 case INVOKE_ID_SET_VIDEO_SCALING_MODE:
475 {
476 int mode = request.readInt32();
477 return mPlayer->setVideoScalingMode(mode);
478 }
Andreas Huberd5e56232013-03-12 11:01:43 -0700479
Chong Zhangdcb89b32013-08-06 09:44:47 -0700480 case INVOKE_ID_GET_TRACK_INFO:
481 {
482 return mPlayer->getTrackInfo(reply);
483 }
484
485 case INVOKE_ID_SELECT_TRACK:
486 {
487 int trackIndex = request.readInt32();
488 return mPlayer->selectTrack(trackIndex, true /* select */);
489 }
490
491 case INVOKE_ID_UNSELECT_TRACK:
492 {
493 int trackIndex = request.readInt32();
494 return mPlayer->selectTrack(trackIndex, false /* select */);
495 }
496
Robert Shih7c4f0d72014-07-09 18:53:31 -0700497 case INVOKE_ID_GET_SELECTED_TRACK:
498 {
499 int32_t type = request.readInt32();
500 return mPlayer->getSelectedTrack(type, reply);
501 }
502
James Dong0d268a32012-08-31 12:18:27 -0700503 default:
504 {
505 return INVALID_OPERATION;
506 }
507 }
Andreas Huberf9334412010-12-15 15:17:42 -0800508}
509
510void NuPlayerDriver::setAudioSink(const sp<AudioSink> &audioSink) {
511 mPlayer->setAudioSink(audioSink);
Marco Nelissenf0b72b52014-09-16 15:43:44 -0700512 mAudioSink = audioSink;
Andreas Huberf9334412010-12-15 15:17:42 -0800513}
514
Andreas Huber84333e02014-02-07 15:36:10 -0800515status_t NuPlayerDriver::setParameter(
516 int /* key */, const Parcel & /* request */) {
Gloria Wang4f9e47f2011-04-25 17:28:22 -0700517 return INVALID_OPERATION;
518}
519
Andreas Huber84333e02014-02-07 15:36:10 -0800520status_t NuPlayerDriver::getParameter(int /* key */, Parcel * /* reply */) {
Gloria Wang4f9e47f2011-04-25 17:28:22 -0700521 return INVALID_OPERATION;
522}
523
Andreas Huberf9334412010-12-15 15:17:42 -0800524status_t NuPlayerDriver::getMetadata(
Andreas Huber84333e02014-02-07 15:36:10 -0800525 const media::Metadata::Filter& /* ids */, Parcel *records) {
Andreas Huber9575c962013-02-05 13:59:56 -0800526 Mutex::Autolock autoLock(mLock);
527
528 using media::Metadata;
529
530 Metadata meta(records);
531
532 meta.appendBool(
533 Metadata::kPauseAvailable,
534 mPlayerFlags & NuPlayer::Source::FLAG_CAN_PAUSE);
535
536 meta.appendBool(
537 Metadata::kSeekBackwardAvailable,
538 mPlayerFlags & NuPlayer::Source::FLAG_CAN_SEEK_BACKWARD);
539
540 meta.appendBool(
541 Metadata::kSeekForwardAvailable,
542 mPlayerFlags & NuPlayer::Source::FLAG_CAN_SEEK_FORWARD);
543
544 meta.appendBool(
545 Metadata::kSeekAvailable,
546 mPlayerFlags & NuPlayer::Source::FLAG_CAN_SEEK);
547
548 return OK;
Andreas Huberf9334412010-12-15 15:17:42 -0800549}
550
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800551void NuPlayerDriver::notifyResetComplete() {
Andy Hung8d121d42014-10-03 09:53:53 -0700552 ALOGD("notifyResetComplete(%p)", this);
Andreas Huber1aef2112011-01-04 14:01:29 -0800553 Mutex::Autolock autoLock(mLock);
Andreas Huber9575c962013-02-05 13:59:56 -0800554
555 CHECK_EQ(mState, STATE_RESET_IN_PROGRESS);
556 mState = STATE_IDLE;
Andreas Huber1aef2112011-01-04 14:01:29 -0800557 mCondition.broadcast();
558}
559
Chong Zhang13d6faa2014-08-22 15:35:28 -0700560void NuPlayerDriver::notifySetSurfaceComplete() {
Andy Hung2abde2c2014-09-30 14:40:32 -0700561 ALOGV("notifySetSurfaceComplete(%p)", this);
Chong Zhang13d6faa2014-08-22 15:35:28 -0700562 Mutex::Autolock autoLock(mLock);
563
564 CHECK(mSetSurfaceInProgress);
565 mSetSurfaceInProgress = false;
566
567 mCondition.broadcast();
568}
569
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800570void NuPlayerDriver::notifyDuration(int64_t durationUs) {
571 Mutex::Autolock autoLock(mLock);
572 mDurationUs = durationUs;
573}
574
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800575void NuPlayerDriver::notifySeekComplete() {
Andy Hung2abde2c2014-09-30 14:40:32 -0700576 ALOGV("notifySeekComplete(%p)", this);
Marco Nelisseneb645a02014-08-20 09:44:44 -0700577 Mutex::Autolock autoLock(mLock);
Ronghua Wua73d9e02014-10-08 15:13:29 -0700578 mSeekInProgress = false;
Marco Nelisseneb645a02014-08-20 09:44:44 -0700579 notifySeekComplete_l();
580}
581
582void NuPlayerDriver::notifySeekComplete_l() {
Lajos Molnar4b75b862013-08-15 15:59:19 -0700583 bool wasSeeking = true;
Marco Nelisseneb645a02014-08-20 09:44:44 -0700584 if (mState == STATE_STOPPED_AND_PREPARING) {
585 wasSeeking = false;
586 mState = STATE_STOPPED_AND_PREPARED;
587 mCondition.broadcast();
588 if (!mIsAsyncPrepare) {
589 // if we are preparing synchronously, no need to notify listener
Lajos Molnar4b75b862013-08-15 15:59:19 -0700590 return;
591 }
Marco Nelisseneb645a02014-08-20 09:44:44 -0700592 } else if (mState == STATE_STOPPED) {
593 // no need to notify listener
594 return;
Lajos Molnar4b75b862013-08-15 15:59:19 -0700595 }
Wei Jia05601952014-08-20 18:21:11 -0700596 notifyListener_l(wasSeeking ? MEDIA_SEEK_COMPLETE : MEDIA_PREPARED);
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800597}
598
Andreas Huber84333e02014-02-07 15:36:10 -0800599status_t NuPlayerDriver::dump(
600 int fd, const Vector<String16> & /* args */) const {
Ronghua Wua73d9e02014-10-08 15:13:29 -0700601 int64_t numFramesTotal;
602 int64_t numFramesDropped;
603 mPlayer->getStats(&numFramesTotal, &numFramesDropped);
Andreas Huber3fe62152011-09-16 15:09:22 -0700604
605 FILE *out = fdopen(dup(fd), "w");
606
607 fprintf(out, " NuPlayer\n");
Kévin PETIT377b2ec2014-02-03 12:35:36 +0000608 fprintf(out, " numFramesTotal(%" PRId64 "), numFramesDropped(%" PRId64 "), "
Andreas Huber3fe62152011-09-16 15:09:22 -0700609 "percentageDropped(%.2f)\n",
Ronghua Wua73d9e02014-10-08 15:13:29 -0700610 numFramesTotal,
611 numFramesDropped,
612 numFramesTotal == 0
613 ? 0.0 : (double)numFramesDropped / numFramesTotal);
Andreas Huber3fe62152011-09-16 15:09:22 -0700614
615 fclose(out);
616 out = NULL;
617
618 return OK;
619}
620
Chong Zhangdcb89b32013-08-06 09:44:47 -0700621void NuPlayerDriver::notifyListener(
622 int msg, int ext1, int ext2, const Parcel *in) {
Wei Jia05601952014-08-20 18:21:11 -0700623 Mutex::Autolock autoLock(mLock);
624 notifyListener_l(msg, ext1, ext2, in);
625}
626
627void NuPlayerDriver::notifyListener_l(
628 int msg, int ext1, int ext2, const Parcel *in) {
Lajos Molnara2e14302014-07-31 12:07:58 -0700629 switch (msg) {
630 case MEDIA_PLAYBACK_COMPLETE:
631 {
Wei Jia71079fc2014-09-10 10:06:11 -0700632 if (mState != STATE_RESET_IN_PROGRESS) {
Marco Nelissenf0b72b52014-09-16 15:43:44 -0700633 if (mLooping || (mAutoLoop
634 && (mAudioSink == NULL || mAudioSink->realtime()))) {
Wei Jia71079fc2014-09-10 10:06:11 -0700635 mPlayer->seekToAsync(0);
636 break;
637 }
638
639 mPlayer->pause();
640 mState = STATE_PAUSED;
Lajos Molnara2e14302014-07-31 12:07:58 -0700641 }
642 // fall through
643 }
644
645 case MEDIA_ERROR:
646 {
647 mAtEOS = true;
648 break;
649 }
650
651 default:
652 break;
Andreas Hubera4af2142011-10-26 15:23:31 -0700653 }
654
Wei Jia05601952014-08-20 18:21:11 -0700655 mLock.unlock();
Chong Zhangdcb89b32013-08-06 09:44:47 -0700656 sendEvent(msg, ext1, ext2, in);
Wei Jia05601952014-08-20 18:21:11 -0700657 mLock.lock();
Andreas Hubera4af2142011-10-26 15:23:31 -0700658}
659
Andreas Huber9575c962013-02-05 13:59:56 -0800660void NuPlayerDriver::notifySetDataSourceCompleted(status_t err) {
661 Mutex::Autolock autoLock(mLock);
662
663 CHECK_EQ(mState, STATE_SET_DATASOURCE_PENDING);
664
665 mAsyncResult = err;
666 mState = (err == OK) ? STATE_UNPREPARED : STATE_IDLE;
667 mCondition.broadcast();
668}
669
670void NuPlayerDriver::notifyPrepareCompleted(status_t err) {
671 Mutex::Autolock autoLock(mLock);
672
Andreas Huberb5f28d42013-04-25 15:11:19 -0700673 if (mState != STATE_PREPARING) {
674 // We were preparing asynchronously when the client called
675 // reset(), we sent a premature "prepared" notification and
676 // then initiated the reset. This notification is stale.
677 CHECK(mState == STATE_RESET_IN_PROGRESS || mState == STATE_IDLE);
678 return;
679 }
680
Andreas Huber9575c962013-02-05 13:59:56 -0800681 CHECK_EQ(mState, STATE_PREPARING);
682
683 mAsyncResult = err;
684
685 if (err == OK) {
Marco Nelissen2a79c322014-08-26 13:57:32 -0700686 // update state before notifying client, so that if client calls back into NuPlayerDriver
687 // in response, NuPlayerDriver has the right state
688 mState = STATE_PREPARED;
Andreas Huberec0c5972013-02-05 14:47:13 -0800689 if (mIsAsyncPrepare) {
Wei Jia05601952014-08-20 18:21:11 -0700690 notifyListener_l(MEDIA_PREPARED);
Andreas Huberec0c5972013-02-05 14:47:13 -0800691 }
Andreas Huber9575c962013-02-05 13:59:56 -0800692 } else {
Marco Nelissen2a79c322014-08-26 13:57:32 -0700693 mState = STATE_UNPREPARED;
Andreas Huberec0c5972013-02-05 14:47:13 -0800694 if (mIsAsyncPrepare) {
Wei Jia05601952014-08-20 18:21:11 -0700695 notifyListener_l(MEDIA_ERROR, MEDIA_ERROR_UNKNOWN, err);
Andreas Huberec0c5972013-02-05 14:47:13 -0800696 }
Andreas Huber9575c962013-02-05 13:59:56 -0800697 }
698
Marco Nelissenf0b72b52014-09-16 15:43:44 -0700699 sp<MetaData> meta = mPlayer->getFileMeta();
700 int32_t loop;
701 if (meta != NULL
702 && meta->findInt32(kKeyAutoLoop, &loop) && loop != 0) {
703 mAutoLoop = true;
704 }
705
Andreas Huber9575c962013-02-05 13:59:56 -0800706 mCondition.broadcast();
707}
708
709void NuPlayerDriver::notifyFlagsChanged(uint32_t flags) {
710 Mutex::Autolock autoLock(mLock);
711
712 mPlayerFlags = flags;
713}
714
Andreas Huberf9334412010-12-15 15:17:42 -0800715} // namespace android