MediaPlayer_to_android.cpp revision a6c69c7e1665b38da8d6784e65210acbe501b92c
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#include "sles_allinclusive.h" 18#include "utils/RefBase.h" 19#include "android_prompts.h" 20// LocAVPlayer and StreamPlayer derive from GenericMediaPlayer, 21// so no need to #include "android_GenericMediaPlayer.h" 22#include "android_LocAVPlayer.h" 23#include "android_StreamPlayer.h" 24 25 26//----------------------------------------------------------------------------- 27static void player_handleMediaPlayerEventNotifications(int event, int data1, int data2, void* user) 28{ 29 30 // FIXME This code is derived from similar code in sfplayer_handlePrefetchEvent. The two 31 // versions are quite similar, but still different enough that they need to be separate. 32 // At some point they should be re-factored and merged if feasible. 33 // As with other OpenMAX AL implementation code, this copy mostly uses SL_ symbols 34 // rather than XA_ unless the difference is significant. 35 36 if (NULL == user) { 37 return; 38 } 39 40 CMediaPlayer* mp = (CMediaPlayer*) user; 41 if (!android::CallbackProtector::enterCbIfOk(mp->mCallbackProtector)) { 42 // it is not safe to enter the callback (the media player is about to go away) 43 return; 44 } 45 union { 46 char c[sizeof(int)]; 47 int i; 48 } u; 49 u.i = event; 50 SL_LOGV("player_handleMediaPlayerEventNotifications(event='%c%c%c%c' (%d), data1=%d, data2=%d, " 51 "user=%p) from AVPlayer", u.c[3], u.c[2], u.c[1], u.c[0], event, data1, data2, user); 52 switch(event) { 53 54 case android::GenericPlayer::kEventPrepared: { 55 SL_LOGV("Received GenericPlayer::kEventPrepared for CMediaPlayer %p", mp); 56 57 // assume no callback 58 slPrefetchCallback callback = NULL; 59 void* callbackPContext; 60 XAuint32 events; 61 62 object_lock_exclusive(&mp->mObject); 63 64 // mark object as prepared; same state is used for successful or unsuccessful prepare 65 assert(mp->mAndroidObjState == ANDROID_PREPARING); 66 mp->mAndroidObjState = ANDROID_READY; 67 68 if (PLAYER_SUCCESS == data1) { 69 // Most of successful prepare completion for mp->mAVPlayer 70 // is handled by GenericPlayer and its subclasses. 71 } else { 72 // AVPlayer prepare() failed prefetching, there is no event in XAPrefetchStatus to 73 // indicate a prefetch error, so we signal it by sending simultaneously two events: 74 // - SL_PREFETCHEVENT_FILLLEVELCHANGE with a level of 0 75 // - SL_PREFETCHEVENT_STATUSCHANGE with a status of SL_PREFETCHSTATUS_UNDERFLOW 76 SL_LOGE(ERROR_PLAYER_PREFETCH_d, data1); 77 if (IsInterfaceInitialized(&mp->mObject, MPH_XAPREFETCHSTATUS)) { 78 mp->mPrefetchStatus.mLevel = 0; 79 mp->mPrefetchStatus.mStatus = SL_PREFETCHSTATUS_UNDERFLOW; 80 if (!(~mp->mPrefetchStatus.mCallbackEventsMask & 81 (SL_PREFETCHEVENT_FILLLEVELCHANGE | SL_PREFETCHEVENT_STATUSCHANGE))) { 82 callback = mp->mPrefetchStatus.mCallback; 83 callbackPContext = mp->mPrefetchStatus.mContext; 84 events = SL_PREFETCHEVENT_FILLLEVELCHANGE | SL_PREFETCHEVENT_STATUSCHANGE; 85 } 86 } 87 } 88 89 object_unlock_exclusive(&mp->mObject); 90 91 // callback with no lock held 92 if (NULL != callback) { 93 (*callback)(&mp->mPrefetchStatus.mItf, callbackPContext, events); 94 } 95 96 break; 97 } 98 99 case android::GenericPlayer::kEventHasVideoSize: { 100 SL_LOGV("Received AVPlayer::kEventHasVideoSize (%d,%d) for CMediaPlayer %p", 101 data1, data2, mp); 102 103 object_lock_exclusive(&mp->mObject); 104 105 // remove an existing video info entry (here we only have one video stream) 106 for(size_t i=0 ; i < mp->mStreamInfo.mStreamInfoTable.size() ; i++) { 107 if (XA_DOMAINTYPE_VIDEO == mp->mStreamInfo.mStreamInfoTable.itemAt(i).domain) { 108 mp->mStreamInfo.mStreamInfoTable.removeAt(i); 109 break; 110 } 111 } 112 // update the stream information with a new video info entry 113 StreamInfo streamInfo; 114 streamInfo.domain = XA_DOMAINTYPE_VIDEO; 115 streamInfo.videoInfo.codecId = 0;// unknown, we don't have that info FIXME 116 streamInfo.videoInfo.width = (XAuint32)data1; 117 streamInfo.videoInfo.height = (XAuint32)data2; 118 streamInfo.videoInfo.bitRate = 0;// unknown, we don't have that info FIXME 119 streamInfo.videoInfo.frameRate = 0; 120 streamInfo.videoInfo.duration = XA_TIME_UNKNOWN; 121 StreamInfo &contInfo = mp->mStreamInfo.mStreamInfoTable.editItemAt(0); 122 contInfo.containerInfo.numStreams = 1; 123 ssize_t index = mp->mStreamInfo.mStreamInfoTable.add(streamInfo); 124 125 // callback is unconditional; there is no bitmask of enabled events 126 xaStreamEventChangeCallback callback = mp->mStreamInfo.mCallback; 127 void* callbackPContext = mp->mStreamInfo.mContext; 128 129 object_unlock_exclusive(&mp->mObject); 130 131 // enqueue notification (outside of lock) that the stream information has been updated 132 if ((NULL != callback) && (index >= 0)) { 133#ifndef USE_ASYNCHRONOUS_STREAMCBEVENT_PROPERTYCHANGE_CALLBACK 134 (*callback)(&mp->mStreamInfo.mItf, XA_STREAMCBEVENT_PROPERTYCHANGE /*eventId*/, 135 1 /*streamIndex, only one stream supported here, 0 is reserved*/, 136 NULL /*pEventData, always NULL in OpenMAX AL 1.0.1*/, 137 callbackPContext /*pContext*/); 138#else 139 SLresult res = EnqueueAsyncCallback_piipp(mp, callback, 140 /*p1*/ &mp->mStreamInfo.mItf, 141 /*i1*/ XA_STREAMCBEVENT_PROPERTYCHANGE /*eventId*/, 142 /*i2*/ 1 /*streamIndex, only one stream supported here, 0 is reserved*/, 143 /*p2*/ NULL /*pEventData, always NULL in OpenMAX AL 1.0.1*/, 144 /*p3*/ callbackPContext /*pContext*/); 145 ALOGW_IF(SL_RESULT_SUCCESS != res, 146 "Callback %p(%p, XA_STREAMCBEVENT_PROPERTYCHANGE, 1, NULL, %p) dropped", 147 callback, &mp->mStreamInfo.mItf, callbackPContext); 148#endif 149 } 150 break; 151 } 152 153 case android::GenericPlayer::kEventEndOfStream: { 154 SL_LOGV("Received AVPlayer::kEventEndOfStream for CMediaPlayer %p", mp); 155 156 object_lock_exclusive(&mp->mObject); 157 // should be xaPlayCallback but we're sharing the itf between SL and AL 158 slPlayCallback playCallback = NULL; 159 void * playContext = NULL; 160 // XAPlayItf callback or no callback? 161 if (mp->mPlay.mEventFlags & XA_PLAYEVENT_HEADATEND) { 162 playCallback = mp->mPlay.mCallback; 163 playContext = mp->mPlay.mContext; 164 } 165 mp->mPlay.mState = XA_PLAYSTATE_PAUSED; 166 object_unlock_exclusive(&mp->mObject); 167 168 // enqueue callback with no lock held 169 if (NULL != playCallback) { 170#ifndef USE_ASYNCHRONOUS_PLAY_CALLBACK 171 (*playCallback)(&mp->mPlay.mItf, playContext, XA_PLAYEVENT_HEADATEND); 172#else 173 SLresult res = EnqueueAsyncCallback_ppi(mp, playCallback, &mp->mPlay.mItf, playContext, 174 XA_PLAYEVENT_HEADATEND); 175 ALOGW_IF(SL_RESULT_SUCCESS != res, 176 "Callback %p(%p, %p, SL_PLAYEVENT_HEADATEND) dropped", playCallback, 177 &mp->mPlay.mItf, playContext); 178#endif 179 } 180 break; 181 } 182 183 case android::GenericPlayer::kEventChannelCount: { 184 SL_LOGV("kEventChannelCount channels = %d", data1); 185 object_lock_exclusive(&mp->mObject); 186 if (UNKNOWN_NUMCHANNELS == mp->mNumChannels && UNKNOWN_NUMCHANNELS != data1) { 187 mp->mNumChannels = data1; 188 android_Player_volumeUpdate(mp); 189 } 190 object_unlock_exclusive(&mp->mObject); 191 } 192 break; 193 194 case android::GenericPlayer::kEventPrefetchFillLevelUpdate: { 195 SL_LOGV("kEventPrefetchFillLevelUpdate"); 196 if (!IsInterfaceInitialized(&mp->mObject, MPH_XAPREFETCHSTATUS)) { 197 break; 198 } 199 slPrefetchCallback callback = NULL; 200 void* callbackPContext = NULL; 201 202 // SLPrefetchStatusItf callback or no callback? 203 interface_lock_exclusive(&mp->mPrefetchStatus); 204 if (mp->mPrefetchStatus.mCallbackEventsMask & SL_PREFETCHEVENT_FILLLEVELCHANGE) { 205 callback = mp->mPrefetchStatus.mCallback; 206 callbackPContext = mp->mPrefetchStatus.mContext; 207 } 208 mp->mPrefetchStatus.mLevel = (SLpermille)data1; 209 interface_unlock_exclusive(&mp->mPrefetchStatus); 210 211 // callback with no lock held 212 if (NULL != callback) { 213 (*callback)(&mp->mPrefetchStatus.mItf, callbackPContext, 214 SL_PREFETCHEVENT_FILLLEVELCHANGE); 215 } 216 } 217 break; 218 219 case android::GenericPlayer::kEventPrefetchStatusChange: { 220 SL_LOGV("kEventPrefetchStatusChange"); 221 if (!IsInterfaceInitialized(&mp->mObject, MPH_XAPREFETCHSTATUS)) { 222 break; 223 } 224 slPrefetchCallback callback = NULL; 225 void* callbackPContext = NULL; 226 227 // SLPrefetchStatusItf callback or no callback? 228 object_lock_exclusive(&mp->mObject); 229 if (mp->mPrefetchStatus.mCallbackEventsMask & SL_PREFETCHEVENT_STATUSCHANGE) { 230 callback = mp->mPrefetchStatus.mCallback; 231 callbackPContext = mp->mPrefetchStatus.mContext; 232 } 233 if (data1 >= android::kStatusIntermediate) { 234 mp->mPrefetchStatus.mStatus = SL_PREFETCHSTATUS_SUFFICIENTDATA; 235 } else if (data1 < android::kStatusIntermediate) { 236 mp->mPrefetchStatus.mStatus = SL_PREFETCHSTATUS_UNDERFLOW; 237 } 238 object_unlock_exclusive(&mp->mObject); 239 240 // callback with no lock held 241 if (NULL != callback) { 242 (*callback)(&mp->mPrefetchStatus.mItf, callbackPContext, SL_PREFETCHEVENT_STATUSCHANGE); 243 } 244 } 245 break; 246 247 case android::GenericPlayer::kEventPlay: { 248 SL_LOGV("kEventPlay"); 249 250 interface_lock_shared(&mp->mPlay); 251 slPlayCallback callback = mp->mPlay.mCallback; 252 void* callbackPContext = mp->mPlay.mContext; 253 interface_unlock_shared(&mp->mPlay); 254 255 if (NULL != callback) { 256 (*callback)(&mp->mPlay.mItf, callbackPContext, (SLuint32) data1); // SL_PLAYEVENT_HEAD* 257 } 258 } 259 break; 260 261 case android::GenericPlayer::kEventErrorAfterPrepare: { 262 SL_LOGV("kEventErrorAfterPrepare"); 263 264 // assume no callback 265 slPrefetchCallback callback = NULL; 266 void* callbackPContext = NULL; 267 268 object_lock_exclusive(&mp->mObject); 269 if (IsInterfaceInitialized(&mp->mObject, MPH_XAPREFETCHSTATUS)) { 270 mp->mPrefetchStatus.mLevel = 0; 271 mp->mPrefetchStatus.mStatus = SL_PREFETCHSTATUS_UNDERFLOW; 272 if (!(~mp->mPrefetchStatus.mCallbackEventsMask & 273 (SL_PREFETCHEVENT_FILLLEVELCHANGE | SL_PREFETCHEVENT_STATUSCHANGE))) { 274 callback = mp->mPrefetchStatus.mCallback; 275 callbackPContext = mp->mPrefetchStatus.mContext; 276 } 277 } 278 object_unlock_exclusive(&mp->mObject); 279 280 // FIXME there's interesting information in data1, but no API to convey it to client 281 SL_LOGE("Error after prepare: %d", data1); 282 283 // callback with no lock held 284 if (NULL != callback) { 285 (*callback)(&mp->mPrefetchStatus.mItf, callbackPContext, 286 SL_PREFETCHEVENT_FILLLEVELCHANGE | SL_PREFETCHEVENT_STATUSCHANGE); 287 } 288 289 } 290 break; 291 292 default: { 293 SL_LOGE("Received unknown event %d, data %d from AVPlayer", event, data1); 294 } 295 } 296 297 mp->mCallbackProtector->exitCb(); 298} 299 300 301//----------------------------------------------------------------------------- 302XAresult android_Player_checkSourceSink(CMediaPlayer *mp) { 303 304 XAresult result = XA_RESULT_SUCCESS; 305 306 const SLDataSource *pSrc = &mp->mDataSource.u.mSource; 307 const SLDataSink *pAudioSnk = &mp->mAudioSink.u.mSink; 308 309 // format check: 310 const SLuint32 sourceLocatorType = *(SLuint32 *)pSrc->pLocator; 311 const SLuint32 sourceFormatType = *(SLuint32 *)pSrc->pFormat; 312 const SLuint32 audioSinkLocatorType = *(SLuint32 *)pAudioSnk->pLocator; 313 //const SLuint32 sinkFormatType = *(SLuint32 *)pAudioSnk->pFormat; 314 315 // Source check 316 switch(sourceLocatorType) { 317 318 case XA_DATALOCATOR_ANDROIDBUFFERQUEUE: { 319 switch (sourceFormatType) { 320 case XA_DATAFORMAT_MIME: { 321 SLDataFormat_MIME *df_mime = (SLDataFormat_MIME *) pSrc->pFormat; 322 if (SL_CONTAINERTYPE_MPEG_TS != df_mime->containerType) { 323 SL_LOGE("Cannot create player with XA_DATALOCATOR_ANDROIDBUFFERQUEUE data source " 324 "that is not fed MPEG-2 TS data"); 325 return SL_RESULT_CONTENT_UNSUPPORTED; 326 } 327 } break; 328 default: 329 SL_LOGE("Cannot create player with XA_DATALOCATOR_ANDROIDBUFFERQUEUE data source " 330 "without SL_DATAFORMAT_MIME format"); 331 return XA_RESULT_CONTENT_UNSUPPORTED; 332 } 333 } break; 334 335 case XA_DATALOCATOR_URI: // intended fall-through 336 case XA_DATALOCATOR_ANDROIDFD: 337 break; 338 339 default: 340 SL_LOGE("Cannot create media player with data locator type 0x%x", 341 (unsigned) sourceLocatorType); 342 return SL_RESULT_PARAMETER_INVALID; 343 }// switch (locatorType) 344 345 // Audio sink check: only playback is supported here 346 switch(audioSinkLocatorType) { 347 348 case XA_DATALOCATOR_OUTPUTMIX: 349 break; 350 351 default: 352 SL_LOGE("Cannot create media player with audio sink data locator of type 0x%x", 353 (unsigned) audioSinkLocatorType); 354 return XA_RESULT_PARAMETER_INVALID; 355 }// switch (locaaudioSinkLocatorTypeorType) 356 357 return result; 358} 359 360 361//----------------------------------------------------------------------------- 362XAresult android_Player_create(CMediaPlayer *mp) { 363 364 XAresult result = XA_RESULT_SUCCESS; 365 366 // FIXME verify data source 367 const SLDataSource *pDataSrc = &mp->mDataSource.u.mSource; 368 // FIXME verify audio data sink 369 const SLDataSink *pAudioSnk = &mp->mAudioSink.u.mSink; 370 // FIXME verify image data sink 371 const SLDataSink *pVideoSnk = &mp->mImageVideoSink.u.mSink; 372 373 XAuint32 sourceLocator = *(XAuint32 *)pDataSrc->pLocator; 374 switch(sourceLocator) { 375 // FIXME support Android simple buffer queue as well 376 case XA_DATALOCATOR_ANDROIDBUFFERQUEUE: 377 mp->mAndroidObjType = AUDIOVIDEOPLAYER_FROM_TS_ANDROIDBUFFERQUEUE; 378 break; 379 case XA_DATALOCATOR_URI: // intended fall-through 380 case SL_DATALOCATOR_ANDROIDFD: 381 mp->mAndroidObjType = AUDIOVIDEOPLAYER_FROM_URIFD; 382 break; 383 case XA_DATALOCATOR_ADDRESS: // intended fall-through 384 default: 385 mp->mAndroidObjType = INVALID_TYPE; 386 SL_LOGE("Unable to create MediaPlayer for data source locator 0x%x", sourceLocator); 387 result = XA_RESULT_PARAMETER_INVALID; 388 break; 389 } 390 391 // FIXME duplicates an initialization also done by higher level 392 mp->mAndroidObjState = ANDROID_UNINITIALIZED; 393 mp->mStreamType = ANDROID_DEFAULT_OUTPUT_STREAM_TYPE; 394 mp->mSessionId = android::AudioSystem::newAudioSessionId(); 395 396 // placeholder: not necessary yet as session ID lifetime doesn't extend beyond player 397 // android::AudioSystem::acquireAudioSessionId(mp->mSessionId); 398 399 mp->mCallbackProtector = new android::CallbackProtector(); 400 401 return result; 402} 403 404 405//----------------------------------------------------------------------------- 406// FIXME abstract out the diff between CMediaPlayer and CAudioPlayer 407XAresult android_Player_realize(CMediaPlayer *mp, SLboolean async) { 408 SL_LOGV("android_Player_realize_l(%p)", mp); 409 XAresult result = XA_RESULT_SUCCESS; 410 411 const SLDataSource *pDataSrc = &mp->mDataSource.u.mSource; 412 const SLuint32 sourceLocator = *(SLuint32 *)pDataSrc->pLocator; 413 414 AudioPlayback_Parameters ap_params; 415 ap_params.sessionId = mp->mSessionId; 416 ap_params.streamType = mp->mStreamType; 417 418 switch(mp->mAndroidObjType) { 419 case AUDIOVIDEOPLAYER_FROM_TS_ANDROIDBUFFERQUEUE: { 420 mp->mAVPlayer = new android::StreamPlayer(&ap_params, true /*hasVideo*/, 421 &mp->mAndroidBufferQueue, mp->mCallbackProtector); 422 mp->mAVPlayer->init(player_handleMediaPlayerEventNotifications, (void*)mp); 423 } 424 break; 425 case AUDIOVIDEOPLAYER_FROM_URIFD: { 426 mp->mAVPlayer = new android::LocAVPlayer(&ap_params, true /*hasVideo*/); 427 mp->mAVPlayer->init(player_handleMediaPlayerEventNotifications, (void*)mp); 428 switch (mp->mDataSource.mLocator.mLocatorType) { 429 case XA_DATALOCATOR_URI: 430 ((android::LocAVPlayer*)mp->mAVPlayer.get())->setDataSource( 431 (const char*)mp->mDataSource.mLocator.mURI.URI); 432 break; 433 case XA_DATALOCATOR_ANDROIDFD: { 434 int64_t offset = (int64_t)mp->mDataSource.mLocator.mFD.offset; 435 ((android::LocAVPlayer*)mp->mAVPlayer.get())->setDataSource( 436 (int)mp->mDataSource.mLocator.mFD.fd, 437 offset == SL_DATALOCATOR_ANDROIDFD_USE_FILE_SIZE ? 438 (int64_t)PLAYER_FD_FIND_FILE_SIZE : offset, 439 (int64_t)mp->mDataSource.mLocator.mFD.length); 440 } 441 break; 442 default: 443 SL_LOGE("Invalid or unsupported data locator type %u for data source", 444 mp->mDataSource.mLocator.mLocatorType); 445 result = XA_RESULT_PARAMETER_INVALID; 446 } 447 } 448 break; 449 case INVALID_TYPE: // intended fall-through 450 default: 451 SL_LOGE("Unable to realize MediaPlayer, invalid internal Android object type"); 452 result = XA_RESULT_PARAMETER_INVALID; 453 break; 454 } 455 456 if (XA_RESULT_SUCCESS == result) { 457 458 // if there is a video sink 459 if (XA_DATALOCATOR_NATIVEDISPLAY == 460 mp->mImageVideoSink.mLocator.mLocatorType) { 461 ANativeWindow *nativeWindow = (ANativeWindow *) 462 mp->mImageVideoSink.mLocator.mNativeDisplay.hWindow; 463 // we already verified earlier that hWindow is non-NULL 464 assert(nativeWindow != NULL); 465 result = android_Player_setNativeWindow(mp, nativeWindow); 466 } 467 468 } 469 470 return result; 471} 472 473// Called with a lock on MediaPlayer, and blocks until safe to destroy 474XAresult android_Player_preDestroy(CMediaPlayer *mp) { 475 SL_LOGV("android_Player_preDestroy(%p)", mp); 476 477 // Not yet clear why this order is important, but it reduces detected deadlocks 478 object_unlock_exclusive(&mp->mObject); 479 if (mp->mCallbackProtector != 0) { 480 mp->mCallbackProtector->requestCbExitAndWait(); 481 } 482 object_lock_exclusive(&mp->mObject); 483 484 if (mp->mAVPlayer != 0) { 485 mp->mAVPlayer->preDestroy(); 486 } 487 SL_LOGV("android_Player_preDestroy(%p) after mAVPlayer->preDestroy()", mp); 488 489 return XA_RESULT_SUCCESS; 490} 491 492//----------------------------------------------------------------------------- 493XAresult android_Player_destroy(CMediaPlayer *mp) { 494 SL_LOGV("android_Player_destroy(%p)", mp); 495 496 mp->mAVPlayer.clear(); 497 498 // placeholder: not necessary yet as session ID lifetime doesn't extend beyond player 499 // android::AudioSystem::releaseAudioSessionId(mp->mSessionId); 500 501 mp->mCallbackProtector.clear(); 502 503 // explicit destructor 504 mp->mAVPlayer.~sp(); 505 mp->mCallbackProtector.~sp(); 506 507 return XA_RESULT_SUCCESS; 508} 509 510 511void android_Player_usePlayEventMask(CMediaPlayer *mp) { 512 if (mp->mAVPlayer != 0) { 513 IPlay *pPlayItf = &mp->mPlay; 514 mp->mAVPlayer->setPlayEvents((int32_t) pPlayItf->mEventFlags, 515 (int32_t) pPlayItf->mMarkerPosition, (int32_t) pPlayItf->mPositionUpdatePeriod); 516 } 517} 518 519 520XAresult android_Player_getDuration(IPlay *pPlayItf, XAmillisecond *pDurMsec) { 521 CMediaPlayer *avp = (CMediaPlayer *)pPlayItf->mThis; 522 523 switch (avp->mAndroidObjType) { 524 525 case AUDIOVIDEOPLAYER_FROM_URIFD: { 526 int dur = ANDROID_UNKNOWN_TIME; 527 if (avp->mAVPlayer != 0) { 528 avp->mAVPlayer->getDurationMsec(&dur); 529 } 530 if (dur == ANDROID_UNKNOWN_TIME) { 531 *pDurMsec = XA_TIME_UNKNOWN; 532 } else { 533 *pDurMsec = (XAmillisecond)dur; 534 } 535 } break; 536 537 case AUDIOVIDEOPLAYER_FROM_TS_ANDROIDBUFFERQUEUE: // intended fall-through 538 default: 539 *pDurMsec = XA_TIME_UNKNOWN; 540 break; 541 } 542 543 return XA_RESULT_SUCCESS; 544} 545 546 547XAresult android_Player_getPosition(IPlay *pPlayItf, XAmillisecond *pPosMsec) { 548 SL_LOGD("android_Player_getPosition()"); 549 XAresult result = XA_RESULT_SUCCESS; 550 CMediaPlayer *avp = (CMediaPlayer *)pPlayItf->mThis; 551 552 switch (avp->mAndroidObjType) { 553 554 case AUDIOVIDEOPLAYER_FROM_TS_ANDROIDBUFFERQUEUE: // intended fall-through 555 case AUDIOVIDEOPLAYER_FROM_URIFD: { 556 int pos = ANDROID_UNKNOWN_TIME; 557 if (avp->mAVPlayer != 0) { 558 avp->mAVPlayer->getPositionMsec(&pos); 559 } 560 if (pos == ANDROID_UNKNOWN_TIME) { 561 *pPosMsec = 0; 562 } else { 563 *pPosMsec = (XAmillisecond)pos; 564 } 565 } break; 566 567 default: 568 // we shouldn't be here 569 assert(false); 570 break; 571 } 572 573 return result; 574} 575 576 577//----------------------------------------------------------------------------- 578/** 579 * pre-condition: mp != NULL 580 */ 581void android_Player_volumeUpdate(CMediaPlayer* mp) 582{ 583 android::GenericPlayer* avp = mp->mAVPlayer.get(); 584 if (avp != NULL) { 585 float volumes[2]; 586 // MediaPlayer does not currently support EffectSend or MuteSolo 587 android_player_volumeUpdate(volumes, &mp->mVolume, mp->mNumChannels, 1.0f, NULL); 588 float leftVol = volumes[0], rightVol = volumes[1]; 589 avp->setVolume(leftVol, rightVol); 590 } 591} 592 593//----------------------------------------------------------------------------- 594/** 595 * pre-condition: gp != 0 596 */ 597XAresult android_Player_setPlayState(const android::sp<android::GenericPlayer> &gp, 598 SLuint32 playState, 599 AndroidObjectState* pObjState) 600{ 601 XAresult result = XA_RESULT_SUCCESS; 602 AndroidObjectState objState = *pObjState; 603 604 switch (playState) { 605 case SL_PLAYSTATE_STOPPED: { 606 SL_LOGV("setting AVPlayer to SL_PLAYSTATE_STOPPED"); 607 gp->stop(); 608 } 609 break; 610 case SL_PLAYSTATE_PAUSED: { 611 SL_LOGV("setting AVPlayer to SL_PLAYSTATE_PAUSED"); 612 switch(objState) { 613 case ANDROID_UNINITIALIZED: 614 *pObjState = ANDROID_PREPARING; 615 gp->prepare(); 616 break; 617 case ANDROID_PREPARING: 618 break; 619 case ANDROID_READY: 620 gp->pause(); 621 break; 622 default: 623 SL_LOGE("Android object in invalid state"); 624 break; 625 } 626 } 627 break; 628 case SL_PLAYSTATE_PLAYING: { 629 SL_LOGV("setting AVPlayer to SL_PLAYSTATE_PLAYING"); 630 switch(objState) { 631 case ANDROID_UNINITIALIZED: 632 *pObjState = ANDROID_PREPARING; 633 gp->prepare(); 634 // intended fall through 635 case ANDROID_PREPARING: 636 // intended fall through 637 case ANDROID_READY: 638 gp->play(); 639 break; 640 default: 641 SL_LOGE("Android object in invalid state"); 642 break; 643 } 644 } 645 break; 646 default: 647 // checked by caller, should not happen 648 break; 649 } 650 651 return result; 652} 653 654 655/** 656 * pre-condition: mp != NULL 657 */ 658XAresult android_Player_seek(CMediaPlayer *mp, SLmillisecond posMsec) { 659 XAresult result = XA_RESULT_SUCCESS; 660 switch (mp->mAndroidObjType) { 661 case AUDIOVIDEOPLAYER_FROM_URIFD: 662 if (mp->mAVPlayer !=0) { 663 mp->mAVPlayer->seek(posMsec); 664 } 665 break; 666 case AUDIOVIDEOPLAYER_FROM_TS_ANDROIDBUFFERQUEUE: // intended fall-through 667 default: { 668 result = XA_RESULT_FEATURE_UNSUPPORTED; 669 } 670 } 671 return result; 672} 673 674 675/** 676 * pre-condition: mp != NULL 677 */ 678XAresult android_Player_loop(CMediaPlayer *mp, SLboolean loopEnable) { 679 XAresult result = XA_RESULT_SUCCESS; 680 switch (mp->mAndroidObjType) { 681 case AUDIOVIDEOPLAYER_FROM_URIFD: 682 if (mp->mAVPlayer !=0) { 683 mp->mAVPlayer->loop(loopEnable); 684 } 685 break; 686 case AUDIOVIDEOPLAYER_FROM_TS_ANDROIDBUFFERQUEUE: // intended fall-through 687 default: { 688 result = XA_RESULT_FEATURE_UNSUPPORTED; 689 } 690 } 691 return result; 692} 693 694 695//----------------------------------------------------------------------------- 696void android_Player_androidBufferQueue_clear_l(CMediaPlayer *mp) { 697 if ((mp->mAndroidObjType == AUDIOVIDEOPLAYER_FROM_TS_ANDROIDBUFFERQUEUE) 698 && (mp->mAVPlayer != 0)) { 699 android::StreamPlayer* splr = static_cast<android::StreamPlayer*>(mp->mAVPlayer.get()); 700 splr->appClear_l(); 701 } 702} 703 704 705void android_Player_androidBufferQueue_onRefilled_l(CMediaPlayer *mp) { 706 if ((mp->mAndroidObjType == AUDIOVIDEOPLAYER_FROM_TS_ANDROIDBUFFERQUEUE) 707 && (mp->mAVPlayer != 0)) { 708 android::StreamPlayer* splr = static_cast<android::StreamPlayer*>(mp->mAVPlayer.get()); 709 splr->queueRefilled(); 710 } 711} 712 713 714/* 715 * pre-conditions: 716 * mp != NULL 717 * mp->mAVPlayer != 0 (player is realized) 718 * nativeWindow can be NULL, but if NULL it is treated as an error 719 */ 720SLresult android_Player_setNativeWindow(CMediaPlayer *mp, ANativeWindow *nativeWindow) 721{ 722 assert(mp != NULL); 723 assert(mp->mAVPlayer != 0); 724 if (nativeWindow == NULL) { 725 SL_LOGE("ANativeWindow is NULL"); 726 return SL_RESULT_PARAMETER_INVALID; 727 } 728 SLresult result; 729 int err; 730 int value; 731 // this could crash if app passes in a bad parameter, but that's OK 732 err = (*nativeWindow->query)(nativeWindow, NATIVE_WINDOW_CONCRETE_TYPE, &value); 733 if (0 != err) { 734 SL_LOGE("Query NATIVE_WINDOW_CONCRETE_TYPE on ANativeWindow * %p failed; " 735 "errno %d", nativeWindow, err); 736 result = SL_RESULT_PARAMETER_INVALID; 737 } else { 738 switch (value) { 739 case NATIVE_WINDOW_SURFACE: { // Surface 740 SL_LOGV("Displaying on ANativeWindow of type NATIVE_WINDOW_SURFACE"); 741 android::sp<android::Surface> nativeSurface( 742 static_cast<android::Surface *>(nativeWindow)); 743 mp->mAVPlayer->setVideoSurfaceTexture( 744 nativeSurface->getSurfaceTexture()); 745 result = SL_RESULT_SUCCESS; 746 } break; 747 case NATIVE_WINDOW_SURFACE_TEXTURE_CLIENT: { // SurfaceTextureClient 748 SL_LOGV("Displaying on ANativeWindow of type NATIVE_WINDOW_SURFACE_TEXTURE_CLIENT"); 749 android::sp<android::SurfaceTextureClient> surfaceTextureClient( 750 static_cast<android::SurfaceTextureClient *>(nativeWindow)); 751 android::sp<android::ISurfaceTexture> nativeSurfaceTexture( 752 surfaceTextureClient->getISurfaceTexture()); 753 mp->mAVPlayer->setVideoSurfaceTexture(nativeSurfaceTexture); 754 result = SL_RESULT_SUCCESS; 755 } break; 756 case NATIVE_WINDOW_FRAMEBUFFER: // FramebufferNativeWindow 757 // fall through 758 default: 759 SL_LOGE("ANativeWindow * %p has unknown or unsupported concrete type %d", 760 nativeWindow, value); 761 result = SL_RESULT_PARAMETER_INVALID; 762 break; 763 } 764 } 765 return result; 766} 767