jobject javaObjectForIBinder(JNIEnv* env, const sp<IBinder>& val)
{
if (val == NULL) return NULL;
if (val->checkSubclass(&gBinderOffsets)) {
// One of our own!
jobject object = static_cast<JavaBBinder*>(val.get())->object();
LOGDEATH("objectForBinder %p: it's our own %p!\n", val.get(), object);
return object;
}
// For the rest of the function we will hold this lock, to serialize
// looking/creation of Java proxies for native Binder proxies.
AutoMutex _l(mProxyLock);
// Someone else's... do we know about it?
jobject object = (jobject)val->findObject(&gBinderProxyOffsets);
if (object != NULL) {
jobject res = jniGetReferent(env, object);
if (res != NULL) {
ALOGV("objectForBinder %p: found existing %p!\n", val.get(), res);
return res;
}
LOGDEATH("Proxy object %p of IBinder %p no longer in working set!!!", object, val.get());
android_atomic_dec(&gNumProxyRefs);
val->detachObject(&gBinderProxyOffsets);
env->DeleteGlobalRef(object);
}
object = env->NewObject(gBinderProxyOffsets.mClass, gBinderProxyOffsets.mConstructor);
if (object != NULL) {
LOGDEATH("objectForBinder %p: created new proxy %p !\n", val.get(), object);
// The proxy holds a reference to the native object.
env->SetLongField(object, gBinderProxyOffsets.mObject, (jlong)val.get());
val->incStrong((void*)javaObjectForIBinder);
// The native object needs to hold a weak reference back to the
// proxy, so we can retrieve the same proxy if it is still active.
jobject refObject = env->NewGlobalRef(
env->GetObjectField(object, gBinderProxyOffsets.mSelf));
val->attachObject(&gBinderProxyOffsets, refObject,
jnienv_to_javavm(env), proxy_cleanup);
// Also remember the death recipients registered on this proxy
sp<DeathRecipientList> drl = new DeathRecipientList;
drl->incStrong((void*)javaObjectForIBinder);
env->SetLongField(object, gBinderProxyOffsets.mOrgue, reinterpret_cast<jlong>(drl.get()));
// Note that a new object reference has been created.
android_atomic_inc(&gNumProxyRefs);
incRefsCreated(env);
}
return object;
}
void ARTSPConnection::onInjectPacket(const sp<AMessage> &msg) {
sp<RefBase> obj;
CHECK(msg->findObject("buffer", &obj));
sp<ABuffer> buffer = static_cast<ABuffer *>(obj.get());
ssize_t n = send(mSocket, buffer->data(), buffer->size(), MTK_SEND_FLAG);
if (n == 0) {
ALOGW("Server unexpectedly closed the connection when sending RTCP.");
} else if (n < 0) {
ALOGW("errno when sending RTCP %d (%s)", errno, strerror(errno));
}
return;
}
void NuPlayer::renderBuffer(bool audio, const sp<AMessage> &msg) {
// LOGV("renderBuffer %s", audio ? "audio" : "video");
sp<AMessage> reply;
CHECK(msg->findMessage("reply", &reply));
if (IsFlushingState(audio ? mFlushingAudio : mFlushingVideo)) {
// We're currently attempting to flush the decoder, in order
// to complete this, the decoder wants all its buffers back,
// so we don't want any output buffers it sent us (from before
// we initiated the flush) to be stuck in the renderer's queue.
LOGV("we're still flushing the %s decoder, sending its output buffer"
" right back.", audio ? "audio" : "video");
reply->post();
return;
}
sp<RefBase> obj;
CHECK(msg->findObject("buffer", &obj));
sp<ABuffer> buffer = static_cast<ABuffer *>(obj.get());
int64_t &skipUntilMediaTimeUs =
audio
? mSkipRenderingAudioUntilMediaTimeUs
: mSkipRenderingVideoUntilMediaTimeUs;
if (skipUntilMediaTimeUs >= 0) {
int64_t mediaTimeUs;
CHECK(buffer->meta()->findInt64("timeUs", &mediaTimeUs));
if (mediaTimeUs < skipUntilMediaTimeUs) {
LOGV("dropping %s buffer at time %lld as requested.",
audio ? "audio" : "video",
mediaTimeUs);
reply->post();
return;
}
skipUntilMediaTimeUs = -1;
}
mRenderer->queueBuffer(audio, buffer, reply);
}
void NuPlayer::RTSPSource::onSDPLoaded(const sp<AMessage> &msg) {
status_t err;
CHECK(msg->findInt32("result", &err));
mSDPLoader.clear();
if (mDisconnectReplyID != 0) {
err = UNKNOWN_ERROR;
}
if (err == OK) {
sp<ASessionDescription> desc;
sp<RefBase> obj;
CHECK(msg->findObject("description", &obj));
desc = static_cast<ASessionDescription *>(obj.get());
AString rtspUri;
if (!desc->findAttribute(0, "a=control", &rtspUri)) {
ALOGE("Unable to find url in SDP");
err = UNKNOWN_ERROR;
} else {
sp<AMessage> notify = new AMessage(kWhatNotify, this);
mHandler = new MyHandler(rtspUri.c_str(), notify, mUIDValid, mUID);
mLooper->registerHandler(mHandler);
mHandler->loadSDP(desc);
}
}
if (err != OK) {
if (mState == CONNECTING) {
// We're still in the preparation phase, signal that it
// failed.
notifyPrepared(err);
}
mState = DISCONNECTED;
setError(err);
if (mDisconnectReplyID != 0) {
finishDisconnectIfPossible();
}
}
}
void NuPlayer::onMessageReceived(const sp<AMessage> &msg) {
switch (msg->what()) {
case kWhatSetDataSource:
{
ALOGV("kWhatSetDataSource");
CHECK(mSource == NULL);
sp<RefBase> obj;
CHECK(msg->findObject("source", &obj));
mSource = static_cast<Source *>(obj.get());
looper()->registerHandler(mSource);
CHECK(mDriver != NULL);
sp<NuPlayerDriver> driver = mDriver.promote();
if (driver != NULL) {
driver->notifySetDataSourceCompleted(OK);
}
break;
}
case kWhatPrepare:
{
mSource->prepareAsync();
break;
}
case kWhatGetTrackInfo:
{
uint32_t replyID;
CHECK(msg->senderAwaitsResponse(&replyID));
status_t err = INVALID_OPERATION;
if (mSource != NULL) {
Parcel* reply;
CHECK(msg->findPointer("reply", (void**)&reply));
err = mSource->getTrackInfo(reply);
}
sp<AMessage> response = new AMessage;
response->setInt32("err", err);
response->postReply(replyID);
break;
}
case kWhatSelectTrack:
{
uint32_t replyID;
CHECK(msg->senderAwaitsResponse(&replyID));
status_t err = INVALID_OPERATION;
if (mSource != NULL) {
size_t trackIndex;
int32_t select;
CHECK(msg->findSize("trackIndex", &trackIndex));
CHECK(msg->findInt32("select", &select));
err = mSource->selectTrack(trackIndex, select);
}
sp<AMessage> response = new AMessage;
response->setInt32("err", err);
response->postReply(replyID);
break;
}
case kWhatPollDuration:
{
int32_t generation;
CHECK(msg->findInt32("generation", &generation));
if (generation != mPollDurationGeneration) {
// stale
break;
}
int64_t durationUs;
if (mDriver != NULL && mSource->getDuration(&durationUs) == OK) {
sp<NuPlayerDriver> driver = mDriver.promote();
if (driver != NULL) {
driver->notifyDuration(durationUs);
}
}
msg->post(1000000ll); // poll again in a second.
break;
}
case kWhatSetVideoNativeWindow:
{
ALOGV("kWhatSetVideoNativeWindow");
mDeferredActions.push_back(
new ShutdownDecoderAction(
false /* audio */, true /* video */));
sp<RefBase> obj;
CHECK(msg->findObject("native-window", &obj));
mDeferredActions.push_back(
new SetSurfaceAction(
static_cast<NativeWindowWrapper *>(obj.get())));
if (obj != NULL) {
// If there is a new surface texture, instantiate decoders
// again if possible.
mDeferredActions.push_back(
new SimpleAction(&NuPlayer::performScanSources));
}
processDeferredActions();
break;
}
case kWhatSetAudioSink:
{
ALOGV("kWhatSetAudioSink");
sp<RefBase> obj;
CHECK(msg->findObject("sink", &obj));
mAudioSink = static_cast<MediaPlayerBase::AudioSink *>(obj.get());
break;
}
case kWhatStart:
{
ALOGV("kWhatStart");
mVideoIsAVC = false;
mAudioEOS = false;
mVideoEOS = false;
mSkipRenderingAudioUntilMediaTimeUs = -1;
mSkipRenderingVideoUntilMediaTimeUs = -1;
mVideoLateByUs = 0;
mNumFramesTotal = 0;
mNumFramesDropped = 0;
mStarted = true;
mSource->start();
uint32_t flags = 0;
if (mSource->isRealTime()) {
flags |= Renderer::FLAG_REAL_TIME;
}
mRenderer = new Renderer(
mAudioSink,
new AMessage(kWhatRendererNotify, id()),
flags);
looper()->registerHandler(mRenderer);
postScanSources();
break;
}
case kWhatScanSources:
{
int32_t generation;
CHECK(msg->findInt32("generation", &generation));
if (generation != mScanSourcesGeneration) {
// Drop obsolete msg.
break;
}
mScanSourcesPending = false;
ALOGV("scanning sources haveAudio=%d, haveVideo=%d",
mAudioDecoder != NULL, mVideoDecoder != NULL);
bool mHadAnySourcesBefore =
(mAudioDecoder != NULL) || (mVideoDecoder != NULL);
if (mNativeWindow != NULL) {
instantiateDecoder(false, &mVideoDecoder);
}
if (mAudioSink != NULL) {
instantiateDecoder(true, &mAudioDecoder);
}
if (!mHadAnySourcesBefore
&& (mAudioDecoder != NULL || mVideoDecoder != NULL)) {
// This is the first time we've found anything playable.
if (mSourceFlags & Source::FLAG_DYNAMIC_DURATION) {
schedulePollDuration();
}
}
status_t err;
if ((err = mSource->feedMoreTSData()) != OK) {
if (mAudioDecoder == NULL && mVideoDecoder == NULL) {
// We're not currently decoding anything (no audio or
// video tracks found) and we just ran out of input data.
if (err == ERROR_END_OF_STREAM) {
notifyListener(MEDIA_PLAYBACK_COMPLETE, 0, 0);
} else {
notifyListener(MEDIA_ERROR, MEDIA_ERROR_UNKNOWN, err);
}
}
break;
}
if ((mAudioDecoder == NULL && mAudioSink != NULL)
|| (mVideoDecoder == NULL && mNativeWindow != NULL)) {
msg->post(100000ll);
mScanSourcesPending = true;
}
break;
}
case kWhatVideoNotify:
case kWhatAudioNotify:
{
bool audio = msg->what() == kWhatAudioNotify;
sp<AMessage> codecRequest;
CHECK(msg->findMessage("codec-request", &codecRequest));
int32_t what;
CHECK(codecRequest->findInt32("what", &what));
if (what == ACodec::kWhatFillThisBuffer) {
status_t err = feedDecoderInputData(
audio, codecRequest);
if (err == -EWOULDBLOCK) {
if (mSource->feedMoreTSData() == OK) {
msg->post(10000ll);
}
}
} else if (what == ACodec::kWhatEOS) {
int32_t err;
CHECK(codecRequest->findInt32("err", &err));
if (err == ERROR_END_OF_STREAM) {
ALOGV("got %s decoder EOS", audio ? "audio" : "video");
} else {
ALOGV("got %s decoder EOS w/ error %d",
audio ? "audio" : "video",
err);
}
mRenderer->queueEOS(audio, err);
} else if (what == ACodec::kWhatFlushCompleted) {
bool needShutdown;
if (audio) {
CHECK(IsFlushingState(mFlushingAudio, &needShutdown));
mFlushingAudio = FLUSHED;
} else {
CHECK(IsFlushingState(mFlushingVideo, &needShutdown));
mFlushingVideo = FLUSHED;
mVideoLateByUs = 0;
}
ALOGV("decoder %s flush completed", audio ? "audio" : "video");
if (needShutdown) {
ALOGV("initiating %s decoder shutdown",
audio ? "audio" : "video");
(audio ? mAudioDecoder : mVideoDecoder)->initiateShutdown();
if (audio) {
mFlushingAudio = SHUTTING_DOWN_DECODER;
} else {
mFlushingVideo = SHUTTING_DOWN_DECODER;
}
}
finishFlushIfPossible();
} else if (what == ACodec::kWhatOutputFormatChanged) {
if (audio) {
int32_t numChannels;
CHECK(codecRequest->findInt32(
"channel-count", &numChannels));
int32_t sampleRate;
CHECK(codecRequest->findInt32("sample-rate", &sampleRate));
ALOGV("Audio output format changed to %d Hz, %d channels",
sampleRate, numChannels);
mAudioSink->close();
audio_output_flags_t flags;
int64_t durationUs;
// FIXME: we should handle the case where the video decoder
// is created after we receive the format change indication.
// Current code will just make that we select deep buffer
// with video which should not be a problem as it should
// not prevent from keeping A/V sync.
if (mVideoDecoder == NULL &&
mSource->getDuration(&durationUs) == OK &&
durationUs
> AUDIO_SINK_MIN_DEEP_BUFFER_DURATION_US) {
flags = AUDIO_OUTPUT_FLAG_DEEP_BUFFER;
} else {
flags = AUDIO_OUTPUT_FLAG_NONE;
}
int32_t channelMask;
if (!codecRequest->findInt32("channel-mask", &channelMask)) {
channelMask = CHANNEL_MASK_USE_CHANNEL_ORDER;
}
CHECK_EQ(mAudioSink->open(
sampleRate,
numChannels,
(audio_channel_mask_t)channelMask,
AUDIO_FORMAT_PCM_16_BIT,
8 /* bufferCount */,
NULL,
NULL,
flags),
(status_t)OK);
mAudioSink->start();
mRenderer->signalAudioSinkChanged();
} else {
// video
int32_t width, height;
CHECK(codecRequest->findInt32("width", &width));
CHECK(codecRequest->findInt32("height", &height));
int32_t cropLeft, cropTop, cropRight, cropBottom;
CHECK(codecRequest->findRect(
"crop",
&cropLeft, &cropTop, &cropRight, &cropBottom));
int32_t displayWidth = cropRight - cropLeft + 1;
int32_t displayHeight = cropBottom - cropTop + 1;
ALOGV("Video output format changed to %d x %d "
"(crop: %d x %d @ (%d, %d))",
width, height,
displayWidth,
displayHeight,
cropLeft, cropTop);
sp<AMessage> videoInputFormat =
mSource->getFormat(false /* audio */);
// Take into account sample aspect ratio if necessary:
int32_t sarWidth, sarHeight;
if (videoInputFormat->findInt32("sar-width", &sarWidth)
&& videoInputFormat->findInt32(
"sar-height", &sarHeight)) {
ALOGV("Sample aspect ratio %d : %d",
sarWidth, sarHeight);
displayWidth = (displayWidth * sarWidth) / sarHeight;
ALOGV("display dimensions %d x %d",
displayWidth, displayHeight);
}
notifyListener(
MEDIA_SET_VIDEO_SIZE, displayWidth, displayHeight);
}
} else if (what == ACodec::kWhatShutdownCompleted) {
ALOGV("%s shutdown completed", audio ? "audio" : "video");
if (audio) {
mAudioDecoder.clear();
CHECK_EQ((int)mFlushingAudio, (int)SHUTTING_DOWN_DECODER);
mFlushingAudio = SHUT_DOWN;
} else {
mVideoDecoder.clear();
CHECK_EQ((int)mFlushingVideo, (int)SHUTTING_DOWN_DECODER);
mFlushingVideo = SHUT_DOWN;
}
finishFlushIfPossible();
} else if (what == ACodec::kWhatError) {
ALOGE("Received error from %s decoder, aborting playback.",
audio ? "audio" : "video");
mRenderer->queueEOS(audio, UNKNOWN_ERROR);
} else if (what == ACodec::kWhatDrainThisBuffer) {
renderBuffer(audio, codecRequest);
} else if (what != ACodec::kWhatComponentAllocated
&& what != ACodec::kWhatComponentConfigured
&& what != ACodec::kWhatBuffersAllocated) {
ALOGV("Unhandled codec notification %d '%c%c%c%c'.",
what,
what >> 24,
(what >> 16) & 0xff,
(what >> 8) & 0xff,
what & 0xff);
}
break;
}
case kWhatRendererNotify:
{
int32_t what;
CHECK(msg->findInt32("what", &what));
if (what == Renderer::kWhatEOS) {
int32_t audio;
CHECK(msg->findInt32("audio", &audio));
int32_t finalResult;
CHECK(msg->findInt32("finalResult", &finalResult));
if (audio) {
mAudioEOS = true;
} else {
mVideoEOS = true;
}
if (finalResult == ERROR_END_OF_STREAM) {
ALOGV("reached %s EOS", audio ? "audio" : "video");
} else {
ALOGE("%s track encountered an error (%d)",
audio ? "audio" : "video", finalResult);
notifyListener(
MEDIA_ERROR, MEDIA_ERROR_UNKNOWN, finalResult);
}
if ((mAudioEOS || mAudioDecoder == NULL)
&& (mVideoEOS || mVideoDecoder == NULL)) {
notifyListener(MEDIA_PLAYBACK_COMPLETE, 0, 0);
}
} else if (what == Renderer::kWhatPosition) {
int64_t positionUs;
CHECK(msg->findInt64("positionUs", &positionUs));
CHECK(msg->findInt64("videoLateByUs", &mVideoLateByUs));
if (mDriver != NULL) {
sp<NuPlayerDriver> driver = mDriver.promote();
if (driver != NULL) {
driver->notifyPosition(positionUs);
driver->notifyFrameStats(
mNumFramesTotal, mNumFramesDropped);
}
}
} else if (what == Renderer::kWhatFlushComplete) {
int32_t audio;
CHECK(msg->findInt32("audio", &audio));
ALOGV("renderer %s flush completed.", audio ? "audio" : "video");
} else if (what == Renderer::kWhatVideoRenderingStart) {
notifyListener(MEDIA_INFO, MEDIA_INFO_RENDERING_START, 0);
} else if (what == Renderer::kWhatMediaRenderingStart) {
ALOGV("media rendering started");
notifyListener(MEDIA_STARTED, 0, 0);
}
break;
}
case kWhatMoreDataQueued:
{
break;
}
case kWhatReset:
{
ALOGV("kWhatReset");
mDeferredActions.push_back(
new ShutdownDecoderAction(
true /* audio */, true /* video */));
mDeferredActions.push_back(
new SimpleAction(&NuPlayer::performReset));
processDeferredActions();
break;
}
case kWhatSeek:
{
int64_t seekTimeUs;
CHECK(msg->findInt64("seekTimeUs", &seekTimeUs));
ALOGV("kWhatSeek seekTimeUs=%lld us", seekTimeUs);
mDeferredActions.push_back(
new SimpleAction(&NuPlayer::performDecoderFlush));
mDeferredActions.push_back(new SeekAction(seekTimeUs));
processDeferredActions();
break;
}
case kWhatPause:
{
CHECK(mRenderer != NULL);
mSource->pause();
mRenderer->pause();
break;
}
case kWhatResume:
{
CHECK(mRenderer != NULL);
mSource->resume();
mRenderer->resume();
break;
}
case kWhatSourceNotify:
{
onSourceNotify(msg);
break;
}
default:
TRESPASS();
break;
}
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::Renderer::onQueueBuffer(const sp<AMessage> &msg) {
int32_t audio;
CHECK(msg->findInt32("audio", &audio));
if (audio) {
mHasAudio = true;
} else {
mHasVideo = true;
}
if (dropBufferWhileFlushing(audio, msg)) {
return;
}
sp<RefBase> obj;
CHECK(msg->findObject("buffer", &obj));
sp<ABuffer> buffer = static_cast<ABuffer *>(obj.get());
sp<AMessage> notifyConsumed;
CHECK(msg->findMessage("notifyConsumed", ¬ifyConsumed));
QueueEntry entry;
entry.mBuffer = buffer;
entry.mNotifyConsumed = notifyConsumed;
entry.mOffset = 0;
entry.mFinalResult = OK;
if (audio) {
mAudioQueue.push_back(entry);
postDrainAudioQueue();
} else {
mVideoQueue.push_back(entry);
postDrainVideoQueue();
}
if (!mSyncQueues || mAudioQueue.empty() || mVideoQueue.empty()) {
return;
}
sp<ABuffer> firstAudioBuffer = (*mAudioQueue.begin()).mBuffer;
sp<ABuffer> firstVideoBuffer = (*mVideoQueue.begin()).mBuffer;
if (firstAudioBuffer == NULL || firstVideoBuffer == NULL) {
// EOS signalled on either queue.
syncQueuesDone();
return;
}
int64_t firstAudioTimeUs;
int64_t firstVideoTimeUs;
CHECK(firstAudioBuffer->meta()
->findInt64("timeUs", &firstAudioTimeUs));
CHECK(firstVideoBuffer->meta()
->findInt64("timeUs", &firstVideoTimeUs));
int64_t diff = firstVideoTimeUs - firstAudioTimeUs;
ALOGV("queueDiff = %.2f secs", diff / 1E6);
if (diff > 100000ll) {
// Audio data starts More than 0.1 secs before video.
// Drop some audio.
(*mAudioQueue.begin()).mNotifyConsumed->post();
mAudioQueue.erase(mAudioQueue.begin());
return;
}
syncQueuesDone();
}
void ARTPSession::onMessageReceived(const sp<AMessage> &msg) {
switch (msg->what()) {
case kWhatAccessUnitComplete:
{
int32_t firstRTCP;
if (msg->findInt32("first-rtcp", &firstRTCP)) {
// There won't be an access unit here, it's just a notification
// that the data communication worked since we got the first
// rtcp packet.
break;
}
size_t trackIndex;
CHECK(msg->findSize("track-index", &trackIndex));
int32_t eos;
if (msg->findInt32("eos", &eos) && eos) {
TrackInfo *info = &mTracks.editItemAt(trackIndex);
info->mPacketSource->signalEOS(ERROR_END_OF_STREAM);
break;
}
sp<RefBase> obj;
CHECK(msg->findObject("access-unit", &obj));
sp<ABuffer> accessUnit = static_cast<ABuffer *>(obj.get());
uint64_t ntpTime;
CHECK(accessUnit->meta()->findInt64(
"ntp-time", (int64_t *)&ntpTime));
#if 0
#if 0
printf("access unit complete size=%d\tntp-time=0x%016llx\n",
accessUnit->size(), ntpTime);
#else
LOGI("access unit complete, size=%d, ntp-time=%llu",
accessUnit->size(), ntpTime);
hexdump(accessUnit->data(), accessUnit->size());
#endif
#endif
#if 0
CHECK_GE(accessUnit->size(), 5u);
CHECK(!memcmp("\x00\x00\x00\x01", accessUnit->data(), 4));
unsigned x = accessUnit->data()[4];
LOGI("access unit complete: nalType=0x%02x, nalRefIdc=0x%02x",
x & 0x1f, (x & 0x60) >> 5);
#endif
accessUnit->meta()->setInt64("ntp-time", ntpTime);
accessUnit->meta()->setInt64("timeUs", 0);
#if 0
int32_t damaged;
if (accessUnit->meta()->findInt32("damaged", &damaged)
&& damaged != 0) {
LOGI("ignoring damaged AU");
} else
#endif
{
TrackInfo *info = &mTracks.editItemAt(trackIndex);
info->mPacketSource->queueAccessUnit(accessUnit);
}
break;
}
default:
TRESPASS();
break;
}
}
status_t WifiDisplaySource::onReceiveClientData(const sp<AMessage> &msg) {
int32_t sessionID;
CHECK(msg->findInt32("sessionID", &sessionID));
sp<RefBase> obj;
CHECK(msg->findObject("data", &obj));
sp<ParsedMessage> data =
static_cast<ParsedMessage *>(obj.get());
ALOGV("session %d received '%s'",
sessionID, data->debugString().c_str());
AString method;
AString uri;
data->getRequestField(0, &method);
int32_t cseq;
if (!data->findInt32("cseq", &cseq)) {
sendErrorResponse(sessionID, "400 Bad Request", -1 /* cseq */);
return ERROR_MALFORMED;
}
if (method.startsWith("RTSP/")) {
// This is a response.
ResponseID id;
id.mSessionID = sessionID;
id.mCSeq = cseq;
ssize_t index = mResponseHandlers.indexOfKey(id);
if (index < 0) {
ALOGW("Received unsolicited server response, cseq %d", cseq);
return ERROR_MALFORMED;
}
HandleRTSPResponseFunc func = mResponseHandlers.valueAt(index);
mResponseHandlers.removeItemsAt(index);
status_t err = (this->*func)(sessionID, data);
if (err != OK) {
ALOGW("Response handler for session %d, cseq %d returned "
"err %d (%s)",
sessionID, cseq, err, strerror(-err));
return err;
}
return OK;
}
AString version;
data->getRequestField(2, &version);
if (!(version == AString("RTSP/1.0"))) {
sendErrorResponse(sessionID, "505 RTSP Version not supported", cseq);
return ERROR_UNSUPPORTED;
}
status_t err;
if (method == "OPTIONS") {
err = onOptionsRequest(sessionID, cseq, data);
} else if (method == "SETUP") {
err = onSetupRequest(sessionID, cseq, data);
} else if (method == "PLAY") {
err = onPlayRequest(sessionID, cseq, data);
} else if (method == "PAUSE") {
err = onPauseRequest(sessionID, cseq, data);
} else if (method == "TEARDOWN") {
err = onTeardownRequest(sessionID, cseq, data);
} else if (method == "GET_PARAMETER") {
err = onGetParameterRequest(sessionID, cseq, data);
} else if (method == "SET_PARAMETER") {
err = onSetParameterRequest(sessionID, cseq, data);
} else {
sendErrorResponse(sessionID, "405 Method Not Allowed", cseq);
err = ERROR_UNSUPPORTED;
}
return err;
}
void TimedTextPlayer::onMessageReceived(const sp<AMessage> &msg) {
switch (msg->what()) {
case kWhatPause: {
mPaused = true;
break;
}
case kWhatResume: {
mPaused = false;
if (mPendingSeekTimeUs != kInvalidTimeUs) {
seekToAsync(mPendingSeekTimeUs);
mPendingSeekTimeUs = kInvalidTimeUs;
} else {
doRead();
}
break;
}
case kWhatStart: {
sp<MediaPlayerBase> listener = mListener.promote();
if (listener == NULL) {
ALOGE("Listener is NULL when kWhatStart is received.");
break;
}
mPaused = false;
mPendingSeekTimeUs = kInvalidTimeUs;
int32_t positionMs = 0;
listener->getCurrentPosition(&positionMs);
int64_t seekTimeUs = positionMs * 1000ll;
notifyListener();
mSendSubtitleGeneration++;
doSeekAndRead(seekTimeUs);
break;
}
case kWhatRetryRead: {
int32_t generation = -1;
CHECK(msg->findInt32("generation", &generation));
if (generation != mSendSubtitleGeneration) {
// Drop obsolete msg.
break;
}
int64_t seekTimeUs;
int seekMode;
if (msg->findInt64("seekTimeUs", &seekTimeUs) &&
msg->findInt32("seekMode", &seekMode)) {
MediaSource::ReadOptions options;
options.setSeekTo(
seekTimeUs,
static_cast<MediaSource::ReadOptions::SeekMode>(seekMode));
doRead(&options);
} else {
doRead();
}
break;
}
case kWhatSeek: {
int64_t seekTimeUs = kInvalidTimeUs;
// Clear a displayed timed text before seeking.
notifyListener();
msg->findInt64("seekTimeUs", &seekTimeUs);
if (seekTimeUs == kInvalidTimeUs) {
sp<MediaPlayerBase> listener = mListener.promote();
if (listener != NULL) {
int32_t positionMs = 0;
listener->getCurrentPosition(&positionMs);
seekTimeUs = positionMs * 1000ll;
}
}
if (mPaused) {
mPendingSeekTimeUs = seekTimeUs;
break;
}
mSendSubtitleGeneration++;
doSeekAndRead(seekTimeUs);
break;
}
case kWhatSendSubtitle: {
int32_t generation;
CHECK(msg->findInt32("generation", &generation));
if (generation != mSendSubtitleGeneration) {
// Drop obsolete msg.
break;
}
// If current time doesn't reach to the fire time,
// re-post the message with the adjusted delay time.
int64_t fireTimeUs = kInvalidTimeUs;
if (msg->findInt64("fireTimeUs", &fireTimeUs)) {
// TODO: check if fireTimeUs is not kInvalidTimeUs.
int64_t delayUs = delayUsFromCurrentTime(fireTimeUs);
if (delayUs > 0) {
msg->post(delayUs);
break;
}
}
sp<RefBase> obj;
if (msg->findObject("subtitle", &obj)) {
sp<ParcelEvent> parcelEvent;
parcelEvent = static_cast<ParcelEvent*>(obj.get());
notifyListener(&(parcelEvent->parcel));
doRead();
} else {
notifyListener();
}
break;
}
case kWhatSetSource: {
mSendSubtitleGeneration++;
sp<RefBase> obj;
msg->findObject("source", &obj);
if (mSource != NULL) {
mSource->stop();
mSource.clear();
mSource = NULL;
}
// null source means deselect track.
if (obj == NULL) {
mPendingSeekTimeUs = kInvalidTimeUs;
mPaused = false;
notifyListener();
break;
}
mSource = static_cast<TimedTextSource*>(obj.get());
status_t err = mSource->start();
if (err != OK) {
notifyError(err);
break;
}
Parcel parcel;
err = mSource->extractGlobalDescriptions(&parcel);
if (err != OK) {
notifyError(err);
break;
}
notifyListener(&parcel);
break;
}
}
}
void SimplePlayer::onMessageReceived(const sp<AMessage> &msg) {
switch (msg->what()) {
case kWhatSetDataSource:
{
status_t err;
if (mState != UNINITIALIZED) {
err = INVALID_OPERATION;
} else {
CHECK(msg->findString("path", &mPath));
mState = UNPREPARED;
}
uint32_t replyID;
CHECK(msg->senderAwaitsResponse(&replyID));
sp<AMessage> response = new AMessage;
response->setInt32("err", err);
response->postReply(replyID);
break;
}
case kWhatSetSurface:
{
status_t err;
if (mState != UNPREPARED) {
err = INVALID_OPERATION;
} else {
sp<RefBase> obj;
CHECK(msg->findObject("native-window", &obj));
mNativeWindow = static_cast<NativeWindowWrapper *>(obj.get());
err = OK;
}
uint32_t replyID;
CHECK(msg->senderAwaitsResponse(&replyID));
sp<AMessage> response = new AMessage;
response->setInt32("err", err);
response->postReply(replyID);
break;
}
case kWhatPrepare:
{
status_t err;
if (mState != UNPREPARED) {
err = INVALID_OPERATION;
} else {
err = onPrepare();
if (err == OK) {
mState = STOPPED;
}
}
uint32_t replyID;
CHECK(msg->senderAwaitsResponse(&replyID));
sp<AMessage> response = new AMessage;
response->setInt32("err", err);
response->postReply(replyID);
break;
}
case kWhatStart:
{
status_t err = OK;
if (mState == UNPREPARED) {
err = onPrepare();
if (err == OK) {
mState = STOPPED;
}
}
if (err == OK) {
if (mState != STOPPED) {
err = INVALID_OPERATION;
} else {
err = onStart();
if (err == OK) {
mState = STARTED;
}
}
}
uint32_t replyID;
CHECK(msg->senderAwaitsResponse(&replyID));
sp<AMessage> response = new AMessage;
response->setInt32("err", err);
response->postReply(replyID);
break;
}
case kWhatStop:
{
status_t err;
if (mState != STARTED) {
err = INVALID_OPERATION;
} else {
err = onStop();
if (err == OK) {
mState = STOPPED;
}
}
uint32_t replyID;
CHECK(msg->senderAwaitsResponse(&replyID));
sp<AMessage> response = new AMessage;
response->setInt32("err", err);
response->postReply(replyID);
break;
}
case kWhatReset:
{
status_t err = OK;
if (mState == STARTED) {
CHECK_EQ(onStop(), (status_t)OK);
mState = STOPPED;
}
if (mState == STOPPED) {
err = onReset();
mState = UNINITIALIZED;
}
uint32_t replyID;
CHECK(msg->senderAwaitsResponse(&replyID));
sp<AMessage> response = new AMessage;
response->setInt32("err", err);
response->postReply(replyID);
break;
}
case kWhatDoMoreStuff:
{
int32_t generation;
CHECK(msg->findInt32("generation", &generation));
if (generation != mDoMoreStuffGeneration) {
break;
}
status_t err = onDoMoreStuff();
if (err == OK) {
msg->post(10000ll);
}
break;
}
default:
TRESPASS();
}
}
void TimedTextPlayer::onMessageReceived(const sp<AMessage> &msg) {
switch (msg->what()) {
case kWhatPause: {
mSendSubtitleGeneration++;
break;
}
case kWhatRetryRead: {
int64_t seekTimeUs;
int seekMode;
if (msg->findInt64("seekTimeUs", &seekTimeUs) &&
msg->findInt32("seekMode", &seekMode)) {
MediaSource::ReadOptions options;
options.setSeekTo(
seekTimeUs,
static_cast<MediaSource::ReadOptions::SeekMode>(seekMode));
doRead(&options);
} else {
doRead();
}
break;
}
case kWhatSeek: {
int64_t seekTimeUs = 0;
msg->findInt64("seekTimeUs", &seekTimeUs);
if (seekTimeUs < 0) {
sp<MediaPlayerBase> listener = mListener.promote();
if (listener != NULL) {
int32_t positionMs = 0;
listener->getCurrentPosition(&positionMs);
seekTimeUs = positionMs * 1000ll;
}
}
doSeekAndRead(seekTimeUs);
break;
}
case kWhatSendSubtitle: {
int32_t generation;
CHECK(msg->findInt32("generation", &generation));
if (generation != mSendSubtitleGeneration) {
// Drop obsolete msg.
break;
}
sp<RefBase> obj;
if (msg->findObject("subtitle", &obj)) {
sp<ParcelEvent> parcelEvent;
parcelEvent = static_cast<ParcelEvent*>(obj.get());
notifyListener(&(parcelEvent->parcel));
doRead();
} else {
notifyListener();
}
break;
}
case kWhatSetSource: {
sp<RefBase> obj;
msg->findObject("source", &obj);
if (obj == NULL) break;
if (mSource != NULL) {
mSource->stop();
}
mSource = static_cast<TimedTextSource*>(obj.get());
status_t err = mSource->start();
if (err != OK) {
notifyError(err);
break;
}
Parcel parcel;
err = mSource->extractGlobalDescriptions(&parcel);
if (err != OK) {
notifyError(err);
break;
}
notifyListener(&parcel);
break;
}
}
}
void NuPlayer::onMessageReceived(const sp<AMessage> &msg) {
switch (msg->what()) {
case kWhatSetDataSource:
{
LOGV("kWhatSetDataSource");
CHECK(mSource == NULL);
sp<RefBase> obj;
CHECK(msg->findObject("source", &obj));
mSource = static_cast<Source *>(obj.get());
break;
}
case kWhatSetVideoNativeWindow:
{
LOGV("kWhatSetVideoNativeWindow");
sp<RefBase> obj;
CHECK(msg->findObject("native-window", &obj));
mNativeWindow = static_cast<NativeWindowWrapper *>(obj.get());
break;
}
case kWhatSetAudioSink:
{
LOGV("kWhatSetAudioSink");
sp<RefBase> obj;
CHECK(msg->findObject("sink", &obj));
mAudioSink = static_cast<MediaPlayerBase::AudioSink *>(obj.get());
break;
}
case kWhatStart:
{
LOGV("kWhatStart");
mVideoIsAVC = false;
mAudioEOS = false;
mVideoEOS = false;
mSkipRenderingAudioUntilMediaTimeUs = -1;
mSkipRenderingVideoUntilMediaTimeUs = -1;
mVideoLateByUs = 0;
mNumFramesTotal = 0;
mNumFramesDropped = 0;
mSource->start();
mRenderer = new Renderer(
mAudioSink,
new AMessage(kWhatRendererNotify, id()));
looper()->registerHandler(mRenderer);
postScanSources();
break;
}
case kWhatScanSources:
{
int32_t generation;
CHECK(msg->findInt32("generation", &generation));
if (generation != mScanSourcesGeneration) {
// Drop obsolete msg.
break;
}
mScanSourcesPending = false;
LOGV("scanning sources haveAudio=%d, haveVideo=%d",
mAudioDecoder != NULL, mVideoDecoder != NULL);
instantiateDecoder(false, &mVideoDecoder);
if (mAudioSink != NULL) {
instantiateDecoder(true, &mAudioDecoder);
}
status_t err;
if ((err = mSource->feedMoreTSData()) != OK) {
if (mAudioDecoder == NULL && mVideoDecoder == NULL) {
// We're not currently decoding anything (no audio or
// video tracks found) and we just ran out of input data.
if (err == ERROR_END_OF_STREAM) {
notifyListener(MEDIA_PLAYBACK_COMPLETE, 0, 0);
} else {
notifyListener(MEDIA_ERROR, MEDIA_ERROR_UNKNOWN, err);
}
}
break;
}
if (mAudioDecoder == NULL || mVideoDecoder == NULL) {
msg->post(100000ll);
mScanSourcesPending = true;
}
break;
}
case kWhatVideoNotify:
case kWhatAudioNotify:
{
bool audio = msg->what() == kWhatAudioNotify;
sp<AMessage> codecRequest;
CHECK(msg->findMessage("codec-request", &codecRequest));
int32_t what;
CHECK(codecRequest->findInt32("what", &what));
if (what == ACodec::kWhatFillThisBuffer) {
status_t err = feedDecoderInputData(
audio, codecRequest);
if (err == -EWOULDBLOCK) {
if (mSource->feedMoreTSData() == OK) {
msg->post(10000ll);
}
}
} else if (what == ACodec::kWhatEOS) {
int32_t err;
CHECK(codecRequest->findInt32("err", &err));
if (err == ERROR_END_OF_STREAM) {
LOGV("got %s decoder EOS", audio ? "audio" : "video");
} else {
LOGV("got %s decoder EOS w/ error %d",
audio ? "audio" : "video",
err);
}
mRenderer->queueEOS(audio, err);
} else if (what == ACodec::kWhatFlushCompleted) {
bool needShutdown;
if (audio) {
CHECK(IsFlushingState(mFlushingAudio, &needShutdown));
mFlushingAudio = FLUSHED;
} else {
CHECK(IsFlushingState(mFlushingVideo, &needShutdown));
mFlushingVideo = FLUSHED;
mVideoLateByUs = 0;
}
LOGV("decoder %s flush completed", audio ? "audio" : "video");
if (needShutdown) {
LOGV("initiating %s decoder shutdown",
audio ? "audio" : "video");
(audio ? mAudioDecoder : mVideoDecoder)->initiateShutdown();
if (audio) {
mFlushingAudio = SHUTTING_DOWN_DECODER;
} else {
mFlushingVideo = SHUTTING_DOWN_DECODER;
}
}
finishFlushIfPossible();
} else if (what == ACodec::kWhatOutputFormatChanged) {
if (audio) {
int32_t numChannels;
CHECK(codecRequest->findInt32("channel-count", &numChannels));
int32_t sampleRate;
CHECK(codecRequest->findInt32("sample-rate", &sampleRate));
LOGV("Audio output format changed to %d Hz, %d channels",
sampleRate, numChannels);
mAudioSink->close();
CHECK_EQ(mAudioSink->open(
sampleRate,
numChannels,
AUDIO_FORMAT_PCM_16_BIT,
8 /* bufferCount */),
(status_t)OK);
mAudioSink->start();
mRenderer->signalAudioSinkChanged();
} else {
// video
int32_t width, height;
CHECK(codecRequest->findInt32("width", &width));
CHECK(codecRequest->findInt32("height", &height));
int32_t cropLeft, cropTop, cropRight, cropBottom;
CHECK(codecRequest->findRect(
"crop",
&cropLeft, &cropTop, &cropRight, &cropBottom));
LOGV("Video output format changed to %d x %d "
"(crop: %d x %d @ (%d, %d))",
width, height,
(cropRight - cropLeft + 1),
(cropBottom - cropTop + 1),
cropLeft, cropTop);
notifyListener(
MEDIA_SET_VIDEO_SIZE,
cropRight - cropLeft + 1,
cropBottom - cropTop + 1);
}
} else if (what == ACodec::kWhatShutdownCompleted) {
LOGV("%s shutdown completed", audio ? "audio" : "video");
if (audio) {
mAudioDecoder.clear();
CHECK_EQ((int)mFlushingAudio, (int)SHUTTING_DOWN_DECODER);
mFlushingAudio = SHUT_DOWN;
} else {
mVideoDecoder.clear();
CHECK_EQ((int)mFlushingVideo, (int)SHUTTING_DOWN_DECODER);
mFlushingVideo = SHUT_DOWN;
}
finishFlushIfPossible();
} else if (what == ACodec::kWhatError) {
LOGE("Received error from %s decoder, aborting playback.",
audio ? "audio" : "video");
mRenderer->queueEOS(audio, UNKNOWN_ERROR);
} else {
CHECK_EQ((int)what, (int)ACodec::kWhatDrainThisBuffer);
renderBuffer(audio, codecRequest);
}
break;
}
case kWhatRendererNotify:
{
int32_t what;
CHECK(msg->findInt32("what", &what));
if (what == Renderer::kWhatEOS) {
int32_t audio;
CHECK(msg->findInt32("audio", &audio));
int32_t finalResult;
CHECK(msg->findInt32("finalResult", &finalResult));
if (audio) {
mAudioEOS = true;
} else {
mVideoEOS = true;
}
if (finalResult == ERROR_END_OF_STREAM) {
LOGV("reached %s EOS", audio ? "audio" : "video");
} else {
LOGE("%s track encountered an error (%d)",
audio ? "audio" : "video", finalResult);
notifyListener(
MEDIA_ERROR, MEDIA_ERROR_UNKNOWN, finalResult);
}
if ((mAudioEOS || mAudioDecoder == NULL)
&& (mVideoEOS || mVideoDecoder == NULL)) {
notifyListener(MEDIA_PLAYBACK_COMPLETE, 0, 0);
}
} else if (what == Renderer::kWhatPosition) {
int64_t positionUs;
CHECK(msg->findInt64("positionUs", &positionUs));
CHECK(msg->findInt64("videoLateByUs", &mVideoLateByUs));
if (mDriver != NULL) {
sp<NuPlayerDriver> driver = mDriver.promote();
if (driver != NULL) {
driver->notifyPosition(positionUs);
driver->notifyFrameStats(
mNumFramesTotal, mNumFramesDropped);
}
}
} else if (what == Renderer::kWhatFlushComplete) {
CHECK_EQ(what, (int32_t)Renderer::kWhatFlushComplete);
int32_t audio;
CHECK(msg->findInt32("audio", &audio));
LOGV("renderer %s flush completed.", audio ? "audio" : "video");
}
break;
}
case kWhatMoreDataQueued:
{
break;
}
case kWhatReset:
{
LOGV("kWhatReset");
if (mRenderer != NULL) {
// There's an edge case where the renderer owns all output
// buffers and is paused, therefore the decoder will not read
// more input data and will never encounter the matching
// discontinuity. To avoid this, we resume the renderer.
if (mFlushingAudio == AWAITING_DISCONTINUITY
|| mFlushingVideo == AWAITING_DISCONTINUITY) {
mRenderer->resume();
}
}
if (mFlushingAudio != NONE || mFlushingVideo != NONE) {
// We're currently flushing, postpone the reset until that's
// completed.
LOGV("postponing reset mFlushingAudio=%d, mFlushingVideo=%d",
mFlushingAudio, mFlushingVideo);
mResetPostponed = true;
break;
}
if (mAudioDecoder == NULL && mVideoDecoder == NULL) {
finishReset();
break;
}
mTimeDiscontinuityPending = true;
if (mAudioDecoder != NULL) {
flushDecoder(true /* audio */, true /* needShutdown */);
}
if (mVideoDecoder != NULL) {
flushDecoder(false /* audio */, true /* needShutdown */);
}
mResetInProgress = true;
break;
}
case kWhatSeek:
{
int64_t seekTimeUs;
CHECK(msg->findInt64("seekTimeUs", &seekTimeUs));
LOGV("kWhatSeek seekTimeUs=%lld us (%.2f secs)",
seekTimeUs, seekTimeUs / 1E6);
mSource->seekTo(seekTimeUs);
if (mDriver != NULL) {
sp<NuPlayerDriver> driver = mDriver.promote();
if (driver != NULL) {
driver->notifySeekComplete();
}
}
break;
}
case kWhatPause:
{
CHECK(mRenderer != NULL);
mRenderer->pause();
break;
}
case kWhatResume:
{
CHECK(mRenderer != NULL);
mRenderer->resume();
break;
}
default:
TRESPASS();
break;
}
}
