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