NuPlayerDriver.cpp revision 15506a6582fb86567c6887c4c426d44be02d12af
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(0), 40 mPauseStartedTimeUs(0), 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 break; 244 245 case STATE_PAUSED: 246 case STATE_STOPPED_AND_PREPARED: 247 { 248 mPlayer->resume(); 249 mPositionUs -= ALooper::GetNowUs() - mPauseStartedTimeUs; 250 break; 251 } 252 253 default: 254 return INVALID_OPERATION; 255 } 256 257 mState = STATE_RUNNING; 258 259 return OK; 260} 261 262status_t NuPlayerDriver::stop() { 263 Mutex::Autolock autoLock(mLock); 264 265 switch (mState) { 266 case STATE_RUNNING: 267 mPlayer->pause(); 268 // fall through 269 270 case STATE_PAUSED: 271 notifyListener(MEDIA_STOPPED); 272 // fall through 273 274 case STATE_PREPARED: 275 case STATE_STOPPED: 276 case STATE_STOPPED_AND_PREPARING: 277 case STATE_STOPPED_AND_PREPARED: 278 mState = STATE_STOPPED; 279 break; 280 281 default: 282 return INVALID_OPERATION; 283 } 284 mPauseStartedTimeUs = ALooper::GetNowUs(); 285 286 return OK; 287} 288 289status_t NuPlayerDriver::pause() { 290 Mutex::Autolock autoLock(mLock); 291 292 switch (mState) { 293 case STATE_PAUSED: 294 case STATE_PREPARED: 295 return OK; 296 297 case STATE_RUNNING: 298 notifyListener(MEDIA_PAUSED); 299 mPlayer->pause(); 300 break; 301 302 default: 303 return INVALID_OPERATION; 304 } 305 306 mPauseStartedTimeUs = ALooper::GetNowUs(); 307 mState = STATE_PAUSED; 308 309 return OK; 310} 311 312bool NuPlayerDriver::isPlaying() { 313 return mState == STATE_RUNNING && !mAtEOS; 314} 315 316status_t NuPlayerDriver::seekTo(int msec) { 317 Mutex::Autolock autoLock(mLock); 318 319 int64_t seekTimeUs = msec * 1000ll; 320 321 switch (mState) { 322 case STATE_PREPARED: 323 { 324 mStartupSeekTimeUs = seekTimeUs; 325 // pretend that the seek completed. It will actually happen when starting playback. 326 // TODO: actually perform the seek here, so the player is ready to go at the new 327 // location 328 notifySeekComplete_l(); 329 break; 330 } 331 332 case STATE_RUNNING: 333 case STATE_PAUSED: 334 { 335 mAtEOS = false; 336 // seeks can take a while, so we essentially paused 337 notifyListener(MEDIA_PAUSED); 338 mPlayer->seekToAsync(seekTimeUs); 339 break; 340 } 341 342 default: 343 return INVALID_OPERATION; 344 } 345 346 return OK; 347} 348 349status_t NuPlayerDriver::getCurrentPosition(int *msec) { 350 Mutex::Autolock autoLock(mLock); 351 352 if (mPositionUs < 0) { 353 *msec = 0; 354 } else { 355 int64_t nowUs = 356 (mState != STATE_RUNNING ? 357 mPauseStartedTimeUs : ALooper::GetNowUs()); 358 *msec = (mPositionUs + nowUs - mNotifyTimeRealUs + 500ll) / 1000; 359 } 360 361 return OK; 362} 363 364status_t NuPlayerDriver::getDuration(int *msec) { 365 Mutex::Autolock autoLock(mLock); 366 367 if (mDurationUs < 0) { 368 return UNKNOWN_ERROR; 369 } 370 371 *msec = (mDurationUs + 500ll) / 1000; 372 373 return OK; 374} 375 376status_t NuPlayerDriver::reset() { 377 Mutex::Autolock autoLock(mLock); 378 379 switch (mState) { 380 case STATE_IDLE: 381 return OK; 382 383 case STATE_SET_DATASOURCE_PENDING: 384 case STATE_RESET_IN_PROGRESS: 385 return INVALID_OPERATION; 386 387 case STATE_PREPARING: 388 { 389 CHECK(mIsAsyncPrepare); 390 391 notifyListener(MEDIA_PREPARED); 392 break; 393 } 394 395 default: 396 break; 397 } 398 399 if (mState != STATE_STOPPED) { 400 notifyListener(MEDIA_STOPPED); 401 } 402 403 mState = STATE_RESET_IN_PROGRESS; 404 mPlayer->resetAsync(); 405 406 while (mState == STATE_RESET_IN_PROGRESS) { 407 mCondition.wait(mLock); 408 } 409 410 mDurationUs = -1; 411 mPositionUs = -1; 412 mStartupSeekTimeUs = -1; 413 mLooping = false; 414 415 return OK; 416} 417 418status_t NuPlayerDriver::setLooping(int loop) { 419 mLooping = loop != 0; 420 return OK; 421} 422 423player_type NuPlayerDriver::playerType() { 424 return NU_PLAYER; 425} 426 427status_t NuPlayerDriver::invoke(const Parcel &request, Parcel *reply) { 428 if (reply == NULL) { 429 ALOGE("reply is a NULL pointer"); 430 return BAD_VALUE; 431 } 432 433 int32_t methodId; 434 status_t ret = request.readInt32(&methodId); 435 if (ret != OK) { 436 ALOGE("Failed to retrieve the requested method to invoke"); 437 return ret; 438 } 439 440 switch (methodId) { 441 case INVOKE_ID_SET_VIDEO_SCALING_MODE: 442 { 443 int mode = request.readInt32(); 444 return mPlayer->setVideoScalingMode(mode); 445 } 446 447 case INVOKE_ID_GET_TRACK_INFO: 448 { 449 return mPlayer->getTrackInfo(reply); 450 } 451 452 case INVOKE_ID_SELECT_TRACK: 453 { 454 int trackIndex = request.readInt32(); 455 return mPlayer->selectTrack(trackIndex, true /* select */); 456 } 457 458 case INVOKE_ID_UNSELECT_TRACK: 459 { 460 int trackIndex = request.readInt32(); 461 return mPlayer->selectTrack(trackIndex, false /* select */); 462 } 463 464 case INVOKE_ID_GET_SELECTED_TRACK: 465 { 466 int32_t type = request.readInt32(); 467 return mPlayer->getSelectedTrack(type, reply); 468 } 469 470 default: 471 { 472 return INVALID_OPERATION; 473 } 474 } 475} 476 477void NuPlayerDriver::setAudioSink(const sp<AudioSink> &audioSink) { 478 mPlayer->setAudioSink(audioSink); 479} 480 481status_t NuPlayerDriver::setParameter( 482 int /* key */, const Parcel & /* request */) { 483 return INVALID_OPERATION; 484} 485 486status_t NuPlayerDriver::getParameter(int /* key */, Parcel * /* reply */) { 487 return INVALID_OPERATION; 488} 489 490status_t NuPlayerDriver::getMetadata( 491 const media::Metadata::Filter& /* ids */, Parcel *records) { 492 Mutex::Autolock autoLock(mLock); 493 494 using media::Metadata; 495 496 Metadata meta(records); 497 498 meta.appendBool( 499 Metadata::kPauseAvailable, 500 mPlayerFlags & NuPlayer::Source::FLAG_CAN_PAUSE); 501 502 meta.appendBool( 503 Metadata::kSeekBackwardAvailable, 504 mPlayerFlags & NuPlayer::Source::FLAG_CAN_SEEK_BACKWARD); 505 506 meta.appendBool( 507 Metadata::kSeekForwardAvailable, 508 mPlayerFlags & NuPlayer::Source::FLAG_CAN_SEEK_FORWARD); 509 510 meta.appendBool( 511 Metadata::kSeekAvailable, 512 mPlayerFlags & NuPlayer::Source::FLAG_CAN_SEEK); 513 514 return OK; 515} 516 517void NuPlayerDriver::notifyResetComplete() { 518 Mutex::Autolock autoLock(mLock); 519 520 CHECK_EQ(mState, STATE_RESET_IN_PROGRESS); 521 mState = STATE_IDLE; 522 mCondition.broadcast(); 523} 524 525void NuPlayerDriver::notifyDuration(int64_t durationUs) { 526 Mutex::Autolock autoLock(mLock); 527 mDurationUs = durationUs; 528} 529 530void NuPlayerDriver::notifyPosition(int64_t positionUs) { 531 Mutex::Autolock autoLock(mLock); 532 mPositionUs = positionUs; 533 mNotifyTimeRealUs = ALooper::GetNowUs(); 534} 535 536void NuPlayerDriver::notifySeekComplete() { 537 Mutex::Autolock autoLock(mLock); 538 notifySeekComplete_l(); 539} 540 541void NuPlayerDriver::notifySeekComplete_l() { 542 bool wasSeeking = true; 543 if (mState == STATE_STOPPED_AND_PREPARING) { 544 wasSeeking = false; 545 mState = STATE_STOPPED_AND_PREPARED; 546 mCondition.broadcast(); 547 if (!mIsAsyncPrepare) { 548 // if we are preparing synchronously, no need to notify listener 549 return; 550 } 551 } else if (mState == STATE_STOPPED) { 552 // no need to notify listener 553 return; 554 } 555 // note: notifyListener called with lock released 556 mLock.unlock(); 557 notifyListener(wasSeeking ? MEDIA_SEEK_COMPLETE : MEDIA_PREPARED); 558 mLock.lock(); 559} 560 561void NuPlayerDriver::notifyFrameStats( 562 int64_t numFramesTotal, int64_t numFramesDropped) { 563 Mutex::Autolock autoLock(mLock); 564 mNumFramesTotal = numFramesTotal; 565 mNumFramesDropped = numFramesDropped; 566} 567 568status_t NuPlayerDriver::dump( 569 int fd, const Vector<String16> & /* args */) const { 570 Mutex::Autolock autoLock(mLock); 571 572 FILE *out = fdopen(dup(fd), "w"); 573 574 fprintf(out, " NuPlayer\n"); 575 fprintf(out, " numFramesTotal(%" PRId64 "), numFramesDropped(%" PRId64 "), " 576 "percentageDropped(%.2f)\n", 577 mNumFramesTotal, 578 mNumFramesDropped, 579 mNumFramesTotal == 0 580 ? 0.0 : (double)mNumFramesDropped / mNumFramesTotal); 581 582 fclose(out); 583 out = NULL; 584 585 return OK; 586} 587 588void NuPlayerDriver::notifyListener( 589 int msg, int ext1, int ext2, const Parcel *in) { 590 switch (msg) { 591 case MEDIA_PLAYBACK_COMPLETE: 592 { 593 if (mLooping) { 594 mPlayer->seekToAsync(0); 595 break; 596 } 597 // fall through 598 } 599 600 case MEDIA_ERROR: 601 { 602 mAtEOS = true; 603 break; 604 } 605 606 default: 607 break; 608 } 609 610 sendEvent(msg, ext1, ext2, in); 611} 612 613void NuPlayerDriver::notifySetDataSourceCompleted(status_t err) { 614 Mutex::Autolock autoLock(mLock); 615 616 CHECK_EQ(mState, STATE_SET_DATASOURCE_PENDING); 617 618 mAsyncResult = err; 619 mState = (err == OK) ? STATE_UNPREPARED : STATE_IDLE; 620 mCondition.broadcast(); 621} 622 623void NuPlayerDriver::notifyPrepareCompleted(status_t err) { 624 Mutex::Autolock autoLock(mLock); 625 626 if (mState != STATE_PREPARING) { 627 // We were preparing asynchronously when the client called 628 // reset(), we sent a premature "prepared" notification and 629 // then initiated the reset. This notification is stale. 630 CHECK(mState == STATE_RESET_IN_PROGRESS || mState == STATE_IDLE); 631 return; 632 } 633 634 CHECK_EQ(mState, STATE_PREPARING); 635 636 mAsyncResult = err; 637 638 if (err == OK) { 639 if (mIsAsyncPrepare) { 640 notifyListener(MEDIA_PREPARED); 641 } 642 mState = STATE_PREPARED; 643 } else { 644 if (mIsAsyncPrepare) { 645 notifyListener(MEDIA_ERROR, MEDIA_ERROR_UNKNOWN, err); 646 } 647 mState = STATE_UNPREPARED; 648 } 649 650 mCondition.broadcast(); 651} 652 653void NuPlayerDriver::notifyFlagsChanged(uint32_t flags) { 654 Mutex::Autolock autoLock(mLock); 655 656 mPlayerFlags = flags; 657} 658 659} // namespace android 660