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