void SourceFile::seek( size_t readPositionFrames )
{
if( readPositionFrames >= mNumFrames )
return;
// adjust read pos for samplerate conversion so that it is relative to file num frames
size_t fileReadPos = readPositionFrames;
if( getSampleRate() != getSampleRateNative() )
fileReadPos *= size_t( (float)mFileNumFrames / (float)mNumFrames );
performSeek( fileReadPos );
mReadPos = readPositionFrames;
}
void RTSPSource::onMessageReceived(const sp<AMessage> &msg) {
if (msg->what() == kWhatDisconnect) {
uint32_t replyID;
CHECK(msg->senderAwaitsResponse(&replyID));
mDisconnectReplyID = replyID;
finishDisconnectIfPossible();
return;
} else if (msg->what() == kWhatPerformSeek) {
int32_t generation;
CHECK(msg->findInt32("generation", &generation));
if (generation != mSeekGeneration) {
// obsolete.
return;
}
int64_t seekTimeUs;
CHECK(msg->findInt64("timeUs", &seekTimeUs));
performSeek(seekTimeUs);
return;
} else if (msg->what() == kWhatPerformPlay) {
int64_t playTimeUs;
CHECK(msg->findInt64("timeUs", &playTimeUs));
performPlay(playTimeUs);
return;
} else if (msg->what() == kWhatPerformPause) {
performPause();
return;
} else if (msg->what() == kWhatPerformResume) {
performResume();
return;
} else if (msg->what() == kWhatPerformSuspend) {
performSuspend();
return;
}
CHECK_EQ(msg->what(), (uint32_t)kWhatNotify);
int32_t what;
int32_t isSeekable = 0;
CHECK(msg->findInt32("what", &what));
switch (what) {
case RtspConnectionHandler::kWhatConnected:
CHECK(msg->findInt32("isSeekable", &isSeekable));
onConnected((isSeekable ? true:false));
break;
case RtspConnectionHandler::kWhatDisconnected:
onDisconnected(msg);
break;
case RtspConnectionHandler::kWhatSeekDone:
{
mState = PLAYING;
// Even if we have reset mLatestPausedUnit in performSeek(),
// it's still possible that kWhatPausedDone event may arrive
// because of previous performPause() command.
for (size_t i = 0; i < mTracks.size(); ++i) {
TrackInfo *info = &mTracks.editItemAt(i);
info->mLatestPausedUnit = 0;
}
mLatestPausedUnit = 0;
break;
}
case RtspConnectionHandler::kWhatPausedDone:
{
for (size_t i = 0; i < mTracks.size(); ++i) {
TrackInfo *info = &mTracks.editItemAt(i);
info->mLatestPausedUnit = info->mLatestReceivedUnit;
}
// The timestamp after a 'Pause' is done is the earliest
// timestamp among all of the latest received units.
TrackInfo *info = &mTracks.editItemAt(0);
mLatestPausedUnit = info->mLatestReceivedUnit;
for (size_t i = 1; i < mTracks.size(); ++i) {
TrackInfo *info = &mTracks.editItemAt(i);
if (mLatestPausedUnit > info->mLatestReceivedUnit) {
mLatestPausedUnit = info->mLatestReceivedUnit;
}
}
break;
}
case RtspConnectionHandler::kWhatAccessUnit:
{
size_t trackIndex;
CHECK(msg->findSize("trackIndex", &trackIndex));
CHECK_LT(trackIndex, mTracks.size());
sp<RefBase> obj;
CHECK(msg->findObject("accessUnit", &obj));
sp<ABuffer> accessUnit = static_cast<ABuffer *>(obj.get());
int32_t damaged;
if (accessUnit->meta()->findInt32("damaged", &damaged)
&& damaged) {
LOGI("dropping damaged access unit.");
break;
}
TrackInfo *info = &mTracks.editItemAt(trackIndex);
sp<AnotherPacketSource> source = info->mSource;
if (source != NULL) {
uint32_t rtpTime;
CHECK(accessUnit->meta()->findInt32("rtp-time", (int32_t *)&rtpTime));
if (!info->mNPTMappingValid) {
// This is a live stream, we didn't receive any normal
// playtime mapping. Assume the first packets correspond
// to time 0.
LOGV("This is a live stream, assuming time = 0");
info->mRTPTime = rtpTime;
info->mNormalPlaytimeUs = 0ll;
info->mNPTMappingValid = true;
}
int64_t nptUs =
((double)rtpTime - (double)info->mRTPTime)
/ info->mTimeScale
* 1000000ll
+ info->mNormalPlaytimeUs;
accessUnit->meta()->setInt64("timeUs", nptUs);
info->mLatestReceivedUnit = nptUs;
// Drop the frames that are older than the frames in the queue.
if (info->mLatestPausedUnit && (int64_t)info->mLatestPausedUnit > nptUs) {
break;
}
source->queueAccessUnit(accessUnit);
}
onTrackDataAvailable(trackIndex);
break;
}
case RtspConnectionHandler::kWhatEOS:
{
size_t trackIndex;
CHECK(msg->findSize("trackIndex", &trackIndex));
CHECK_LT(trackIndex, mTracks.size());
int32_t finalResult;
CHECK(msg->findInt32("finalResult", &finalResult));
CHECK_NE(finalResult, (status_t)OK);
TrackInfo *info = &mTracks.editItemAt(trackIndex);
sp<AnotherPacketSource> source = info->mSource;
if (source != NULL) {
source->signalEOS(finalResult);
}
break;
}
case RtspConnectionHandler::kWhatSeekDiscontinuity:
{
size_t trackIndex;
CHECK(msg->findSize("trackIndex", &trackIndex));
CHECK_LT(trackIndex, mTracks.size());
TrackInfo *info = &mTracks.editItemAt(trackIndex);
sp<AnotherPacketSource> source = info->mSource;
if (source != NULL) {
source->queueDiscontinuity(ATSParser::DISCONTINUITY_SEEK, NULL);
}
break;
}
case RtspConnectionHandler::kWhatNormalPlayTimeMapping:
{
size_t trackIndex;
CHECK(msg->findSize("trackIndex", &trackIndex));
CHECK_LT(trackIndex, mTracks.size());
uint32_t rtpTime;
CHECK(msg->findInt32("rtpTime", (int32_t *)&rtpTime));
int64_t nptUs;
CHECK(msg->findInt64("nptUs", &nptUs));
TrackInfo *info = &mTracks.editItemAt(trackIndex);
info->mRTPTime = rtpTime;
info->mNormalPlaytimeUs = nptUs;
info->mNPTMappingValid = true;
break;
}
case RtspConnectionHandler::kWhatTryTCPInterleaving:
{
// By default, we will request to deliver RTP over UDP. If the play
// request timed out and we didn't receive any RTP packet, we will
// fail back to use RTP interleaved in the existing RTSP/TCP
// connection. And in this case, we have to explicitly perform
// another play event to request the server to start streaming
// again.
int64_t playTimeUs;
if (!msg->findInt64("timeUs", &playTimeUs)) {
playTimeUs = 0;
}
performPlay(playTimeUs);
break;
}
default:
TRESPASS();
}
}
void NuPlayer::RTSPSource::onMessageReceived(const sp<AMessage> &msg) {
if (msg->what() == kWhatDisconnect) {
sp<AReplyToken> replyID;
CHECK(msg->senderAwaitsResponse(&replyID));
mDisconnectReplyID = replyID;
finishDisconnectIfPossible();
return;
} else if (msg->what() == kWhatPerformSeek) {
int32_t generation;
CHECK(msg->findInt32("generation", &generation));
CHECK(msg->senderAwaitsResponse(&mSeekReplyID));
if (generation != mSeekGeneration) {
// obsolete.
finishSeek(OK);
return;
}
int64_t seekTimeUs;
CHECK(msg->findInt64("timeUs", &seekTimeUs));
performSeek(seekTimeUs);
return;
} else if (msg->what() == kWhatPollBuffering) {
onPollBuffering();
return;
} else if (msg->what() == kWhatSignalEOS) {
onSignalEOS(msg);
return;
}
CHECK_EQ(msg->what(), (int)kWhatNotify);
int32_t what;
CHECK(msg->findInt32("what", &what));
switch (what) {
case MyHandler::kWhatConnected:
{
onConnected();
notifyVideoSizeChanged();
uint32_t flags = 0;
if (mHandler->isSeekable()) {
flags = FLAG_CAN_PAUSE
| FLAG_CAN_SEEK
| FLAG_CAN_SEEK_BACKWARD
| FLAG_CAN_SEEK_FORWARD;
}
notifyFlagsChanged(flags);
schedulePollBuffering();
break;
}
case MyHandler::kWhatDisconnected:
{
onDisconnected(msg);
break;
}
case MyHandler::kWhatSeekDone:
{
mState = CONNECTED;
// Unblock seekTo here in case we attempted to seek in a live stream
finishSeek(OK);
break;
}
case MyHandler::kWhatSeekPaused:
{
sp<AnotherPacketSource> source = getSource(true /* audio */);
if (source != NULL) {
source->queueDiscontinuity(ATSParser::DISCONTINUITY_NONE,
/* extra */ NULL,
/* discard */ true);
}
source = getSource(false /* video */);
if (source != NULL) {
source->queueDiscontinuity(ATSParser::DISCONTINUITY_NONE,
/* extra */ NULL,
/* discard */ true);
};
status_t err = OK;
msg->findInt32("err", &err);
if (err == OK) {
int64_t timeUs;
CHECK(msg->findInt64("time", &timeUs));
mHandler->continueSeekAfterPause(timeUs);
} else {
finishSeek(err);
}
break;
}
case MyHandler::kWhatAccessUnit:
{
size_t trackIndex;
CHECK(msg->findSize("trackIndex", &trackIndex));
if (mTSParser == NULL) {
CHECK_LT(trackIndex, mTracks.size());
} else {
CHECK_EQ(trackIndex, 0u);
}
sp<ABuffer> accessUnit;
CHECK(msg->findBuffer("accessUnit", &accessUnit));
int32_t damaged;
if (accessUnit->meta()->findInt32("damaged", &damaged)
&& damaged) {
ALOGI("dropping damaged access unit.");
break;
}
if (mTSParser != NULL) {
size_t offset = 0;
status_t err = OK;
while (offset + 188 <= accessUnit->size()) {
err = mTSParser->feedTSPacket(
accessUnit->data() + offset, 188);
if (err != OK) {
break;
}
offset += 188;
}
if (offset < accessUnit->size()) {
err = ERROR_MALFORMED;
}
if (err != OK) {
signalSourceEOS(err);
}
postSourceEOSIfNecessary();
break;
}
TrackInfo *info = &mTracks.editItemAt(trackIndex);
sp<AnotherPacketSource> source = info->mSource;
if (source != NULL) {
uint32_t rtpTime;
CHECK(accessUnit->meta()->findInt32("rtp-time", (int32_t *)&rtpTime));
if (!info->mNPTMappingValid) {
// This is a live stream, we didn't receive any normal
// playtime mapping. We won't map to npt time.
source->queueAccessUnit(accessUnit);
break;
}
int64_t nptUs =
((double)rtpTime - (double)info->mRTPTime)
/ info->mTimeScale
* 1000000ll
+ info->mNormalPlaytimeUs;
accessUnit->meta()->setInt64("timeUs", nptUs);
source->queueAccessUnit(accessUnit);
}
postSourceEOSIfNecessary();
break;
}
case MyHandler::kWhatEOS:
{
int32_t finalResult;
CHECK(msg->findInt32("finalResult", &finalResult));
CHECK_NE(finalResult, (status_t)OK);
if (mTSParser != NULL) {
signalSourceEOS(finalResult);
}
size_t trackIndex;
CHECK(msg->findSize("trackIndex", &trackIndex));
CHECK_LT(trackIndex, mTracks.size());
TrackInfo *info = &mTracks.editItemAt(trackIndex);
sp<AnotherPacketSource> source = info->mSource;
if (source != NULL) {
source->signalEOS(finalResult);
}
break;
}
case MyHandler::kWhatSeekDiscontinuity:
{
size_t trackIndex;
CHECK(msg->findSize("trackIndex", &trackIndex));
CHECK_LT(trackIndex, mTracks.size());
TrackInfo *info = &mTracks.editItemAt(trackIndex);
sp<AnotherPacketSource> source = info->mSource;
if (source != NULL) {
source->queueDiscontinuity(
ATSParser::DISCONTINUITY_TIME,
NULL,
true /* discard */);
}
break;
}
case MyHandler::kWhatNormalPlayTimeMapping:
{
size_t trackIndex;
CHECK(msg->findSize("trackIndex", &trackIndex));
CHECK_LT(trackIndex, mTracks.size());
uint32_t rtpTime;
CHECK(msg->findInt32("rtpTime", (int32_t *)&rtpTime));
int64_t nptUs;
CHECK(msg->findInt64("nptUs", &nptUs));
TrackInfo *info = &mTracks.editItemAt(trackIndex);
info->mRTPTime = rtpTime;
info->mNormalPlaytimeUs = nptUs;
info->mNPTMappingValid = true;
break;
}
case SDPLoader::kWhatSDPLoaded:
{
onSDPLoaded(msg);
break;
}
default:
TRESPASS();
}
}
