int64_t AudioPlayer::getMediaTimeUs() {
Mutex::Autolock autoLock(mLock);
if (useOffload()) {
int64_t playPosition = 0;
if (mSeeking) {
return mSeekTimeUs;
}
playPosition = getOutputPlayPositionUs_l();
if (!mReachedEOS)
mPositionTimeRealUs = playPosition;
ALOGV("getMediaTimeUs getOutputPlayPositionUs_l() playPosition = %lld,\
mPositionTimeRealUs %lld", playPosition, mPositionTimeRealUs);
mPositionTimeMediaUs = mPositionTimeRealUs;
return mPositionTimeRealUs;
}
if (mPositionTimeMediaUs < 0 || mPositionTimeRealUs < 0) {
// mSeekTimeUs is either seek time while seeking or 0 if playback did not start.
return mSeekTimeUs;
}
int64_t realTimeOffset = getRealTimeUsLocked() - mPositionTimeRealUs;
if (realTimeOffset < 0) {
realTimeOffset = 0;
}
return mPositionTimeMediaUs + realTimeOffset;
}
void AudioPlayer::notifyAudioEOS() {
ALOGV("AudioPlayer@0x%p notifyAudioEOS", this);
if (useOffload()) {
mPositionTimeRealUs = getOutputPlayPositionUs_l ();
ALOGV("notifyAudioEOS: mPositionTimeRealUs = %lld ",mPositionTimeRealUs);
}
if (mObserver != NULL) {
mObserver->postAudioEOS(0);
ALOGV("Notified observer of EOS!");
}
}
status_t AudioPlayer::seekTo(int64_t time_us) {
Mutex::Autolock autoLock(mLock);
ALOGV("seekTo( %lld )", time_us);
if(useOffload())
{
int64_t playPosition = 0;
playPosition = getOutputPlayPositionUs_l();
/*Ignore the seek if seek time is same as player position.
Time comparisons are done in msec because when seek time
is past EOF, media player reset it to the clip duration
which is in Msec converted from Usec */
if((time_us/1000) == (playPosition/1000))
{
ALOGE("Ignore seek and post seek complete");
if(mObserver)
mObserver->postAudioSeekComplete();
return OK;
}
}
mSeeking = true;
mPositionTimeRealUs = mPositionTimeMediaUs = -1;
mReachedEOS = false;
mSeekTimeUs = time_us;
mStartPosUs = time_us;
// Flush resets the number of played frames
mNumFramesPlayed = 0;
mNumFramesPlayedSysTimeUs = ALooper::GetNowUs();
if (mAudioSink != NULL) {
if (mPlaying) {
mAudioSink->pause();
}
mAudioSink->flush();
if (mPlaying) {
mAudioSink->start();
}
} else {
if (mPlaying) {
mAudioTrack->pause();
}
mAudioTrack->flush();
if (mPlaying) {
mAudioTrack->start();
}
}
return OK;
}
int64_t AudioPlayer::getRealTimeUs() {
Mutex::Autolock autoLock(mLock);
if (useOffload()) {
int64_t playPosition = 0;
if (mSeeking) {
return mSeekTimeUs;
}
playPosition = getOutputPlayPositionUs_l();
if(!mReachedEOS)
mPositionTimeRealUs = playPosition;
mPositionTimeMediaUs = mPositionTimeRealUs;
return mPositionTimeRealUs;
}
return getRealTimeUsLocked();
}
bool AudioPlayer::getMediaTimeMapping(
int64_t *realtime_us, int64_t *mediatime_us) {
Mutex::Autolock autoLock(mLock);
if (useOffload()) {
int64_t playPosition = 0;
if (mSeeking) {
playPosition = mSeekTimeUs;
} else {
playPosition = getOutputPlayPositionUs_l();
}
if(!mReachedEOS)
mPositionTimeRealUs = playPosition;
mPositionTimeMediaUs = mPositionTimeRealUs;
*realtime_us = mPositionTimeRealUs;
*mediatime_us = mPositionTimeRealUs;
} else {
*realtime_us = mPositionTimeRealUs;
*mediatime_us = mPositionTimeMediaUs;
}
return mPositionTimeRealUs != -1 && mPositionTimeMediaUs != -1;
}
size_t AudioPlayer::fillBuffer(void *data, size_t size) {
ATRACE_CALL();
if (mNumFramesPlayed == 0) {
ALOGV("AudioCallback");
}
if (mReachedEOS) {
return 0;
}
bool postSeekComplete = false;
bool postEOS = false;
int64_t postEOSDelayUs = 0;
size_t size_done = 0;
size_t size_remaining = size;
while (size_remaining > 0) {
MediaSource::ReadOptions options;
bool refreshSeekTime = false;
{
Mutex::Autolock autoLock(mLock);
if (mSeeking) {
if (mIsFirstBuffer) {
if (mFirstBuffer != NULL) {
mFirstBuffer->release();
mFirstBuffer = NULL;
}
mIsFirstBuffer = false;
}
options.setSeekTo(mSeekTimeUs);
refreshSeekTime = true;
if (mInputBuffer != NULL) {
mInputBuffer->release();
mInputBuffer = NULL;
}
mSeeking = false;
if (mObserver) {
postSeekComplete = true;
}
}
}
if (mInputBuffer == NULL) {
status_t err;
if (mIsFirstBuffer) {
mInputBuffer = mFirstBuffer;
mFirstBuffer = NULL;
err = mFirstBufferResult;
mIsFirstBuffer = false;
} else {
if(!mSourcePaused) {
err = mSource->read(&mInputBuffer, &options);
if (err == OK && mInputBuffer == NULL && mSourcePaused) {
ALOGV("mSourcePaused, return 0 from fillBuffer");
return 0;
}
} else {
break;
}
}
if(err == -EAGAIN) {
if(mSourcePaused){
break;
} else {
continue;
}
}
CHECK((err == OK && mInputBuffer != NULL)
|| (err != OK && mInputBuffer == NULL));
Mutex::Autolock autoLock(mLock);
if (err != OK) {
if (!mReachedEOS) {
if (useOffload()) {
// After seek there is a possible race condition if
// OffloadThread is observing state_stopping_1 before
// framesReady() > 0. Ensure sink stop is called
// after last buffer is released. This ensures the
// partial buffer is written to the driver before
// stopping one is observed.The drawback is that
// there will be an unnecessary call to the parser
// after parser signalled EOS.
if (size_done > 0) {
ALOGW("send Partial buffer down\n");
ALOGW("skip calling stop till next fillBuffer\n");
break;
}
// no more buffers to push - stop() and wait for STREAM_END
// don't set mReachedEOS until stream end received
if (mAudioSink != NULL) {
mAudioSink->stop();
} else {
mAudioTrack->stop();
}
} else {
if (mObserver) {
// We don't want to post EOS right away but only
// after all frames have actually been played out.
// These are the number of frames submitted to the
// AudioTrack that you haven't heard yet.
uint32_t numFramesPendingPlayout =
getNumFramesPendingPlayout();
// These are the number of frames we're going to
// submit to the AudioTrack by returning from this
// callback.
uint32_t numAdditionalFrames = size_done / mFrameSize;
numFramesPendingPlayout += numAdditionalFrames;
int64_t timeToCompletionUs =
(1000000ll * numFramesPendingPlayout) / mSampleRate;
ALOGV("total number of frames played: %lld (%lld us)",
(mNumFramesPlayed + numAdditionalFrames),
1000000ll * (mNumFramesPlayed + numAdditionalFrames)
/ mSampleRate);
ALOGV("%d frames left to play, %lld us (%.2f secs)",
numFramesPendingPlayout,
timeToCompletionUs, timeToCompletionUs / 1E6);
postEOS = true;
if (mAudioSink->needsTrailingPadding()) {
postEOSDelayUs = timeToCompletionUs + mLatencyUs;
} else {
postEOSDelayUs = 0;
}
}
mReachedEOS = true;
}
}
mFinalStatus = err;
break;
}
if (mAudioSink != NULL) {
mLatencyUs = (int64_t)mAudioSink->latency() * 1000;
} else {
mLatencyUs = (int64_t)mAudioTrack->latency() * 1000;
}
if(mInputBuffer->range_length() != 0) {
CHECK(mInputBuffer->meta_data()->findInt64(
kKeyTime, &mPositionTimeMediaUs));
}
// need to adjust the mStartPosUs for offload decoding since parser
// might not be able to get the exact seek time requested.
if (refreshSeekTime) {
if (useOffload()) {
if (postSeekComplete) {
ALOGV("fillBuffer is going to post SEEK_COMPLETE");
mObserver->postAudioSeekComplete();
postSeekComplete = false;
}
mStartPosUs = mPositionTimeMediaUs;
ALOGV("adjust seek time to: %.2f", mStartPosUs/ 1E6);
}
// clear seek time with mLock locked and once we have valid mPositionTimeMediaUs
// and mPositionTimeRealUs
// before clearing mSeekTimeUs check if a new seek request has been received while
// we were reading from the source with mLock released.
if (!mSeeking) {
mSeekTimeUs = 0;
}
}
if (!useOffload()) {
mPositionTimeRealUs =
((mNumFramesPlayed + size_done / mFrameSize) * 1000000)
/ mSampleRate;
ALOGV("buffer->size() = %d, "
"mPositionTimeMediaUs=%.2f mPositionTimeRealUs=%.2f",
mInputBuffer->range_length(),
mPositionTimeMediaUs / 1E6, mPositionTimeRealUs / 1E6);
}
}
if (mInputBuffer->range_length() == 0) {
mInputBuffer->release();
mInputBuffer = NULL;
continue;
}
size_t copy = size_remaining;
if (copy > mInputBuffer->range_length()) {
copy = mInputBuffer->range_length();
}
memcpy((char *)data + size_done,
(const char *)mInputBuffer->data() + mInputBuffer->range_offset(),
copy);
mInputBuffer->set_range(mInputBuffer->range_offset() + copy,
mInputBuffer->range_length() - copy);
size_done += copy;
size_remaining -= copy;
}
if (useOffload()) {
// We must ask the hardware what it has played
mPositionTimeRealUs = getOutputPlayPositionUs_l();
ALOGV("mPositionTimeMediaUs=%.2f mPositionTimeRealUs=%.2f",
mPositionTimeMediaUs / 1E6, mPositionTimeRealUs / 1E6);
}
{
Mutex::Autolock autoLock(mLock);
mNumFramesPlayed += size_done / mFrameSize;
if (mReachedEOS) {
mPinnedTimeUs = mNumFramesPlayedSysTimeUs;
} else {
mNumFramesPlayedSysTimeUs = ALooper::GetNowUs();
mPinnedTimeUs = -1ll;
}
}
if (postEOS) {
mObserver->postAudioEOS(postEOSDelayUs);
}
if (postSeekComplete) {
mObserver->postAudioSeekComplete();
}
return size_done;
}
