1 /* 2 * Copyright (C) 2011 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 USE_LOG SLAndroidLogLevel_Verbose 18 19 #include "sles_allinclusive.h" 20 21 #include <media/stagefright/foundation/ADebug.h> 22 #include <sys/stat.h> 23 24 namespace android { 25 26 //-------------------------------------------------------------------------------------------------- 27 GenericPlayer::GenericPlayer(const AudioPlayback_Parameters* params) : 28 mDataLocatorType(kDataLocatorNone), 29 mNotifyClient(NULL), 30 mNotifyUser(NULL), 31 mStateFlags(0), 32 mPlaybackParams(*params), 33 mDurationMsec(ANDROID_UNKNOWN_TIME), 34 mCacheStatus(kStatusEmpty), 35 mCacheFill(0), 36 mLastNotifiedCacheFill(0), 37 mCacheFillNotifThreshold(100), 38 mEventFlags(0), 39 mMarkerPositionMs(ANDROID_UNKNOWN_TIME), 40 mPositionUpdatePeriodMs(1000), // per spec 41 mOneShotGeneration(0), 42 mDeliveredNewPosMs(ANDROID_UNKNOWN_TIME), 43 mObservedPositionMs(ANDROID_UNKNOWN_TIME) 44 { 45 SL_LOGD("GenericPlayer::GenericPlayer()"); 46 47 mLooper = new android::ALooper(); 48 49 mAndroidAudioLevels.mFinalVolume[0] = 1.0f; 50 mAndroidAudioLevels.mFinalVolume[1] = 1.0f; 51 } 52 53 54 GenericPlayer::~GenericPlayer() { 55 SL_LOGV("GenericPlayer::~GenericPlayer()"); 56 57 resetDataLocator(); 58 } 59 60 61 void GenericPlayer::init(const notif_cbf_t cbf, void* notifUser) { 62 SL_LOGD("GenericPlayer::init()"); 63 64 { 65 android::Mutex::Autolock autoLock(mNotifyClientLock); 66 mNotifyClient = cbf; 67 mNotifyUser = notifUser; 68 } 69 70 mLooper->registerHandler(this); 71 mLooper->start(false /*runOnCallingThread*/, false /*canCallJava*/, PRIORITY_DEFAULT); 72 } 73 74 75 void GenericPlayer::preDestroy() { 76 SL_LOGD("GenericPlayer::preDestroy()"); 77 { 78 android::Mutex::Autolock autoLock(mNotifyClientLock); 79 mNotifyClient = NULL; 80 mNotifyUser = NULL; 81 } 82 83 mLooper->stop(); 84 mLooper->unregisterHandler(id()); 85 } 86 87 88 void GenericPlayer::setDataSource(const char *uri) { 89 SL_LOGV("GenericPlayer::setDataSource(uri=%s)", uri); 90 resetDataLocator(); 91 92 mDataLocator.uriRef = uri; 93 94 mDataLocatorType = kDataLocatorUri; 95 } 96 97 98 void GenericPlayer::setDataSource(int fd, int64_t offset, int64_t length, bool closeAfterUse) { 99 SL_LOGV("GenericPlayer::setDataSource(fd=%d, offset=%lld, length=%lld, closeAfterUse=%s)", fd, 100 offset, length, closeAfterUse ? "true" : "false"); 101 resetDataLocator(); 102 103 mDataLocator.fdi.fd = fd; 104 105 struct stat sb; 106 int ret = fstat(fd, &sb); 107 if (ret != 0) { 108 SL_LOGE("GenericPlayer::setDataSource: fstat(%d) failed: %d, %s", fd, ret, strerror(errno)); 109 return; 110 } 111 112 if (offset >= sb.st_size) { 113 SL_LOGE("SfPlayer::setDataSource: invalid offset"); 114 return; 115 } 116 mDataLocator.fdi.offset = offset; 117 118 if (PLAYER_FD_FIND_FILE_SIZE == length) { 119 mDataLocator.fdi.length = sb.st_size; 120 } else if (offset + length > sb.st_size) { 121 mDataLocator.fdi.length = sb.st_size - offset; 122 } else { 123 mDataLocator.fdi.length = length; 124 } 125 126 mDataLocator.fdi.mCloseAfterUse = closeAfterUse; 127 128 mDataLocatorType = kDataLocatorFd; 129 } 130 131 132 void GenericPlayer::prepare() { 133 SL_LOGD("GenericPlayer::prepare()"); 134 // do not attempt prepare more than once 135 if (!(mStateFlags & (kFlagPrepared | kFlagPreparedUnsuccessfully))) { 136 sp<AMessage> msg = new AMessage(kWhatPrepare, id()); 137 msg->post(); 138 } 139 } 140 141 142 void GenericPlayer::play() { 143 SL_LOGD("GenericPlayer::play()"); 144 sp<AMessage> msg = new AMessage(kWhatPlay, id()); 145 msg->post(); 146 } 147 148 149 void GenericPlayer::pause() { 150 SL_LOGD("GenericPlayer::pause()"); 151 sp<AMessage> msg = new AMessage(kWhatPause, id()); 152 msg->post(); 153 } 154 155 156 void GenericPlayer::stop() { 157 SL_LOGD("GenericPlayer::stop()"); 158 (new AMessage(kWhatPause, id()))->post(); 159 160 // after a stop, playback should resume from the start. 161 seek(0); 162 } 163 164 165 void GenericPlayer::seek(int64_t timeMsec) { 166 SL_LOGV("GenericPlayer::seek %lld", timeMsec); 167 if (timeMsec < 0 && timeMsec != ANDROID_UNKNOWN_TIME) { 168 SL_LOGE("GenericPlayer::seek error, can't seek to negative time %lldms", timeMsec); 169 return; 170 } 171 sp<AMessage> msg = new AMessage(kWhatSeek, id()); 172 msg->setInt64(WHATPARAM_SEEK_SEEKTIME_MS, timeMsec); 173 msg->post(); 174 } 175 176 177 void GenericPlayer::loop(bool loop) { 178 SL_LOGV("GenericPlayer::loop %s", loop ? "true" : "false"); 179 sp<AMessage> msg = new AMessage(kWhatLoop, id()); 180 msg->setInt32(WHATPARAM_LOOP_LOOPING, (int32_t)loop); 181 msg->post(); 182 } 183 184 185 void GenericPlayer::setBufferingUpdateThreshold(int16_t thresholdPercent) { 186 SL_LOGV("GenericPlayer::setBufferingUpdateThreshold %d", thresholdPercent); 187 sp<AMessage> msg = new AMessage(kWhatBuffUpdateThres, id()); 188 msg->setInt32(WHATPARAM_BUFFERING_UPDATETHRESHOLD_PERCENT, (int32_t)thresholdPercent); 189 msg->post(); 190 } 191 192 193 //-------------------------------------------------- 194 void GenericPlayer::getDurationMsec(int* msec) { 195 Mutex::Autolock _l(mSettingsLock); 196 *msec = mDurationMsec; 197 } 198 199 //-------------------------------------------------- 200 void GenericPlayer::setVolume(float leftVol, float rightVol) 201 { 202 { 203 Mutex::Autolock _l(mSettingsLock); 204 mAndroidAudioLevels.mFinalVolume[0] = leftVol; 205 mAndroidAudioLevels.mFinalVolume[1] = rightVol; 206 } 207 // send a message for the volume to be updated by the object which implements the volume 208 (new AMessage(kWhatVolumeUpdate, id()))->post(); 209 } 210 211 212 //-------------------------------------------------- 213 void GenericPlayer::attachAuxEffect(int32_t effectId) 214 { 215 SL_LOGV("GenericPlayer::attachAuxEffect(id=%d)", effectId); 216 sp<AMessage> msg = new AMessage(kWhatAttachAuxEffect, id()); 217 msg->setInt32(WHATPARAM_ATTACHAUXEFFECT, effectId); 218 msg->post(); 219 } 220 221 222 //-------------------------------------------------- 223 void GenericPlayer::setAuxEffectSendLevel(float level) 224 { 225 SL_LOGV("GenericPlayer::setAuxEffectSendLevel(level=%g)", level); 226 sp<AMessage> msg = new AMessage(kWhatSetAuxEffectSendLevel, id()); 227 msg->setFloat(WHATPARAM_SETAUXEFFECTSENDLEVEL, level); 228 msg->post(); 229 } 230 231 232 //-------------------------------------------------- 233 // Call after changing any of the IPlay settings related to SL_PLAYEVENT_* 234 void GenericPlayer::setPlayEvents(int32_t eventFlags, int32_t markerPositionMs, 235 int32_t positionUpdatePeriodMs) 236 { 237 // Normalize ms that are within the valid unsigned range, but not in the int32_t range 238 if (markerPositionMs < 0) { 239 markerPositionMs = ANDROID_UNKNOWN_TIME; 240 } 241 if (positionUpdatePeriodMs < 0) { 242 positionUpdatePeriodMs = ANDROID_UNKNOWN_TIME; 243 } 244 // markers are delivered accurately, but new position updates are limited to every 100 ms 245 if (positionUpdatePeriodMs < 100) { 246 positionUpdatePeriodMs = 100; 247 } 248 sp<AMessage> msg = new AMessage(kWhatSetPlayEvents, id()); 249 msg->setInt32(WHATPARAM_SETPLAYEVENTS_FLAGS, eventFlags); 250 msg->setInt32(WHATPARAM_SETPLAYEVENTS_MARKER, markerPositionMs); 251 msg->setInt32(WHATPARAM_SETPLAYEVENTS_UPDATE, positionUpdatePeriodMs); 252 msg->post(); 253 } 254 255 256 //-------------------------------------------------- 257 /* 258 * post-condition: mDataLocatorType == kDataLocatorNone 259 * 260 */ 261 void GenericPlayer::resetDataLocator() { 262 SL_LOGV("GenericPlayer::resetDataLocator()"); 263 if (mDataLocatorType == kDataLocatorFd && mDataLocator.fdi.mCloseAfterUse) { 264 (void) ::close(mDataLocator.fdi.fd); 265 // would be redundant, as we're about to invalidate the union mDataLocator 266 //mDataLocator.fdi.fd = -1; 267 //mDataLocator.fdi.mCloseAfterUse = false; 268 } 269 mDataLocatorType = kDataLocatorNone; 270 } 271 272 273 void GenericPlayer::notify(const char* event, int data, bool async) { 274 SL_LOGV("GenericPlayer::notify(event=%s, data=%d, async=%s)", event, data, 275 async ? "true" : "false"); 276 sp<AMessage> msg = new AMessage(kWhatNotif, id()); 277 msg->setInt32(event, (int32_t)data); 278 if (async) { 279 msg->post(); 280 } else { 281 this->onNotify(msg); 282 } 283 } 284 285 286 void GenericPlayer::notify(const char* event, int data1, int data2, bool async) { 287 SL_LOGV("GenericPlayer::notify(event=%s, data1=%d, data2=%d, async=%s)", event, data1, data2, 288 async ? "true" : "false"); 289 sp<AMessage> msg = new AMessage(kWhatNotif, id()); 290 msg->setRect(event, 0, 0, (int32_t)data1, (int32_t)data2); 291 if (async) { 292 msg->post(); 293 } else { 294 this->onNotify(msg); 295 } 296 } 297 298 299 //-------------------------------------------------- 300 // AHandler implementation 301 void GenericPlayer::onMessageReceived(const sp<AMessage> &msg) { 302 SL_LOGV("GenericPlayer::onMessageReceived()"); 303 switch (msg->what()) { 304 case kWhatPrepare: 305 SL_LOGV("kWhatPrepare"); 306 onPrepare(); 307 break; 308 309 case kWhatNotif: 310 SL_LOGV("kWhatNotif"); 311 onNotify(msg); 312 break; 313 314 case kWhatPlay: 315 SL_LOGV("kWhatPlay"); 316 onPlay(); 317 break; 318 319 case kWhatPause: 320 SL_LOGV("kWhatPause"); 321 onPause(); 322 break; 323 324 case kWhatSeek: 325 SL_LOGV("kWhatSeek"); 326 onSeek(msg); 327 break; 328 329 case kWhatLoop: 330 SL_LOGV("kWhatLoop"); 331 onLoop(msg); 332 break; 333 334 case kWhatVolumeUpdate: 335 SL_LOGV("kWhatVolumeUpdate"); 336 onVolumeUpdate(); 337 break; 338 339 case kWhatSeekComplete: 340 SL_LOGV("kWhatSeekComplete"); 341 onSeekComplete(); 342 break; 343 344 case kWhatBufferingUpdate: 345 SL_LOGV("kWhatBufferingUpdate"); 346 onBufferingUpdate(msg); 347 break; 348 349 case kWhatBuffUpdateThres: 350 SL_LOGV("kWhatBuffUpdateThres"); 351 onSetBufferingUpdateThreshold(msg); 352 break; 353 354 case kWhatAttachAuxEffect: 355 SL_LOGV("kWhatAttachAuxEffect"); 356 onAttachAuxEffect(msg); 357 break; 358 359 case kWhatSetAuxEffectSendLevel: 360 SL_LOGV("kWhatSetAuxEffectSendLevel"); 361 onSetAuxEffectSendLevel(msg); 362 break; 363 364 case kWhatSetPlayEvents: 365 SL_LOGV("kWhatSetPlayEvents"); 366 onSetPlayEvents(msg); 367 break; 368 369 case kWhatOneShot: 370 SL_LOGV("kWhatOneShot"); 371 onOneShot(msg); 372 break; 373 374 default: 375 SL_LOGE("GenericPlayer::onMessageReceived unknown message %d", msg->what()); 376 TRESPASS(); 377 } 378 } 379 380 381 //-------------------------------------------------- 382 // Event handlers 383 // it is strictly verboten to call those methods outside of the event loop 384 385 void GenericPlayer::onPrepare() { 386 SL_LOGV("GenericPlayer::onPrepare()"); 387 // Subclass is responsible for indicating whether prepare was successful or unsuccessful 388 // by updating mStateFlags accordingly. It must set exactly one of these two flags. 389 assert(!(mStateFlags & kFlagPrepared) != !(mStateFlags & kFlagPreparedUnsuccessfully)); 390 notify(PLAYEREVENT_PREPARED, mStateFlags & kFlagPrepared ? PLAYER_SUCCESS : PLAYER_FAILURE, 391 true /*async*/); 392 SL_LOGD("GenericPlayer::onPrepare() done, mStateFlags=0x%x", mStateFlags); 393 } 394 395 396 void GenericPlayer::onNotify(const sp<AMessage> &msg) { 397 SL_LOGV("GenericPlayer::onNotify()"); 398 notif_cbf_t notifClient; 399 void* notifUser; 400 { 401 android::Mutex::Autolock autoLock(mNotifyClientLock); 402 if (NULL == mNotifyClient) { 403 return; 404 } else { 405 notifClient = mNotifyClient; 406 notifUser = mNotifyUser; 407 } 408 } 409 410 int32_t val1, val2; 411 if (msg->findInt32(PLAYEREVENT_PREFETCHSTATUSCHANGE, &val1)) { 412 SL_LOGV("GenericPlayer notifying %s = %d", PLAYEREVENT_PREFETCHSTATUSCHANGE, val1); 413 notifClient(kEventPrefetchStatusChange, val1, 0, notifUser); 414 } else if (msg->findInt32(PLAYEREVENT_PREFETCHFILLLEVELUPDATE, &val1)) { 415 SL_LOGV("GenericPlayer notifying %s = %d", PLAYEREVENT_PREFETCHFILLLEVELUPDATE, val1); 416 notifClient(kEventPrefetchFillLevelUpdate, val1, 0, notifUser); 417 } else if (msg->findInt32(PLAYEREVENT_ENDOFSTREAM, &val1)) { 418 SL_LOGV("GenericPlayer notifying %s = %d", PLAYEREVENT_ENDOFSTREAM, val1); 419 notifClient(kEventEndOfStream, val1, 0, notifUser); 420 } else if (msg->findInt32(PLAYEREVENT_PREPARED, &val1)) { 421 SL_LOGV("GenericPlayer notifying %s = %d", PLAYEREVENT_PREPARED, val1); 422 notifClient(kEventPrepared, val1, 0, notifUser); 423 } else if (msg->findInt32(PLAYEREVENT_CHANNEL_COUNT, &val1)) { 424 SL_LOGV("GenericPlayer notifying %s = %d", PLAYEREVENT_CHANNEL_COUNT, val1); 425 notifClient(kEventChannelCount, val1, 0, notifUser); 426 } else if (msg->findRect(PLAYEREVENT_VIDEO_SIZE_UPDATE, &val1, &val2, &val1, &val2)) { 427 SL_LOGV("GenericPlayer notifying %s = %d, %d", PLAYEREVENT_VIDEO_SIZE_UPDATE, val1, val2); 428 notifClient(kEventHasVideoSize, val1, val2, notifUser); 429 } else if (msg->findInt32(PLAYEREVENT_PLAY, &val1)) { 430 SL_LOGV("GenericPlayer notifying %s = %d", PLAYEREVENT_PLAY, val1); 431 notifClient(kEventPlay, val1, 0, notifUser); 432 } else if (msg->findInt32(PLAYEREVENT_ERRORAFTERPREPARE, &val1)) { 433 SL_LOGV("GenericPlayer notifying %s = %d", PLAYEREVENT_ERRORAFTERPREPARE, val1); 434 notifClient(kEventErrorAfterPrepare, val1, 0, notifUser); 435 } else { 436 SL_LOGV("GenericPlayer notifying unknown"); 437 } 438 } 439 440 441 void GenericPlayer::onPlay() { 442 SL_LOGD("GenericPlayer::onPlay()"); 443 if ((mStateFlags & (kFlagPrepared | kFlagPlaying)) == kFlagPrepared) { 444 SL_LOGD("starting player"); 445 mStateFlags |= kFlagPlaying; 446 updateOneShot(); 447 } 448 } 449 450 451 void GenericPlayer::onPause() { 452 SL_LOGD("GenericPlayer::onPause()"); 453 if (!(~mStateFlags & (kFlagPrepared | kFlagPlaying))) { 454 SL_LOGV("pausing player"); 455 mStateFlags &= ~kFlagPlaying; 456 updateOneShot(); 457 } 458 } 459 460 461 void GenericPlayer::onSeek(const sp<AMessage> &msg) { 462 SL_LOGV("GenericPlayer::onSeek"); 463 } 464 465 466 void GenericPlayer::onLoop(const sp<AMessage> &msg) { 467 SL_LOGV("GenericPlayer::onLoop"); 468 } 469 470 471 void GenericPlayer::onVolumeUpdate() { 472 SL_LOGV("GenericPlayer::onVolumeUpdate"); 473 } 474 475 476 void GenericPlayer::onSeekComplete() { 477 SL_LOGD("GenericPlayer::onSeekComplete()"); 478 mStateFlags &= ~kFlagSeeking; 479 // avoid spurious or lost events caused by seeking past a marker 480 mDeliveredNewPosMs = ANDROID_UNKNOWN_TIME; 481 mObservedPositionMs = ANDROID_UNKNOWN_TIME; 482 updateOneShot(); 483 } 484 485 486 void GenericPlayer::onBufferingUpdate(const sp<AMessage> &msg) { 487 SL_LOGV("GenericPlayer::onBufferingUpdate"); 488 } 489 490 491 void GenericPlayer::onSetBufferingUpdateThreshold(const sp<AMessage> &msg) { 492 SL_LOGV("GenericPlayer::onSetBufferingUpdateThreshold"); 493 int32_t thresholdPercent = 0; 494 if (msg->findInt32(WHATPARAM_BUFFERING_UPDATETHRESHOLD_PERCENT, &thresholdPercent)) { 495 Mutex::Autolock _l(mSettingsLock); 496 mCacheFillNotifThreshold = (int16_t)thresholdPercent; 497 } 498 } 499 500 501 void GenericPlayer::onAttachAuxEffect(const sp<AMessage> &msg) { 502 SL_LOGV("GenericPlayer::onAttachAuxEffect()"); 503 } 504 505 506 void GenericPlayer::onSetAuxEffectSendLevel(const sp<AMessage> &msg) { 507 SL_LOGV("GenericPlayer::onSetAuxEffectSendLevel()"); 508 } 509 510 511 void GenericPlayer::onSetPlayEvents(const sp<AMessage> &msg) { 512 SL_LOGV("GenericPlayer::onSetPlayEvents()"); 513 int32_t eventFlags, markerPositionMs, positionUpdatePeriodMs; 514 if (msg->findInt32(WHATPARAM_SETPLAYEVENTS_FLAGS, &eventFlags) && 515 msg->findInt32(WHATPARAM_SETPLAYEVENTS_MARKER, &markerPositionMs) && 516 msg->findInt32(WHATPARAM_SETPLAYEVENTS_UPDATE, &positionUpdatePeriodMs)) { 517 mEventFlags = eventFlags; 518 mMarkerPositionMs = markerPositionMs; 519 mPositionUpdatePeriodMs = positionUpdatePeriodMs; 520 updateOneShot(); 521 } 522 } 523 524 525 void GenericPlayer::onOneShot(const sp<AMessage> &msg) { 526 SL_LOGV("GenericPlayer::onOneShot()"); 527 int32_t generation; 528 if (msg->findInt32(WHATPARAM_ONESHOT_GENERATION, &generation)) { 529 if (generation != mOneShotGeneration) { 530 SL_LOGV("GenericPlayer::onOneShot() generation %d cancelled; latest is %d", 531 generation, mOneShotGeneration); 532 return; 533 } 534 updateOneShot(); 535 } 536 } 537 538 539 //------------------------------------------------- 540 void GenericPlayer::notifyStatus() { 541 SL_LOGV("GenericPlayer::notifyStatus"); 542 notify(PLAYEREVENT_PREFETCHSTATUSCHANGE, (int32_t)mCacheStatus, true /*async*/); 543 } 544 545 546 void GenericPlayer::notifyCacheFill() { 547 SL_LOGV("GenericPlayer::notifyCacheFill"); 548 mLastNotifiedCacheFill = mCacheFill; 549 notify(PLAYEREVENT_PREFETCHFILLLEVELUPDATE, (int32_t)mLastNotifiedCacheFill, true/*async*/); 550 } 551 552 553 void GenericPlayer::seekComplete() { 554 SL_LOGV("GenericPlayer::seekComplete"); 555 sp<AMessage> msg = new AMessage(kWhatSeekComplete, id()); 556 msg->post(); 557 } 558 559 560 void GenericPlayer::bufferingUpdate(int16_t fillLevelPerMille) { 561 SL_LOGV("GenericPlayer::bufferingUpdate"); 562 sp<AMessage> msg = new AMessage(kWhatBufferingUpdate, id()); 563 msg->setInt32(WHATPARAM_BUFFERING_UPDATE, fillLevelPerMille); 564 msg->post(); 565 } 566 567 568 // For the meaning of positionMs, see comment in declaration at android_GenericPlayer.h 569 void GenericPlayer::updateOneShot(int positionMs) 570 { 571 SL_LOGV("GenericPlayer::updateOneShot"); 572 573 // nop until prepared 574 if (!(mStateFlags & kFlagPrepared)) { 575 return; 576 } 577 578 // cancel any pending one-shot(s) 579 ++mOneShotGeneration; 580 581 // don't restart one-shot if player is paused or stopped 582 if (!(mStateFlags & kFlagPlaying)) { 583 return; 584 } 585 586 // get current player position in milliseconds 587 if (positionMs < 0) { 588 positionMs = ANDROID_UNKNOWN_TIME; 589 } 590 if (positionMs == ANDROID_UNKNOWN_TIME) { 591 getPositionMsec(&positionMs); 592 // normalize it 593 if (positionMs < 0) { 594 positionMs = ANDROID_UNKNOWN_TIME; 595 } 596 if (ANDROID_UNKNOWN_TIME == positionMs) { 597 // getPositionMsec is not working for some reason, give up 598 //LOGV("Does anyone really know what time it is?"); 599 return; 600 } 601 } 602 603 // if we observe the player position going backwards, even without without a seek, then recover 604 if (mObservedPositionMs != ANDROID_UNKNOWN_TIME && positionMs < mObservedPositionMs) { 605 mDeliveredNewPosMs = ANDROID_UNKNOWN_TIME; 606 mObservedPositionMs = positionMs; 607 } 608 609 // delayUs is the expected delay between current position and marker; 610 // the default is infinity in case there are no upcoming marker(s) 611 int64_t delayUs = -1; 612 613 // is there a marker? 614 if ((mEventFlags & SL_PLAYEVENT_HEADATMARKER) && (mMarkerPositionMs != ANDROID_UNKNOWN_TIME)) { 615 // check to see if we have observed the position passing through the marker 616 if (mObservedPositionMs <= mMarkerPositionMs && mMarkerPositionMs <= positionMs) { 617 notify(PLAYEREVENT_PLAY, (int32_t) SL_PLAYEVENT_HEADATMARKER, true /*async*/); 618 } else if (positionMs < mMarkerPositionMs) { 619 delayUs = (mMarkerPositionMs - positionMs) * 1000LL; 620 } 621 } 622 623 // are periodic position updates needed? 624 if ((mEventFlags & SL_PLAYEVENT_HEADATNEWPOS) && 625 (mPositionUpdatePeriodMs != ANDROID_UNKNOWN_TIME)) { 626 // check to see if we have observed the position passing through a virtual marker, where the 627 // virtual marker is at the previously delivered new position plus position update period 628 int32_t virtualMarkerMs; 629 if (mDeliveredNewPosMs != ANDROID_UNKNOWN_TIME) { 630 virtualMarkerMs = mDeliveredNewPosMs + mPositionUpdatePeriodMs; 631 } else if (mObservedPositionMs != ANDROID_UNKNOWN_TIME) { 632 virtualMarkerMs = mObservedPositionMs + mPositionUpdatePeriodMs; 633 // pretend there has been an update in the past 634 mDeliveredNewPosMs = mObservedPositionMs; 635 } else { 636 virtualMarkerMs = positionMs + mPositionUpdatePeriodMs; 637 // pretend there has been an update in the past 638 mDeliveredNewPosMs = positionMs; 639 } 640 // nextVirtualMarkerMs will be set to the position of the next upcoming virtual marker 641 int32_t nextVirtualMarkerMs; 642 if (mObservedPositionMs <= virtualMarkerMs && virtualMarkerMs <= positionMs) { 643 // we did pass through the virtual marker, now compute the next virtual marker 644 mDeliveredNewPosMs = virtualMarkerMs; 645 nextVirtualMarkerMs = virtualMarkerMs + mPositionUpdatePeriodMs; 646 // re-synchronize if we missed an update 647 if (nextVirtualMarkerMs <= positionMs) { 648 SL_LOGW("Missed SL_PLAYEVENT_HEADATNEWPOS for position %d; current position %d", 649 nextVirtualMarkerMs, positionMs); 650 // try to catch up by setting next goal to current position plus update period 651 mDeliveredNewPosMs = positionMs; 652 nextVirtualMarkerMs = positionMs + mPositionUpdatePeriodMs; 653 } 654 notify(PLAYEREVENT_PLAY, (int32_t) SL_PLAYEVENT_HEADATNEWPOS, true /*async*/); 655 } else { 656 // we did not pass through the virtual marker yet, so use same marker again 657 nextVirtualMarkerMs = virtualMarkerMs; 658 } 659 // note that if arithmetic overflow occurred, nextVirtualMarkerMs will be negative 660 if (positionMs < nextVirtualMarkerMs) { 661 int64_t trialDelayUs; 662 trialDelayUs = (nextVirtualMarkerMs - positionMs) * 1000LL; 663 if (trialDelayUs > 0 && (delayUs == -1 || trialDelayUs < delayUs)) { 664 delayUs = trialDelayUs; 665 } 666 } 667 } 668 669 // we have a new observed position 670 mObservedPositionMs = positionMs; 671 672 // post the new one-shot message if needed 673 if (advancesPositionInRealTime() && delayUs >= 0) { 674 // 20 ms min delay to avoid near busy waiting 675 if (delayUs < 20000LL) { 676 delayUs = 20000LL; 677 } 678 // 1 minute max delay avoids indefinite memory leaks caused by cancelled one-shots 679 if (delayUs > 60000000LL) { 680 delayUs = 60000000LL; 681 } 682 //SL_LOGI("delayUs = %lld", delayUs); 683 sp<AMessage> msg = new AMessage(kWhatOneShot, id()); 684 msg->setInt32(WHATPARAM_ONESHOT_GENERATION, mOneShotGeneration); 685 msg->post(delayUs); 686 } 687 688 } 689 690 } // namespace android 691