NuPlayerDriver.cpp revision e427abf1ea252ff305fc33aacdd2e83cf34891b5
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 <inttypes.h> 20#include <utils/Log.h> 21 22#include "NuPlayerDriver.h" 23 24#include "NuPlayer.h" 25#include "NuPlayerSource.h" 26 27#include <media/stagefright/foundation/ADebug.h> 28#include <media/stagefright/foundation/ALooper.h> 29#include <media/stagefright/MetaData.h> 30 31namespace android { 32 33NuPlayerDriver::NuPlayerDriver() 34 : mState(STATE_IDLE), 35 mIsAsyncPrepare(false), 36 mAsyncResult(UNKNOWN_ERROR), 37 mSetSurfaceInProgress(false), 38 mDurationUs(-1), 39 mPositionUs(-1), 40 mNotifyTimeRealUs(-1), 41 mPauseStartedTimeUs(-1), 42 mNumFramesTotal(0), 43 mNumFramesDropped(0), 44 mLooper(new ALooper), 45 mPlayerFlags(0), 46 mAtEOS(false), 47 mLooping(false), 48 mAutoLoop(false), 49 mStartupSeekTimeUs(-1) { 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 60 mPlayer->setDriver(this); 61} 62 63NuPlayerDriver::~NuPlayerDriver() { 64 mLooper->stop(); 65} 66 67status_t NuPlayerDriver::initCheck() { 68 return OK; 69} 70 71status_t NuPlayerDriver::setUID(uid_t uid) { 72 mPlayer->setUID(uid); 73 74 return OK; 75} 76 77status_t NuPlayerDriver::setDataSource( 78 const sp<IMediaHTTPService> &httpService, 79 const char *url, 80 const KeyedVector<String8, String8> *headers) { 81 Mutex::Autolock autoLock(mLock); 82 83 ALOGV("setDataSource: url=%s", url); 84 if (mState != STATE_IDLE) { 85 return INVALID_OPERATION; 86 } 87 88 mState = STATE_SET_DATASOURCE_PENDING; 89 90 mPlayer->setDataSourceAsync(httpService, url, headers); 91 92 while (mState == STATE_SET_DATASOURCE_PENDING) { 93 mCondition.wait(mLock); 94 } 95 96 return mAsyncResult; 97} 98 99status_t NuPlayerDriver::setDataSource(int fd, int64_t offset, int64_t length) { 100 Mutex::Autolock autoLock(mLock); 101 102 ALOGV("setDataSource: fd=%d", fd); 103 if (mState != STATE_IDLE) { 104 return INVALID_OPERATION; 105 } 106 107 mState = STATE_SET_DATASOURCE_PENDING; 108 109 mPlayer->setDataSourceAsync(fd, offset, length); 110 111 while (mState == STATE_SET_DATASOURCE_PENDING) { 112 mCondition.wait(mLock); 113 } 114 115 return mAsyncResult; 116} 117 118status_t NuPlayerDriver::setDataSource(const sp<IStreamSource> &source) { 119 Mutex::Autolock autoLock(mLock); 120 121 ALOGV("setDataSource: stream source"); 122 if (mState != STATE_IDLE) { 123 return INVALID_OPERATION; 124 } 125 126 mState = STATE_SET_DATASOURCE_PENDING; 127 128 mPlayer->setDataSourceAsync(source); 129 130 while (mState == STATE_SET_DATASOURCE_PENDING) { 131 mCondition.wait(mLock); 132 } 133 134 return mAsyncResult; 135} 136 137status_t NuPlayerDriver::setVideoSurfaceTexture( 138 const sp<IGraphicBufferProducer> &bufferProducer) { 139 Mutex::Autolock autoLock(mLock); 140 141 if (mSetSurfaceInProgress) { 142 return INVALID_OPERATION; 143 } 144 145 switch (mState) { 146 case STATE_SET_DATASOURCE_PENDING: 147 case STATE_RESET_IN_PROGRESS: 148 return INVALID_OPERATION; 149 150 default: 151 break; 152 } 153 154 mSetSurfaceInProgress = true; 155 156 mPlayer->setVideoSurfaceTextureAsync(bufferProducer); 157 158 while (mSetSurfaceInProgress) { 159 mCondition.wait(mLock); 160 } 161 162 return OK; 163} 164 165status_t NuPlayerDriver::prepare() { 166 Mutex::Autolock autoLock(mLock); 167 return prepare_l(); 168} 169 170status_t NuPlayerDriver::prepare_l() { 171 switch (mState) { 172 case STATE_UNPREPARED: 173 mState = STATE_PREPARING; 174 175 // Make sure we're not posting any notifications, success or 176 // failure information is only communicated through our result 177 // code. 178 mIsAsyncPrepare = false; 179 mPlayer->prepareAsync(); 180 while (mState == STATE_PREPARING) { 181 mCondition.wait(mLock); 182 } 183 return (mState == STATE_PREPARED) ? OK : UNKNOWN_ERROR; 184 case STATE_STOPPED: 185 // this is really just paused. handle as seek to start 186 mAtEOS = false; 187 mState = STATE_STOPPED_AND_PREPARING; 188 mIsAsyncPrepare = false; 189 mPlayer->seekToAsync(0); 190 while (mState == STATE_STOPPED_AND_PREPARING) { 191 mCondition.wait(mLock); 192 } 193 return (mState == STATE_STOPPED_AND_PREPARED) ? OK : UNKNOWN_ERROR; 194 default: 195 return INVALID_OPERATION; 196 }; 197} 198 199status_t NuPlayerDriver::prepareAsync() { 200 Mutex::Autolock autoLock(mLock); 201 202 switch (mState) { 203 case STATE_UNPREPARED: 204 mState = STATE_PREPARING; 205 mIsAsyncPrepare = true; 206 mPlayer->prepareAsync(); 207 return OK; 208 case STATE_STOPPED: 209 // this is really just paused. handle as seek to start 210 mAtEOS = false; 211 mState = STATE_STOPPED_AND_PREPARING; 212 mIsAsyncPrepare = true; 213 mPlayer->seekToAsync(0); 214 return OK; 215 default: 216 return INVALID_OPERATION; 217 }; 218} 219 220status_t NuPlayerDriver::start() { 221 Mutex::Autolock autoLock(mLock); 222 223 switch (mState) { 224 case STATE_UNPREPARED: 225 { 226 status_t err = prepare_l(); 227 228 if (err != OK) { 229 return err; 230 } 231 232 CHECK_EQ(mState, STATE_PREPARED); 233 234 // fall through 235 } 236 237 case STATE_PREPARED: 238 { 239 mAtEOS = false; 240 mPlayer->start(); 241 242 if (mStartupSeekTimeUs >= 0) { 243 if (mStartupSeekTimeUs > 0) { 244 mPlayer->seekToAsync(mStartupSeekTimeUs); 245 } 246 247 mStartupSeekTimeUs = -1; 248 } 249 break; 250 } 251 252 case STATE_RUNNING: 253 { 254 if (mAtEOS) { 255 mPlayer->seekToAsync(0); 256 mAtEOS = false; 257 mPositionUs = -1; 258 } 259 break; 260 } 261 262 case STATE_PAUSED: 263 case STATE_STOPPED_AND_PREPARED: 264 { 265 if (mAtEOS) { 266 mPlayer->seekToAsync(0); 267 mAtEOS = false; 268 mPlayer->resume(); 269 mPositionUs = -1; 270 } else { 271 mPlayer->resume(); 272 if (mNotifyTimeRealUs != -1) { 273 // Pause time must be set if here by setPauseStartedTimeIfNeeded(). 274 //CHECK(mPauseStartedTimeUs != -1); 275 276 // if no seek occurs, adjust our notify time so that getCurrentPosition() 277 // is continuous if read immediately after calling start(). 278 mNotifyTimeRealUs += ALooper::GetNowUs() - mPauseStartedTimeUs; 279 } 280 } 281 break; 282 } 283 284 default: 285 return INVALID_OPERATION; 286 } 287 288 mState = STATE_RUNNING; 289 mPauseStartedTimeUs = -1; 290 291 return OK; 292} 293 294status_t NuPlayerDriver::stop() { 295 Mutex::Autolock autoLock(mLock); 296 297 switch (mState) { 298 case STATE_RUNNING: 299 mPlayer->pause(); 300 // fall through 301 302 case STATE_PAUSED: 303 mState = STATE_STOPPED; 304 notifyListener_l(MEDIA_STOPPED); 305 break; 306 307 case STATE_PREPARED: 308 case STATE_STOPPED: 309 case STATE_STOPPED_AND_PREPARING: 310 case STATE_STOPPED_AND_PREPARED: 311 mState = STATE_STOPPED; 312 break; 313 314 default: 315 return INVALID_OPERATION; 316 } 317 setPauseStartedTimeIfNeeded(); 318 319 return OK; 320} 321 322status_t NuPlayerDriver::pause() { 323 Mutex::Autolock autoLock(mLock); 324 325 switch (mState) { 326 case STATE_PAUSED: 327 case STATE_PREPARED: 328 return OK; 329 330 case STATE_RUNNING: 331 setPauseStartedTimeIfNeeded(); 332 mState = STATE_PAUSED; 333 notifyListener_l(MEDIA_PAUSED); 334 mPlayer->pause(); 335 break; 336 337 default: 338 return INVALID_OPERATION; 339 } 340 341 return OK; 342} 343 344bool NuPlayerDriver::isPlaying() { 345 return mState == STATE_RUNNING && !mAtEOS; 346} 347 348status_t NuPlayerDriver::seekTo(int msec) { 349 Mutex::Autolock autoLock(mLock); 350 351 int64_t seekTimeUs = msec * 1000ll; 352 353 switch (mState) { 354 case STATE_PREPARED: 355 { 356 mStartupSeekTimeUs = seekTimeUs; 357 // pretend that the seek completed. It will actually happen when starting playback. 358 // TODO: actually perform the seek here, so the player is ready to go at the new 359 // location 360 notifySeekComplete_l(); 361 break; 362 } 363 364 case STATE_RUNNING: 365 case STATE_PAUSED: 366 { 367 mAtEOS = false; 368 // seeks can take a while, so we essentially paused 369 notifyListener_l(MEDIA_PAUSED); 370 mPlayer->seekToAsync(seekTimeUs, true /* needNotify */); 371 break; 372 } 373 374 default: 375 return INVALID_OPERATION; 376 } 377 378 mPositionUs = seekTimeUs; 379 mNotifyTimeRealUs = -1; 380 return OK; 381} 382 383status_t NuPlayerDriver::getCurrentPosition(int *msec) { 384 Mutex::Autolock autoLock(mLock); 385 386 if (mPositionUs < 0) { 387 // mPositionUs is the media time. 388 // It is negative under these cases 389 // (1) == -1 after reset, or very first playback, no stream notification yet. 390 // (2) == -1 start after end of stream, no stream notification yet. 391 // (3) == large negative # after ~292,471 years of continuous playback. 392 393 //CHECK_EQ(mPositionUs, -1); 394 *msec = 0; 395 } else if (mNotifyTimeRealUs == -1) { 396 // A seek has occurred just occurred, no stream notification yet. 397 // mPositionUs (>= 0) is the new media position. 398 *msec = mPositionUs / 1000; 399 } else { 400 // mPosition must be valid (i.e. >= 0) by the first check above. 401 // We're either playing or have pause time set: mPauseStartedTimeUs is >= 0 402 //LOG_ALWAYS_FATAL_IF( 403 // !isPlaying() && mPauseStartedTimeUs < 0, 404 // "Player in non-playing mState(%d) and mPauseStartedTimeUs(%lld) < 0", 405 // mState, (long long)mPauseStartedTimeUs); 406 ALOG_ASSERT(mNotifyTimeRealUs >= 0); 407 int64_t nowUs = 408 (isPlaying() ? ALooper::GetNowUs() : mPauseStartedTimeUs); 409 *msec = (mPositionUs + nowUs - mNotifyTimeRealUs + 500ll) / 1000; 410 // It is possible for *msec to be negative if the media position is > 596 hours. 411 // but we turn on this checking in NDEBUG == 0 mode. 412 ALOG_ASSERT(*msec >= 0); 413 ALOGV("getCurrentPosition nowUs(%lld)", (long long)nowUs); 414 } 415 ALOGV("getCurrentPosition returning(%d) mPositionUs(%lld) mNotifyRealTimeUs(%lld)", 416 *msec, (long long)mPositionUs, (long long)mNotifyTimeRealUs); 417 return OK; 418} 419 420status_t NuPlayerDriver::getDuration(int *msec) { 421 Mutex::Autolock autoLock(mLock); 422 423 if (mDurationUs < 0) { 424 return UNKNOWN_ERROR; 425 } 426 427 *msec = (mDurationUs + 500ll) / 1000; 428 429 return OK; 430} 431 432status_t NuPlayerDriver::reset() { 433 Mutex::Autolock autoLock(mLock); 434 435 switch (mState) { 436 case STATE_IDLE: 437 return OK; 438 439 case STATE_SET_DATASOURCE_PENDING: 440 case STATE_RESET_IN_PROGRESS: 441 return INVALID_OPERATION; 442 443 case STATE_PREPARING: 444 { 445 CHECK(mIsAsyncPrepare); 446 447 notifyListener_l(MEDIA_PREPARED); 448 break; 449 } 450 451 default: 452 break; 453 } 454 455 if (mState != STATE_STOPPED) { 456 notifyListener_l(MEDIA_STOPPED); 457 } 458 459 mState = STATE_RESET_IN_PROGRESS; 460 mPlayer->resetAsync(); 461 462 while (mState == STATE_RESET_IN_PROGRESS) { 463 mCondition.wait(mLock); 464 } 465 466 mDurationUs = -1; 467 mPositionUs = -1; 468 mStartupSeekTimeUs = -1; 469 mLooping = false; 470 471 return OK; 472} 473 474status_t NuPlayerDriver::setLooping(int loop) { 475 mLooping = loop != 0; 476 return OK; 477} 478 479player_type NuPlayerDriver::playerType() { 480 return NU_PLAYER; 481} 482 483status_t NuPlayerDriver::invoke(const Parcel &request, Parcel *reply) { 484 if (reply == NULL) { 485 ALOGE("reply is a NULL pointer"); 486 return BAD_VALUE; 487 } 488 489 int32_t methodId; 490 status_t ret = request.readInt32(&methodId); 491 if (ret != OK) { 492 ALOGE("Failed to retrieve the requested method to invoke"); 493 return ret; 494 } 495 496 switch (methodId) { 497 case INVOKE_ID_SET_VIDEO_SCALING_MODE: 498 { 499 int mode = request.readInt32(); 500 return mPlayer->setVideoScalingMode(mode); 501 } 502 503 case INVOKE_ID_GET_TRACK_INFO: 504 { 505 return mPlayer->getTrackInfo(reply); 506 } 507 508 case INVOKE_ID_SELECT_TRACK: 509 { 510 int trackIndex = request.readInt32(); 511 return mPlayer->selectTrack(trackIndex, true /* select */); 512 } 513 514 case INVOKE_ID_UNSELECT_TRACK: 515 { 516 int trackIndex = request.readInt32(); 517 return mPlayer->selectTrack(trackIndex, false /* select */); 518 } 519 520 case INVOKE_ID_GET_SELECTED_TRACK: 521 { 522 int32_t type = request.readInt32(); 523 return mPlayer->getSelectedTrack(type, reply); 524 } 525 526 default: 527 { 528 return INVALID_OPERATION; 529 } 530 } 531} 532 533void NuPlayerDriver::setAudioSink(const sp<AudioSink> &audioSink) { 534 mPlayer->setAudioSink(audioSink); 535 mAudioSink = audioSink; 536} 537 538status_t NuPlayerDriver::setParameter( 539 int /* key */, const Parcel & /* request */) { 540 return INVALID_OPERATION; 541} 542 543status_t NuPlayerDriver::getParameter(int /* key */, Parcel * /* reply */) { 544 return INVALID_OPERATION; 545} 546 547status_t NuPlayerDriver::getMetadata( 548 const media::Metadata::Filter& /* ids */, Parcel *records) { 549 Mutex::Autolock autoLock(mLock); 550 551 using media::Metadata; 552 553 Metadata meta(records); 554 555 meta.appendBool( 556 Metadata::kPauseAvailable, 557 mPlayerFlags & NuPlayer::Source::FLAG_CAN_PAUSE); 558 559 meta.appendBool( 560 Metadata::kSeekBackwardAvailable, 561 mPlayerFlags & NuPlayer::Source::FLAG_CAN_SEEK_BACKWARD); 562 563 meta.appendBool( 564 Metadata::kSeekForwardAvailable, 565 mPlayerFlags & NuPlayer::Source::FLAG_CAN_SEEK_FORWARD); 566 567 meta.appendBool( 568 Metadata::kSeekAvailable, 569 mPlayerFlags & NuPlayer::Source::FLAG_CAN_SEEK); 570 571 return OK; 572} 573 574void NuPlayerDriver::notifyResetComplete() { 575 Mutex::Autolock autoLock(mLock); 576 577 CHECK_EQ(mState, STATE_RESET_IN_PROGRESS); 578 mState = STATE_IDLE; 579 mCondition.broadcast(); 580} 581 582void NuPlayerDriver::notifySetSurfaceComplete() { 583 Mutex::Autolock autoLock(mLock); 584 585 CHECK(mSetSurfaceInProgress); 586 mSetSurfaceInProgress = false; 587 588 mCondition.broadcast(); 589} 590 591void NuPlayerDriver::notifyDuration(int64_t durationUs) { 592 Mutex::Autolock autoLock(mLock); 593 mDurationUs = durationUs; 594} 595 596void NuPlayerDriver::notifyPosition(int64_t positionUs) { 597 Mutex::Autolock autoLock(mLock); 598 if (isPlaying()) { 599 mPositionUs = positionUs; 600 mNotifyTimeRealUs = ALooper::GetNowUs(); 601 } 602} 603 604void NuPlayerDriver::notifySeekComplete() { 605 Mutex::Autolock autoLock(mLock); 606 notifySeekComplete_l(); 607} 608 609void NuPlayerDriver::notifySeekComplete_l() { 610 bool wasSeeking = true; 611 if (mState == STATE_STOPPED_AND_PREPARING) { 612 wasSeeking = false; 613 mState = STATE_STOPPED_AND_PREPARED; 614 mCondition.broadcast(); 615 if (!mIsAsyncPrepare) { 616 // if we are preparing synchronously, no need to notify listener 617 return; 618 } 619 } else if (mState == STATE_STOPPED) { 620 // no need to notify listener 621 return; 622 } 623 notifyListener_l(wasSeeking ? MEDIA_SEEK_COMPLETE : MEDIA_PREPARED); 624} 625 626void NuPlayerDriver::notifyFrameStats( 627 int64_t numFramesTotal, int64_t numFramesDropped) { 628 Mutex::Autolock autoLock(mLock); 629 mNumFramesTotal = numFramesTotal; 630 mNumFramesDropped = numFramesDropped; 631} 632 633status_t NuPlayerDriver::dump( 634 int fd, const Vector<String16> & /* args */) const { 635 Mutex::Autolock autoLock(mLock); 636 637 FILE *out = fdopen(dup(fd), "w"); 638 639 fprintf(out, " NuPlayer\n"); 640 fprintf(out, " numFramesTotal(%" PRId64 "), numFramesDropped(%" PRId64 "), " 641 "percentageDropped(%.2f)\n", 642 mNumFramesTotal, 643 mNumFramesDropped, 644 mNumFramesTotal == 0 645 ? 0.0 : (double)mNumFramesDropped / mNumFramesTotal); 646 647 fclose(out); 648 out = NULL; 649 650 return OK; 651} 652 653void NuPlayerDriver::notifyListener( 654 int msg, int ext1, int ext2, const Parcel *in) { 655 Mutex::Autolock autoLock(mLock); 656 notifyListener_l(msg, ext1, ext2, in); 657} 658 659void NuPlayerDriver::notifyListener_l( 660 int msg, int ext1, int ext2, const Parcel *in) { 661 switch (msg) { 662 case MEDIA_PLAYBACK_COMPLETE: 663 { 664 if (mState != STATE_RESET_IN_PROGRESS) { 665 if (mLooping || (mAutoLoop 666 && (mAudioSink == NULL || mAudioSink->realtime()))) { 667 mPlayer->seekToAsync(0); 668 break; 669 } 670 671 mPlayer->pause(); 672 mState = STATE_PAUSED; 673 } 674 // fall through 675 } 676 677 case MEDIA_ERROR: 678 { 679 mAtEOS = true; 680 setPauseStartedTimeIfNeeded(); 681 break; 682 } 683 684 default: 685 break; 686 } 687 688 mLock.unlock(); 689 sendEvent(msg, ext1, ext2, in); 690 mLock.lock(); 691} 692 693void NuPlayerDriver::notifySetDataSourceCompleted(status_t err) { 694 Mutex::Autolock autoLock(mLock); 695 696 CHECK_EQ(mState, STATE_SET_DATASOURCE_PENDING); 697 698 mAsyncResult = err; 699 mState = (err == OK) ? STATE_UNPREPARED : STATE_IDLE; 700 mCondition.broadcast(); 701} 702 703void NuPlayerDriver::notifyPrepareCompleted(status_t err) { 704 Mutex::Autolock autoLock(mLock); 705 706 if (mState != STATE_PREPARING) { 707 // We were preparing asynchronously when the client called 708 // reset(), we sent a premature "prepared" notification and 709 // then initiated the reset. This notification is stale. 710 CHECK(mState == STATE_RESET_IN_PROGRESS || mState == STATE_IDLE); 711 return; 712 } 713 714 CHECK_EQ(mState, STATE_PREPARING); 715 716 mAsyncResult = err; 717 718 if (err == OK) { 719 // update state before notifying client, so that if client calls back into NuPlayerDriver 720 // in response, NuPlayerDriver has the right state 721 mState = STATE_PREPARED; 722 if (mIsAsyncPrepare) { 723 notifyListener_l(MEDIA_PREPARED); 724 } 725 } else { 726 mState = STATE_UNPREPARED; 727 if (mIsAsyncPrepare) { 728 notifyListener_l(MEDIA_ERROR, MEDIA_ERROR_UNKNOWN, err); 729 } 730 } 731 732 sp<MetaData> meta = mPlayer->getFileMeta(); 733 int32_t loop; 734 if (meta != NULL 735 && meta->findInt32(kKeyAutoLoop, &loop) && loop != 0) { 736 mAutoLoop = true; 737 } 738 739 mCondition.broadcast(); 740} 741 742void NuPlayerDriver::notifyFlagsChanged(uint32_t flags) { 743 Mutex::Autolock autoLock(mLock); 744 745 mPlayerFlags = flags; 746} 747 748void NuPlayerDriver::setPauseStartedTimeIfNeeded() { 749 if (mPauseStartedTimeUs == -1) { 750 mPauseStartedTimeUs = ALooper::GetNowUs(); 751 } 752} 753 754} // namespace android 755