blob: 20703f38906837cc1adabebc121ee0f815cb538f [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>
Andreas Huber9575c962013-02-05 13:59:56 -080029#include <media/stagefright/MetaData.h>
Andreas Huberf9334412010-12-15 15:17:42 -080030
31namespace android {
32
33NuPlayerDriver::NuPlayerDriver()
Andreas Huber9575c962013-02-05 13:59:56 -080034 : mState(STATE_IDLE),
Andreas Huberec0c5972013-02-05 14:47:13 -080035 mIsAsyncPrepare(false),
Andreas Huber9575c962013-02-05 13:59:56 -080036 mAsyncResult(UNKNOWN_ERROR),
Andreas Huber57a339c2012-12-03 11:18:00 -080037 mSetSurfaceInProgress(false),
Andreas Huber43c3e6c2011-01-05 12:17:08 -080038 mDurationUs(-1),
39 mPositionUs(-1),
Andreas Huber3fe62152011-09-16 15:09:22 -070040 mNumFramesTotal(0),
41 mNumFramesDropped(0),
Andreas Huber1aef2112011-01-04 14:01:29 -080042 mLooper(new ALooper),
Andreas Huber9575c962013-02-05 13:59:56 -080043 mPlayerFlags(0),
Andreas Hubera4af2142011-10-26 15:23:31 -070044 mAtEOS(false),
Andreas Huber43c3e6c2011-01-05 12:17:08 -080045 mStartupSeekTimeUs(-1) {
Andreas Huberf9334412010-12-15 15:17:42 -080046 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
Andreas Huber43c3e6c2011-01-05 12:17:08 -080056 mPlayer->setDriver(this);
Andreas Huberf9334412010-12-15 15:17:42 -080057}
58
59NuPlayerDriver::~NuPlayerDriver() {
60 mLooper->stop();
61}
62
63status_t NuPlayerDriver::initCheck() {
64 return OK;
65}
66
Andreas Huber9b80c2b2011-06-30 15:47:02 -070067status_t NuPlayerDriver::setUID(uid_t uid) {
68 mPlayer->setUID(uid);
69
70 return OK;
71}
72
Andreas Huberf9334412010-12-15 15:17:42 -080073status_t NuPlayerDriver::setDataSource(
Andreas Huber1b86fe02014-01-29 11:13:26 -080074 const sp<IMediaHTTPService> &httpService,
75 const char *url,
76 const KeyedVector<String8, String8> *headers) {
Andreas Huber9575c962013-02-05 13:59:56 -080077 Mutex::Autolock autoLock(mLock);
Andreas Huber43c3e6c2011-01-05 12:17:08 -080078
Andreas Huber9575c962013-02-05 13:59:56 -080079 if (mState != STATE_IDLE) {
80 return INVALID_OPERATION;
81 }
Andreas Huber5bc087c2010-12-23 10:27:40 -080082
Andreas Huber9575c962013-02-05 13:59:56 -080083 mState = STATE_SET_DATASOURCE_PENDING;
Andreas Huber43c3e6c2011-01-05 12:17:08 -080084
Andreas Huber1b86fe02014-01-29 11:13:26 -080085 mPlayer->setDataSourceAsync(httpService, url, headers);
Andreas Huber9575c962013-02-05 13:59:56 -080086
87 while (mState == STATE_SET_DATASOURCE_PENDING) {
88 mCondition.wait(mLock);
89 }
90
91 return mAsyncResult;
Andreas Huberf9334412010-12-15 15:17:42 -080092}
93
94status_t NuPlayerDriver::setDataSource(int fd, int64_t offset, int64_t length) {
Andreas Huber9575c962013-02-05 13:59:56 -080095 Mutex::Autolock autoLock(mLock);
Andreas Huberafed0e12011-09-20 15:39:58 -070096
Andreas Huber9575c962013-02-05 13:59:56 -080097 if (mState != STATE_IDLE) {
98 return INVALID_OPERATION;
99 }
Andreas Huberafed0e12011-09-20 15:39:58 -0700100
Andreas Huber9575c962013-02-05 13:59:56 -0800101 mState = STATE_SET_DATASOURCE_PENDING;
Andreas Huberafed0e12011-09-20 15:39:58 -0700102
Andreas Huber9575c962013-02-05 13:59:56 -0800103 mPlayer->setDataSourceAsync(fd, offset, length);
104
105 while (mState == STATE_SET_DATASOURCE_PENDING) {
106 mCondition.wait(mLock);
107 }
108
109 return mAsyncResult;
Andreas Huberf9334412010-12-15 15:17:42 -0800110}
111
112status_t NuPlayerDriver::setDataSource(const sp<IStreamSource> &source) {
Andreas Huber9575c962013-02-05 13:59:56 -0800113 Mutex::Autolock autoLock(mLock);
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800114
Andreas Huber9575c962013-02-05 13:59:56 -0800115 if (mState != STATE_IDLE) {
116 return INVALID_OPERATION;
117 }
Andreas Huberf9334412010-12-15 15:17:42 -0800118
Andreas Huber9575c962013-02-05 13:59:56 -0800119 mState = STATE_SET_DATASOURCE_PENDING;
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800120
Andreas Huber9575c962013-02-05 13:59:56 -0800121 mPlayer->setDataSourceAsync(source);
122
123 while (mState == STATE_SET_DATASOURCE_PENDING) {
124 mCondition.wait(mLock);
125 }
126
127 return mAsyncResult;
Andreas Huberf9334412010-12-15 15:17:42 -0800128}
129
Glenn Kasten11731182011-02-08 17:26:17 -0800130status_t NuPlayerDriver::setVideoSurfaceTexture(
Andy McFadden8ba01022012-12-18 09:46:54 -0800131 const sp<IGraphicBufferProducer> &bufferProducer) {
Andreas Huber57a339c2012-12-03 11:18:00 -0800132 Mutex::Autolock autoLock(mLock);
133
Andreas Huber9575c962013-02-05 13:59:56 -0800134 if (mSetSurfaceInProgress) {
Andreas Huber57a339c2012-12-03 11:18:00 -0800135 return INVALID_OPERATION;
136 }
137
Andreas Huber9575c962013-02-05 13:59:56 -0800138 switch (mState) {
139 case STATE_SET_DATASOURCE_PENDING:
140 case STATE_RESET_IN_PROGRESS:
141 return INVALID_OPERATION;
142
143 default:
144 break;
145 }
146
Andreas Huber57a339c2012-12-03 11:18:00 -0800147 mSetSurfaceInProgress = true;
148
Andy McFadden8ba01022012-12-18 09:46:54 -0800149 mPlayer->setVideoSurfaceTextureAsync(bufferProducer);
Andreas Huber57a339c2012-12-03 11:18:00 -0800150
151 while (mSetSurfaceInProgress) {
152 mCondition.wait(mLock);
153 }
Glenn Kasten11731182011-02-08 17:26:17 -0800154
155 return OK;
156}
157
Andreas Huberf9334412010-12-15 15:17:42 -0800158status_t NuPlayerDriver::prepare() {
Andreas Huber9575c962013-02-05 13:59:56 -0800159 Mutex::Autolock autoLock(mLock);
160 return prepare_l();
161}
162
163status_t NuPlayerDriver::prepare_l() {
164 switch (mState) {
165 case STATE_UNPREPARED:
166 mState = STATE_PREPARING;
Andreas Huberec0c5972013-02-05 14:47:13 -0800167
168 // Make sure we're not posting any notifications, success or
169 // failure information is only communicated through our result
170 // code.
171 mIsAsyncPrepare = false;
Andreas Huber9575c962013-02-05 13:59:56 -0800172 mPlayer->prepareAsync();
173 while (mState == STATE_PREPARING) {
174 mCondition.wait(mLock);
175 }
176 return (mState == STATE_PREPARED) ? OK : UNKNOWN_ERROR;
177 default:
178 return INVALID_OPERATION;
179 };
Andreas Huberf9334412010-12-15 15:17:42 -0800180}
181
182status_t NuPlayerDriver::prepareAsync() {
Andreas Huber9575c962013-02-05 13:59:56 -0800183 Mutex::Autolock autoLock(mLock);
Andreas Huberafed0e12011-09-20 15:39:58 -0700184
Andreas Huber9575c962013-02-05 13:59:56 -0800185 switch (mState) {
186 case STATE_UNPREPARED:
187 mState = STATE_PREPARING;
Andreas Huberec0c5972013-02-05 14:47:13 -0800188 mIsAsyncPrepare = true;
Andreas Huber9575c962013-02-05 13:59:56 -0800189 mPlayer->prepareAsync();
190 return OK;
191 default:
192 return INVALID_OPERATION;
193 };
Andreas Huberf9334412010-12-15 15:17:42 -0800194}
195
196status_t NuPlayerDriver::start() {
Andreas Huber9575c962013-02-05 13:59:56 -0800197 Mutex::Autolock autoLock(mLock);
198
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800199 switch (mState) {
Andreas Huber9575c962013-02-05 13:59:56 -0800200 case STATE_UNPREPARED:
201 {
202 status_t err = prepare_l();
203
204 if (err != OK) {
205 return err;
206 }
207
208 CHECK_EQ(mState, STATE_PREPARED);
209
210 // fall through
211 }
212
213 case STATE_PREPARED:
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800214 {
Andreas Hubera4af2142011-10-26 15:23:31 -0700215 mAtEOS = false;
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800216 mPlayer->start();
217
218 if (mStartupSeekTimeUs >= 0) {
Andreas Huber2048d0c2011-07-15 16:25:41 -0700219 if (mStartupSeekTimeUs == 0) {
220 notifySeekComplete();
221 } else {
222 mPlayer->seekToAsync(mStartupSeekTimeUs);
223 }
224
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800225 mStartupSeekTimeUs = -1;
226 }
227 break;
228 }
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800229
Andreas Huber9575c962013-02-05 13:59:56 -0800230 case STATE_RUNNING:
231 break;
232
233 case STATE_PAUSED:
234 {
Marco Nelissenc6993232014-07-02 15:01:57 -0700235 if (mAtEOS) {
236 mPlayer->seekToAsync(0);
237 }
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800238 mPlayer->resume();
239 break;
240 }
Andreas Huber9575c962013-02-05 13:59:56 -0800241
242 default:
243 return INVALID_OPERATION;
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800244 }
245
Andreas Huber9575c962013-02-05 13:59:56 -0800246 mState = STATE_RUNNING;
Andreas Huberf9334412010-12-15 15:17:42 -0800247
248 return OK;
249}
250
251status_t NuPlayerDriver::stop() {
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800252 return pause();
Andreas Huberf9334412010-12-15 15:17:42 -0800253}
254
255status_t NuPlayerDriver::pause() {
Andreas Huber9575c962013-02-05 13:59:56 -0800256 Mutex::Autolock autoLock(mLock);
257
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800258 switch (mState) {
Andreas Huber9575c962013-02-05 13:59:56 -0800259 case STATE_PAUSED:
260 case STATE_PREPARED:
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800261 return OK;
Andreas Huber9575c962013-02-05 13:59:56 -0800262
263 case STATE_RUNNING:
Lajos Molnarcbaffcf2013-08-14 18:30:38 -0700264 notifyListener(MEDIA_PAUSED);
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800265 mPlayer->pause();
266 break;
Andreas Huber9575c962013-02-05 13:59:56 -0800267
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800268 default:
Andreas Huber9575c962013-02-05 13:59:56 -0800269 return INVALID_OPERATION;
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800270 }
271
Andreas Huber9575c962013-02-05 13:59:56 -0800272 mState = STATE_PAUSED;
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800273
Andreas Huberf9334412010-12-15 15:17:42 -0800274 return OK;
275}
276
277bool NuPlayerDriver::isPlaying() {
Andreas Huber9575c962013-02-05 13:59:56 -0800278 return mState == STATE_RUNNING && !mAtEOS;
Andreas Huberf9334412010-12-15 15:17:42 -0800279}
280
281status_t NuPlayerDriver::seekTo(int msec) {
Andreas Huber9575c962013-02-05 13:59:56 -0800282 Mutex::Autolock autoLock(mLock);
283
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800284 int64_t seekTimeUs = msec * 1000ll;
285
286 switch (mState) {
Andreas Huber9575c962013-02-05 13:59:56 -0800287 case STATE_PREPARED:
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800288 {
Marco Nelissenc6993232014-07-02 15:01:57 -0700289 int curpos = 0;
290 if (mPositionUs > 0) {
291 curpos = (mPositionUs + 500ll) / 1000;
292 }
293 if (curpos == msec) {
294 // nothing to do, and doing something anyway could result in deadlock (b/15323063)
295 break;
296 }
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800297 mStartupSeekTimeUs = seekTimeUs;
Marco Nelissendd114d12014-05-28 15:23:14 -0700298 // pretend that the seek completed. It will actually happen when starting playback.
299 // TODO: actually perform the seek here, so the player is ready to go at the new
300 // location
301 notifySeekComplete();
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800302 break;
303 }
Andreas Huber9575c962013-02-05 13:59:56 -0800304
305 case STATE_RUNNING:
306 case STATE_PAUSED:
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800307 {
Andreas Hubera4af2142011-10-26 15:23:31 -0700308 mAtEOS = false;
Lajos Molnarcbaffcf2013-08-14 18:30:38 -0700309 // seeks can take a while, so we essentially paused
310 notifyListener(MEDIA_PAUSED);
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800311 mPlayer->seekToAsync(seekTimeUs);
312 break;
313 }
314
315 default:
Andreas Huber9575c962013-02-05 13:59:56 -0800316 return INVALID_OPERATION;
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800317 }
318
319 return OK;
Andreas Huberf9334412010-12-15 15:17:42 -0800320}
321
322status_t NuPlayerDriver::getCurrentPosition(int *msec) {
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800323 Mutex::Autolock autoLock(mLock);
324
325 if (mPositionUs < 0) {
326 *msec = 0;
327 } else {
328 *msec = (mPositionUs + 500ll) / 1000;
329 }
Andreas Huber5bc087c2010-12-23 10:27:40 -0800330
331 return OK;
Andreas Huberf9334412010-12-15 15:17:42 -0800332}
333
334status_t NuPlayerDriver::getDuration(int *msec) {
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800335 Mutex::Autolock autoLock(mLock);
336
337 if (mDurationUs < 0) {
Andreas Huberd85929f2013-04-11 11:07:55 -0700338 return UNKNOWN_ERROR;
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800339 }
Andreas Huber5bc087c2010-12-23 10:27:40 -0800340
Andreas Huberd85929f2013-04-11 11:07:55 -0700341 *msec = (mDurationUs + 500ll) / 1000;
342
Andreas Huber5bc087c2010-12-23 10:27:40 -0800343 return OK;
Andreas Huberf9334412010-12-15 15:17:42 -0800344}
345
346status_t NuPlayerDriver::reset() {
Andreas Huber1aef2112011-01-04 14:01:29 -0800347 Mutex::Autolock autoLock(mLock);
Andreas Huber1aef2112011-01-04 14:01:29 -0800348
Andreas Huber9575c962013-02-05 13:59:56 -0800349 switch (mState) {
350 case STATE_IDLE:
351 return OK;
352
353 case STATE_SET_DATASOURCE_PENDING:
354 case STATE_RESET_IN_PROGRESS:
355 return INVALID_OPERATION;
356
Andreas Huberb5f28d42013-04-25 15:11:19 -0700357 case STATE_PREPARING:
358 {
359 CHECK(mIsAsyncPrepare);
360
361 notifyListener(MEDIA_PREPARED);
362 break;
363 }
364
Andreas Huber9575c962013-02-05 13:59:56 -0800365 default:
366 break;
367 }
368
Lajos Molnarcbaffcf2013-08-14 18:30:38 -0700369 notifyListener(MEDIA_STOPPED);
370
Andreas Huber9575c962013-02-05 13:59:56 -0800371 mState = STATE_RESET_IN_PROGRESS;
Andreas Huber1aef2112011-01-04 14:01:29 -0800372 mPlayer->resetAsync();
373
Andreas Huber9575c962013-02-05 13:59:56 -0800374 while (mState == STATE_RESET_IN_PROGRESS) {
Andreas Huber1aef2112011-01-04 14:01:29 -0800375 mCondition.wait(mLock);
376 }
377
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800378 mDurationUs = -1;
379 mPositionUs = -1;
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800380 mStartupSeekTimeUs = -1;
381
Andreas Huberf9334412010-12-15 15:17:42 -0800382 return OK;
383}
384
Andreas Huber84333e02014-02-07 15:36:10 -0800385status_t NuPlayerDriver::setLooping(int /* loop */) {
Andreas Huberf9334412010-12-15 15:17:42 -0800386 return INVALID_OPERATION;
387}
388
389player_type NuPlayerDriver::playerType() {
390 return NU_PLAYER;
391}
392
393status_t NuPlayerDriver::invoke(const Parcel &request, Parcel *reply) {
James Dong0d268a32012-08-31 12:18:27 -0700394 if (reply == NULL) {
395 ALOGE("reply is a NULL pointer");
396 return BAD_VALUE;
397 }
398
399 int32_t methodId;
400 status_t ret = request.readInt32(&methodId);
401 if (ret != OK) {
402 ALOGE("Failed to retrieve the requested method to invoke");
403 return ret;
404 }
405
406 switch (methodId) {
407 case INVOKE_ID_SET_VIDEO_SCALING_MODE:
408 {
409 int mode = request.readInt32();
410 return mPlayer->setVideoScalingMode(mode);
411 }
Andreas Huberd5e56232013-03-12 11:01:43 -0700412
Chong Zhangdcb89b32013-08-06 09:44:47 -0700413 case INVOKE_ID_GET_TRACK_INFO:
414 {
415 return mPlayer->getTrackInfo(reply);
416 }
417
418 case INVOKE_ID_SELECT_TRACK:
419 {
420 int trackIndex = request.readInt32();
421 return mPlayer->selectTrack(trackIndex, true /* select */);
422 }
423
424 case INVOKE_ID_UNSELECT_TRACK:
425 {
426 int trackIndex = request.readInt32();
427 return mPlayer->selectTrack(trackIndex, false /* select */);
428 }
429
James Dong0d268a32012-08-31 12:18:27 -0700430 default:
431 {
432 return INVALID_OPERATION;
433 }
434 }
Andreas Huberf9334412010-12-15 15:17:42 -0800435}
436
437void NuPlayerDriver::setAudioSink(const sp<AudioSink> &audioSink) {
438 mPlayer->setAudioSink(audioSink);
439}
440
Andreas Huber84333e02014-02-07 15:36:10 -0800441status_t NuPlayerDriver::setParameter(
442 int /* key */, const Parcel & /* request */) {
Gloria Wang4f9e47f2011-04-25 17:28:22 -0700443 return INVALID_OPERATION;
444}
445
Andreas Huber84333e02014-02-07 15:36:10 -0800446status_t NuPlayerDriver::getParameter(int /* key */, Parcel * /* reply */) {
Gloria Wang4f9e47f2011-04-25 17:28:22 -0700447 return INVALID_OPERATION;
448}
449
Andreas Huberf9334412010-12-15 15:17:42 -0800450status_t NuPlayerDriver::getMetadata(
Andreas Huber84333e02014-02-07 15:36:10 -0800451 const media::Metadata::Filter& /* ids */, Parcel *records) {
Andreas Huber9575c962013-02-05 13:59:56 -0800452 Mutex::Autolock autoLock(mLock);
453
454 using media::Metadata;
455
456 Metadata meta(records);
457
458 meta.appendBool(
459 Metadata::kPauseAvailable,
460 mPlayerFlags & NuPlayer::Source::FLAG_CAN_PAUSE);
461
462 meta.appendBool(
463 Metadata::kSeekBackwardAvailable,
464 mPlayerFlags & NuPlayer::Source::FLAG_CAN_SEEK_BACKWARD);
465
466 meta.appendBool(
467 Metadata::kSeekForwardAvailable,
468 mPlayerFlags & NuPlayer::Source::FLAG_CAN_SEEK_FORWARD);
469
470 meta.appendBool(
471 Metadata::kSeekAvailable,
472 mPlayerFlags & NuPlayer::Source::FLAG_CAN_SEEK);
473
474 return OK;
Andreas Huberf9334412010-12-15 15:17:42 -0800475}
476
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800477void NuPlayerDriver::notifyResetComplete() {
Andreas Huber1aef2112011-01-04 14:01:29 -0800478 Mutex::Autolock autoLock(mLock);
Andreas Huber9575c962013-02-05 13:59:56 -0800479
480 CHECK_EQ(mState, STATE_RESET_IN_PROGRESS);
481 mState = STATE_IDLE;
Andreas Huber1aef2112011-01-04 14:01:29 -0800482 mCondition.broadcast();
483}
484
Andreas Huber57a339c2012-12-03 11:18:00 -0800485void NuPlayerDriver::notifySetSurfaceComplete() {
486 Mutex::Autolock autoLock(mLock);
Andreas Huber9575c962013-02-05 13:59:56 -0800487
Andreas Huber57a339c2012-12-03 11:18:00 -0800488 CHECK(mSetSurfaceInProgress);
489 mSetSurfaceInProgress = false;
Andreas Huber9575c962013-02-05 13:59:56 -0800490
Andreas Huber57a339c2012-12-03 11:18:00 -0800491 mCondition.broadcast();
492}
493
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800494void NuPlayerDriver::notifyDuration(int64_t durationUs) {
495 Mutex::Autolock autoLock(mLock);
496 mDurationUs = durationUs;
497}
498
499void NuPlayerDriver::notifyPosition(int64_t positionUs) {
500 Mutex::Autolock autoLock(mLock);
501 mPositionUs = positionUs;
502}
503
504void NuPlayerDriver::notifySeekComplete() {
Andreas Hubera4af2142011-10-26 15:23:31 -0700505 notifyListener(MEDIA_SEEK_COMPLETE);
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800506}
507
Andreas Huber3fe62152011-09-16 15:09:22 -0700508void NuPlayerDriver::notifyFrameStats(
509 int64_t numFramesTotal, int64_t numFramesDropped) {
510 Mutex::Autolock autoLock(mLock);
511 mNumFramesTotal = numFramesTotal;
512 mNumFramesDropped = numFramesDropped;
513}
514
Andreas Huber84333e02014-02-07 15:36:10 -0800515status_t NuPlayerDriver::dump(
516 int fd, const Vector<String16> & /* args */) const {
Andreas Huber3fe62152011-09-16 15:09:22 -0700517 Mutex::Autolock autoLock(mLock);
518
519 FILE *out = fdopen(dup(fd), "w");
520
521 fprintf(out, " NuPlayer\n");
Kévin PETIT377b2ec2014-02-03 12:35:36 +0000522 fprintf(out, " numFramesTotal(%" PRId64 "), numFramesDropped(%" PRId64 "), "
Andreas Huber3fe62152011-09-16 15:09:22 -0700523 "percentageDropped(%.2f)\n",
524 mNumFramesTotal,
525 mNumFramesDropped,
526 mNumFramesTotal == 0
527 ? 0.0 : (double)mNumFramesDropped / mNumFramesTotal);
528
529 fclose(out);
530 out = NULL;
531
532 return OK;
533}
534
Chong Zhangdcb89b32013-08-06 09:44:47 -0700535void NuPlayerDriver::notifyListener(
536 int msg, int ext1, int ext2, const Parcel *in) {
Andreas Hubera4af2142011-10-26 15:23:31 -0700537 if (msg == MEDIA_PLAYBACK_COMPLETE || msg == MEDIA_ERROR) {
538 mAtEOS = true;
Marco Nelissenc6993232014-07-02 15:01:57 -0700539 if (msg == MEDIA_PLAYBACK_COMPLETE) {
540 mState = STATE_PAUSED;
541 }
Andreas Hubera4af2142011-10-26 15:23:31 -0700542 }
543
Chong Zhangdcb89b32013-08-06 09:44:47 -0700544 sendEvent(msg, ext1, ext2, in);
Andreas Hubera4af2142011-10-26 15:23:31 -0700545}
546
Andreas Huber9575c962013-02-05 13:59:56 -0800547void NuPlayerDriver::notifySetDataSourceCompleted(status_t err) {
548 Mutex::Autolock autoLock(mLock);
549
550 CHECK_EQ(mState, STATE_SET_DATASOURCE_PENDING);
551
552 mAsyncResult = err;
553 mState = (err == OK) ? STATE_UNPREPARED : STATE_IDLE;
554 mCondition.broadcast();
555}
556
557void NuPlayerDriver::notifyPrepareCompleted(status_t err) {
558 Mutex::Autolock autoLock(mLock);
559
Andreas Huberb5f28d42013-04-25 15:11:19 -0700560 if (mState != STATE_PREPARING) {
561 // We were preparing asynchronously when the client called
562 // reset(), we sent a premature "prepared" notification and
563 // then initiated the reset. This notification is stale.
564 CHECK(mState == STATE_RESET_IN_PROGRESS || mState == STATE_IDLE);
565 return;
566 }
567
Andreas Huber9575c962013-02-05 13:59:56 -0800568 CHECK_EQ(mState, STATE_PREPARING);
569
570 mAsyncResult = err;
571
572 if (err == OK) {
Andreas Huberec0c5972013-02-05 14:47:13 -0800573 if (mIsAsyncPrepare) {
574 notifyListener(MEDIA_PREPARED);
575 }
Andreas Huber9575c962013-02-05 13:59:56 -0800576 mState = STATE_PREPARED;
577 } else {
Andreas Huberec0c5972013-02-05 14:47:13 -0800578 if (mIsAsyncPrepare) {
579 notifyListener(MEDIA_ERROR, MEDIA_ERROR_UNKNOWN, err);
580 }
Andreas Huber9575c962013-02-05 13:59:56 -0800581 mState = STATE_UNPREPARED;
582 }
583
584 mCondition.broadcast();
585}
586
587void NuPlayerDriver::notifyFlagsChanged(uint32_t flags) {
588 Mutex::Autolock autoLock(mLock);
589
590 mPlayerFlags = flags;
591}
592
Andreas Huberf9334412010-12-15 15:17:42 -0800593} // namespace android