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