Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2010 The Android Open Source Project |
| 3 | * |
| 4 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | * you may not use this file except in compliance with the License. |
| 6 | * You may obtain a copy of the License at |
| 7 | * |
| 8 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | * |
| 10 | * Unless required by applicable law or agreed to in writing, software |
| 11 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | * See the License for the specific language governing permissions and |
| 14 | * limitations under the License. |
| 15 | */ |
| 16 | |
| 17 | //#define LOG_NDEBUG 0 |
| 18 | #define LOG_TAG "NuPlayerDriver" |
Kévin PETIT | 377b2ec | 2014-02-03 12:35:36 +0000 | [diff] [blame] | 19 | #include <inttypes.h> |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 20 | #include <utils/Log.h> |
| 21 | |
| 22 | #include "NuPlayerDriver.h" |
| 23 | |
| 24 | #include "NuPlayer.h" |
Andreas Huber | 9575c96 | 2013-02-05 13:59:56 -0800 | [diff] [blame] | 25 | #include "NuPlayerSource.h" |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 26 | |
Andreas Huber | 1aef211 | 2011-01-04 14:01:29 -0800 | [diff] [blame] | 27 | #include <media/stagefright/foundation/ADebug.h> |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 28 | #include <media/stagefright/foundation/ALooper.h> |
Ronghua Wu | a73d9e0 | 2014-10-08 15:13:29 -0700 | [diff] [blame^] | 29 | #include <media/stagefright/foundation/AUtils.h> |
Andreas Huber | 9575c96 | 2013-02-05 13:59:56 -0800 | [diff] [blame] | 30 | #include <media/stagefright/MetaData.h> |
Andy Hung | 2abde2c | 2014-09-30 14:40:32 -0700 | [diff] [blame] | 31 | #include <media/stagefright/Utils.h> |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 32 | |
| 33 | namespace android { |
| 34 | |
| 35 | NuPlayerDriver::NuPlayerDriver() |
Andreas Huber | 9575c96 | 2013-02-05 13:59:56 -0800 | [diff] [blame] | 36 | : mState(STATE_IDLE), |
Andreas Huber | ec0c597 | 2013-02-05 14:47:13 -0800 | [diff] [blame] | 37 | mIsAsyncPrepare(false), |
Andreas Huber | 9575c96 | 2013-02-05 13:59:56 -0800 | [diff] [blame] | 38 | mAsyncResult(UNKNOWN_ERROR), |
Chong Zhang | 13d6faa | 2014-08-22 15:35:28 -0700 | [diff] [blame] | 39 | mSetSurfaceInProgress(false), |
Andreas Huber | 43c3e6c | 2011-01-05 12:17:08 -0800 | [diff] [blame] | 40 | mDurationUs(-1), |
| 41 | mPositionUs(-1), |
Ronghua Wu | a73d9e0 | 2014-10-08 15:13:29 -0700 | [diff] [blame^] | 42 | mSeekInProgress(false), |
Andreas Huber | 1aef211 | 2011-01-04 14:01:29 -0800 | [diff] [blame] | 43 | mLooper(new ALooper), |
Andreas Huber | 9575c96 | 2013-02-05 13:59:56 -0800 | [diff] [blame] | 44 | mPlayerFlags(0), |
Andreas Huber | a4af214 | 2011-10-26 15:23:31 -0700 | [diff] [blame] | 45 | mAtEOS(false), |
Lajos Molnar | a2e1430 | 2014-07-31 12:07:58 -0700 | [diff] [blame] | 46 | mLooping(false), |
Marco Nelissen | f0b72b5 | 2014-09-16 15:43:44 -0700 | [diff] [blame] | 47 | mAutoLoop(false), |
Andreas Huber | 43c3e6c | 2011-01-05 12:17:08 -0800 | [diff] [blame] | 48 | mStartupSeekTimeUs(-1) { |
Andy Hung | 2abde2c | 2014-09-30 14:40:32 -0700 | [diff] [blame] | 49 | ALOGV("NuPlayerDriver(%p)", this); |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 50 | 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 Huber | 43c3e6c | 2011-01-05 12:17:08 -0800 | [diff] [blame] | 60 | mPlayer->setDriver(this); |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 61 | } |
| 62 | |
| 63 | NuPlayerDriver::~NuPlayerDriver() { |
Andy Hung | 2abde2c | 2014-09-30 14:40:32 -0700 | [diff] [blame] | 64 | ALOGV("~NuPlayerDriver(%p)", this); |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 65 | mLooper->stop(); |
| 66 | } |
| 67 | |
| 68 | status_t NuPlayerDriver::initCheck() { |
| 69 | return OK; |
| 70 | } |
| 71 | |
Andreas Huber | 9b80c2b | 2011-06-30 15:47:02 -0700 | [diff] [blame] | 72 | status_t NuPlayerDriver::setUID(uid_t uid) { |
| 73 | mPlayer->setUID(uid); |
| 74 | |
| 75 | return OK; |
| 76 | } |
| 77 | |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 78 | status_t NuPlayerDriver::setDataSource( |
Andreas Huber | 1b86fe0 | 2014-01-29 11:13:26 -0800 | [diff] [blame] | 79 | const sp<IMediaHTTPService> &httpService, |
| 80 | const char *url, |
| 81 | const KeyedVector<String8, String8> *headers) { |
Andy Hung | 2abde2c | 2014-09-30 14:40:32 -0700 | [diff] [blame] | 82 | ALOGV("setDataSource(%p) url(%s)", this, uriDebugString(url, false).c_str()); |
Andreas Huber | 9575c96 | 2013-02-05 13:59:56 -0800 | [diff] [blame] | 83 | Mutex::Autolock autoLock(mLock); |
Andreas Huber | 43c3e6c | 2011-01-05 12:17:08 -0800 | [diff] [blame] | 84 | |
Andreas Huber | 9575c96 | 2013-02-05 13:59:56 -0800 | [diff] [blame] | 85 | if (mState != STATE_IDLE) { |
| 86 | return INVALID_OPERATION; |
| 87 | } |
Andreas Huber | 5bc087c | 2010-12-23 10:27:40 -0800 | [diff] [blame] | 88 | |
Andreas Huber | 9575c96 | 2013-02-05 13:59:56 -0800 | [diff] [blame] | 89 | mState = STATE_SET_DATASOURCE_PENDING; |
Andreas Huber | 43c3e6c | 2011-01-05 12:17:08 -0800 | [diff] [blame] | 90 | |
Andreas Huber | 1b86fe0 | 2014-01-29 11:13:26 -0800 | [diff] [blame] | 91 | mPlayer->setDataSourceAsync(httpService, url, headers); |
Andreas Huber | 9575c96 | 2013-02-05 13:59:56 -0800 | [diff] [blame] | 92 | |
| 93 | while (mState == STATE_SET_DATASOURCE_PENDING) { |
| 94 | mCondition.wait(mLock); |
| 95 | } |
| 96 | |
| 97 | return mAsyncResult; |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 98 | } |
| 99 | |
| 100 | status_t NuPlayerDriver::setDataSource(int fd, int64_t offset, int64_t length) { |
Andy Hung | 2abde2c | 2014-09-30 14:40:32 -0700 | [diff] [blame] | 101 | ALOGV("setDataSource(%p) file(%d)", this, fd); |
Andreas Huber | 9575c96 | 2013-02-05 13:59:56 -0800 | [diff] [blame] | 102 | Mutex::Autolock autoLock(mLock); |
Andreas Huber | afed0e1 | 2011-09-20 15:39:58 -0700 | [diff] [blame] | 103 | |
Andreas Huber | 9575c96 | 2013-02-05 13:59:56 -0800 | [diff] [blame] | 104 | if (mState != STATE_IDLE) { |
| 105 | return INVALID_OPERATION; |
| 106 | } |
Andreas Huber | afed0e1 | 2011-09-20 15:39:58 -0700 | [diff] [blame] | 107 | |
Andreas Huber | 9575c96 | 2013-02-05 13:59:56 -0800 | [diff] [blame] | 108 | mState = STATE_SET_DATASOURCE_PENDING; |
Andreas Huber | afed0e1 | 2011-09-20 15:39:58 -0700 | [diff] [blame] | 109 | |
Andreas Huber | 9575c96 | 2013-02-05 13:59:56 -0800 | [diff] [blame] | 110 | mPlayer->setDataSourceAsync(fd, offset, length); |
| 111 | |
| 112 | while (mState == STATE_SET_DATASOURCE_PENDING) { |
| 113 | mCondition.wait(mLock); |
| 114 | } |
| 115 | |
| 116 | return mAsyncResult; |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 117 | } |
| 118 | |
| 119 | status_t NuPlayerDriver::setDataSource(const sp<IStreamSource> &source) { |
Andy Hung | 2abde2c | 2014-09-30 14:40:32 -0700 | [diff] [blame] | 120 | ALOGV("setDataSource(%p) stream source", this); |
Andreas Huber | 9575c96 | 2013-02-05 13:59:56 -0800 | [diff] [blame] | 121 | Mutex::Autolock autoLock(mLock); |
Andreas Huber | 43c3e6c | 2011-01-05 12:17:08 -0800 | [diff] [blame] | 122 | |
Andreas Huber | 9575c96 | 2013-02-05 13:59:56 -0800 | [diff] [blame] | 123 | if (mState != STATE_IDLE) { |
| 124 | return INVALID_OPERATION; |
| 125 | } |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 126 | |
Andreas Huber | 9575c96 | 2013-02-05 13:59:56 -0800 | [diff] [blame] | 127 | mState = STATE_SET_DATASOURCE_PENDING; |
Andreas Huber | 43c3e6c | 2011-01-05 12:17:08 -0800 | [diff] [blame] | 128 | |
Andreas Huber | 9575c96 | 2013-02-05 13:59:56 -0800 | [diff] [blame] | 129 | mPlayer->setDataSourceAsync(source); |
| 130 | |
| 131 | while (mState == STATE_SET_DATASOURCE_PENDING) { |
| 132 | mCondition.wait(mLock); |
| 133 | } |
| 134 | |
| 135 | return mAsyncResult; |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 136 | } |
| 137 | |
Glenn Kasten | 1173118 | 2011-02-08 17:26:17 -0800 | [diff] [blame] | 138 | status_t NuPlayerDriver::setVideoSurfaceTexture( |
Andy McFadden | 8ba0102 | 2012-12-18 09:46:54 -0800 | [diff] [blame] | 139 | const sp<IGraphicBufferProducer> &bufferProducer) { |
Andy Hung | 2abde2c | 2014-09-30 14:40:32 -0700 | [diff] [blame] | 140 | ALOGV("setVideoSurfaceTexture(%p)", this); |
Andreas Huber | 57a339c | 2012-12-03 11:18:00 -0800 | [diff] [blame] | 141 | Mutex::Autolock autoLock(mLock); |
| 142 | |
Chong Zhang | 13d6faa | 2014-08-22 15:35:28 -0700 | [diff] [blame] | 143 | if (mSetSurfaceInProgress) { |
| 144 | return INVALID_OPERATION; |
| 145 | } |
| 146 | |
Andreas Huber | 9575c96 | 2013-02-05 13:59:56 -0800 | [diff] [blame] | 147 | 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 Zhang | 13d6faa | 2014-08-22 15:35:28 -0700 | [diff] [blame] | 156 | mSetSurfaceInProgress = true; |
| 157 | |
Andy McFadden | 8ba0102 | 2012-12-18 09:46:54 -0800 | [diff] [blame] | 158 | mPlayer->setVideoSurfaceTextureAsync(bufferProducer); |
Andreas Huber | 57a339c | 2012-12-03 11:18:00 -0800 | [diff] [blame] | 159 | |
Chong Zhang | 13d6faa | 2014-08-22 15:35:28 -0700 | [diff] [blame] | 160 | while (mSetSurfaceInProgress) { |
| 161 | mCondition.wait(mLock); |
| 162 | } |
| 163 | |
Glenn Kasten | 1173118 | 2011-02-08 17:26:17 -0800 | [diff] [blame] | 164 | return OK; |
| 165 | } |
| 166 | |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 167 | status_t NuPlayerDriver::prepare() { |
Andy Hung | 2abde2c | 2014-09-30 14:40:32 -0700 | [diff] [blame] | 168 | ALOGV("prepare(%p)", this); |
Andreas Huber | 9575c96 | 2013-02-05 13:59:56 -0800 | [diff] [blame] | 169 | Mutex::Autolock autoLock(mLock); |
| 170 | return prepare_l(); |
| 171 | } |
| 172 | |
| 173 | status_t NuPlayerDriver::prepare_l() { |
| 174 | switch (mState) { |
| 175 | case STATE_UNPREPARED: |
| 176 | mState = STATE_PREPARING; |
Andreas Huber | ec0c597 | 2013-02-05 14:47:13 -0800 | [diff] [blame] | 177 | |
| 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 Huber | 9575c96 | 2013-02-05 13:59:56 -0800 | [diff] [blame] | 182 | mPlayer->prepareAsync(); |
| 183 | while (mState == STATE_PREPARING) { |
| 184 | mCondition.wait(mLock); |
| 185 | } |
| 186 | return (mState == STATE_PREPARED) ? OK : UNKNOWN_ERROR; |
Lajos Molnar | 4b75b86 | 2013-08-15 15:59:19 -0700 | [diff] [blame] | 187 | 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 Huber | 9575c96 | 2013-02-05 13:59:56 -0800 | [diff] [blame] | 197 | default: |
| 198 | return INVALID_OPERATION; |
| 199 | }; |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 200 | } |
| 201 | |
| 202 | status_t NuPlayerDriver::prepareAsync() { |
Andy Hung | 2abde2c | 2014-09-30 14:40:32 -0700 | [diff] [blame] | 203 | ALOGV("prepareAsync(%p)", this); |
Andreas Huber | 9575c96 | 2013-02-05 13:59:56 -0800 | [diff] [blame] | 204 | Mutex::Autolock autoLock(mLock); |
Andreas Huber | afed0e1 | 2011-09-20 15:39:58 -0700 | [diff] [blame] | 205 | |
Andreas Huber | 9575c96 | 2013-02-05 13:59:56 -0800 | [diff] [blame] | 206 | switch (mState) { |
| 207 | case STATE_UNPREPARED: |
| 208 | mState = STATE_PREPARING; |
Andreas Huber | ec0c597 | 2013-02-05 14:47:13 -0800 | [diff] [blame] | 209 | mIsAsyncPrepare = true; |
Andreas Huber | 9575c96 | 2013-02-05 13:59:56 -0800 | [diff] [blame] | 210 | mPlayer->prepareAsync(); |
| 211 | return OK; |
Lajos Molnar | 4b75b86 | 2013-08-15 15:59:19 -0700 | [diff] [blame] | 212 | 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 Huber | 9575c96 | 2013-02-05 13:59:56 -0800 | [diff] [blame] | 219 | default: |
| 220 | return INVALID_OPERATION; |
| 221 | }; |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 222 | } |
| 223 | |
| 224 | status_t NuPlayerDriver::start() { |
Andy Hung | 2abde2c | 2014-09-30 14:40:32 -0700 | [diff] [blame] | 225 | ALOGD("start(%p)", this); |
Andreas Huber | 9575c96 | 2013-02-05 13:59:56 -0800 | [diff] [blame] | 226 | Mutex::Autolock autoLock(mLock); |
| 227 | |
Andreas Huber | 43c3e6c | 2011-01-05 12:17:08 -0800 | [diff] [blame] | 228 | switch (mState) { |
Andreas Huber | 9575c96 | 2013-02-05 13:59:56 -0800 | [diff] [blame] | 229 | 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 Huber | 43c3e6c | 2011-01-05 12:17:08 -0800 | [diff] [blame] | 243 | { |
Andreas Huber | a4af214 | 2011-10-26 15:23:31 -0700 | [diff] [blame] | 244 | mAtEOS = false; |
Andreas Huber | 43c3e6c | 2011-01-05 12:17:08 -0800 | [diff] [blame] | 245 | mPlayer->start(); |
| 246 | |
| 247 | if (mStartupSeekTimeUs >= 0) { |
Wei Jia | e427abf | 2014-09-22 15:21:11 -0700 | [diff] [blame] | 248 | if (mStartupSeekTimeUs > 0) { |
Andreas Huber | 2048d0c | 2011-07-15 16:25:41 -0700 | [diff] [blame] | 249 | mPlayer->seekToAsync(mStartupSeekTimeUs); |
| 250 | } |
| 251 | |
Andreas Huber | 43c3e6c | 2011-01-05 12:17:08 -0800 | [diff] [blame] | 252 | mStartupSeekTimeUs = -1; |
| 253 | } |
| 254 | break; |
| 255 | } |
Andreas Huber | 43c3e6c | 2011-01-05 12:17:08 -0800 | [diff] [blame] | 256 | |
Andreas Huber | 9575c96 | 2013-02-05 13:59:56 -0800 | [diff] [blame] | 257 | case STATE_RUNNING: |
Wei Jia | 0560195 | 2014-08-20 18:21:11 -0700 | [diff] [blame] | 258 | { |
| 259 | if (mAtEOS) { |
| 260 | mPlayer->seekToAsync(0); |
| 261 | mAtEOS = false; |
| 262 | mPositionUs = -1; |
| 263 | } |
Andreas Huber | 9575c96 | 2013-02-05 13:59:56 -0800 | [diff] [blame] | 264 | break; |
Wei Jia | 0560195 | 2014-08-20 18:21:11 -0700 | [diff] [blame] | 265 | } |
Andreas Huber | 9575c96 | 2013-02-05 13:59:56 -0800 | [diff] [blame] | 266 | |
| 267 | case STATE_PAUSED: |
Lajos Molnar | 4b75b86 | 2013-08-15 15:59:19 -0700 | [diff] [blame] | 268 | case STATE_STOPPED_AND_PREPARED: |
Andreas Huber | 9575c96 | 2013-02-05 13:59:56 -0800 | [diff] [blame] | 269 | { |
Robert Shih | 6e9f6b4 | 2014-09-16 17:07:22 -0700 | [diff] [blame] | 270 | if (mAtEOS) { |
| 271 | mPlayer->seekToAsync(0); |
| 272 | mAtEOS = false; |
| 273 | mPlayer->resume(); |
| 274 | mPositionUs = -1; |
| 275 | } else { |
| 276 | mPlayer->resume(); |
Robert Shih | 6e9f6b4 | 2014-09-16 17:07:22 -0700 | [diff] [blame] | 277 | } |
Andreas Huber | 43c3e6c | 2011-01-05 12:17:08 -0800 | [diff] [blame] | 278 | break; |
| 279 | } |
Andreas Huber | 9575c96 | 2013-02-05 13:59:56 -0800 | [diff] [blame] | 280 | |
| 281 | default: |
| 282 | return INVALID_OPERATION; |
Andreas Huber | 43c3e6c | 2011-01-05 12:17:08 -0800 | [diff] [blame] | 283 | } |
| 284 | |
Andreas Huber | 9575c96 | 2013-02-05 13:59:56 -0800 | [diff] [blame] | 285 | mState = STATE_RUNNING; |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 286 | |
| 287 | return OK; |
| 288 | } |
| 289 | |
| 290 | status_t NuPlayerDriver::stop() { |
Andy Hung | 2abde2c | 2014-09-30 14:40:32 -0700 | [diff] [blame] | 291 | ALOGD("stop(%p)", this); |
Lajos Molnar | 4b75b86 | 2013-08-15 15:59:19 -0700 | [diff] [blame] | 292 | Mutex::Autolock autoLock(mLock); |
| 293 | |
| 294 | switch (mState) { |
| 295 | case STATE_RUNNING: |
| 296 | mPlayer->pause(); |
| 297 | // fall through |
| 298 | |
| 299 | case STATE_PAUSED: |
Marco Nelissen | 2a79c32 | 2014-08-26 13:57:32 -0700 | [diff] [blame] | 300 | mState = STATE_STOPPED; |
Wei Jia | 0560195 | 2014-08-20 18:21:11 -0700 | [diff] [blame] | 301 | notifyListener_l(MEDIA_STOPPED); |
Marco Nelissen | 2a79c32 | 2014-08-26 13:57:32 -0700 | [diff] [blame] | 302 | break; |
Lajos Molnar | 4b75b86 | 2013-08-15 15:59:19 -0700 | [diff] [blame] | 303 | |
| 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 Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 316 | } |
| 317 | |
| 318 | status_t NuPlayerDriver::pause() { |
Andreas Huber | 9575c96 | 2013-02-05 13:59:56 -0800 | [diff] [blame] | 319 | Mutex::Autolock autoLock(mLock); |
| 320 | |
Andreas Huber | 43c3e6c | 2011-01-05 12:17:08 -0800 | [diff] [blame] | 321 | switch (mState) { |
Andreas Huber | 9575c96 | 2013-02-05 13:59:56 -0800 | [diff] [blame] | 322 | case STATE_PAUSED: |
| 323 | case STATE_PREPARED: |
Andreas Huber | 43c3e6c | 2011-01-05 12:17:08 -0800 | [diff] [blame] | 324 | return OK; |
Andreas Huber | 9575c96 | 2013-02-05 13:59:56 -0800 | [diff] [blame] | 325 | |
| 326 | case STATE_RUNNING: |
Marco Nelissen | 2a79c32 | 2014-08-26 13:57:32 -0700 | [diff] [blame] | 327 | mState = STATE_PAUSED; |
Wei Jia | 0560195 | 2014-08-20 18:21:11 -0700 | [diff] [blame] | 328 | notifyListener_l(MEDIA_PAUSED); |
Andreas Huber | 43c3e6c | 2011-01-05 12:17:08 -0800 | [diff] [blame] | 329 | mPlayer->pause(); |
| 330 | break; |
Andreas Huber | 9575c96 | 2013-02-05 13:59:56 -0800 | [diff] [blame] | 331 | |
Andreas Huber | 43c3e6c | 2011-01-05 12:17:08 -0800 | [diff] [blame] | 332 | default: |
Andreas Huber | 9575c96 | 2013-02-05 13:59:56 -0800 | [diff] [blame] | 333 | return INVALID_OPERATION; |
Andreas Huber | 43c3e6c | 2011-01-05 12:17:08 -0800 | [diff] [blame] | 334 | } |
| 335 | |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 336 | return OK; |
| 337 | } |
| 338 | |
| 339 | bool NuPlayerDriver::isPlaying() { |
Andreas Huber | 9575c96 | 2013-02-05 13:59:56 -0800 | [diff] [blame] | 340 | return mState == STATE_RUNNING && !mAtEOS; |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 341 | } |
| 342 | |
| 343 | status_t NuPlayerDriver::seekTo(int msec) { |
Andy Hung | 2abde2c | 2014-09-30 14:40:32 -0700 | [diff] [blame] | 344 | ALOGD("seekTo(%p) %d ms", this, msec); |
Andreas Huber | 9575c96 | 2013-02-05 13:59:56 -0800 | [diff] [blame] | 345 | Mutex::Autolock autoLock(mLock); |
| 346 | |
Andreas Huber | 43c3e6c | 2011-01-05 12:17:08 -0800 | [diff] [blame] | 347 | int64_t seekTimeUs = msec * 1000ll; |
| 348 | |
| 349 | switch (mState) { |
Andreas Huber | 9575c96 | 2013-02-05 13:59:56 -0800 | [diff] [blame] | 350 | case STATE_PREPARED: |
Andreas Huber | 43c3e6c | 2011-01-05 12:17:08 -0800 | [diff] [blame] | 351 | { |
| 352 | mStartupSeekTimeUs = seekTimeUs; |
Marco Nelissen | dd114d1 | 2014-05-28 15:23:14 -0700 | [diff] [blame] | 353 | // 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 Nelissen | eb645a0 | 2014-08-20 09:44:44 -0700 | [diff] [blame] | 356 | notifySeekComplete_l(); |
Andreas Huber | 43c3e6c | 2011-01-05 12:17:08 -0800 | [diff] [blame] | 357 | break; |
| 358 | } |
Andreas Huber | 9575c96 | 2013-02-05 13:59:56 -0800 | [diff] [blame] | 359 | |
| 360 | case STATE_RUNNING: |
| 361 | case STATE_PAUSED: |
Andreas Huber | 43c3e6c | 2011-01-05 12:17:08 -0800 | [diff] [blame] | 362 | { |
Andreas Huber | a4af214 | 2011-10-26 15:23:31 -0700 | [diff] [blame] | 363 | mAtEOS = false; |
Ronghua Wu | a73d9e0 | 2014-10-08 15:13:29 -0700 | [diff] [blame^] | 364 | mSeekInProgress = true; |
Lajos Molnar | cbaffcf | 2013-08-14 18:30:38 -0700 | [diff] [blame] | 365 | // seeks can take a while, so we essentially paused |
Wei Jia | 0560195 | 2014-08-20 18:21:11 -0700 | [diff] [blame] | 366 | notifyListener_l(MEDIA_PAUSED); |
Wei Jia | e427abf | 2014-09-22 15:21:11 -0700 | [diff] [blame] | 367 | mPlayer->seekToAsync(seekTimeUs, true /* needNotify */); |
Andreas Huber | 43c3e6c | 2011-01-05 12:17:08 -0800 | [diff] [blame] | 368 | break; |
| 369 | } |
| 370 | |
| 371 | default: |
Andreas Huber | 9575c96 | 2013-02-05 13:59:56 -0800 | [diff] [blame] | 372 | return INVALID_OPERATION; |
Andreas Huber | 43c3e6c | 2011-01-05 12:17:08 -0800 | [diff] [blame] | 373 | } |
| 374 | |
Wei Jia | 0560195 | 2014-08-20 18:21:11 -0700 | [diff] [blame] | 375 | mPositionUs = seekTimeUs; |
Andreas Huber | 43c3e6c | 2011-01-05 12:17:08 -0800 | [diff] [blame] | 376 | return OK; |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 377 | } |
| 378 | |
| 379 | status_t NuPlayerDriver::getCurrentPosition(int *msec) { |
Ronghua Wu | a73d9e0 | 2014-10-08 15:13:29 -0700 | [diff] [blame^] | 380 | int64_t tempUs = 0; |
| 381 | status_t ret = mPlayer->getCurrentPosition(&tempUs); |
| 382 | |
Andreas Huber | 43c3e6c | 2011-01-05 12:17:08 -0800 | [diff] [blame] | 383 | Mutex::Autolock autoLock(mLock); |
Ronghua Wu | a73d9e0 | 2014-10-08 15:13:29 -0700 | [diff] [blame^] | 384 | // 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 Huber | 43c3e6c | 2011-01-05 12:17:08 -0800 | [diff] [blame] | 389 | } else { |
Ronghua Wu | a73d9e0 | 2014-10-08 15:13:29 -0700 | [diff] [blame^] | 390 | mPositionUs = tempUs; |
Andreas Huber | 43c3e6c | 2011-01-05 12:17:08 -0800 | [diff] [blame] | 391 | } |
Ronghua Wu | a73d9e0 | 2014-10-08 15:13:29 -0700 | [diff] [blame^] | 392 | *msec = (int)divRound(tempUs, (int64_t)(1000)); |
Andreas Huber | 5bc087c | 2010-12-23 10:27:40 -0800 | [diff] [blame] | 393 | return OK; |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 394 | } |
| 395 | |
| 396 | status_t NuPlayerDriver::getDuration(int *msec) { |
Andreas Huber | 43c3e6c | 2011-01-05 12:17:08 -0800 | [diff] [blame] | 397 | Mutex::Autolock autoLock(mLock); |
| 398 | |
| 399 | if (mDurationUs < 0) { |
Andreas Huber | d85929f | 2013-04-11 11:07:55 -0700 | [diff] [blame] | 400 | return UNKNOWN_ERROR; |
Andreas Huber | 43c3e6c | 2011-01-05 12:17:08 -0800 | [diff] [blame] | 401 | } |
Andreas Huber | 5bc087c | 2010-12-23 10:27:40 -0800 | [diff] [blame] | 402 | |
Andreas Huber | d85929f | 2013-04-11 11:07:55 -0700 | [diff] [blame] | 403 | *msec = (mDurationUs + 500ll) / 1000; |
| 404 | |
Andreas Huber | 5bc087c | 2010-12-23 10:27:40 -0800 | [diff] [blame] | 405 | return OK; |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 406 | } |
| 407 | |
| 408 | status_t NuPlayerDriver::reset() { |
Andy Hung | 2abde2c | 2014-09-30 14:40:32 -0700 | [diff] [blame] | 409 | ALOGD("reset(%p)", this); |
Andreas Huber | 1aef211 | 2011-01-04 14:01:29 -0800 | [diff] [blame] | 410 | Mutex::Autolock autoLock(mLock); |
Andreas Huber | 1aef211 | 2011-01-04 14:01:29 -0800 | [diff] [blame] | 411 | |
Andreas Huber | 9575c96 | 2013-02-05 13:59:56 -0800 | [diff] [blame] | 412 | 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 Huber | b5f28d4 | 2013-04-25 15:11:19 -0700 | [diff] [blame] | 420 | case STATE_PREPARING: |
| 421 | { |
| 422 | CHECK(mIsAsyncPrepare); |
| 423 | |
Wei Jia | 0560195 | 2014-08-20 18:21:11 -0700 | [diff] [blame] | 424 | notifyListener_l(MEDIA_PREPARED); |
Andreas Huber | b5f28d4 | 2013-04-25 15:11:19 -0700 | [diff] [blame] | 425 | break; |
| 426 | } |
| 427 | |
Andreas Huber | 9575c96 | 2013-02-05 13:59:56 -0800 | [diff] [blame] | 428 | default: |
| 429 | break; |
| 430 | } |
| 431 | |
Lajos Molnar | 4b75b86 | 2013-08-15 15:59:19 -0700 | [diff] [blame] | 432 | if (mState != STATE_STOPPED) { |
Wei Jia | 0560195 | 2014-08-20 18:21:11 -0700 | [diff] [blame] | 433 | notifyListener_l(MEDIA_STOPPED); |
Lajos Molnar | 4b75b86 | 2013-08-15 15:59:19 -0700 | [diff] [blame] | 434 | } |
Lajos Molnar | cbaffcf | 2013-08-14 18:30:38 -0700 | [diff] [blame] | 435 | |
Andreas Huber | 9575c96 | 2013-02-05 13:59:56 -0800 | [diff] [blame] | 436 | mState = STATE_RESET_IN_PROGRESS; |
Andreas Huber | 1aef211 | 2011-01-04 14:01:29 -0800 | [diff] [blame] | 437 | mPlayer->resetAsync(); |
| 438 | |
Andreas Huber | 9575c96 | 2013-02-05 13:59:56 -0800 | [diff] [blame] | 439 | while (mState == STATE_RESET_IN_PROGRESS) { |
Andreas Huber | 1aef211 | 2011-01-04 14:01:29 -0800 | [diff] [blame] | 440 | mCondition.wait(mLock); |
| 441 | } |
| 442 | |
Andreas Huber | 43c3e6c | 2011-01-05 12:17:08 -0800 | [diff] [blame] | 443 | mDurationUs = -1; |
| 444 | mPositionUs = -1; |
Andreas Huber | 43c3e6c | 2011-01-05 12:17:08 -0800 | [diff] [blame] | 445 | mStartupSeekTimeUs = -1; |
Lajos Molnar | a2e1430 | 2014-07-31 12:07:58 -0700 | [diff] [blame] | 446 | mLooping = false; |
Andreas Huber | 43c3e6c | 2011-01-05 12:17:08 -0800 | [diff] [blame] | 447 | |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 448 | return OK; |
| 449 | } |
| 450 | |
Lajos Molnar | a2e1430 | 2014-07-31 12:07:58 -0700 | [diff] [blame] | 451 | status_t NuPlayerDriver::setLooping(int loop) { |
| 452 | mLooping = loop != 0; |
| 453 | return OK; |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 454 | } |
| 455 | |
| 456 | player_type NuPlayerDriver::playerType() { |
| 457 | return NU_PLAYER; |
| 458 | } |
| 459 | |
| 460 | status_t NuPlayerDriver::invoke(const Parcel &request, Parcel *reply) { |
James Dong | 0d268a3 | 2012-08-31 12:18:27 -0700 | [diff] [blame] | 461 | 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 Huber | d5e5623 | 2013-03-12 11:01:43 -0700 | [diff] [blame] | 479 | |
Chong Zhang | dcb89b3 | 2013-08-06 09:44:47 -0700 | [diff] [blame] | 480 | 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 Shih | 7c4f0d7 | 2014-07-09 18:53:31 -0700 | [diff] [blame] | 497 | case INVOKE_ID_GET_SELECTED_TRACK: |
| 498 | { |
| 499 | int32_t type = request.readInt32(); |
| 500 | return mPlayer->getSelectedTrack(type, reply); |
| 501 | } |
| 502 | |
James Dong | 0d268a3 | 2012-08-31 12:18:27 -0700 | [diff] [blame] | 503 | default: |
| 504 | { |
| 505 | return INVALID_OPERATION; |
| 506 | } |
| 507 | } |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 508 | } |
| 509 | |
| 510 | void NuPlayerDriver::setAudioSink(const sp<AudioSink> &audioSink) { |
| 511 | mPlayer->setAudioSink(audioSink); |
Marco Nelissen | f0b72b5 | 2014-09-16 15:43:44 -0700 | [diff] [blame] | 512 | mAudioSink = audioSink; |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 513 | } |
| 514 | |
Andreas Huber | 84333e0 | 2014-02-07 15:36:10 -0800 | [diff] [blame] | 515 | status_t NuPlayerDriver::setParameter( |
| 516 | int /* key */, const Parcel & /* request */) { |
Gloria Wang | 4f9e47f | 2011-04-25 17:28:22 -0700 | [diff] [blame] | 517 | return INVALID_OPERATION; |
| 518 | } |
| 519 | |
Andreas Huber | 84333e0 | 2014-02-07 15:36:10 -0800 | [diff] [blame] | 520 | status_t NuPlayerDriver::getParameter(int /* key */, Parcel * /* reply */) { |
Gloria Wang | 4f9e47f | 2011-04-25 17:28:22 -0700 | [diff] [blame] | 521 | return INVALID_OPERATION; |
| 522 | } |
| 523 | |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 524 | status_t NuPlayerDriver::getMetadata( |
Andreas Huber | 84333e0 | 2014-02-07 15:36:10 -0800 | [diff] [blame] | 525 | const media::Metadata::Filter& /* ids */, Parcel *records) { |
Andreas Huber | 9575c96 | 2013-02-05 13:59:56 -0800 | [diff] [blame] | 526 | 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 Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 549 | } |
| 550 | |
Andreas Huber | 43c3e6c | 2011-01-05 12:17:08 -0800 | [diff] [blame] | 551 | void NuPlayerDriver::notifyResetComplete() { |
Andy Hung | 8d121d4 | 2014-10-03 09:53:53 -0700 | [diff] [blame] | 552 | ALOGD("notifyResetComplete(%p)", this); |
Andreas Huber | 1aef211 | 2011-01-04 14:01:29 -0800 | [diff] [blame] | 553 | Mutex::Autolock autoLock(mLock); |
Andreas Huber | 9575c96 | 2013-02-05 13:59:56 -0800 | [diff] [blame] | 554 | |
| 555 | CHECK_EQ(mState, STATE_RESET_IN_PROGRESS); |
| 556 | mState = STATE_IDLE; |
Andreas Huber | 1aef211 | 2011-01-04 14:01:29 -0800 | [diff] [blame] | 557 | mCondition.broadcast(); |
| 558 | } |
| 559 | |
Chong Zhang | 13d6faa | 2014-08-22 15:35:28 -0700 | [diff] [blame] | 560 | void NuPlayerDriver::notifySetSurfaceComplete() { |
Andy Hung | 2abde2c | 2014-09-30 14:40:32 -0700 | [diff] [blame] | 561 | ALOGV("notifySetSurfaceComplete(%p)", this); |
Chong Zhang | 13d6faa | 2014-08-22 15:35:28 -0700 | [diff] [blame] | 562 | Mutex::Autolock autoLock(mLock); |
| 563 | |
| 564 | CHECK(mSetSurfaceInProgress); |
| 565 | mSetSurfaceInProgress = false; |
| 566 | |
| 567 | mCondition.broadcast(); |
| 568 | } |
| 569 | |
Andreas Huber | 43c3e6c | 2011-01-05 12:17:08 -0800 | [diff] [blame] | 570 | void NuPlayerDriver::notifyDuration(int64_t durationUs) { |
| 571 | Mutex::Autolock autoLock(mLock); |
| 572 | mDurationUs = durationUs; |
| 573 | } |
| 574 | |
Andreas Huber | 43c3e6c | 2011-01-05 12:17:08 -0800 | [diff] [blame] | 575 | void NuPlayerDriver::notifySeekComplete() { |
Andy Hung | 2abde2c | 2014-09-30 14:40:32 -0700 | [diff] [blame] | 576 | ALOGV("notifySeekComplete(%p)", this); |
Marco Nelissen | eb645a0 | 2014-08-20 09:44:44 -0700 | [diff] [blame] | 577 | Mutex::Autolock autoLock(mLock); |
Ronghua Wu | a73d9e0 | 2014-10-08 15:13:29 -0700 | [diff] [blame^] | 578 | mSeekInProgress = false; |
Marco Nelissen | eb645a0 | 2014-08-20 09:44:44 -0700 | [diff] [blame] | 579 | notifySeekComplete_l(); |
| 580 | } |
| 581 | |
| 582 | void NuPlayerDriver::notifySeekComplete_l() { |
Lajos Molnar | 4b75b86 | 2013-08-15 15:59:19 -0700 | [diff] [blame] | 583 | bool wasSeeking = true; |
Marco Nelissen | eb645a0 | 2014-08-20 09:44:44 -0700 | [diff] [blame] | 584 | 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 Molnar | 4b75b86 | 2013-08-15 15:59:19 -0700 | [diff] [blame] | 590 | return; |
| 591 | } |
Marco Nelissen | eb645a0 | 2014-08-20 09:44:44 -0700 | [diff] [blame] | 592 | } else if (mState == STATE_STOPPED) { |
| 593 | // no need to notify listener |
| 594 | return; |
Lajos Molnar | 4b75b86 | 2013-08-15 15:59:19 -0700 | [diff] [blame] | 595 | } |
Wei Jia | 0560195 | 2014-08-20 18:21:11 -0700 | [diff] [blame] | 596 | notifyListener_l(wasSeeking ? MEDIA_SEEK_COMPLETE : MEDIA_PREPARED); |
Andreas Huber | 43c3e6c | 2011-01-05 12:17:08 -0800 | [diff] [blame] | 597 | } |
| 598 | |
Andreas Huber | 84333e0 | 2014-02-07 15:36:10 -0800 | [diff] [blame] | 599 | status_t NuPlayerDriver::dump( |
| 600 | int fd, const Vector<String16> & /* args */) const { |
Ronghua Wu | a73d9e0 | 2014-10-08 15:13:29 -0700 | [diff] [blame^] | 601 | int64_t numFramesTotal; |
| 602 | int64_t numFramesDropped; |
| 603 | mPlayer->getStats(&numFramesTotal, &numFramesDropped); |
Andreas Huber | 3fe6215 | 2011-09-16 15:09:22 -0700 | [diff] [blame] | 604 | |
| 605 | FILE *out = fdopen(dup(fd), "w"); |
| 606 | |
| 607 | fprintf(out, " NuPlayer\n"); |
Kévin PETIT | 377b2ec | 2014-02-03 12:35:36 +0000 | [diff] [blame] | 608 | fprintf(out, " numFramesTotal(%" PRId64 "), numFramesDropped(%" PRId64 "), " |
Andreas Huber | 3fe6215 | 2011-09-16 15:09:22 -0700 | [diff] [blame] | 609 | "percentageDropped(%.2f)\n", |
Ronghua Wu | a73d9e0 | 2014-10-08 15:13:29 -0700 | [diff] [blame^] | 610 | numFramesTotal, |
| 611 | numFramesDropped, |
| 612 | numFramesTotal == 0 |
| 613 | ? 0.0 : (double)numFramesDropped / numFramesTotal); |
Andreas Huber | 3fe6215 | 2011-09-16 15:09:22 -0700 | [diff] [blame] | 614 | |
| 615 | fclose(out); |
| 616 | out = NULL; |
| 617 | |
| 618 | return OK; |
| 619 | } |
| 620 | |
Chong Zhang | dcb89b3 | 2013-08-06 09:44:47 -0700 | [diff] [blame] | 621 | void NuPlayerDriver::notifyListener( |
| 622 | int msg, int ext1, int ext2, const Parcel *in) { |
Wei Jia | 0560195 | 2014-08-20 18:21:11 -0700 | [diff] [blame] | 623 | Mutex::Autolock autoLock(mLock); |
| 624 | notifyListener_l(msg, ext1, ext2, in); |
| 625 | } |
| 626 | |
| 627 | void NuPlayerDriver::notifyListener_l( |
| 628 | int msg, int ext1, int ext2, const Parcel *in) { |
Lajos Molnar | a2e1430 | 2014-07-31 12:07:58 -0700 | [diff] [blame] | 629 | switch (msg) { |
| 630 | case MEDIA_PLAYBACK_COMPLETE: |
| 631 | { |
Wei Jia | 71079fc | 2014-09-10 10:06:11 -0700 | [diff] [blame] | 632 | if (mState != STATE_RESET_IN_PROGRESS) { |
Marco Nelissen | f0b72b5 | 2014-09-16 15:43:44 -0700 | [diff] [blame] | 633 | if (mLooping || (mAutoLoop |
| 634 | && (mAudioSink == NULL || mAudioSink->realtime()))) { |
Wei Jia | 71079fc | 2014-09-10 10:06:11 -0700 | [diff] [blame] | 635 | mPlayer->seekToAsync(0); |
| 636 | break; |
| 637 | } |
| 638 | |
| 639 | mPlayer->pause(); |
| 640 | mState = STATE_PAUSED; |
Lajos Molnar | a2e1430 | 2014-07-31 12:07:58 -0700 | [diff] [blame] | 641 | } |
| 642 | // fall through |
| 643 | } |
| 644 | |
| 645 | case MEDIA_ERROR: |
| 646 | { |
| 647 | mAtEOS = true; |
| 648 | break; |
| 649 | } |
| 650 | |
| 651 | default: |
| 652 | break; |
Andreas Huber | a4af214 | 2011-10-26 15:23:31 -0700 | [diff] [blame] | 653 | } |
| 654 | |
Wei Jia | 0560195 | 2014-08-20 18:21:11 -0700 | [diff] [blame] | 655 | mLock.unlock(); |
Chong Zhang | dcb89b3 | 2013-08-06 09:44:47 -0700 | [diff] [blame] | 656 | sendEvent(msg, ext1, ext2, in); |
Wei Jia | 0560195 | 2014-08-20 18:21:11 -0700 | [diff] [blame] | 657 | mLock.lock(); |
Andreas Huber | a4af214 | 2011-10-26 15:23:31 -0700 | [diff] [blame] | 658 | } |
| 659 | |
Andreas Huber | 9575c96 | 2013-02-05 13:59:56 -0800 | [diff] [blame] | 660 | void 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 | |
| 670 | void NuPlayerDriver::notifyPrepareCompleted(status_t err) { |
| 671 | Mutex::Autolock autoLock(mLock); |
| 672 | |
Andreas Huber | b5f28d4 | 2013-04-25 15:11:19 -0700 | [diff] [blame] | 673 | 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 Huber | 9575c96 | 2013-02-05 13:59:56 -0800 | [diff] [blame] | 681 | CHECK_EQ(mState, STATE_PREPARING); |
| 682 | |
| 683 | mAsyncResult = err; |
| 684 | |
| 685 | if (err == OK) { |
Marco Nelissen | 2a79c32 | 2014-08-26 13:57:32 -0700 | [diff] [blame] | 686 | // 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 Huber | ec0c597 | 2013-02-05 14:47:13 -0800 | [diff] [blame] | 689 | if (mIsAsyncPrepare) { |
Wei Jia | 0560195 | 2014-08-20 18:21:11 -0700 | [diff] [blame] | 690 | notifyListener_l(MEDIA_PREPARED); |
Andreas Huber | ec0c597 | 2013-02-05 14:47:13 -0800 | [diff] [blame] | 691 | } |
Andreas Huber | 9575c96 | 2013-02-05 13:59:56 -0800 | [diff] [blame] | 692 | } else { |
Marco Nelissen | 2a79c32 | 2014-08-26 13:57:32 -0700 | [diff] [blame] | 693 | mState = STATE_UNPREPARED; |
Andreas Huber | ec0c597 | 2013-02-05 14:47:13 -0800 | [diff] [blame] | 694 | if (mIsAsyncPrepare) { |
Wei Jia | 0560195 | 2014-08-20 18:21:11 -0700 | [diff] [blame] | 695 | notifyListener_l(MEDIA_ERROR, MEDIA_ERROR_UNKNOWN, err); |
Andreas Huber | ec0c597 | 2013-02-05 14:47:13 -0800 | [diff] [blame] | 696 | } |
Andreas Huber | 9575c96 | 2013-02-05 13:59:56 -0800 | [diff] [blame] | 697 | } |
| 698 | |
Marco Nelissen | f0b72b5 | 2014-09-16 15:43:44 -0700 | [diff] [blame] | 699 | 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 Huber | 9575c96 | 2013-02-05 13:59:56 -0800 | [diff] [blame] | 706 | mCondition.broadcast(); |
| 707 | } |
| 708 | |
| 709 | void NuPlayerDriver::notifyFlagsChanged(uint32_t flags) { |
| 710 | Mutex::Autolock autoLock(mLock); |
| 711 | |
| 712 | mPlayerFlags = flags; |
| 713 | } |
| 714 | |
Andreas Huber | f933441 | 2010-12-15 15:17:42 -0800 | [diff] [blame] | 715 | } // namespace android |