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