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