You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
716 lines
24 KiB
716 lines
24 KiB
/*
|
|
* Copyright (C) 2011 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
//#define USE_LOG SLAndroidLogLevel_Verbose
|
|
|
|
#include "sles_allinclusive.h"
|
|
|
|
#include <media/stagefright/foundation/ADebug.h>
|
|
#include <sys/stat.h>
|
|
#include <inttypes.h>
|
|
|
|
namespace android {
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
GenericPlayer::GenericPlayer(const AudioPlayback_Parameters* params) :
|
|
mDataLocatorType(kDataLocatorNone),
|
|
mNotifyClient(NULL),
|
|
mNotifyUser(NULL),
|
|
mStateFlags(0),
|
|
mPlaybackParams(*params),
|
|
mDurationMsec(ANDROID_UNKNOWN_TIME),
|
|
mPlaybackRatePermille(1000),
|
|
mCacheStatus(kStatusEmpty),
|
|
mCacheFill(0),
|
|
mLastNotifiedCacheFill(0),
|
|
mCacheFillNotifThreshold(100),
|
|
mEventFlags(0),
|
|
mMarkerPositionMs(ANDROID_UNKNOWN_TIME),
|
|
mPositionUpdatePeriodMs(1000), // per spec
|
|
mOneShotGeneration(0),
|
|
mDeliveredNewPosMs(ANDROID_UNKNOWN_TIME),
|
|
mObservedPositionMs(ANDROID_UNKNOWN_TIME)
|
|
{
|
|
SL_LOGD("GenericPlayer::GenericPlayer()");
|
|
|
|
mLooper = new android::ALooper();
|
|
|
|
// Post-construction accesses need to be protected by mSettingsLock
|
|
mAndroidAudioLevels.mFinalVolume[0] = 1.0f;
|
|
mAndroidAudioLevels.mFinalVolume[1] = 1.0f;
|
|
}
|
|
|
|
|
|
GenericPlayer::~GenericPlayer() {
|
|
SL_LOGV("GenericPlayer::~GenericPlayer()");
|
|
|
|
resetDataLocator();
|
|
}
|
|
|
|
|
|
void GenericPlayer::init(const notif_cbf_t cbf, void* notifUser) {
|
|
SL_LOGD("GenericPlayer::init()");
|
|
|
|
{
|
|
android::Mutex::Autolock autoLock(mNotifyClientLock);
|
|
mNotifyClient = cbf;
|
|
mNotifyUser = notifUser;
|
|
}
|
|
|
|
mLooper->registerHandler(this);
|
|
mLooper->start(false /*runOnCallingThread*/, true /*canCallJava*/, PRIORITY_DEFAULT);
|
|
}
|
|
|
|
|
|
void GenericPlayer::preDestroy() {
|
|
SL_LOGD("GenericPlayer::preDestroy()");
|
|
{
|
|
android::Mutex::Autolock autoLock(mNotifyClientLock);
|
|
mNotifyClient = NULL;
|
|
mNotifyUser = NULL;
|
|
}
|
|
|
|
mLooper->stop();
|
|
mLooper->unregisterHandler(id());
|
|
}
|
|
|
|
|
|
void GenericPlayer::setDataSource(const char *uri) {
|
|
SL_LOGV("GenericPlayer::setDataSource(uri=%s)", uri);
|
|
resetDataLocator();
|
|
|
|
mDataLocator.uriRef = uri;
|
|
|
|
mDataLocatorType = kDataLocatorUri;
|
|
}
|
|
|
|
|
|
void GenericPlayer::setDataSource(int fd, int64_t offset, int64_t length, bool closeAfterUse) {
|
|
SL_LOGV("GenericPlayer::setDataSource(fd=%d, offset=%lld, length=%lld, closeAfterUse=%s)", fd,
|
|
offset, length, closeAfterUse ? "true" : "false");
|
|
resetDataLocator();
|
|
|
|
mDataLocator.fdi.fd = fd;
|
|
|
|
struct stat sb;
|
|
int ret = fstat(fd, &sb);
|
|
if (ret != 0) {
|
|
SL_LOGE("GenericPlayer::setDataSource: fstat(%d) failed: %d, %s", fd, ret, strerror(errno));
|
|
return;
|
|
}
|
|
|
|
if (offset >= sb.st_size) {
|
|
SL_LOGE("SfPlayer::setDataSource: invalid offset");
|
|
return;
|
|
}
|
|
mDataLocator.fdi.offset = offset;
|
|
|
|
if (PLAYER_FD_FIND_FILE_SIZE == length) {
|
|
mDataLocator.fdi.length = sb.st_size;
|
|
} else if (offset + length > sb.st_size) {
|
|
mDataLocator.fdi.length = sb.st_size - offset;
|
|
} else {
|
|
mDataLocator.fdi.length = length;
|
|
}
|
|
|
|
mDataLocator.fdi.mCloseAfterUse = closeAfterUse;
|
|
|
|
mDataLocatorType = kDataLocatorFd;
|
|
}
|
|
|
|
|
|
void GenericPlayer::prepare() {
|
|
SL_LOGD("GenericPlayer::prepare()");
|
|
// do not attempt prepare more than once
|
|
if (!(mStateFlags & (kFlagPrepared | kFlagPreparedUnsuccessfully))) {
|
|
sp<AMessage> msg = new AMessage(kWhatPrepare, this);
|
|
msg->post();
|
|
}
|
|
}
|
|
|
|
|
|
void GenericPlayer::play() {
|
|
SL_LOGD("GenericPlayer::play()");
|
|
sp<AMessage> msg = new AMessage(kWhatPlay, this);
|
|
msg->post();
|
|
}
|
|
|
|
|
|
void GenericPlayer::pause() {
|
|
SL_LOGD("GenericPlayer::pause()");
|
|
sp<AMessage> msg = new AMessage(kWhatPause, this);
|
|
msg->post();
|
|
}
|
|
|
|
|
|
void GenericPlayer::stop() {
|
|
SL_LOGD("GenericPlayer::stop()");
|
|
(new AMessage(kWhatPause, this))->post();
|
|
|
|
// after a stop, playback should resume from the start.
|
|
seek(0);
|
|
}
|
|
|
|
|
|
void GenericPlayer::seek(int64_t timeMsec) {
|
|
SL_LOGV("GenericPlayer::seek %lld", timeMsec);
|
|
if (timeMsec < 0 && timeMsec != ANDROID_UNKNOWN_TIME) {
|
|
SL_LOGE("GenericPlayer::seek error, can't seek to negative time %" PRId64 "ms", timeMsec);
|
|
return;
|
|
}
|
|
sp<AMessage> msg = new AMessage(kWhatSeek, this);
|
|
msg->setInt64(WHATPARAM_SEEK_SEEKTIME_MS, timeMsec);
|
|
msg->post();
|
|
}
|
|
|
|
|
|
void GenericPlayer::loop(bool loop) {
|
|
SL_LOGV("GenericPlayer::loop %s", loop ? "true" : "false");
|
|
sp<AMessage> msg = new AMessage(kWhatLoop, this);
|
|
msg->setInt32(WHATPARAM_LOOP_LOOPING, (int32_t)loop);
|
|
msg->post();
|
|
}
|
|
|
|
|
|
void GenericPlayer::setBufferingUpdateThreshold(int16_t thresholdPercent) {
|
|
SL_LOGV("GenericPlayer::setBufferingUpdateThreshold %d", thresholdPercent);
|
|
sp<AMessage> msg = new AMessage(kWhatBuffUpdateThres, this);
|
|
msg->setInt32(WHATPARAM_BUFFERING_UPDATETHRESHOLD_PERCENT, (int32_t)thresholdPercent);
|
|
msg->post();
|
|
}
|
|
|
|
|
|
//--------------------------------------------------
|
|
void GenericPlayer::getDurationMsec(int* msec) {
|
|
Mutex::Autolock _l(mSettingsLock);
|
|
*msec = mDurationMsec;
|
|
}
|
|
|
|
//--------------------------------------------------
|
|
void GenericPlayer::setVolume(float leftVol, float rightVol)
|
|
{
|
|
{
|
|
Mutex::Autolock _l(mSettingsLock);
|
|
mAndroidAudioLevels.mFinalVolume[0] = leftVol;
|
|
mAndroidAudioLevels.mFinalVolume[1] = rightVol;
|
|
}
|
|
// send a message for the volume to be updated by the object which implements the volume
|
|
(new AMessage(kWhatVolumeUpdate, this))->post();
|
|
}
|
|
|
|
|
|
//--------------------------------------------------
|
|
void GenericPlayer::attachAuxEffect(int32_t effectId)
|
|
{
|
|
SL_LOGV("GenericPlayer::attachAuxEffect(id=%d)", effectId);
|
|
sp<AMessage> msg = new AMessage(kWhatAttachAuxEffect, this);
|
|
msg->setInt32(WHATPARAM_ATTACHAUXEFFECT, effectId);
|
|
msg->post();
|
|
}
|
|
|
|
|
|
//--------------------------------------------------
|
|
void GenericPlayer::setAuxEffectSendLevel(float level)
|
|
{
|
|
SL_LOGV("GenericPlayer::setAuxEffectSendLevel(level=%g)", level);
|
|
sp<AMessage> msg = new AMessage(kWhatSetAuxEffectSendLevel, this);
|
|
msg->setFloat(WHATPARAM_SETAUXEFFECTSENDLEVEL, level);
|
|
msg->post();
|
|
}
|
|
|
|
|
|
//--------------------------------------------------
|
|
void GenericPlayer::setPlaybackRate(int32_t ratePermille) {
|
|
SL_LOGV("GenericPlayer::setPlaybackRate(ratePermille=%d)", ratePermille);
|
|
{
|
|
Mutex::Autolock _l(mSettingsLock);
|
|
mPlaybackRatePermille = (int16_t)ratePermille;
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------
|
|
// Call after changing any of the IPlay settings related to SL_PLAYEVENT_*
|
|
void GenericPlayer::setPlayEvents(int32_t eventFlags, int32_t markerPositionMs,
|
|
int32_t positionUpdatePeriodMs)
|
|
{
|
|
// Normalize ms that are within the valid unsigned range, but not in the int32_t range
|
|
if (markerPositionMs < 0) {
|
|
markerPositionMs = ANDROID_UNKNOWN_TIME;
|
|
}
|
|
if (positionUpdatePeriodMs < 0) {
|
|
positionUpdatePeriodMs = ANDROID_UNKNOWN_TIME;
|
|
}
|
|
// markers are delivered accurately, but new position updates are limited to every 100 ms
|
|
if (positionUpdatePeriodMs < 100) {
|
|
positionUpdatePeriodMs = 100;
|
|
}
|
|
sp<AMessage> msg = new AMessage(kWhatSetPlayEvents, this);
|
|
msg->setInt32(WHATPARAM_SETPLAYEVENTS_FLAGS, eventFlags);
|
|
msg->setInt32(WHATPARAM_SETPLAYEVENTS_MARKER, markerPositionMs);
|
|
msg->setInt32(WHATPARAM_SETPLAYEVENTS_UPDATE, positionUpdatePeriodMs);
|
|
msg->post();
|
|
}
|
|
|
|
|
|
//--------------------------------------------------
|
|
/*
|
|
* post-condition: mDataLocatorType == kDataLocatorNone
|
|
*
|
|
*/
|
|
void GenericPlayer::resetDataLocator() {
|
|
SL_LOGV("GenericPlayer::resetDataLocator()");
|
|
if (mDataLocatorType == kDataLocatorFd && mDataLocator.fdi.mCloseAfterUse) {
|
|
(void) ::close(mDataLocator.fdi.fd);
|
|
// would be redundant, as we're about to invalidate the union mDataLocator
|
|
//mDataLocator.fdi.fd = -1;
|
|
//mDataLocator.fdi.mCloseAfterUse = false;
|
|
}
|
|
mDataLocatorType = kDataLocatorNone;
|
|
}
|
|
|
|
|
|
void GenericPlayer::notify(const char* event, int data, bool async) {
|
|
SL_LOGV("GenericPlayer::notify(event=%s, data=%d, async=%s)", event, data,
|
|
async ? "true" : "false");
|
|
sp<AMessage> msg = new AMessage(kWhatNotif, this);
|
|
msg->setInt32(event, (int32_t)data);
|
|
if (async) {
|
|
msg->post();
|
|
} else {
|
|
onNotify(msg);
|
|
}
|
|
}
|
|
|
|
|
|
void GenericPlayer::notify(const char* event, int data1, int data2, bool async) {
|
|
SL_LOGV("GenericPlayer::notify(event=%s, data1=%d, data2=%d, async=%s)", event, data1, data2,
|
|
async ? "true" : "false");
|
|
sp<AMessage> msg = new AMessage(kWhatNotif, this);
|
|
msg->setRect(event, 0, 0, (int32_t)data1, (int32_t)data2);
|
|
if (async) {
|
|
msg->post();
|
|
} else {
|
|
onNotify(msg);
|
|
}
|
|
}
|
|
|
|
|
|
//--------------------------------------------------
|
|
// AHandler implementation
|
|
void GenericPlayer::onMessageReceived(const sp<AMessage> &msg) {
|
|
SL_LOGV("GenericPlayer::onMessageReceived()");
|
|
switch (msg->what()) {
|
|
case kWhatPrepare:
|
|
SL_LOGV("kWhatPrepare");
|
|
onPrepare();
|
|
break;
|
|
|
|
case kWhatNotif:
|
|
SL_LOGV("kWhatNotif");
|
|
onNotify(msg);
|
|
break;
|
|
|
|
case kWhatPlay:
|
|
SL_LOGV("kWhatPlay");
|
|
onPlay();
|
|
break;
|
|
|
|
case kWhatPause:
|
|
SL_LOGV("kWhatPause");
|
|
onPause();
|
|
break;
|
|
|
|
case kWhatSeek:
|
|
SL_LOGV("kWhatSeek");
|
|
onSeek(msg);
|
|
break;
|
|
|
|
case kWhatLoop:
|
|
SL_LOGV("kWhatLoop");
|
|
onLoop(msg);
|
|
break;
|
|
|
|
case kWhatVolumeUpdate:
|
|
SL_LOGV("kWhatVolumeUpdate");
|
|
onVolumeUpdate();
|
|
break;
|
|
|
|
case kWhatSeekComplete:
|
|
SL_LOGV("kWhatSeekComplete");
|
|
onSeekComplete();
|
|
break;
|
|
|
|
case kWhatBufferingUpdate:
|
|
SL_LOGV("kWhatBufferingUpdate");
|
|
onBufferingUpdate(msg);
|
|
break;
|
|
|
|
case kWhatBuffUpdateThres:
|
|
SL_LOGV("kWhatBuffUpdateThres");
|
|
onSetBufferingUpdateThreshold(msg);
|
|
break;
|
|
|
|
case kWhatAttachAuxEffect:
|
|
SL_LOGV("kWhatAttachAuxEffect");
|
|
onAttachAuxEffect(msg);
|
|
break;
|
|
|
|
case kWhatSetAuxEffectSendLevel:
|
|
SL_LOGV("kWhatSetAuxEffectSendLevel");
|
|
onSetAuxEffectSendLevel(msg);
|
|
break;
|
|
|
|
case kWhatSetPlayEvents:
|
|
SL_LOGV("kWhatSetPlayEvents");
|
|
onSetPlayEvents(msg);
|
|
break;
|
|
|
|
case kWhatOneShot:
|
|
SL_LOGV("kWhatOneShot");
|
|
onOneShot(msg);
|
|
break;
|
|
|
|
default:
|
|
SL_LOGE("GenericPlayer::onMessageReceived unknown message %d", msg->what());
|
|
TRESPASS();
|
|
}
|
|
}
|
|
|
|
|
|
//--------------------------------------------------
|
|
// Event handlers
|
|
// it is strictly verboten to call those methods outside of the event loop
|
|
|
|
void GenericPlayer::onPrepare() {
|
|
SL_LOGV("GenericPlayer::onPrepare()");
|
|
// Subclass is responsible for indicating whether prepare was successful or unsuccessful
|
|
// by updating mStateFlags accordingly. It must set exactly one of these two flags.
|
|
assert(!(mStateFlags & kFlagPrepared) != !(mStateFlags & kFlagPreparedUnsuccessfully));
|
|
notify(PLAYEREVENT_PREPARED, mStateFlags & kFlagPrepared ? PLAYER_SUCCESS : PLAYER_FAILURE,
|
|
true /*async*/);
|
|
SL_LOGD("GenericPlayer::onPrepare() done, mStateFlags=0x%x", mStateFlags);
|
|
}
|
|
|
|
|
|
void GenericPlayer::onNotify(const sp<AMessage> &msg) {
|
|
SL_LOGV("GenericPlayer::onNotify()");
|
|
notif_cbf_t notifClient;
|
|
void* notifUser;
|
|
{
|
|
android::Mutex::Autolock autoLock(mNotifyClientLock);
|
|
if (NULL == mNotifyClient) {
|
|
return;
|
|
} else {
|
|
notifClient = mNotifyClient;
|
|
notifUser = mNotifyUser;
|
|
}
|
|
}
|
|
|
|
int32_t val1, val2;
|
|
if (msg->findInt32(PLAYEREVENT_PREFETCHSTATUSCHANGE, &val1)) {
|
|
SL_LOGV("GenericPlayer notifying %s = %d", PLAYEREVENT_PREFETCHSTATUSCHANGE, val1);
|
|
notifClient(kEventPrefetchStatusChange, val1, 0, notifUser);
|
|
// There is exactly one notification per message, hence "else if" instead of "if"
|
|
} else if (msg->findInt32(PLAYEREVENT_PREFETCHFILLLEVELUPDATE, &val1)) {
|
|
SL_LOGV("GenericPlayer notifying %s = %d", PLAYEREVENT_PREFETCHFILLLEVELUPDATE, val1);
|
|
notifClient(kEventPrefetchFillLevelUpdate, val1, 0, notifUser);
|
|
} else if (msg->findInt32(PLAYEREVENT_ENDOFSTREAM, &val1)) {
|
|
SL_LOGV("GenericPlayer notifying %s = %d", PLAYEREVENT_ENDOFSTREAM, val1);
|
|
notifClient(kEventEndOfStream, val1, 0, notifUser);
|
|
} else if (msg->findInt32(PLAYEREVENT_PREPARED, &val1)) {
|
|
SL_LOGV("GenericPlayer notifying %s = %d", PLAYEREVENT_PREPARED, val1);
|
|
notifClient(kEventPrepared, val1, 0, notifUser);
|
|
} else if (msg->findInt32(PLAYEREVENT_CHANNEL_COUNT, &val1)) {
|
|
SL_LOGV("GenericPlayer notifying %s = %d", PLAYEREVENT_CHANNEL_COUNT, val1);
|
|
notifClient(kEventChannelCount, val1, 0, notifUser);
|
|
} else if (msg->findRect(PLAYEREVENT_VIDEO_SIZE_UPDATE, &val1, &val2, &val1, &val2)) {
|
|
SL_LOGV("GenericPlayer notifying %s = %d, %d", PLAYEREVENT_VIDEO_SIZE_UPDATE, val1, val2);
|
|
notifClient(kEventHasVideoSize, val1, val2, notifUser);
|
|
} else if (msg->findInt32(PLAYEREVENT_PLAY, &val1)) {
|
|
SL_LOGV("GenericPlayer notifying %s = %d", PLAYEREVENT_PLAY, val1);
|
|
notifClient(kEventPlay, val1, 0, notifUser);
|
|
} else if (msg->findInt32(PLAYEREVENT_ERRORAFTERPREPARE, &val1)) {
|
|
SL_LOGV("GenericPlayer notifying %s = %d", PLAYEREVENT_ERRORAFTERPREPARE, val1);
|
|
notifClient(kEventErrorAfterPrepare, val1, 0, notifUser);
|
|
} else {
|
|
SL_LOGV("GenericPlayer notifying unknown");
|
|
}
|
|
}
|
|
|
|
|
|
void GenericPlayer::onPlay() {
|
|
SL_LOGD("GenericPlayer::onPlay()");
|
|
if ((mStateFlags & (kFlagPrepared | kFlagPlaying)) == kFlagPrepared) {
|
|
SL_LOGD("starting player");
|
|
mStateFlags |= kFlagPlaying;
|
|
updateOneShot();
|
|
}
|
|
}
|
|
|
|
|
|
void GenericPlayer::onPause() {
|
|
SL_LOGD("GenericPlayer::onPause()");
|
|
if (!(~mStateFlags & (kFlagPrepared | kFlagPlaying))) {
|
|
SL_LOGV("pausing player");
|
|
mStateFlags &= ~kFlagPlaying;
|
|
updateOneShot();
|
|
}
|
|
}
|
|
|
|
|
|
void GenericPlayer::onSeek(const sp<AMessage> &msg) {
|
|
SL_LOGV("GenericPlayer::onSeek");
|
|
}
|
|
|
|
|
|
void GenericPlayer::onLoop(const sp<AMessage> &msg) {
|
|
SL_LOGV("GenericPlayer::onLoop");
|
|
}
|
|
|
|
|
|
void GenericPlayer::onVolumeUpdate() {
|
|
SL_LOGV("GenericPlayer::onVolumeUpdate");
|
|
}
|
|
|
|
|
|
void GenericPlayer::onSeekComplete() {
|
|
SL_LOGD("GenericPlayer::onSeekComplete()");
|
|
mStateFlags &= ~kFlagSeeking;
|
|
// avoid spurious or lost events caused by seeking past a marker
|
|
mDeliveredNewPosMs = ANDROID_UNKNOWN_TIME;
|
|
mObservedPositionMs = ANDROID_UNKNOWN_TIME;
|
|
updateOneShot();
|
|
}
|
|
|
|
|
|
void GenericPlayer::onBufferingUpdate(const sp<AMessage> &msg) {
|
|
SL_LOGV("GenericPlayer::onBufferingUpdate");
|
|
}
|
|
|
|
|
|
void GenericPlayer::onSetBufferingUpdateThreshold(const sp<AMessage> &msg) {
|
|
SL_LOGV("GenericPlayer::onSetBufferingUpdateThreshold");
|
|
int32_t thresholdPercent = 0;
|
|
if (msg->findInt32(WHATPARAM_BUFFERING_UPDATETHRESHOLD_PERCENT, &thresholdPercent)) {
|
|
Mutex::Autolock _l(mSettingsLock);
|
|
mCacheFillNotifThreshold = (int16_t)thresholdPercent;
|
|
}
|
|
}
|
|
|
|
|
|
void GenericPlayer::onAttachAuxEffect(const sp<AMessage> &msg) {
|
|
SL_LOGV("GenericPlayer::onAttachAuxEffect()");
|
|
}
|
|
|
|
|
|
void GenericPlayer::onSetAuxEffectSendLevel(const sp<AMessage> &msg) {
|
|
SL_LOGV("GenericPlayer::onSetAuxEffectSendLevel()");
|
|
}
|
|
|
|
|
|
void GenericPlayer::onSetPlayEvents(const sp<AMessage> &msg) {
|
|
SL_LOGV("GenericPlayer::onSetPlayEvents()");
|
|
int32_t eventFlags, markerPositionMs, positionUpdatePeriodMs;
|
|
if (msg->findInt32(WHATPARAM_SETPLAYEVENTS_FLAGS, &eventFlags) &&
|
|
msg->findInt32(WHATPARAM_SETPLAYEVENTS_MARKER, &markerPositionMs) &&
|
|
msg->findInt32(WHATPARAM_SETPLAYEVENTS_UPDATE, &positionUpdatePeriodMs)) {
|
|
mEventFlags = eventFlags;
|
|
mMarkerPositionMs = markerPositionMs;
|
|
mPositionUpdatePeriodMs = positionUpdatePeriodMs;
|
|
updateOneShot();
|
|
}
|
|
}
|
|
|
|
|
|
void GenericPlayer::onOneShot(const sp<AMessage> &msg) {
|
|
SL_LOGV("GenericPlayer::onOneShot()");
|
|
int32_t generation;
|
|
if (msg->findInt32(WHATPARAM_ONESHOT_GENERATION, &generation)) {
|
|
if (generation != mOneShotGeneration) {
|
|
SL_LOGV("GenericPlayer::onOneShot() generation %d cancelled; latest is %d",
|
|
generation, mOneShotGeneration);
|
|
return;
|
|
}
|
|
updateOneShot();
|
|
}
|
|
}
|
|
|
|
|
|
//-------------------------------------------------
|
|
void GenericPlayer::notifyStatus() {
|
|
SL_LOGV("GenericPlayer::notifyStatus");
|
|
notify(PLAYEREVENT_PREFETCHSTATUSCHANGE, (int32_t)mCacheStatus, true /*async*/);
|
|
}
|
|
|
|
|
|
void GenericPlayer::notifyCacheFill() {
|
|
SL_LOGV("GenericPlayer::notifyCacheFill");
|
|
mLastNotifiedCacheFill = mCacheFill;
|
|
notify(PLAYEREVENT_PREFETCHFILLLEVELUPDATE, (int32_t)mLastNotifiedCacheFill, true/*async*/);
|
|
}
|
|
|
|
|
|
void GenericPlayer::seekComplete() {
|
|
SL_LOGV("GenericPlayer::seekComplete");
|
|
sp<AMessage> msg = new AMessage(kWhatSeekComplete, this);
|
|
msg->post();
|
|
}
|
|
|
|
|
|
void GenericPlayer::bufferingUpdate(int16_t fillLevelPerMille) {
|
|
SL_LOGV("GenericPlayer::bufferingUpdate");
|
|
sp<AMessage> msg = new AMessage(kWhatBufferingUpdate, this);
|
|
msg->setInt32(WHATPARAM_BUFFERING_UPDATE, fillLevelPerMille);
|
|
msg->post();
|
|
}
|
|
|
|
|
|
// For the meaning of positionMs, see comment in declaration at android_GenericPlayer.h
|
|
void GenericPlayer::updateOneShot(int positionMs)
|
|
{
|
|
SL_LOGV("GenericPlayer::updateOneShot");
|
|
|
|
// nop until prepared
|
|
if (!(mStateFlags & kFlagPrepared)) {
|
|
return;
|
|
}
|
|
|
|
// cancel any pending one-shot(s)
|
|
++mOneShotGeneration;
|
|
|
|
// don't restart one-shot if player is paused or stopped
|
|
if (!(mStateFlags & kFlagPlaying)) {
|
|
return;
|
|
}
|
|
|
|
// get current player position in milliseconds
|
|
if (positionMs < 0) {
|
|
positionMs = ANDROID_UNKNOWN_TIME;
|
|
}
|
|
if (positionMs == ANDROID_UNKNOWN_TIME) {
|
|
getPositionMsec(&positionMs);
|
|
// normalize it
|
|
if (positionMs < 0) {
|
|
positionMs = ANDROID_UNKNOWN_TIME;
|
|
}
|
|
if (ANDROID_UNKNOWN_TIME == positionMs) {
|
|
// getPositionMsec is not working for some reason, give up
|
|
//ALOGV("Does anyone really know what time it is?");
|
|
return;
|
|
}
|
|
}
|
|
|
|
// if we observe the player position going backwards, even without without a seek, then recover
|
|
if (mObservedPositionMs != ANDROID_UNKNOWN_TIME && positionMs < mObservedPositionMs) {
|
|
mDeliveredNewPosMs = ANDROID_UNKNOWN_TIME;
|
|
mObservedPositionMs = positionMs;
|
|
}
|
|
|
|
// delayUs is the expected delay between current position and marker;
|
|
// the default is infinity in case there are no upcoming marker(s)
|
|
int64_t delayUs = -1;
|
|
|
|
// is there a marker?
|
|
if ((mEventFlags & SL_PLAYEVENT_HEADATMARKER) && (mMarkerPositionMs != ANDROID_UNKNOWN_TIME)) {
|
|
// check to see if we have observed the position passing through the marker
|
|
if (mObservedPositionMs <= mMarkerPositionMs && mMarkerPositionMs <= positionMs) {
|
|
notify(PLAYEREVENT_PLAY, (int32_t) SL_PLAYEVENT_HEADATMARKER, true /*async*/);
|
|
} else if (positionMs < mMarkerPositionMs) {
|
|
delayUs = (mMarkerPositionMs - positionMs) * 1000LL;
|
|
}
|
|
}
|
|
|
|
// are periodic position updates needed?
|
|
if ((mEventFlags & SL_PLAYEVENT_HEADATNEWPOS) &&
|
|
(mPositionUpdatePeriodMs != ANDROID_UNKNOWN_TIME)) {
|
|
// check to see if we have observed the position passing through a virtual marker, where the
|
|
// virtual marker is at the previously delivered new position plus position update period
|
|
int32_t virtualMarkerMs;
|
|
if (mDeliveredNewPosMs != ANDROID_UNKNOWN_TIME) {
|
|
virtualMarkerMs = mDeliveredNewPosMs + mPositionUpdatePeriodMs;
|
|
} else if (mObservedPositionMs != ANDROID_UNKNOWN_TIME) {
|
|
virtualMarkerMs = mObservedPositionMs + mPositionUpdatePeriodMs;
|
|
// pretend there has been an update in the past
|
|
mDeliveredNewPosMs = mObservedPositionMs;
|
|
} else {
|
|
virtualMarkerMs = positionMs + mPositionUpdatePeriodMs;
|
|
// pretend there has been an update in the past
|
|
mDeliveredNewPosMs = positionMs;
|
|
}
|
|
// nextVirtualMarkerMs will be set to the position of the next upcoming virtual marker
|
|
int32_t nextVirtualMarkerMs;
|
|
if (mObservedPositionMs <= virtualMarkerMs && virtualMarkerMs <= positionMs) {
|
|
// we did pass through the virtual marker, now compute the next virtual marker
|
|
mDeliveredNewPosMs = virtualMarkerMs;
|
|
nextVirtualMarkerMs = virtualMarkerMs + mPositionUpdatePeriodMs;
|
|
// re-synchronize if we missed an update
|
|
if (nextVirtualMarkerMs <= positionMs) {
|
|
SL_LOGW("Missed SL_PLAYEVENT_HEADATNEWPOS for position %d; current position %d",
|
|
nextVirtualMarkerMs, positionMs);
|
|
// try to catch up by setting next goal to current position plus update period
|
|
mDeliveredNewPosMs = positionMs;
|
|
nextVirtualMarkerMs = positionMs + mPositionUpdatePeriodMs;
|
|
}
|
|
notify(PLAYEREVENT_PLAY, (int32_t) SL_PLAYEVENT_HEADATNEWPOS, true /*async*/);
|
|
} else {
|
|
// we did not pass through the virtual marker yet, so use same marker again
|
|
nextVirtualMarkerMs = virtualMarkerMs;
|
|
}
|
|
// note that if arithmetic overflow occurred, nextVirtualMarkerMs will be negative
|
|
if (positionMs < nextVirtualMarkerMs) {
|
|
int64_t trialDelayUs;
|
|
trialDelayUs = (nextVirtualMarkerMs - positionMs) * 1000LL;
|
|
if (trialDelayUs > 0 && (delayUs == -1 || trialDelayUs < delayUs)) {
|
|
delayUs = trialDelayUs;
|
|
}
|
|
}
|
|
}
|
|
|
|
// we have a new observed position
|
|
mObservedPositionMs = positionMs;
|
|
|
|
if (mPlaybackRatePermille == 0) {
|
|
// playback is frozen, no update expected (and no division by zero below)
|
|
return;
|
|
}
|
|
|
|
// post the new one-shot message if needed
|
|
if (advancesPositionInRealTime() && delayUs >= 0) {
|
|
// scale delay according to playback rate (reported positions won't change, but reported
|
|
// time will advance slower or faster depending on rate)
|
|
{
|
|
Mutex::Autolock _l(mSettingsLock);
|
|
delayUs = delayUs * 1000 / mPlaybackRatePermille;
|
|
}
|
|
|
|
// 20 ms min delay to avoid near busy waiting
|
|
if (delayUs < 20000LL) {
|
|
delayUs = 20000LL;
|
|
}
|
|
// 1 minute max delay avoids indefinite memory leaks caused by cancelled one-shots
|
|
if (delayUs > 60000000LL) {
|
|
delayUs = 60000000LL;
|
|
}
|
|
//SL_LOGI("delayUs = %lld", delayUs);
|
|
sp<AMessage> msg = new AMessage(kWhatOneShot, this);
|
|
msg->setInt32(WHATPARAM_ONESHOT_GENERATION, mOneShotGeneration);
|
|
msg->post(delayUs);
|
|
}
|
|
|
|
}
|
|
|
|
} // namespace android
|