blob: 621347d7631140839714be3dec6b8cbb90059f96 [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>
Praveen Chavan3a20d292015-05-21 08:47:34 -070021#include <cutils/properties.h>
Andreas Huberf9334412010-12-15 15:17:42 -080022
23#include "NuPlayerDriver.h"
24
25#include "NuPlayer.h"
Andreas Huber9575c962013-02-05 13:59:56 -080026#include "NuPlayerSource.h"
Andreas Huberf9334412010-12-15 15:17:42 -080027
Andreas Huber1aef2112011-01-04 14:01:29 -080028#include <media/stagefright/foundation/ADebug.h>
Andreas Huberf9334412010-12-15 15:17:42 -080029#include <media/stagefright/foundation/ALooper.h>
Ronghua Wua73d9e02014-10-08 15:13:29 -070030#include <media/stagefright/foundation/AUtils.h>
Andreas Huber9575c962013-02-05 13:59:56 -080031#include <media/stagefright/MetaData.h>
Andy Hung2abde2c2014-09-30 14:40:32 -070032#include <media/stagefright/Utils.h>
Andreas Huberf9334412010-12-15 15:17:42 -080033
Ray Essickd4d00612017-01-03 09:36:27 -080034#include <media/IMediaAnalyticsService.h>
35
Wei Jia1de22232017-01-04 16:09:50 -080036static const int kDumpLockRetries = 50;
37static const int kDumpLockSleepUs = 20000;
38
Andreas Huberf9334412010-12-15 15:17:42 -080039namespace android {
40
Ray Essickafb43f72017-03-09 10:23:55 -080041// key for media statistics
42static const char *kKeyPlayer = "nuplayer";
43// attrs for media statistics
44static const char *kPlayerVMime = "android.media.mediaplayer.video.mime";
45static const char *kPlayerVCodec = "android.media.mediaplayer.video.codec";
46static const char *kPlayerWidth = "android.media.mediaplayer.width";
47static const char *kPlayerHeight = "android.media.mediaplayer.height";
48static const char *kPlayerFrames = "android.media.mediaplayer.frames";
49static const char *kPlayerFramesDropped = "android.media.mediaplayer.dropped";
50static const char *kPlayerAMime = "android.media.mediaplayer.audio.mime";
51static const char *kPlayerACodec = "android.media.mediaplayer.audio.codec";
52static const char *kPlayerDuration = "android.media.mediaplayer.durationMs";
53static const char *kPlayerPlaying = "android.media.mediaplayer.playingMs";
54static const char *kPlayerError = "android.media.mediaplayer.err";
55static const char *kPlayerErrorCode = "android.media.mediaplayer.errcode";
56
Ray Essickd4d00612017-01-03 09:36:27 -080057
Ronghua Wu68845c12015-07-21 09:50:48 -070058NuPlayerDriver::NuPlayerDriver(pid_t pid)
Andreas Huber9575c962013-02-05 13:59:56 -080059 : mState(STATE_IDLE),
Andreas Huberec0c5972013-02-05 14:47:13 -080060 mIsAsyncPrepare(false),
Andreas Huber9575c962013-02-05 13:59:56 -080061 mAsyncResult(UNKNOWN_ERROR),
Chong Zhang13d6faa2014-08-22 15:35:28 -070062 mSetSurfaceInProgress(false),
Andreas Huber43c3e6c2011-01-05 12:17:08 -080063 mDurationUs(-1),
64 mPositionUs(-1),
Ronghua Wua73d9e02014-10-08 15:13:29 -070065 mSeekInProgress(false),
Ray Essickd4d00612017-01-03 09:36:27 -080066 mPlayingTimeUs(0),
Andreas Huber1aef2112011-01-04 14:01:29 -080067 mLooper(new ALooper),
Hassan Shojania69579622017-03-07 09:16:52 -080068 mPlayer(new NuPlayer(pid)),
Andreas Huber9575c962013-02-05 13:59:56 -080069 mPlayerFlags(0),
Ray Essickd4d00612017-01-03 09:36:27 -080070 mAnalyticsItem(NULL),
Andreas Hubera4af2142011-10-26 15:23:31 -070071 mAtEOS(false),
Lajos Molnara2e14302014-07-31 12:07:58 -070072 mLooping(false),
Wei Jia419187c2015-10-29 10:07:26 -070073 mAutoLoop(false) {
Wei Jia1de22232017-01-04 16:09:50 -080074 ALOGD("NuPlayerDriver(%p) created, clientPid(%d)", this, pid);
Andreas Huberf9334412010-12-15 15:17:42 -080075 mLooper->setName("NuPlayerDriver Looper");
76
Ray Essickd4d00612017-01-03 09:36:27 -080077 // set up an analytics record
Ray Essickafb43f72017-03-09 10:23:55 -080078 mAnalyticsItem = new MediaAnalyticsItem(kKeyPlayer);
Ray Essickd4d00612017-01-03 09:36:27 -080079 mAnalyticsItem->generateSessionID();
80
Andreas Huberf9334412010-12-15 15:17:42 -080081 mLooper->start(
82 false, /* runOnCallingThread */
83 true, /* canCallJava */
84 PRIORITY_AUDIO);
85
Andreas Huberf9334412010-12-15 15:17:42 -080086 mLooper->registerHandler(mPlayer);
87
Andreas Huber43c3e6c2011-01-05 12:17:08 -080088 mPlayer->setDriver(this);
Andreas Huberf9334412010-12-15 15:17:42 -080089}
90
91NuPlayerDriver::~NuPlayerDriver() {
Andy Hung2abde2c2014-09-30 14:40:32 -070092 ALOGV("~NuPlayerDriver(%p)", this);
Andreas Huberf9334412010-12-15 15:17:42 -080093 mLooper->stop();
Ray Essickd4d00612017-01-03 09:36:27 -080094
95 // finalize any pending metrics, usually a no-op.
96 finalizeMetrics("destructor");
97 logMetrics("destructor");
98
99 if (mAnalyticsItem != NULL) {
100 delete mAnalyticsItem;
101 mAnalyticsItem = NULL;
102 }
Andreas Huberf9334412010-12-15 15:17:42 -0800103}
104
105status_t NuPlayerDriver::initCheck() {
106 return OK;
107}
108
Andreas Huber9b80c2b2011-06-30 15:47:02 -0700109status_t NuPlayerDriver::setUID(uid_t uid) {
110 mPlayer->setUID(uid);
111
112 return OK;
113}
114
Andreas Huberf9334412010-12-15 15:17:42 -0800115status_t NuPlayerDriver::setDataSource(
Andreas Huber1b86fe02014-01-29 11:13:26 -0800116 const sp<IMediaHTTPService> &httpService,
117 const char *url,
118 const KeyedVector<String8, String8> *headers) {
Andy Hung2abde2c2014-09-30 14:40:32 -0700119 ALOGV("setDataSource(%p) url(%s)", this, uriDebugString(url, false).c_str());
Andreas Huber9575c962013-02-05 13:59:56 -0800120 Mutex::Autolock autoLock(mLock);
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800121
Andreas Huber9575c962013-02-05 13:59:56 -0800122 if (mState != STATE_IDLE) {
123 return INVALID_OPERATION;
124 }
Andreas Huber5bc087c2010-12-23 10:27:40 -0800125
Andreas Huber9575c962013-02-05 13:59:56 -0800126 mState = STATE_SET_DATASOURCE_PENDING;
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800127
Andreas Huber1b86fe02014-01-29 11:13:26 -0800128 mPlayer->setDataSourceAsync(httpService, url, headers);
Andreas Huber9575c962013-02-05 13:59:56 -0800129
130 while (mState == STATE_SET_DATASOURCE_PENDING) {
131 mCondition.wait(mLock);
132 }
133
134 return mAsyncResult;
Andreas Huberf9334412010-12-15 15:17:42 -0800135}
136
137status_t NuPlayerDriver::setDataSource(int fd, int64_t offset, int64_t length) {
Andy Hung2abde2c2014-09-30 14:40:32 -0700138 ALOGV("setDataSource(%p) file(%d)", this, fd);
Andreas Huber9575c962013-02-05 13:59:56 -0800139 Mutex::Autolock autoLock(mLock);
Andreas Huberafed0e12011-09-20 15:39:58 -0700140
Andreas Huber9575c962013-02-05 13:59:56 -0800141 if (mState != STATE_IDLE) {
142 return INVALID_OPERATION;
143 }
Andreas Huberafed0e12011-09-20 15:39:58 -0700144
Andreas Huber9575c962013-02-05 13:59:56 -0800145 mState = STATE_SET_DATASOURCE_PENDING;
Andreas Huberafed0e12011-09-20 15:39:58 -0700146
Andreas Huber9575c962013-02-05 13:59:56 -0800147 mPlayer->setDataSourceAsync(fd, offset, length);
148
149 while (mState == STATE_SET_DATASOURCE_PENDING) {
150 mCondition.wait(mLock);
151 }
152
153 return mAsyncResult;
Andreas Huberf9334412010-12-15 15:17:42 -0800154}
155
156status_t NuPlayerDriver::setDataSource(const sp<IStreamSource> &source) {
Andy Hung2abde2c2014-09-30 14:40:32 -0700157 ALOGV("setDataSource(%p) stream source", this);
Andreas Huber9575c962013-02-05 13:59:56 -0800158 Mutex::Autolock autoLock(mLock);
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800159
Andreas Huber9575c962013-02-05 13:59:56 -0800160 if (mState != STATE_IDLE) {
161 return INVALID_OPERATION;
162 }
Andreas Huberf9334412010-12-15 15:17:42 -0800163
Andreas Huber9575c962013-02-05 13:59:56 -0800164 mState = STATE_SET_DATASOURCE_PENDING;
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800165
Andreas Huber9575c962013-02-05 13:59:56 -0800166 mPlayer->setDataSourceAsync(source);
167
168 while (mState == STATE_SET_DATASOURCE_PENDING) {
169 mCondition.wait(mLock);
170 }
171
172 return mAsyncResult;
Andreas Huberf9334412010-12-15 15:17:42 -0800173}
174
Chris Watkins99f31602015-03-20 13:06:33 -0700175status_t NuPlayerDriver::setDataSource(const sp<DataSource> &source) {
176 ALOGV("setDataSource(%p) callback source", this);
177 Mutex::Autolock autoLock(mLock);
178
179 if (mState != STATE_IDLE) {
180 return INVALID_OPERATION;
181 }
182
183 mState = STATE_SET_DATASOURCE_PENDING;
184
185 mPlayer->setDataSourceAsync(source);
186
187 while (mState == STATE_SET_DATASOURCE_PENDING) {
188 mCondition.wait(mLock);
189 }
190
191 return mAsyncResult;
192}
193
Glenn Kasten11731182011-02-08 17:26:17 -0800194status_t NuPlayerDriver::setVideoSurfaceTexture(
Andy McFadden8ba01022012-12-18 09:46:54 -0800195 const sp<IGraphicBufferProducer> &bufferProducer) {
Andy Hung2abde2c2014-09-30 14:40:32 -0700196 ALOGV("setVideoSurfaceTexture(%p)", this);
Andreas Huber57a339c2012-12-03 11:18:00 -0800197 Mutex::Autolock autoLock(mLock);
198
Chong Zhang13d6faa2014-08-22 15:35:28 -0700199 if (mSetSurfaceInProgress) {
200 return INVALID_OPERATION;
201 }
202
Andreas Huber9575c962013-02-05 13:59:56 -0800203 switch (mState) {
204 case STATE_SET_DATASOURCE_PENDING:
205 case STATE_RESET_IN_PROGRESS:
206 return INVALID_OPERATION;
207
208 default:
209 break;
210 }
211
Chong Zhang13d6faa2014-08-22 15:35:28 -0700212 mSetSurfaceInProgress = true;
213
Andy McFadden8ba01022012-12-18 09:46:54 -0800214 mPlayer->setVideoSurfaceTextureAsync(bufferProducer);
Andreas Huber57a339c2012-12-03 11:18:00 -0800215
Chong Zhang13d6faa2014-08-22 15:35:28 -0700216 while (mSetSurfaceInProgress) {
217 mCondition.wait(mLock);
218 }
219
Glenn Kasten11731182011-02-08 17:26:17 -0800220 return OK;
221}
222
Wei Jia48fa06d2016-12-20 15:30:49 -0800223status_t NuPlayerDriver::getDefaultBufferingSettings(BufferingSettings* buffering) {
224 ALOGV("getDefaultBufferingSettings(%p)", this);
Wei Jiaaaa4dfa2017-02-28 17:22:59 -0800225 {
226 Mutex::Autolock autoLock(mLock);
227 if (mState == STATE_IDLE) {
228 return INVALID_OPERATION;
229 }
Wei Jia48fa06d2016-12-20 15:30:49 -0800230 }
231
232 return mPlayer->getDefaultBufferingSettings(buffering);
233}
234
235status_t NuPlayerDriver::setBufferingSettings(const BufferingSettings& buffering) {
236 ALOGV("setBufferingSettings(%p)", this);
Wei Jiaaaa4dfa2017-02-28 17:22:59 -0800237 {
238 Mutex::Autolock autoLock(mLock);
239 if (mState == STATE_IDLE) {
240 return INVALID_OPERATION;
241 }
Wei Jia48fa06d2016-12-20 15:30:49 -0800242 }
243
244 return mPlayer->setBufferingSettings(buffering);
245}
246
Andreas Huberf9334412010-12-15 15:17:42 -0800247status_t NuPlayerDriver::prepare() {
Andy Hung2abde2c2014-09-30 14:40:32 -0700248 ALOGV("prepare(%p)", this);
Andreas Huber9575c962013-02-05 13:59:56 -0800249 Mutex::Autolock autoLock(mLock);
250 return prepare_l();
251}
252
253status_t NuPlayerDriver::prepare_l() {
254 switch (mState) {
255 case STATE_UNPREPARED:
256 mState = STATE_PREPARING;
Andreas Huberec0c5972013-02-05 14:47:13 -0800257
258 // Make sure we're not posting any notifications, success or
259 // failure information is only communicated through our result
260 // code.
261 mIsAsyncPrepare = false;
Andreas Huber9575c962013-02-05 13:59:56 -0800262 mPlayer->prepareAsync();
263 while (mState == STATE_PREPARING) {
264 mCondition.wait(mLock);
265 }
266 return (mState == STATE_PREPARED) ? OK : UNKNOWN_ERROR;
Lajos Molnar4b75b862013-08-15 15:59:19 -0700267 case STATE_STOPPED:
268 // this is really just paused. handle as seek to start
269 mAtEOS = false;
270 mState = STATE_STOPPED_AND_PREPARING;
271 mIsAsyncPrepare = false;
Wei Jiac5de0912016-11-18 10:22:14 -0800272 mPlayer->seekToAsync(0, MediaPlayerSeekMode::SEEK_PREVIOUS_SYNC /* mode */,
273 true /* needNotify */);
Lajos Molnar4b75b862013-08-15 15:59:19 -0700274 while (mState == STATE_STOPPED_AND_PREPARING) {
275 mCondition.wait(mLock);
276 }
277 return (mState == STATE_STOPPED_AND_PREPARED) ? OK : UNKNOWN_ERROR;
Andreas Huber9575c962013-02-05 13:59:56 -0800278 default:
279 return INVALID_OPERATION;
280 };
Andreas Huberf9334412010-12-15 15:17:42 -0800281}
282
283status_t NuPlayerDriver::prepareAsync() {
Andy Hung2abde2c2014-09-30 14:40:32 -0700284 ALOGV("prepareAsync(%p)", this);
Andreas Huber9575c962013-02-05 13:59:56 -0800285 Mutex::Autolock autoLock(mLock);
Andreas Huberafed0e12011-09-20 15:39:58 -0700286
Andreas Huber9575c962013-02-05 13:59:56 -0800287 switch (mState) {
288 case STATE_UNPREPARED:
289 mState = STATE_PREPARING;
Andreas Huberec0c5972013-02-05 14:47:13 -0800290 mIsAsyncPrepare = true;
Andreas Huber9575c962013-02-05 13:59:56 -0800291 mPlayer->prepareAsync();
292 return OK;
Lajos Molnar4b75b862013-08-15 15:59:19 -0700293 case STATE_STOPPED:
294 // this is really just paused. handle as seek to start
295 mAtEOS = false;
296 mState = STATE_STOPPED_AND_PREPARING;
297 mIsAsyncPrepare = true;
Wei Jiac5de0912016-11-18 10:22:14 -0800298 mPlayer->seekToAsync(0, MediaPlayerSeekMode::SEEK_PREVIOUS_SYNC /* mode */,
299 true /* needNotify */);
Lajos Molnar4b75b862013-08-15 15:59:19 -0700300 return OK;
Andreas Huber9575c962013-02-05 13:59:56 -0800301 default:
302 return INVALID_OPERATION;
303 };
Andreas Huberf9334412010-12-15 15:17:42 -0800304}
305
306status_t NuPlayerDriver::start() {
Wei Jia67c2c942015-06-11 10:46:54 -0700307 ALOGD("start(%p), state is %d, eos is %d", this, mState, mAtEOS);
Andreas Huber9575c962013-02-05 13:59:56 -0800308 Mutex::Autolock autoLock(mLock);
Wei Jia8a092d32016-06-03 14:57:24 -0700309 return start_l();
310}
Andreas Huber9575c962013-02-05 13:59:56 -0800311
Wei Jia8a092d32016-06-03 14:57:24 -0700312status_t NuPlayerDriver::start_l() {
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800313 switch (mState) {
Andreas Huber9575c962013-02-05 13:59:56 -0800314 case STATE_UNPREPARED:
315 {
316 status_t err = prepare_l();
317
318 if (err != OK) {
319 return err;
320 }
321
322 CHECK_EQ(mState, STATE_PREPARED);
323
324 // fall through
325 }
326
Wei Jia94211742014-10-28 17:09:06 -0700327 case STATE_PAUSED:
328 case STATE_STOPPED_AND_PREPARED:
Andreas Huber9575c962013-02-05 13:59:56 -0800329 case STATE_PREPARED:
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800330 {
331 mPlayer->start();
332
Wei Jia419187c2015-10-29 10:07:26 -0700333 // fall through
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800334 }
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800335
Andreas Huber9575c962013-02-05 13:59:56 -0800336 case STATE_RUNNING:
Wei Jia05601952014-08-20 18:21:11 -0700337 {
338 if (mAtEOS) {
339 mPlayer->seekToAsync(0);
340 mAtEOS = false;
341 mPositionUs = -1;
342 }
Andreas Huber9575c962013-02-05 13:59:56 -0800343 break;
Wei Jia05601952014-08-20 18:21:11 -0700344 }
Andreas Huber9575c962013-02-05 13:59:56 -0800345
Andreas Huber9575c962013-02-05 13:59:56 -0800346 default:
347 return INVALID_OPERATION;
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800348 }
349
Andreas Huber9575c962013-02-05 13:59:56 -0800350 mState = STATE_RUNNING;
Andreas Huberf9334412010-12-15 15:17:42 -0800351
352 return OK;
353}
354
355status_t NuPlayerDriver::stop() {
Andy Hung2abde2c2014-09-30 14:40:32 -0700356 ALOGD("stop(%p)", this);
Lajos Molnar4b75b862013-08-15 15:59:19 -0700357 Mutex::Autolock autoLock(mLock);
358
359 switch (mState) {
360 case STATE_RUNNING:
361 mPlayer->pause();
362 // fall through
363
364 case STATE_PAUSED:
Marco Nelissen2a79c322014-08-26 13:57:32 -0700365 mState = STATE_STOPPED;
Wei Jia05601952014-08-20 18:21:11 -0700366 notifyListener_l(MEDIA_STOPPED);
Marco Nelissen2a79c322014-08-26 13:57:32 -0700367 break;
Lajos Molnar4b75b862013-08-15 15:59:19 -0700368
369 case STATE_PREPARED:
370 case STATE_STOPPED:
371 case STATE_STOPPED_AND_PREPARING:
372 case STATE_STOPPED_AND_PREPARED:
373 mState = STATE_STOPPED;
374 break;
375
376 default:
377 return INVALID_OPERATION;
378 }
379
380 return OK;
Andreas Huberf9334412010-12-15 15:17:42 -0800381}
382
383status_t NuPlayerDriver::pause() {
Wei Jia03a56532016-03-23 13:43:31 -0700384 ALOGD("pause(%p)", this);
Ronghua Wuf83408b2014-11-19 10:02:16 -0800385 // The NuPlayerRenderer may get flushed if pause for long enough, e.g. the pause timeout tear
386 // down for audio offload mode. If that happens, the NuPlayerRenderer will no longer know the
387 // current position. So similar to seekTo, update |mPositionUs| to the pause position by calling
388 // getCurrentPosition here.
Wei Jia62cc8d02016-01-21 13:03:20 -0800389 int unused;
390 getCurrentPosition(&unused);
Ronghua Wuf83408b2014-11-19 10:02:16 -0800391
Andreas Huber9575c962013-02-05 13:59:56 -0800392 Mutex::Autolock autoLock(mLock);
393
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800394 switch (mState) {
Andreas Huber9575c962013-02-05 13:59:56 -0800395 case STATE_PAUSED:
396 case STATE_PREPARED:
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800397 return OK;
Andreas Huber9575c962013-02-05 13:59:56 -0800398
399 case STATE_RUNNING:
Marco Nelissen2a79c322014-08-26 13:57:32 -0700400 mState = STATE_PAUSED;
Wei Jia05601952014-08-20 18:21:11 -0700401 notifyListener_l(MEDIA_PAUSED);
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800402 mPlayer->pause();
403 break;
Andreas Huber9575c962013-02-05 13:59:56 -0800404
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800405 default:
Andreas Huber9575c962013-02-05 13:59:56 -0800406 return INVALID_OPERATION;
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800407 }
408
Andreas Huberf9334412010-12-15 15:17:42 -0800409 return OK;
410}
411
412bool NuPlayerDriver::isPlaying() {
Andreas Huber9575c962013-02-05 13:59:56 -0800413 return mState == STATE_RUNNING && !mAtEOS;
Andreas Huberf9334412010-12-15 15:17:42 -0800414}
415
Lajos Molnar3a474aa2015-04-24 17:10:07 -0700416status_t NuPlayerDriver::setPlaybackSettings(const AudioPlaybackRate &rate) {
Lajos Molnar3a474aa2015-04-24 17:10:07 -0700417 status_t err = mPlayer->setPlaybackSettings(rate);
418 if (err == OK) {
Wei Jia62cc8d02016-01-21 13:03:20 -0800419 // try to update position
420 int unused;
421 getCurrentPosition(&unused);
Wei Jiaf3631d22015-10-06 10:32:32 -0700422 Mutex::Autolock autoLock(mLock);
Lajos Molnar3a474aa2015-04-24 17:10:07 -0700423 if (rate.mSpeed == 0.f && mState == STATE_RUNNING) {
424 mState = STATE_PAUSED;
Lajos Molnar3a474aa2015-04-24 17:10:07 -0700425 notifyListener_l(MEDIA_PAUSED);
Wei Jia8a092d32016-06-03 14:57:24 -0700426 } else if (rate.mSpeed != 0.f
427 && (mState == STATE_PAUSED
428 || mState == STATE_STOPPED_AND_PREPARED
429 || mState == STATE_PREPARED)) {
430 err = start_l();
Lajos Molnar3a474aa2015-04-24 17:10:07 -0700431 }
432 }
433 return err;
434}
435
436status_t NuPlayerDriver::getPlaybackSettings(AudioPlaybackRate *rate) {
437 return mPlayer->getPlaybackSettings(rate);
438}
439
440status_t NuPlayerDriver::setSyncSettings(const AVSyncSettings &sync, float videoFpsHint) {
441 return mPlayer->setSyncSettings(sync, videoFpsHint);
442}
443
444status_t NuPlayerDriver::getSyncSettings(AVSyncSettings *sync, float *videoFps) {
445 return mPlayer->getSyncSettings(sync, videoFps);
Wei Jia98160162015-02-04 17:01:11 -0800446}
447
Wei Jiac5de0912016-11-18 10:22:14 -0800448status_t NuPlayerDriver::seekTo(int msec, MediaPlayerSeekMode mode) {
449 ALOGD("seekTo(%p) (%d ms, %d) at state %d", this, msec, mode, mState);
Andreas Huber9575c962013-02-05 13:59:56 -0800450 Mutex::Autolock autoLock(mLock);
451
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800452 int64_t seekTimeUs = msec * 1000ll;
453
454 switch (mState) {
Andreas Huber9575c962013-02-05 13:59:56 -0800455 case STATE_PREPARED:
Wei Jia94211742014-10-28 17:09:06 -0700456 case STATE_STOPPED_AND_PREPARED:
Andreas Huber9575c962013-02-05 13:59:56 -0800457 case STATE_PAUSED:
Wei Jia1061c9c2015-05-19 16:02:17 -0700458 case STATE_RUNNING:
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800459 {
Andreas Hubera4af2142011-10-26 15:23:31 -0700460 mAtEOS = false;
Ronghua Wua73d9e02014-10-08 15:13:29 -0700461 mSeekInProgress = true;
Lajos Molnarcbaffcf2013-08-14 18:30:38 -0700462 // seeks can take a while, so we essentially paused
Wei Jia05601952014-08-20 18:21:11 -0700463 notifyListener_l(MEDIA_PAUSED);
Wei Jiac5de0912016-11-18 10:22:14 -0800464 mPlayer->seekToAsync(seekTimeUs, mode, true /* needNotify */);
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800465 break;
466 }
467
468 default:
Andreas Huber9575c962013-02-05 13:59:56 -0800469 return INVALID_OPERATION;
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800470 }
471
Wei Jia05601952014-08-20 18:21:11 -0700472 mPositionUs = seekTimeUs;
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800473 return OK;
Andreas Huberf9334412010-12-15 15:17:42 -0800474}
475
476status_t NuPlayerDriver::getCurrentPosition(int *msec) {
Ronghua Wua73d9e02014-10-08 15:13:29 -0700477 int64_t tempUs = 0;
Wei Jiad4cdba12014-12-18 10:44:17 -0800478 {
479 Mutex::Autolock autoLock(mLock);
Wei Jia62cc8d02016-01-21 13:03:20 -0800480 if (mSeekInProgress || (mState == STATE_PAUSED && !mAtEOS)) {
Wei Jiad4cdba12014-12-18 10:44:17 -0800481 tempUs = (mPositionUs <= 0) ? 0 : mPositionUs;
482 *msec = (int)divRound(tempUs, (int64_t)(1000));
483 return OK;
484 }
485 }
486
Ronghua Wua73d9e02014-10-08 15:13:29 -0700487 status_t ret = mPlayer->getCurrentPosition(&tempUs);
488
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800489 Mutex::Autolock autoLock(mLock);
Ronghua Wua73d9e02014-10-08 15:13:29 -0700490 // We need to check mSeekInProgress here because mPlayer->seekToAsync is an async call, which
491 // means getCurrentPosition can be called before seek is completed. Iow, renderer may return a
492 // position value that's different the seek to position.
Wei Jiad4cdba12014-12-18 10:44:17 -0800493 if (ret != OK) {
Ronghua Wua73d9e02014-10-08 15:13:29 -0700494 tempUs = (mPositionUs <= 0) ? 0 : mPositionUs;
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800495 } else {
Ronghua Wua73d9e02014-10-08 15:13:29 -0700496 mPositionUs = tempUs;
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800497 }
Ronghua Wua73d9e02014-10-08 15:13:29 -0700498 *msec = (int)divRound(tempUs, (int64_t)(1000));
Andreas Huber5bc087c2010-12-23 10:27:40 -0800499 return OK;
Andreas Huberf9334412010-12-15 15:17:42 -0800500}
501
502status_t NuPlayerDriver::getDuration(int *msec) {
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800503 Mutex::Autolock autoLock(mLock);
504
505 if (mDurationUs < 0) {
Andreas Huberd85929f2013-04-11 11:07:55 -0700506 return UNKNOWN_ERROR;
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800507 }
Andreas Huber5bc087c2010-12-23 10:27:40 -0800508
Andreas Huberd85929f2013-04-11 11:07:55 -0700509 *msec = (mDurationUs + 500ll) / 1000;
510
Andreas Huber5bc087c2010-12-23 10:27:40 -0800511 return OK;
Andreas Huberf9334412010-12-15 15:17:42 -0800512}
513
Ray Essickd4d00612017-01-03 09:36:27 -0800514void NuPlayerDriver::finalizeMetrics(const char *where) {
515 if (where == NULL) {
516 where = "unknown";
517 }
Ray Essickafb43f72017-03-09 10:23:55 -0800518 ALOGV("finalizeMetrics(%p) from %s at state %d", this, where, mState);
Ray Essickd4d00612017-01-03 09:36:27 -0800519
520 // gather the final stats for this record
521 Vector<sp<AMessage>> trackStats;
522 mPlayer->getStats(&trackStats);
523
524 if (trackStats.size() > 0) {
525 for (size_t i = 0; i < trackStats.size(); ++i) {
526 const sp<AMessage> &stats = trackStats.itemAt(i);
527
528 AString mime;
529 stats->findString("mime", &mime);
530
531 AString name;
532 stats->findString("component-name", &name);
533
534 if (mime.startsWith("video/")) {
535 int32_t width, height;
Ray Essickafb43f72017-03-09 10:23:55 -0800536 mAnalyticsItem->setCString(kPlayerVMime, mime.c_str());
Ray Essickd4d00612017-01-03 09:36:27 -0800537 if (!name.empty()) {
Ray Essickafb43f72017-03-09 10:23:55 -0800538 mAnalyticsItem->setCString(kPlayerVCodec, name.c_str());
Ray Essickd4d00612017-01-03 09:36:27 -0800539 }
540
541 if (stats->findInt32("width", &width)
542 && stats->findInt32("height", &height)) {
Ray Essickafb43f72017-03-09 10:23:55 -0800543 mAnalyticsItem->setInt32(kPlayerWidth, width);
544 mAnalyticsItem->setInt32(kPlayerHeight, height);
Ray Essickd4d00612017-01-03 09:36:27 -0800545 }
546
547 int64_t numFramesTotal = 0;
548 int64_t numFramesDropped = 0;
549 stats->findInt64("frames-total", &numFramesTotal);
550 stats->findInt64("frames-dropped-output", &numFramesDropped);
551
Ray Essickafb43f72017-03-09 10:23:55 -0800552 mAnalyticsItem->setInt64(kPlayerFrames, numFramesTotal);
553 mAnalyticsItem->setInt64(kPlayerFramesDropped, numFramesDropped);
Ray Essickd4d00612017-01-03 09:36:27 -0800554
555
556 } else if (mime.startsWith("audio/")) {
Ray Essickafb43f72017-03-09 10:23:55 -0800557 mAnalyticsItem->setCString(kPlayerAMime, mime.c_str());
Ray Essickd4d00612017-01-03 09:36:27 -0800558 if (!name.empty()) {
Ray Essickafb43f72017-03-09 10:23:55 -0800559 mAnalyticsItem->setCString(kPlayerACodec, name.c_str());
Ray Essickd4d00612017-01-03 09:36:27 -0800560 }
561 }
562 }
563
564 // getDuration() uses mLock for mutex -- careful where we use it.
565 int duration_ms = -1;
566 getDuration(&duration_ms);
567 if (duration_ms != -1) {
Ray Essickafb43f72017-03-09 10:23:55 -0800568 mAnalyticsItem->setInt64(kPlayerDuration, duration_ms);
Ray Essickd4d00612017-01-03 09:36:27 -0800569 }
570
571 if (mPlayingTimeUs > 0) {
Ray Essickafb43f72017-03-09 10:23:55 -0800572 mAnalyticsItem->setInt64(kPlayerPlaying, (mPlayingTimeUs+500)/1000 );
Ray Essickd4d00612017-01-03 09:36:27 -0800573 }
574 }
575}
576
577
578void NuPlayerDriver::logMetrics(const char *where) {
579 if (where == NULL) {
580 where = "unknown";
581 }
Ray Essickafb43f72017-03-09 10:23:55 -0800582 ALOGV("logMetrics(%p) from %s at state %d", this, where, mState);
Ray Essickd4d00612017-01-03 09:36:27 -0800583
584 if (mAnalyticsItem == NULL || mAnalyticsItem->isEnabled() == false) {
585 return;
586 }
587
588 // only bother to log non-empty records
589 if (mAnalyticsItem->count() > 0) {
590
591 mAnalyticsItem->setFinalized(true);
592 mAnalyticsItem->selfrecord();
593
594 // re-init in case we prepare() and start() again.
595 delete mAnalyticsItem ;
596 mAnalyticsItem = new MediaAnalyticsItem("nuplayer");
597 if (mAnalyticsItem) {
598 mAnalyticsItem->generateSessionID();
599 }
600 } else {
601 ALOGV("did not have anything to record");
602 }
603}
604
Andreas Huberf9334412010-12-15 15:17:42 -0800605status_t NuPlayerDriver::reset() {
Wei Jiaf3c2b3d2015-08-06 11:39:45 -0700606 ALOGD("reset(%p) at state %d", this, mState);
Ray Essickd4d00612017-01-03 09:36:27 -0800607
608 finalizeMetrics("reset");
609 logMetrics("reset");
610
Andreas Huber1aef2112011-01-04 14:01:29 -0800611 Mutex::Autolock autoLock(mLock);
Andreas Huber1aef2112011-01-04 14:01:29 -0800612
Andreas Huber9575c962013-02-05 13:59:56 -0800613 switch (mState) {
614 case STATE_IDLE:
615 return OK;
616
617 case STATE_SET_DATASOURCE_PENDING:
618 case STATE_RESET_IN_PROGRESS:
619 return INVALID_OPERATION;
620
Andreas Huberb5f28d42013-04-25 15:11:19 -0700621 case STATE_PREPARING:
622 {
623 CHECK(mIsAsyncPrepare);
624
Wei Jia05601952014-08-20 18:21:11 -0700625 notifyListener_l(MEDIA_PREPARED);
Andreas Huberb5f28d42013-04-25 15:11:19 -0700626 break;
627 }
628
Andreas Huber9575c962013-02-05 13:59:56 -0800629 default:
630 break;
631 }
632
Lajos Molnar4b75b862013-08-15 15:59:19 -0700633 if (mState != STATE_STOPPED) {
Wei Jia05601952014-08-20 18:21:11 -0700634 notifyListener_l(MEDIA_STOPPED);
Lajos Molnar4b75b862013-08-15 15:59:19 -0700635 }
Lajos Molnarcbaffcf2013-08-14 18:30:38 -0700636
Marco Nelissen96626b72016-12-01 13:58:59 -0800637 if (property_get_bool("persist.debug.sf.stats", false)) {
Praveen Chavan3a20d292015-05-21 08:47:34 -0700638 Vector<String16> args;
639 dump(-1, args);
640 }
641
Andreas Huber9575c962013-02-05 13:59:56 -0800642 mState = STATE_RESET_IN_PROGRESS;
Andreas Huber1aef2112011-01-04 14:01:29 -0800643 mPlayer->resetAsync();
644
Andreas Huber9575c962013-02-05 13:59:56 -0800645 while (mState == STATE_RESET_IN_PROGRESS) {
Andreas Huber1aef2112011-01-04 14:01:29 -0800646 mCondition.wait(mLock);
647 }
648
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800649 mDurationUs = -1;
650 mPositionUs = -1;
Lajos Molnara2e14302014-07-31 12:07:58 -0700651 mLooping = false;
Ray Essickd4d00612017-01-03 09:36:27 -0800652 mPlayingTimeUs = 0;
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800653
Andreas Huberf9334412010-12-15 15:17:42 -0800654 return OK;
655}
656
Lajos Molnara2e14302014-07-31 12:07:58 -0700657status_t NuPlayerDriver::setLooping(int loop) {
658 mLooping = loop != 0;
659 return OK;
Andreas Huberf9334412010-12-15 15:17:42 -0800660}
661
662player_type NuPlayerDriver::playerType() {
663 return NU_PLAYER;
664}
665
666status_t NuPlayerDriver::invoke(const Parcel &request, Parcel *reply) {
James Dong0d268a32012-08-31 12:18:27 -0700667 if (reply == NULL) {
668 ALOGE("reply is a NULL pointer");
669 return BAD_VALUE;
670 }
671
672 int32_t methodId;
673 status_t ret = request.readInt32(&methodId);
674 if (ret != OK) {
675 ALOGE("Failed to retrieve the requested method to invoke");
676 return ret;
677 }
678
679 switch (methodId) {
680 case INVOKE_ID_SET_VIDEO_SCALING_MODE:
681 {
682 int mode = request.readInt32();
683 return mPlayer->setVideoScalingMode(mode);
684 }
Andreas Huberd5e56232013-03-12 11:01:43 -0700685
Chong Zhangdcb89b32013-08-06 09:44:47 -0700686 case INVOKE_ID_GET_TRACK_INFO:
687 {
688 return mPlayer->getTrackInfo(reply);
689 }
690
691 case INVOKE_ID_SELECT_TRACK:
692 {
693 int trackIndex = request.readInt32();
Robert Shih6ffb1fd2014-10-29 16:24:32 -0700694 int msec = 0;
695 // getCurrentPosition should always return OK
696 getCurrentPosition(&msec);
697 return mPlayer->selectTrack(trackIndex, true /* select */, msec * 1000ll);
Chong Zhangdcb89b32013-08-06 09:44:47 -0700698 }
699
700 case INVOKE_ID_UNSELECT_TRACK:
701 {
702 int trackIndex = request.readInt32();
Robert Shih6ffb1fd2014-10-29 16:24:32 -0700703 return mPlayer->selectTrack(trackIndex, false /* select */, 0xdeadbeef /* not used */);
Chong Zhangdcb89b32013-08-06 09:44:47 -0700704 }
705
Robert Shih7c4f0d72014-07-09 18:53:31 -0700706 case INVOKE_ID_GET_SELECTED_TRACK:
707 {
708 int32_t type = request.readInt32();
709 return mPlayer->getSelectedTrack(type, reply);
710 }
711
James Dong0d268a32012-08-31 12:18:27 -0700712 default:
713 {
714 return INVALID_OPERATION;
715 }
716 }
Andreas Huberf9334412010-12-15 15:17:42 -0800717}
718
719void NuPlayerDriver::setAudioSink(const sp<AudioSink> &audioSink) {
720 mPlayer->setAudioSink(audioSink);
Marco Nelissenf0b72b52014-09-16 15:43:44 -0700721 mAudioSink = audioSink;
Andreas Huberf9334412010-12-15 15:17:42 -0800722}
723
Andreas Huber84333e02014-02-07 15:36:10 -0800724status_t NuPlayerDriver::setParameter(
725 int /* key */, const Parcel & /* request */) {
Gloria Wang4f9e47f2011-04-25 17:28:22 -0700726 return INVALID_OPERATION;
727}
728
Ray Essickdb122142017-01-25 17:51:55 -0800729status_t NuPlayerDriver::getParameter(int key, Parcel *reply) {
730
731 if (key == FOURCC('m','t','r','X')) {
732 // mtrX -- a play on 'metrics' (not matrix)
733 // gather current info all together, parcel it, and send it back
734 finalizeMetrics("api");
735 mAnalyticsItem->writeToParcel(reply);
736 return OK;
737 }
738
Gloria Wang4f9e47f2011-04-25 17:28:22 -0700739 return INVALID_OPERATION;
740}
741
Andreas Huberf9334412010-12-15 15:17:42 -0800742status_t NuPlayerDriver::getMetadata(
Andreas Huber84333e02014-02-07 15:36:10 -0800743 const media::Metadata::Filter& /* ids */, Parcel *records) {
Andreas Huber9575c962013-02-05 13:59:56 -0800744 Mutex::Autolock autoLock(mLock);
745
746 using media::Metadata;
747
748 Metadata meta(records);
749
750 meta.appendBool(
751 Metadata::kPauseAvailable,
752 mPlayerFlags & NuPlayer::Source::FLAG_CAN_PAUSE);
753
754 meta.appendBool(
755 Metadata::kSeekBackwardAvailable,
756 mPlayerFlags & NuPlayer::Source::FLAG_CAN_SEEK_BACKWARD);
757
758 meta.appendBool(
759 Metadata::kSeekForwardAvailable,
760 mPlayerFlags & NuPlayer::Source::FLAG_CAN_SEEK_FORWARD);
761
762 meta.appendBool(
763 Metadata::kSeekAvailable,
764 mPlayerFlags & NuPlayer::Source::FLAG_CAN_SEEK);
765
766 return OK;
Andreas Huberf9334412010-12-15 15:17:42 -0800767}
768
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800769void NuPlayerDriver::notifyResetComplete() {
Andy Hung8d121d42014-10-03 09:53:53 -0700770 ALOGD("notifyResetComplete(%p)", this);
Andreas Huber1aef2112011-01-04 14:01:29 -0800771 Mutex::Autolock autoLock(mLock);
Andreas Huber9575c962013-02-05 13:59:56 -0800772
773 CHECK_EQ(mState, STATE_RESET_IN_PROGRESS);
774 mState = STATE_IDLE;
Andreas Huber1aef2112011-01-04 14:01:29 -0800775 mCondition.broadcast();
776}
777
Chong Zhang13d6faa2014-08-22 15:35:28 -0700778void NuPlayerDriver::notifySetSurfaceComplete() {
Andy Hung2abde2c2014-09-30 14:40:32 -0700779 ALOGV("notifySetSurfaceComplete(%p)", this);
Chong Zhang13d6faa2014-08-22 15:35:28 -0700780 Mutex::Autolock autoLock(mLock);
781
782 CHECK(mSetSurfaceInProgress);
783 mSetSurfaceInProgress = false;
784
785 mCondition.broadcast();
786}
787
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800788void NuPlayerDriver::notifyDuration(int64_t durationUs) {
789 Mutex::Autolock autoLock(mLock);
790 mDurationUs = durationUs;
791}
792
Ray Essickd4d00612017-01-03 09:36:27 -0800793void NuPlayerDriver::notifyMorePlayingTimeUs(int64_t playingUs) {
794 Mutex::Autolock autoLock(mLock);
795 mPlayingTimeUs += playingUs;
796}
797
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800798void NuPlayerDriver::notifySeekComplete() {
Andy Hung2abde2c2014-09-30 14:40:32 -0700799 ALOGV("notifySeekComplete(%p)", this);
Marco Nelisseneb645a02014-08-20 09:44:44 -0700800 Mutex::Autolock autoLock(mLock);
Ronghua Wua73d9e02014-10-08 15:13:29 -0700801 mSeekInProgress = false;
Marco Nelisseneb645a02014-08-20 09:44:44 -0700802 notifySeekComplete_l();
803}
804
805void NuPlayerDriver::notifySeekComplete_l() {
Lajos Molnar4b75b862013-08-15 15:59:19 -0700806 bool wasSeeking = true;
Marco Nelisseneb645a02014-08-20 09:44:44 -0700807 if (mState == STATE_STOPPED_AND_PREPARING) {
808 wasSeeking = false;
809 mState = STATE_STOPPED_AND_PREPARED;
810 mCondition.broadcast();
811 if (!mIsAsyncPrepare) {
812 // if we are preparing synchronously, no need to notify listener
Lajos Molnar4b75b862013-08-15 15:59:19 -0700813 return;
814 }
Marco Nelisseneb645a02014-08-20 09:44:44 -0700815 } else if (mState == STATE_STOPPED) {
816 // no need to notify listener
817 return;
Lajos Molnar4b75b862013-08-15 15:59:19 -0700818 }
Wei Jia05601952014-08-20 18:21:11 -0700819 notifyListener_l(wasSeeking ? MEDIA_SEEK_COMPLETE : MEDIA_PREPARED);
Andreas Huber43c3e6c2011-01-05 12:17:08 -0800820}
821
Andreas Huber84333e02014-02-07 15:36:10 -0800822status_t NuPlayerDriver::dump(
823 int fd, const Vector<String16> & /* args */) const {
Praveen Chavane1e5d7a2015-05-19 19:09:48 -0700824
825 Vector<sp<AMessage> > trackStats;
826 mPlayer->getStats(&trackStats);
Andreas Huber3fe62152011-09-16 15:09:22 -0700827
Praveen Chavan3a20d292015-05-21 08:47:34 -0700828 AString logString(" NuPlayer\n");
829 char buf[256] = {0};
Andreas Huber3fe62152011-09-16 15:09:22 -0700830
Wei Jia1de22232017-01-04 16:09:50 -0800831 bool locked = false;
832 for (int i = 0; i < kDumpLockRetries; ++i) {
833 if (mLock.tryLock() == NO_ERROR) {
834 locked = true;
835 break;
836 }
837 usleep(kDumpLockSleepUs);
838 }
839
840 if (locked) {
841 snprintf(buf, sizeof(buf), " state(%d), atEOS(%d), looping(%d), autoLoop(%d)\n",
842 mState, mAtEOS, mLooping, mAutoLoop);
843 mLock.unlock();
844 } else {
845 snprintf(buf, sizeof(buf), " NPD(%p) lock is taken\n", this);
846 }
847 logString.append(buf);
848
Praveen Chavane1e5d7a2015-05-19 19:09:48 -0700849 for (size_t i = 0; i < trackStats.size(); ++i) {
850 const sp<AMessage> &stats = trackStats.itemAt(i);
Andreas Huber3fe62152011-09-16 15:09:22 -0700851
Praveen Chavane1e5d7a2015-05-19 19:09:48 -0700852 AString mime;
853 if (stats->findString("mime", &mime)) {
Praveen Chavan3a20d292015-05-21 08:47:34 -0700854 snprintf(buf, sizeof(buf), " mime(%s)\n", mime.c_str());
855 logString.append(buf);
Praveen Chavane1e5d7a2015-05-19 19:09:48 -0700856 }
857
858 AString name;
859 if (stats->findString("component-name", &name)) {
Praveen Chavan3a20d292015-05-21 08:47:34 -0700860 snprintf(buf, sizeof(buf), " decoder(%s)\n", name.c_str());
861 logString.append(buf);
Praveen Chavane1e5d7a2015-05-19 19:09:48 -0700862 }
863
864 if (mime.startsWith("video/")) {
865 int32_t width, height;
866 if (stats->findInt32("width", &width)
867 && stats->findInt32("height", &height)) {
Praveen Chavan3a20d292015-05-21 08:47:34 -0700868 snprintf(buf, sizeof(buf), " resolution(%d x %d)\n", width, height);
869 logString.append(buf);
Praveen Chavane1e5d7a2015-05-19 19:09:48 -0700870 }
871
872 int64_t numFramesTotal = 0;
873 int64_t numFramesDropped = 0;
874
875 stats->findInt64("frames-total", &numFramesTotal);
876 stats->findInt64("frames-dropped-output", &numFramesDropped);
Praveen Chavan3a20d292015-05-21 08:47:34 -0700877 snprintf(buf, sizeof(buf), " numFramesTotal(%lld), numFramesDropped(%lld), "
Praveen Chavane1e5d7a2015-05-19 19:09:48 -0700878 "percentageDropped(%.2f%%)\n",
879 (long long)numFramesTotal,
880 (long long)numFramesDropped,
881 numFramesTotal == 0
882 ? 0.0 : (double)(numFramesDropped * 100) / numFramesTotal);
Praveen Chavan3a20d292015-05-21 08:47:34 -0700883 logString.append(buf);
Praveen Chavane1e5d7a2015-05-19 19:09:48 -0700884 }
885 }
Praveen Chavan3a20d292015-05-21 08:47:34 -0700886
887 ALOGI("%s", logString.c_str());
888
889 if (fd >= 0) {
890 FILE *out = fdopen(dup(fd), "w");
891 fprintf(out, "%s", logString.c_str());
892 fclose(out);
893 out = NULL;
894 }
Andreas Huber3fe62152011-09-16 15:09:22 -0700895
896 return OK;
897}
898
Chong Zhangdcb89b32013-08-06 09:44:47 -0700899void NuPlayerDriver::notifyListener(
900 int msg, int ext1, int ext2, const Parcel *in) {
Wei Jia05601952014-08-20 18:21:11 -0700901 Mutex::Autolock autoLock(mLock);
902 notifyListener_l(msg, ext1, ext2, in);
903}
904
905void NuPlayerDriver::notifyListener_l(
906 int msg, int ext1, int ext2, const Parcel *in) {
Hassan Shojaniacefac142017-02-06 21:02:02 -0800907 ALOGD("notifyListener_l(%p), (%d, %d, %d, %d), loop setting(%d, %d)",
908 this, msg, ext1, ext2, (in == NULL ? -1 : (int)in->dataSize()), mAutoLoop, mLooping);
Lajos Molnara2e14302014-07-31 12:07:58 -0700909 switch (msg) {
910 case MEDIA_PLAYBACK_COMPLETE:
911 {
Wei Jia71079fc2014-09-10 10:06:11 -0700912 if (mState != STATE_RESET_IN_PROGRESS) {
Marco Nelissen707eade2014-11-18 09:50:35 -0800913 if (mAutoLoop) {
914 audio_stream_type_t streamType = AUDIO_STREAM_MUSIC;
915 if (mAudioSink != NULL) {
916 streamType = mAudioSink->getAudioStreamType();
917 }
918 if (streamType == AUDIO_STREAM_NOTIFICATION) {
919 ALOGW("disabling auto-loop for notification");
920 mAutoLoop = false;
921 }
922 }
Marco Nelissenb7848f12014-12-04 08:57:56 -0800923 if (mLooping || mAutoLoop) {
Wei Jia71079fc2014-09-10 10:06:11 -0700924 mPlayer->seekToAsync(0);
Marco Nelissen368e3372014-11-11 13:56:44 -0800925 if (mAudioSink != NULL) {
926 // The renderer has stopped the sink at the end in order to play out
927 // the last little bit of audio. If we're looping, we need to restart it.
928 mAudioSink->start();
929 }
Marco Nelissen0e4bd4d2015-10-08 10:00:34 -0700930 // don't send completion event when looping
931 return;
Wei Jia71079fc2014-09-10 10:06:11 -0700932 }
933
934 mPlayer->pause();
Lajos Molnar18def1b2014-08-01 13:39:30 -0700935 mState = STATE_PAUSED;
Lajos Molnara2e14302014-07-31 12:07:58 -0700936 }
937 // fall through
Marco Nelissenc6993232014-07-02 15:01:57 -0700938 }
Lajos Molnara2e14302014-07-31 12:07:58 -0700939
940 case MEDIA_ERROR:
941 {
Ray Essickafb43f72017-03-09 10:23:55 -0800942 // when we have an error, add it to the analytics for this playback.
943 // ext1 is our primary 'error type' value. Only add ext2 when non-zero.
944 // [test against msg is due to fall through from previous switch value]
945 if (msg == MEDIA_ERROR) {
946 mAnalyticsItem->setInt32(kPlayerError, ext1);
947 if (ext2 != 0) {
948 mAnalyticsItem->setInt32(kPlayerErrorCode, ext2);
949 }
950 }
Lajos Molnara2e14302014-07-31 12:07:58 -0700951 mAtEOS = true;
952 break;
953 }
954
955 default:
956 break;
Andreas Hubera4af2142011-10-26 15:23:31 -0700957 }
958
Wei Jia05601952014-08-20 18:21:11 -0700959 mLock.unlock();
Chong Zhangdcb89b32013-08-06 09:44:47 -0700960 sendEvent(msg, ext1, ext2, in);
Wei Jia05601952014-08-20 18:21:11 -0700961 mLock.lock();
Andreas Hubera4af2142011-10-26 15:23:31 -0700962}
963
Andreas Huber9575c962013-02-05 13:59:56 -0800964void NuPlayerDriver::notifySetDataSourceCompleted(status_t err) {
965 Mutex::Autolock autoLock(mLock);
966
967 CHECK_EQ(mState, STATE_SET_DATASOURCE_PENDING);
968
969 mAsyncResult = err;
970 mState = (err == OK) ? STATE_UNPREPARED : STATE_IDLE;
971 mCondition.broadcast();
972}
973
974void NuPlayerDriver::notifyPrepareCompleted(status_t err) {
Hassan Shojaniacefac142017-02-06 21:02:02 -0800975 ALOGV("notifyPrepareCompleted %d", err);
976
Andreas Huber9575c962013-02-05 13:59:56 -0800977 Mutex::Autolock autoLock(mLock);
978
Andreas Huberb5f28d42013-04-25 15:11:19 -0700979 if (mState != STATE_PREPARING) {
980 // We were preparing asynchronously when the client called
981 // reset(), we sent a premature "prepared" notification and
982 // then initiated the reset. This notification is stale.
983 CHECK(mState == STATE_RESET_IN_PROGRESS || mState == STATE_IDLE);
984 return;
985 }
986
Andreas Huber9575c962013-02-05 13:59:56 -0800987 CHECK_EQ(mState, STATE_PREPARING);
988
989 mAsyncResult = err;
990
991 if (err == OK) {
Marco Nelissen2a79c322014-08-26 13:57:32 -0700992 // update state before notifying client, so that if client calls back into NuPlayerDriver
993 // in response, NuPlayerDriver has the right state
994 mState = STATE_PREPARED;
Andreas Huberec0c5972013-02-05 14:47:13 -0800995 if (mIsAsyncPrepare) {
Wei Jia05601952014-08-20 18:21:11 -0700996 notifyListener_l(MEDIA_PREPARED);
Andreas Huberec0c5972013-02-05 14:47:13 -0800997 }
Andreas Huber9575c962013-02-05 13:59:56 -0800998 } else {
Marco Nelissen2a79c322014-08-26 13:57:32 -0700999 mState = STATE_UNPREPARED;
Andreas Huberec0c5972013-02-05 14:47:13 -08001000 if (mIsAsyncPrepare) {
Wei Jia05601952014-08-20 18:21:11 -07001001 notifyListener_l(MEDIA_ERROR, MEDIA_ERROR_UNKNOWN, err);
Andreas Huberec0c5972013-02-05 14:47:13 -08001002 }
Andreas Huber9575c962013-02-05 13:59:56 -08001003 }
1004
Marco Nelissenf0b72b52014-09-16 15:43:44 -07001005 sp<MetaData> meta = mPlayer->getFileMeta();
1006 int32_t loop;
1007 if (meta != NULL
1008 && meta->findInt32(kKeyAutoLoop, &loop) && loop != 0) {
1009 mAutoLoop = true;
1010 }
1011
Andreas Huber9575c962013-02-05 13:59:56 -08001012 mCondition.broadcast();
1013}
1014
1015void NuPlayerDriver::notifyFlagsChanged(uint32_t flags) {
1016 Mutex::Autolock autoLock(mLock);
1017
1018 mPlayerFlags = flags;
1019}
1020
Hassan Shojaniacefac142017-02-06 21:02:02 -08001021// Modular DRM
1022status_t NuPlayerDriver::prepareDrm(const uint8_t uuid[16], const Vector<uint8_t> &drmSessionId)
1023{
1024 ALOGV("prepareDrm(%p) state: %d", this, mState);
1025
Hassan Shojaniacefac142017-02-06 21:02:02 -08001026 // leaving the state verification for mediaplayer.cpp
1027 status_t ret = mPlayer->prepareDrm(uuid, drmSessionId);
1028
1029 ALOGV("prepareDrm ret: %d", ret);
1030
1031 return ret;
1032}
1033
1034status_t NuPlayerDriver::releaseDrm()
1035{
1036 ALOGV("releaseDrm(%p) state: %d", this, mState);
1037
Hassan Shojaniacefac142017-02-06 21:02:02 -08001038 // leaving the state verification for mediaplayer.cpp
1039 status_t ret = mPlayer->releaseDrm();
1040
1041 ALOGV("releaseDrm ret: %d", ret);
1042
1043 return ret;
1044}
1045
Andreas Huberf9334412010-12-15 15:17:42 -08001046} // namespace android