NuPlayerDriver.cpp revision cbaffcffee6418d678806e63097c19fe26d48fe0
1/* 2 * Copyright (C) 2010 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17//#define LOG_NDEBUG 0 18#define LOG_TAG "NuPlayerDriver" 19#include <utils/Log.h> 20 21#include "NuPlayerDriver.h" 22 23#include "NuPlayer.h" 24#include "NuPlayerSource.h" 25 26#include <media/stagefright/foundation/ADebug.h> 27#include <media/stagefright/foundation/ALooper.h> 28#include <media/stagefright/MetaData.h> 29 30namespace android { 31 32NuPlayerDriver::NuPlayerDriver() 33 : mState(STATE_IDLE), 34 mIsAsyncPrepare(false), 35 mAsyncResult(UNKNOWN_ERROR), 36 mSetSurfaceInProgress(false), 37 mDurationUs(-1), 38 mPositionUs(-1), 39 mNumFramesTotal(0), 40 mNumFramesDropped(0), 41 mLooper(new ALooper), 42 mPlayerFlags(0), 43 mAtEOS(false), 44 mStartupSeekTimeUs(-1) { 45 mLooper->setName("NuPlayerDriver Looper"); 46 47 mLooper->start( 48 false, /* runOnCallingThread */ 49 true, /* canCallJava */ 50 PRIORITY_AUDIO); 51 52 mPlayer = new NuPlayer; 53 mLooper->registerHandler(mPlayer); 54 55 mPlayer->setDriver(this); 56} 57 58NuPlayerDriver::~NuPlayerDriver() { 59 mLooper->stop(); 60} 61 62status_t NuPlayerDriver::initCheck() { 63 return OK; 64} 65 66status_t NuPlayerDriver::setUID(uid_t uid) { 67 mPlayer->setUID(uid); 68 69 return OK; 70} 71 72status_t NuPlayerDriver::setDataSource( 73 const char *url, const KeyedVector<String8, String8> *headers) { 74 Mutex::Autolock autoLock(mLock); 75 76 if (mState != STATE_IDLE) { 77 return INVALID_OPERATION; 78 } 79 80 mState = STATE_SET_DATASOURCE_PENDING; 81 82 mPlayer->setDataSourceAsync(url, headers); 83 84 while (mState == STATE_SET_DATASOURCE_PENDING) { 85 mCondition.wait(mLock); 86 } 87 88 return mAsyncResult; 89} 90 91status_t NuPlayerDriver::setDataSource(int fd, int64_t offset, int64_t length) { 92 Mutex::Autolock autoLock(mLock); 93 94 if (mState != STATE_IDLE) { 95 return INVALID_OPERATION; 96 } 97 98 mState = STATE_SET_DATASOURCE_PENDING; 99 100 mPlayer->setDataSourceAsync(fd, offset, length); 101 102 while (mState == STATE_SET_DATASOURCE_PENDING) { 103 mCondition.wait(mLock); 104 } 105 106 return mAsyncResult; 107} 108 109status_t NuPlayerDriver::setDataSource(const sp<IStreamSource> &source) { 110 Mutex::Autolock autoLock(mLock); 111 112 if (mState != STATE_IDLE) { 113 return INVALID_OPERATION; 114 } 115 116 mState = STATE_SET_DATASOURCE_PENDING; 117 118 mPlayer->setDataSourceAsync(source); 119 120 while (mState == STATE_SET_DATASOURCE_PENDING) { 121 mCondition.wait(mLock); 122 } 123 124 return mAsyncResult; 125} 126 127status_t NuPlayerDriver::setVideoSurfaceTexture( 128 const sp<IGraphicBufferProducer> &bufferProducer) { 129 Mutex::Autolock autoLock(mLock); 130 131 if (mSetSurfaceInProgress) { 132 return INVALID_OPERATION; 133 } 134 135 switch (mState) { 136 case STATE_SET_DATASOURCE_PENDING: 137 case STATE_RESET_IN_PROGRESS: 138 return INVALID_OPERATION; 139 140 default: 141 break; 142 } 143 144 mSetSurfaceInProgress = true; 145 146 mPlayer->setVideoSurfaceTextureAsync(bufferProducer); 147 148 while (mSetSurfaceInProgress) { 149 mCondition.wait(mLock); 150 } 151 152 return OK; 153} 154 155status_t NuPlayerDriver::prepare() { 156 Mutex::Autolock autoLock(mLock); 157 return prepare_l(); 158} 159 160status_t NuPlayerDriver::prepare_l() { 161 switch (mState) { 162 case STATE_UNPREPARED: 163 mState = STATE_PREPARING; 164 165 // Make sure we're not posting any notifications, success or 166 // failure information is only communicated through our result 167 // code. 168 mIsAsyncPrepare = false; 169 mPlayer->prepareAsync(); 170 while (mState == STATE_PREPARING) { 171 mCondition.wait(mLock); 172 } 173 return (mState == STATE_PREPARED) ? OK : UNKNOWN_ERROR; 174 default: 175 return INVALID_OPERATION; 176 }; 177} 178 179status_t NuPlayerDriver::prepareAsync() { 180 Mutex::Autolock autoLock(mLock); 181 182 switch (mState) { 183 case STATE_UNPREPARED: 184 mState = STATE_PREPARING; 185 mIsAsyncPrepare = true; 186 mPlayer->prepareAsync(); 187 return OK; 188 default: 189 return INVALID_OPERATION; 190 }; 191} 192 193status_t NuPlayerDriver::start() { 194 Mutex::Autolock autoLock(mLock); 195 196 switch (mState) { 197 case STATE_UNPREPARED: 198 { 199 status_t err = prepare_l(); 200 201 if (err != OK) { 202 return err; 203 } 204 205 CHECK_EQ(mState, STATE_PREPARED); 206 207 // fall through 208 } 209 210 case STATE_PREPARED: 211 { 212 mAtEOS = false; 213 mPlayer->start(); 214 215 if (mStartupSeekTimeUs >= 0) { 216 if (mStartupSeekTimeUs == 0) { 217 notifySeekComplete(); 218 } else { 219 mPlayer->seekToAsync(mStartupSeekTimeUs); 220 } 221 222 mStartupSeekTimeUs = -1; 223 } 224 break; 225 } 226 227 case STATE_RUNNING: 228 break; 229 230 case STATE_PAUSED: 231 { 232 mPlayer->resume(); 233 break; 234 } 235 236 default: 237 return INVALID_OPERATION; 238 } 239 240 mState = STATE_RUNNING; 241 242 return OK; 243} 244 245status_t NuPlayerDriver::stop() { 246 return pause(); 247} 248 249status_t NuPlayerDriver::pause() { 250 Mutex::Autolock autoLock(mLock); 251 252 switch (mState) { 253 case STATE_PAUSED: 254 case STATE_PREPARED: 255 return OK; 256 257 case STATE_RUNNING: 258 notifyListener(MEDIA_PAUSED); 259 mPlayer->pause(); 260 break; 261 262 default: 263 return INVALID_OPERATION; 264 } 265 266 mState = STATE_PAUSED; 267 268 return OK; 269} 270 271bool NuPlayerDriver::isPlaying() { 272 return mState == STATE_RUNNING && !mAtEOS; 273} 274 275status_t NuPlayerDriver::seekTo(int msec) { 276 Mutex::Autolock autoLock(mLock); 277 278 int64_t seekTimeUs = msec * 1000ll; 279 280 switch (mState) { 281 case STATE_PREPARED: 282 { 283 mStartupSeekTimeUs = seekTimeUs; 284 break; 285 } 286 287 case STATE_RUNNING: 288 case STATE_PAUSED: 289 { 290 mAtEOS = false; 291 // seeks can take a while, so we essentially paused 292 notifyListener(MEDIA_PAUSED); 293 mPlayer->seekToAsync(seekTimeUs); 294 break; 295 } 296 297 default: 298 return INVALID_OPERATION; 299 } 300 301 return OK; 302} 303 304status_t NuPlayerDriver::getCurrentPosition(int *msec) { 305 Mutex::Autolock autoLock(mLock); 306 307 if (mPositionUs < 0) { 308 *msec = 0; 309 } else { 310 *msec = (mPositionUs + 500ll) / 1000; 311 } 312 313 return OK; 314} 315 316status_t NuPlayerDriver::getDuration(int *msec) { 317 Mutex::Autolock autoLock(mLock); 318 319 if (mDurationUs < 0) { 320 return UNKNOWN_ERROR; 321 } 322 323 *msec = (mDurationUs + 500ll) / 1000; 324 325 return OK; 326} 327 328status_t NuPlayerDriver::reset() { 329 Mutex::Autolock autoLock(mLock); 330 331 switch (mState) { 332 case STATE_IDLE: 333 return OK; 334 335 case STATE_SET_DATASOURCE_PENDING: 336 case STATE_RESET_IN_PROGRESS: 337 return INVALID_OPERATION; 338 339 case STATE_PREPARING: 340 { 341 CHECK(mIsAsyncPrepare); 342 343 notifyListener(MEDIA_PREPARED); 344 break; 345 } 346 347 default: 348 break; 349 } 350 351 notifyListener(MEDIA_STOPPED); 352 353 mState = STATE_RESET_IN_PROGRESS; 354 mPlayer->resetAsync(); 355 356 while (mState == STATE_RESET_IN_PROGRESS) { 357 mCondition.wait(mLock); 358 } 359 360 mDurationUs = -1; 361 mPositionUs = -1; 362 mStartupSeekTimeUs = -1; 363 364 return OK; 365} 366 367status_t NuPlayerDriver::setLooping(int loop) { 368 return INVALID_OPERATION; 369} 370 371player_type NuPlayerDriver::playerType() { 372 return NU_PLAYER; 373} 374 375status_t NuPlayerDriver::invoke(const Parcel &request, Parcel *reply) { 376 if (reply == NULL) { 377 ALOGE("reply is a NULL pointer"); 378 return BAD_VALUE; 379 } 380 381 int32_t methodId; 382 status_t ret = request.readInt32(&methodId); 383 if (ret != OK) { 384 ALOGE("Failed to retrieve the requested method to invoke"); 385 return ret; 386 } 387 388 switch (methodId) { 389 case INVOKE_ID_SET_VIDEO_SCALING_MODE: 390 { 391 int mode = request.readInt32(); 392 return mPlayer->setVideoScalingMode(mode); 393 } 394 395 default: 396 { 397 return INVALID_OPERATION; 398 } 399 } 400} 401 402void NuPlayerDriver::setAudioSink(const sp<AudioSink> &audioSink) { 403 mPlayer->setAudioSink(audioSink); 404} 405 406status_t NuPlayerDriver::setParameter(int key, const Parcel &request) { 407 return INVALID_OPERATION; 408} 409 410status_t NuPlayerDriver::getParameter(int key, Parcel *reply) { 411 return INVALID_OPERATION; 412} 413 414status_t NuPlayerDriver::getMetadata( 415 const media::Metadata::Filter& ids, Parcel *records) { 416 Mutex::Autolock autoLock(mLock); 417 418 using media::Metadata; 419 420 Metadata meta(records); 421 422 meta.appendBool( 423 Metadata::kPauseAvailable, 424 mPlayerFlags & NuPlayer::Source::FLAG_CAN_PAUSE); 425 426 meta.appendBool( 427 Metadata::kSeekBackwardAvailable, 428 mPlayerFlags & NuPlayer::Source::FLAG_CAN_SEEK_BACKWARD); 429 430 meta.appendBool( 431 Metadata::kSeekForwardAvailable, 432 mPlayerFlags & NuPlayer::Source::FLAG_CAN_SEEK_FORWARD); 433 434 meta.appendBool( 435 Metadata::kSeekAvailable, 436 mPlayerFlags & NuPlayer::Source::FLAG_CAN_SEEK); 437 438 return OK; 439} 440 441void NuPlayerDriver::notifyResetComplete() { 442 Mutex::Autolock autoLock(mLock); 443 444 CHECK_EQ(mState, STATE_RESET_IN_PROGRESS); 445 mState = STATE_IDLE; 446 mCondition.broadcast(); 447} 448 449void NuPlayerDriver::notifySetSurfaceComplete() { 450 Mutex::Autolock autoLock(mLock); 451 452 CHECK(mSetSurfaceInProgress); 453 mSetSurfaceInProgress = false; 454 455 mCondition.broadcast(); 456} 457 458void NuPlayerDriver::notifyDuration(int64_t durationUs) { 459 Mutex::Autolock autoLock(mLock); 460 mDurationUs = durationUs; 461} 462 463void NuPlayerDriver::notifyPosition(int64_t positionUs) { 464 Mutex::Autolock autoLock(mLock); 465 mPositionUs = positionUs; 466} 467 468void NuPlayerDriver::notifySeekComplete() { 469 notifyListener(MEDIA_SEEK_COMPLETE); 470} 471 472void NuPlayerDriver::notifyFrameStats( 473 int64_t numFramesTotal, int64_t numFramesDropped) { 474 Mutex::Autolock autoLock(mLock); 475 mNumFramesTotal = numFramesTotal; 476 mNumFramesDropped = numFramesDropped; 477} 478 479status_t NuPlayerDriver::dump(int fd, const Vector<String16> &args) const { 480 Mutex::Autolock autoLock(mLock); 481 482 FILE *out = fdopen(dup(fd), "w"); 483 484 fprintf(out, " NuPlayer\n"); 485 fprintf(out, " numFramesTotal(%lld), numFramesDropped(%lld), " 486 "percentageDropped(%.2f)\n", 487 mNumFramesTotal, 488 mNumFramesDropped, 489 mNumFramesTotal == 0 490 ? 0.0 : (double)mNumFramesDropped / mNumFramesTotal); 491 492 fclose(out); 493 out = NULL; 494 495 return OK; 496} 497 498void NuPlayerDriver::notifyListener(int msg, int ext1, int ext2) { 499 if (msg == MEDIA_PLAYBACK_COMPLETE || msg == MEDIA_ERROR) { 500 mAtEOS = true; 501 } 502 503 sendEvent(msg, ext1, ext2); 504} 505 506void NuPlayerDriver::notifySetDataSourceCompleted(status_t err) { 507 Mutex::Autolock autoLock(mLock); 508 509 CHECK_EQ(mState, STATE_SET_DATASOURCE_PENDING); 510 511 mAsyncResult = err; 512 mState = (err == OK) ? STATE_UNPREPARED : STATE_IDLE; 513 mCondition.broadcast(); 514} 515 516void NuPlayerDriver::notifyPrepareCompleted(status_t err) { 517 Mutex::Autolock autoLock(mLock); 518 519 if (mState != STATE_PREPARING) { 520 // We were preparing asynchronously when the client called 521 // reset(), we sent a premature "prepared" notification and 522 // then initiated the reset. This notification is stale. 523 CHECK(mState == STATE_RESET_IN_PROGRESS || mState == STATE_IDLE); 524 return; 525 } 526 527 CHECK_EQ(mState, STATE_PREPARING); 528 529 mAsyncResult = err; 530 531 if (err == OK) { 532 if (mIsAsyncPrepare) { 533 notifyListener(MEDIA_PREPARED); 534 } 535 mState = STATE_PREPARED; 536 } else { 537 if (mIsAsyncPrepare) { 538 notifyListener(MEDIA_ERROR, MEDIA_ERROR_UNKNOWN, err); 539 } 540 mState = STATE_UNPREPARED; 541 } 542 543 mCondition.broadcast(); 544} 545 546void NuPlayerDriver::notifyFlagsChanged(uint32_t flags) { 547 Mutex::Autolock autoLock(mLock); 548 549 mPlayerFlags = flags; 550} 551 552} // namespace android 553