void ARTSPConnection::onMessageReceived(const sp<AMessage> &msg) {
switch (msg->what()) {
case kWhatConnect:
onConnect(msg);
break;
case kWhatDisconnect:
onDisconnect(msg);
break;
case kWhatCompleteConnection:
onCompleteConnection(msg);
break;
case kWhatSendRequest:
onSendRequest(msg);
break;
case kWhatReceiveResponse:
onReceiveResponse();
break;
case kWhatObserveBinaryData:
{
CHECK(msg->findMessage("reply", &mObserveBinaryMessage));
break;
}
default:
TRESPASS();
break;
}
}
void ARTSPConnection::onReconnect(const sp<AMessage> &msg) {
ALOGV("onReconnect");
sp<AMessage> reply;
CHECK(msg->findMessage("reply", &reply));
int32_t connectionID;
CHECK(msg->findInt32("connection-id", &connectionID));
if ((connectionID != mConnectionID) || mState != CONNECTING) {
// While we were attempting to connect, the attempt was
// cancelled.
reply->setInt32("result", -ECONNABORTED);
reply->post();
if (mAddrHeader != NULL) {
freeaddrinfo((struct addrinfo *)mAddrHeader);
mAddrHeader = NULL;
}
return;
}
int32_t port;
CHECK(msg->findInt32("port", &port));
if (!createSocketAndConnect(mAddrHeader, port, reply)) {
ALOGV("Failed to reconnect");
reply->setInt32("result", -errno);
mState = DISCONNECTED;
mSocket = -1;
reply->post();
freeaddrinfo((struct addrinfo *)mAddrHeader);
mAddrHeader = NULL;
}
}
void ARTSPConnection::onCompleteConnection(const sp<AMessage> &msg) {
sp<AMessage> reply;
CHECK(msg->findMessage("reply", &reply));
int32_t connectionID;
CHECK(msg->findInt32("connection-id", &connectionID));
if ((connectionID != mConnectionID) || mState != CONNECTING) {
// While we were attempting to connect, the attempt was
// cancelled.
reply->setInt32("result", -ECONNABORTED);
reply->post();
return;
}
struct timeval tv;
tv.tv_sec = 0;
tv.tv_usec = kSelectTimeoutUs;
fd_set ws;
FD_ZERO(&ws);
FD_SET(mSocket, &ws);
int res = select(mSocket + 1, NULL, &ws, NULL, &tv);
CHECK_GE(res, 0);
if (res == 0) {
// Timed out. Not yet connected.
msg->post();
return;
}
int err;
socklen_t optionLen = sizeof(err);
CHECK_EQ(getsockopt(mSocket, SOL_SOCKET, SO_ERROR, &err, &optionLen), 0);
CHECK_EQ(optionLen, (socklen_t)sizeof(err));
if (err != 0) {
LOGE("err = %d (%s)", err, strerror(err));
reply->setInt32("result", -err);
mState = DISCONNECTED;
if (mUIDValid) {
HTTPBase::UnRegisterSocketUserTag(mSocket);
}
close(mSocket);
mSocket = -1;
} else {
reply->setInt32("result", OK);
mState = CONNECTED;
mNextCSeq = 1;
postReceiveReponseEvent();
}
reply->post();
}
void DirectRenderer::onSetFormat(const sp<AMessage> &msg) {
size_t trackIndex;
CHECK(msg->findSize("trackIndex", &trackIndex));
sp<AMessage> format;
CHECK(msg->findMessage("format", &format));
internalSetFormat(trackIndex, format);
}
void ARTSPConnection::onSendRequest(const sp<AMessage> &msg) {
sp<AMessage> reply;
CHECK(msg->findMessage("reply", &reply));
if (mState != CONNECTED) {
reply->setInt32("result", -ENOTCONN);
reply->post();
return;
}
AString request;
CHECK(msg->findString("request", &request));
// Find the boundary between headers and the body.
ssize_t i = request.find("\r\n\r\n");
CHECK_GE(i, 0);
int32_t cseq = mNextCSeq++;
AString cseqHeader = "CSeq: ";
cseqHeader.append(cseq);
cseqHeader.append("\r\n");
request.insert(cseqHeader, i + 2);
LOGV("%s", request.c_str());
size_t numBytesSent = 0;
while (numBytesSent < request.size()) {
ssize_t n =
send(mSocket, request.c_str() + numBytesSent,
request.size() - numBytesSent, 0);
if (n == 0) {
// Server closed the connection.
LOGE("Server unexpectedly closed the connection.");
reply->setInt32("result", ERROR_IO);
reply->post();
return;
} else if (n < 0) {
if (errno == EINTR) {
continue;
}
LOGE("Error sending rtsp request.");
reply->setInt32("result", -errno);
reply->post();
return;
}
numBytesSent += (size_t)n;
}
mPendingRequests.add(cseq, reply);
}
status_t SaturationFilter::setParameters(const sp<AMessage> &msg) {
sp<AMessage> params;
CHECK(msg->findMessage("params", ¶ms));
float saturation;
if (params->findFloat("saturation", &saturation)) {
mSaturation = saturation;
}
return OK;
}
void ARTSPConnection::onDisconnect(const sp<AMessage> &msg) {
if (mState == CONNECTED || mState == CONNECTING) {
performDisconnect();
}
sp<AMessage> reply;
CHECK(msg->findMessage("reply", &reply));
reply->setInt32("result", OK);
reply->post();
}
void ARTSPConnection::onDisconnect(const sp<AMessage> &msg) {
if (mState == CONNECTED || mState == CONNECTING) {
close(mSocket);
mSocket = -1;
flushPendingRequests();
}
sp<AMessage> reply;
CHECK(msg->findMessage("reply", &reply));
reply->setInt32("result", OK);
mState = DISCONNECTED;
reply->post();
}
void ARTSPConnection::onMessageReceived(const sp<AMessage> &msg) {
switch (msg->what()) {
case kWhatConnect:
onConnect(msg);
break;
case kWhatDisconnect:
onDisconnect(msg);
break;
case kWhatCompleteConnection:
onCompleteConnection(msg);
break;
case kWhatSendRequest:
onSendRequest(msg);
break;
case kWhatReceiveResponse:
onReceiveResponse();
break;
case kWhatObserveBinaryData:
{
CHECK(msg->findMessage("reply", &mObserveBinaryMessage));
break;
}
#ifndef ANDROID_DEFAULT_CODE
case kWhatTimeout:
{
unsigned long cseq;
CHECK(msg->findInt32("cseq", (int32_t*)&cseq));
onTimeout(cseq);
break;
}
case kWhatInjectPacket:
{
onInjectPacket(msg);
break;
}
#endif // #ifndef ANDROID_DEFAULT_CODE
default:
TRESPASS();
break;
}
}
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);
}
bool NuPlayer::Renderer::dropBufferWhileFlushing(
bool audio, const sp<AMessage> &msg) {
bool flushing = false;
{
Mutex::Autolock autoLock(mFlushLock);
if (audio) {
flushing = mFlushingAudio;
} else {
flushing = mFlushingVideo;
}
}
if (!flushing) {
return false;
}
sp<AMessage> notifyConsumed;
if (msg->findMessage("notifyConsumed", ¬ifyConsumed)) {
notifyConsumed->post();
}
return true;
}
void DashPlayer::Decoder::onFillThisBuffer(const sp<AMessage> &msg) {
sp<AMessage> reply;
CHECK(msg->findMessage("reply", &reply));
#if 0
sp<ABuffer> outBuffer;
CHECK(msg->findBuffer("buffer", &outBuffer));
#else
sp<ABuffer> outBuffer;
#endif
if (mCSDIndex < mCSD.size()) {
outBuffer = mCSD.editItemAt(mCSDIndex++);
outBuffer->meta()->setInt64("timeUs", 0);
reply->setBuffer("buffer", outBuffer);
reply->post();
return;
}
sp<AMessage> notify = mNotify->dup();
notify->setMessage("codec-request", msg);
notify->post();
}
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 MediaPuller::onMessageReceived(const sp<AMessage> &msg) {
switch (msg->what()) {
case kWhatStart:
{
status_t err;
ALOGI("start mIsAudio=%d",mIsAudio);
if (mIsAudio) {
// This atrocity causes AudioSource to deliver absolute
// systemTime() based timestamps (off by 1 us).
#ifdef MTB_SUPPORT
ATRACE_BEGIN_EXT("AudioPuller, kWhatStart");
#endif
sp<MetaData> params = new MetaData;
params->setInt64(kKeyTime, 1ll);
err = mSource->start(params.get());
} else {
#ifdef MTB_SUPPORT
ATRACE_BEGIN_EXT("VideoPuller, kWhatStart");
#endif
err = mSource->start();
if (err != OK) {
ALOGE("source failed to start w/ err %d", err);
}
}
if (err == OK) {
ALOGI("start done, start to schedulePull data");
schedulePull();
}
sp<AMessage> response = new AMessage;
response->setInt32("err", err);
uint32_t replyID;
CHECK(msg->senderAwaitsResponse(&replyID));
response->postReply(replyID);
#ifdef MTB_SUPPORT
ATRACE_END_EXT("VideoPuller, kWhatStart");
#endif
break;
}
case kWhatStop:
{
sp<MetaData> meta = mSource->getFormat();
const char *tmp;
CHECK(meta->findCString(kKeyMIMEType, &tmp));
AString mime = tmp;
ALOGI("MediaPuller(%s) stopping.", mime.c_str());
mSource->stop();
ALOGI("MediaPuller(%s) stopped.", mime.c_str());
++mPullGeneration;
sp<AMessage> notify;
CHECK(msg->findMessage("notify", ¬ify));
notify->post();
break;
}
case kWhatPull:
{
int32_t generation;
#ifdef MTB_SUPPORT
if (mIsAudio) {
ATRACE_BEGIN_EXT("AudioPuller, kWhatPull");
} else {
ATRACE_BEGIN_EXT("VideoPuller, kWhatPull");
}
#endif
CHECK(msg->findInt32("generation", &generation));
if (generation != mPullGeneration) {
break;
}
MediaBuffer *mbuf;
status_t err = mSource->read(&mbuf);
if (mPaused) {
if (err == OK) {
mbuf->release();
mbuf = NULL;
}
schedulePull();
break;
}
if (err != OK) {
if (err == ERROR_END_OF_STREAM) {
ALOGI("stream ended.");
} else {
ALOGE("error %d reading stream.", err);
}
ALOGI("err=%d.post kWhatEOS",err);
sp<AMessage> notify = mNotify->dup();
notify->setInt32("what", kWhatEOS);
notify->post();
} else {
int64_t timeUs;
CHECK(mbuf->meta_data()->findInt64(kKeyTime, &timeUs));
#ifdef MTB_SUPPORT
if (mIsAudio) {
ATRACE_ONESHOT(ATRACE_ONESHOT_ADATA, "AudioPuller, TS: %lld ms", timeUs/1000);
}
else {
ATRACE_ONESHOT(ATRACE_ONESHOT_VDATA, "VideoPuller, TS: %lld ms", timeUs/1000);
}
#endif
sp<ABuffer> accessUnit = new ABuffer(mbuf->range_length());
memcpy(accessUnit->data(),
(const uint8_t *)mbuf->data() + mbuf->range_offset(),
mbuf->range_length());
accessUnit->meta()->setInt64("timeUs", timeUs);
#ifndef ANDROID_DEFAULT_CODE
sp<WfdDebugInfo> debugInfo= defaultWfdDebugInfo();
int64_t MpMs = ALooper::GetNowUs();
debugInfo->addTimeInfoByKey(!mIsAudio , timeUs, "MpIn", MpMs/1000);
int64_t NowMpDelta =0;
NowMpDelta = (MpMs - timeUs)/1000;
if(mFirstDeltaMs == -1){
mFirstDeltaMs = NowMpDelta;
ALOGE("[check Input 1th][%s] ,timestamp=%lld ms,[ts and now delta change]=%lld ms",
mIsAudio?"audio":"video",timeUs/1000,NowMpDelta);
}
NowMpDelta = NowMpDelta - mFirstDeltaMs;
if(NowMpDelta > 500ll || NowMpDelta < -500ll ){
ALOGE("[check Input][%s] ,timestamp=%lld ms,[ts and now delta change]=%lld ms",
mIsAudio?"audio":"video",timeUs/1000,NowMpDelta);
}
#endif
if (mIsAudio) {
mbuf->release();
mbuf = NULL;
ALOGI("[WFDP][%s] ,timestamp=%lld ms",mIsAudio?"audio":"video",timeUs/1000);
} else {
// video encoder will release MediaBuffer when done
// with underlying data.
accessUnit->meta()->setPointer("mediaBuffer", mbuf);
ALOGI("[WFDP][%s] ,mediaBuffer=%p,timestamp=%lld ms",mIsAudio?"audio":"video",mbuf,timeUs/1000);
}
sp<AMessage> notify = mNotify->dup();
notify->setInt32("what", kWhatAccessUnit);
notify->setBuffer("accessUnit", accessUnit);
notify->post();
if (mbuf != NULL) {
ALOGV("posted mbuf %p", mbuf);
}
schedulePull();
#ifdef MTB_SUPPORT
if (mIsAudio) {
ATRACE_END_EXT("AudioPuller, kWhatPull");
} else {
ATRACE_END_EXT("VideoPuller, kWhatPull");
}
#endif
}
break;
}
case kWhatPause:
{
mPaused = true;
break;
}
case kWhatResume:
{
mPaused = false;
break;
}
default:
TRESPASS();
}
}
void ARTSPConnection::onSendRequest(const sp<AMessage> &msg) {
sp<AMessage> reply;
CHECK(msg->findMessage("reply", &reply));
if (mState != CONNECTED) {
reply->setInt32("result", -ENOTCONN);
reply->post();
return;
}
AString request;
CHECK(msg->findString("request", &request));
// Just in case we need to re-issue the request with proper authentication
// later, stash it away.
reply->setString("original-request", request.c_str(), request.size());
addAuthentication(&request);
addUserAgent(&request);
// Find the boundary between headers and the body.
ssize_t i = request.find("\r\n\r\n");
CHECK_GE(i, 0);
int32_t cseq = mNextCSeq++;
AString cseqHeader = "CSeq: ";
cseqHeader.append(cseq);
cseqHeader.append("\r\n");
request.insert(cseqHeader, i + 2);
ALOGV("request: '%s'", request.c_str());
size_t numBytesSent = 0;
while (numBytesSent < request.size()) {
ssize_t n =
send(mSocket, request.c_str() + numBytesSent,
request.size() - numBytesSent, 0);
if (n < 0 && errno == EINTR) {
continue;
}
if (n <= 0) {
performDisconnect();
if (n == 0) {
// Server closed the connection.
ALOGE("Server unexpectedly closed the connection.");
reply->setInt32("result", ERROR_IO);
reply->post();
} else {
ALOGE("Error sending rtsp request. (%s)", strerror(errno));
reply->setInt32("result", -errno);
reply->post();
}
return;
}
numBytesSent += (size_t)n;
}
mPendingRequests.add(cseq, reply);
}
void NuPlayer::Renderer::onMessageReceived(const sp<AMessage> &msg) {
switch (msg->what()) {
case kWhatDrainAudioQueue:
{
int32_t generation;
CHECK(msg->findInt32("generation", &generation));
if (generation != mAudioQueueGeneration) {
break;
}
mDrainAudioQueuePending = false;
if (onDrainAudioQueue()) {
uint32_t numFramesPlayed;
CHECK_EQ(mAudioSink->getPosition(&numFramesPlayed),
(status_t)OK);
uint32_t numFramesPendingPlayout =
mNumFramesWritten - numFramesPlayed;
// This is how long the audio sink will have data to
// play back.
int64_t delayUs =
mAudioSink->msecsPerFrame()
* numFramesPendingPlayout * 1000ll;
// Let's give it more data after about half that time
// has elapsed.
#ifndef ANDROID_DEFAULT_CODE
// half that is to large, set it to 20ms
if (numFramesPlayed > mNumFramesWritten)
ALOGW("numFramesPlayed(%d) > mNumFramesWritten(%d), no reset @ kWhatDrainAudioQueue",
numFramesPlayed, mNumFramesWritten);
if (delayUs > 40000)
delayUs = 40000;
#endif
postDrainAudioQueue(delayUs / 2);
}
break;
}
case kWhatDrainVideoQueue:
{
int32_t generation;
CHECK(msg->findInt32("generation", &generation));
if (generation != mVideoQueueGeneration) {
break;
}
mDrainVideoQueuePending = false;
onDrainVideoQueue();
postDrainVideoQueue();
break;
}
case kWhatQueueBuffer:
{
onQueueBuffer(msg);
break;
}
case kWhatQueueEOS:
{
LOGI("kWhatQueueEOS");
mNeedCheckBuffer = false;
onQueueEOS(msg);
break;
}
case kWhatFlush:
{
onFlush(msg);
break;
}
case kWhatAudioSinkChanged:
{
onAudioSinkChanged();
break;
}
case kWhatPause:
{
onPause();
break;
}
case kWhatResume:
{
mIsbufferempty = false;
onResume();
break;
}
#ifndef ANDROID_DEFAULT_CODE
case kWhatCheckRenderBufferStatus:
{
ALOGV("kWhatCheckRenderBufferStatus need check buff : %s",mNeedCheckBuffer?"YES":"NO");
sp<AMessage> notify = mNotify->dup();
notify->setInt32("what", kWhatBufferNotify);
int32_t rate = 0;
ALOGV("mIsSeeking(%d) mVideoQueue.size(%d) mAudioQueue.size(%d)",mIsSeeking,mVideoQueue.size(),mAudioQueue.size());
if(mNeedCheckBuffer == true){
switch(mIsbufferempty){
case true:
if(mIsSeeking == true)
{ // only check VideoQueue after seek
if (mVideoQueue.size()>0){
ALOGV("kWhatCheckRenderBufferStatus full");
rate = 100;
notify->setInt32("bufRate", rate);
notify->post();
mIsSeeking = false;
}
}
else
{
if(mDebugDisableAVsync)//Disable AV SYNC for debug
{
ALOGV("kWhatCheckRenderBufferStatus full");
rate = 100;
notify->setInt32("bufRate", rate);
notify->post();
}
else if (mAudioQueue.size()>2)//Wait audio
{
ALOGV("kWhatCheckRenderBufferStatus full");
rate = 100;
notify->setInt32("bufRate", rate);
notify->post();
}
}
break;
case false:
if(mIsSeeking == true)
{ // only check VideoQueue after seek
if (mVideoQueue.empty())
{
mIsbufferempty = true;
ALOGV("kWhatCheckRenderBufferStatus empty");
rate = 0;
notify->setInt32("bufRate", rate);
notify->post();
}
}
else
{
if(mDebugDisableAVsync)//Disable AV SYNC for debug
{
mIsbufferempty = true;
ALOGV("kWhatCheckRenderBufferStatus empty");
rate = 0;
notify->setInt32("bufRate", rate);
notify->post();
}
else if (mAudioQueue.empty())//Wait audio empty
{
mIsbufferempty = true;
ALOGV("kWhatCheckRenderBufferStatus empty");
rate = 0;
notify->setInt32("bufRate", rate);
notify->post();
}
}
break;
default:
break;
}
}else{
rate = 100;
notify->setInt32("bufRate", rate);
notify->post();
}
(new AMessage(kWhatCheckRenderBufferStatus, id()))->post(300000);
break;
}
case kWhatStatusNotify:
{
int32_t status;
sp<AMessage> message;
CHECK(msg->findMessage("message", &message));
CHECK(message->findInt32("status", &status));
LOGI(" kWhatStatusNotify %d",status);
switch(status){
case MEDIA_SEEK_COMPLETE:
mIsSeeking = true;
break;
default:
break;
}
break;
}
#endif
default:
TRESPASS();
break;
}
}
void MediaPuller::onMessageReceived(const sp<AMessage> &msg) {
switch (msg->what()) {
case kWhatStart:
{
status_t err;
if (mIsAudio) {
// This atrocity causes AudioSource to deliver absolute
// systemTime() based timestamps (off by 1 us).
sp<MetaData> params = new MetaData;
params->setInt64(kKeyTime, 1ll);
err = mSource->start(params.get());
} else {
err = mSource->start();
if (err != OK) {
ALOGE("source failed to start w/ err %d", err);
}
}
if (err == OK) {
schedulePull();
}
sp<AMessage> response = new AMessage;
response->setInt32("err", err);
uint32_t replyID;
CHECK(msg->senderAwaitsResponse(&replyID));
response->postReply(replyID);
break;
}
case kWhatStop:
{
sp<MetaData> meta = mSource->getFormat();
const char *tmp;
CHECK(meta->findCString(kKeyMIMEType, &tmp));
AString mime = tmp;
ALOGI("MediaPuller(%s) stopping.", mime.c_str());
mSource->stop();
ALOGI("MediaPuller(%s) stopped.", mime.c_str());
++mPullGeneration;
sp<AMessage> notify;
CHECK(msg->findMessage("notify", ¬ify));
notify->post();
break;
}
case kWhatPull:
{
int32_t generation;
CHECK(msg->findInt32("generation", &generation));
if (generation != mPullGeneration) {
break;
}
MediaBuffer *mbuf;
status_t err = mSource->read(&mbuf);
if (mPaused) {
if (err == OK) {
mbuf->release();
mbuf = NULL;
}
schedulePull();
break;
}
if (err != OK) {
if (err == ERROR_END_OF_STREAM) {
ALOGI("stream ended.");
} else {
ALOGE("error %d reading stream.", err);
}
sp<AMessage> notify = mNotify->dup();
notify->setInt32("what", kWhatEOS);
notify->post();
} else {
int64_t timeUs;
CHECK(mbuf->meta_data()->findInt64(kKeyTime, &timeUs));
sp<ABuffer> accessUnit = new ABuffer(mbuf->range_length());
memcpy(accessUnit->data(),
(const uint8_t *)mbuf->data() + mbuf->range_offset(),
mbuf->range_length());
accessUnit->meta()->setInt64("timeUs", timeUs);
if (mIsAudio) {
mbuf->release();
mbuf = NULL;
} else {
// video encoder will release MediaBuffer when done
// with underlying data.
accessUnit->setMediaBufferBase(mbuf);
}
sp<AMessage> notify = mNotify->dup();
notify->setInt32("what", kWhatAccessUnit);
notify->setBuffer("accessUnit", accessUnit);
notify->post();
if (mbuf != NULL) {
ALOGV("posted mbuf %p", mbuf);
}
schedulePull();
}
break;
}
case kWhatPause:
{
mPaused = true;
break;
}
case kWhatResume:
{
mPaused = false;
break;
}
default:
TRESPASS();
}
}
void NuPlayer::HTTPLiveSource::onSessionNotify(const sp<AMessage> &msg) {
int32_t what;
CHECK(msg->findInt32("what", &what));
switch (what) {
case LiveSession::kWhatPrepared:
{
// notify the current size here if we have it, otherwise report an initial size of (0,0)
sp<AMessage> format = getFormat(false /* audio */);
int32_t width;
int32_t height;
if (format != NULL &&
format->findInt32("width", &width) && format->findInt32("height", &height)) {
notifyVideoSizeChanged(format);
} else {
notifyVideoSizeChanged();
}
#ifdef MTK_AOSP_ENHANCEMENT
uint32_t flags = 0;
#else
uint32_t flags = FLAG_CAN_PAUSE;
#endif
if (mLiveSession->isSeekable()) {
#ifdef MTK_AOSP_ENHANCEMENT
flags |= FLAG_CAN_PAUSE;
#endif
flags |= FLAG_CAN_SEEK;
flags |= FLAG_CAN_SEEK_BACKWARD;
flags |= FLAG_CAN_SEEK_FORWARD;
}
if (mLiveSession->hasDynamicDuration()) {
flags |= FLAG_DYNAMIC_DURATION;
}
notifyFlagsChanged(flags);
notifyPrepared();
break;
}
case LiveSession::kWhatPreparationFailed:
{
status_t err;
CHECK(msg->findInt32("err", &err));
notifyPrepared(err);
break;
}
case LiveSession::kWhatStreamsChanged:
{
uint32_t changedMask;
CHECK(msg->findInt32(
"changedMask", (int32_t *)&changedMask));
bool audio = changedMask & LiveSession::STREAMTYPE_AUDIO;
bool video = changedMask & LiveSession::STREAMTYPE_VIDEO;
#ifdef MTK_AOSP_ENHANCEMENT
ALOGI("receive LiveSession::kWhatStreamsChanged,queue Decoder Shutdown for %s,%s",\
audio?"audio":"",video?"video":"");
#endif
sp<AMessage> reply;
CHECK(msg->findMessage("reply", &reply));
sp<AMessage> notify = dupNotify();
notify->setInt32("what", kWhatQueueDecoderShutdown);
notify->setInt32("audio", audio);
notify->setInt32("video", video);
notify->setMessage("reply", reply);
notify->post();
break;
}
case LiveSession::kWhatError:
{
break;
}
#ifdef MTK_AOSP_ENHANCEMENT
case LiveSession::kWhatPicture:
case LiveSession::kWhatBufferingStart:
case LiveSession::kWhatBufferingEnd:
{
onSessionNotify_l(msg);
break;
}
#endif
default:
TRESPASS();
}
}
void NuPlayer::HTTPLiveSource::onSessionNotify(const sp<AMessage> &msg) {
int32_t what;
CHECK(msg->findInt32("what", &what));
switch (what) {
case LiveSession::kWhatPrepared:
{
// notify the current size here if we have it, otherwise report an initial size of (0,0)
sp<AMessage> format = getFormat(false /* audio */);
int32_t width;
int32_t height;
if (format != NULL &&
format->findInt32("width", &width) && format->findInt32("height", &height)) {
notifyVideoSizeChanged(width, height);
} else {
#ifdef ANDROID_DEFAULT_CODE
notifyVideoSizeChanged(0, 0);
#endif
}
#ifdef ANDROID_DEFAULT_CODE
uint32_t flags = FLAG_CAN_PAUSE;
#else
uint32_t flags = 0;
#endif
if (mLiveSession->isSeekable()) {
#ifndef ANDROID_DEFAULT_CODE
flags |= FLAG_CAN_PAUSE;
#endif
flags |= FLAG_CAN_SEEK;
flags |= FLAG_CAN_SEEK_BACKWARD;
flags |= FLAG_CAN_SEEK_FORWARD;
}
if (mLiveSession->hasDynamicDuration()) {
flags |= FLAG_DYNAMIC_DURATION;
}
notifyFlagsChanged(flags);
notifyPrepared();
break;
}
case LiveSession::kWhatPreparationFailed:
{
status_t err;
CHECK(msg->findInt32("err", &err));
notifyPrepared(err);
break;
}
case LiveSession::kWhatStreamsChanged:
{
uint32_t changedMask;
CHECK(msg->findInt32(
"changedMask", (int32_t *)&changedMask));
bool audio = changedMask & LiveSession::STREAMTYPE_AUDIO;
bool video = changedMask & LiveSession::STREAMTYPE_VIDEO;
sp<AMessage> reply;
CHECK(msg->findMessage("reply", &reply));
sp<AMessage> notify = dupNotify();
notify->setInt32("what", kWhatQueueDecoderShutdown);
notify->setInt32("audio", audio);
notify->setInt32("video", video);
notify->setMessage("reply", reply);
notify->post();
break;
}
case LiveSession::kWhatError:
{
break;
}
#ifndef ANDROID_DEFAULT_CODE
case LiveSession::kWhatPicture:
{
sp<ABuffer> metabuffer;
CHECK(msg->findBuffer("buffer", &metabuffer));
AString mimeType;
sp<ABuffer> buffer;
if(((metabuffer)->meta()->findString("mime", &mimeType)) &&
((metabuffer)->meta()->findBuffer("pictureBuffer", &buffer)))
{
if (mMetaData == NULL)
{
mMetaData = new MetaData;
}
mMetaData->setCString(kKeyAlbumArtMIME, mimeType.c_str());
mMetaData->setData(kKeyAlbumArt, MetaData::TYPE_NONE, buffer->data(), buffer->size());
ALOGI("kKeyAlbumArt set Data :%s, datasize:%d", mimeType.c_str(), buffer->size());
sp<AMessage> notify = dupNotify();
notify->setInt32("what", NuPlayer::Source::kWhatPicture);
notify->post();
}
break;
}
case LiveSession::kWhatBufferingStart:
{
sp<AMessage> notify = dupNotify();
notify->setInt32("what", kWhatBufferingStart);
notify->post();
break;
}
case LiveSession::kWhatBufferingEnd:
{
sp<AMessage> notify = dupNotify();
notify->setInt32("what", kWhatBufferingEnd);
notify->post();
break;
}
#endif
default:
TRESPASS();
}
}
status_t NuPlayer::feedDecoderInputData(bool audio, const sp<AMessage> &msg) {
sp<AMessage> reply;
CHECK(msg->findMessage("reply", &reply));
if ((audio && IsFlushingState(mFlushingAudio))
|| (!audio && IsFlushingState(mFlushingVideo))) {
reply->setInt32("err", INFO_DISCONTINUITY);
reply->post();
return OK;
}
sp<ABuffer> accessUnit;
bool dropAccessUnit;
do {
status_t err = mSource->dequeueAccessUnit(audio, &accessUnit);
if (err == -EWOULDBLOCK) {
return err;
} else if (err != OK) {
if (err == INFO_DISCONTINUITY) {
int32_t type;
CHECK(accessUnit->meta()->findInt32("discontinuity", &type));
bool formatChange =
(audio &&
(type & ATSParser::DISCONTINUITY_AUDIO_FORMAT))
|| (!audio &&
(type & ATSParser::DISCONTINUITY_VIDEO_FORMAT));
bool timeChange = (type & ATSParser::DISCONTINUITY_TIME) != 0;
LOGI("%s discontinuity (formatChange=%d, time=%d)",
audio ? "audio" : "video", formatChange, timeChange);
if (audio) {
mSkipRenderingAudioUntilMediaTimeUs = -1;
} else {
mSkipRenderingVideoUntilMediaTimeUs = -1;
}
if (timeChange) {
sp<AMessage> extra;
if (accessUnit->meta()->findMessage("extra", &extra)
&& extra != NULL) {
int64_t resumeAtMediaTimeUs;
if (extra->findInt64(
"resume-at-mediatimeUs", &resumeAtMediaTimeUs)) {
LOGI("suppressing rendering of %s until %lld us",
audio ? "audio" : "video", resumeAtMediaTimeUs);
if (audio) {
mSkipRenderingAudioUntilMediaTimeUs =
resumeAtMediaTimeUs;
} else {
mSkipRenderingVideoUntilMediaTimeUs =
resumeAtMediaTimeUs;
}
}
}
}
mTimeDiscontinuityPending =
mTimeDiscontinuityPending || timeChange;
if (formatChange || timeChange) {
flushDecoder(audio, formatChange);
} else {
// This stream is unaffected by the discontinuity
if (audio) {
mFlushingAudio = FLUSHED;
} else {
mFlushingVideo = FLUSHED;
}
finishFlushIfPossible();
return -EWOULDBLOCK;
}
}
reply->setInt32("err", err);
reply->post();
return OK;
}
if (!audio) {
++mNumFramesTotal;
}
dropAccessUnit = false;
if (!audio
&& mVideoLateByUs > 100000ll
&& mVideoIsAVC
&& !IsAVCReferenceFrame(accessUnit)) {
dropAccessUnit = true;
++mNumFramesDropped;
}
} while (dropAccessUnit);
// LOGV("returned a valid buffer of %s data", audio ? "audio" : "video");
#if 0
int64_t mediaTimeUs;
CHECK(accessUnit->meta()->findInt64("timeUs", &mediaTimeUs));
LOGV("feeding %s input buffer at media time %.2f secs",
audio ? "audio" : "video",
mediaTimeUs / 1E6);
#endif
reply->setObject("buffer", accessUnit);
reply->post();
return OK;
}
void ARTSPConnection::onSendRequest(const sp<AMessage> &msg) {
#ifndef ANDROID_DEFAULT_CODE
int32_t backup;
if (msg->findInt32("backup-keep-tcp", &backup)) {
mForceQuitTCP = backup;
}
#endif
sp<AMessage> reply;
CHECK(msg->findMessage("reply", &reply));
if (mState != CONNECTED) {
reply->setInt32("result", -ENOTCONN);
reply->post();
return;
}
AString request;
CHECK(msg->findString("request", &request));
// Just in case we need to re-issue the request with proper authentication
// later, stash it away.
reply->setString("original-request", request.c_str(), request.size());
#ifndef ANDROID_DEFAULT_CODE
// mtk80902: ALPS01139972 - SETUP resp with a wrong Session "xxx\0\0\0.."
// so the followed \r\n is ignored by find's strstr operation
if (request.find("\r\n\r\n") < 0) {
ALOGW("what the hell with this req?"); // seems print str is useless..
reply->setInt32("result", -EBADMSG);
reply->post();
return;
}
#endif
addAuthentication(&request);
addUserAgent(&request);
// Find the boundary between headers and the body.
ssize_t i = request.find("\r\n\r\n");
CHECK_GE(i, 0);
int32_t cseq = mNextCSeq++;
AString cseqHeader = "CSeq: ";
cseqHeader.append(cseq);
cseqHeader.append("\r\n");
request.insert(cseqHeader, i + 2);
#ifndef ANDROID_DEFAULT_CODE
ALOGI("request: '%s'", request.c_str());
#else
ALOGV("request: '%s'", request.c_str());
#endif
size_t numBytesSent = 0;
while (numBytesSent < request.size()) {
ssize_t n =
#ifndef ANDROID_DEFAULT_CODE
send(mSocket, request.c_str() + numBytesSent,
request.size() - numBytesSent, MTK_SEND_FLAG);
#else
send(mSocket, request.c_str() + numBytesSent,
request.size() - numBytesSent, 0);
#endif
if (n < 0 && errno == EINTR) {
continue;
}
if (n <= 0) {
performDisconnect();
if (n == 0) {
// Server closed the connection.
ALOGE("Server unexpectedly closed the connection.");
reply->setInt32("result", ERROR_IO);
reply->post();
} else {
ALOGE("Error sending rtsp request. (%s)", strerror(errno));
reply->setInt32("result", -errno);
reply->post();
}
return;
}
numBytesSent += (size_t)n;
}
mPendingRequests.add(cseq, reply);
#ifndef ANDROID_DEFAULT_CODE
sp<AMessage> timeout = new AMessage(kWhatTimeout, id());
timeout->setInt32("cseq", cseq);
int64_t t;
if (reply->findInt64("timeout", &t)) {
timeout->post(t);
} else {
timeout->post(kRequestTimeout);
}
#endif // #ifndef ANDROID_DEFAULT_CODE
}
void ARTSPConnection::onConnect(const sp<AMessage> &msg) {
++mConnectionID;
if (mState != DISCONNECTED) {
close(mSocket);
mSocket = -1;
flushPendingRequests();
}
mState = CONNECTING;
AString url;
CHECK(msg->findString("url", &url));
sp<AMessage> reply;
CHECK(msg->findMessage("reply", &reply));
AString host, path;
unsigned port;
if (!ParseURL(url.c_str(), &host, &port, &path)) {
LOGE("Malformed rtsp url %s", url.c_str());
reply->setInt32("result", ERROR_MALFORMED);
reply->post();
mState = DISCONNECTED;
return;
}
struct hostent *ent = gethostbyname(host.c_str());
if (ent == NULL) {
LOGE("Unknown host %s", host.c_str());
reply->setInt32("result", -ENOENT);
reply->post();
mState = DISCONNECTED;
return;
}
mSocket = socket(AF_INET, SOCK_STREAM, 0);
MakeSocketBlocking(mSocket, false);
struct sockaddr_in remote;
memset(remote.sin_zero, 0, sizeof(remote.sin_zero));
remote.sin_family = AF_INET;
remote.sin_addr.s_addr = *(in_addr_t *)ent->h_addr;
remote.sin_port = htons(port);
int err = ::connect(
mSocket, (const struct sockaddr *)&remote, sizeof(remote));
reply->setInt32("server-ip", ntohl(remote.sin_addr.s_addr));
if (err < 0) {
if (errno == EINPROGRESS) {
sp<AMessage> msg = new AMessage(kWhatCompleteConnection, id());
msg->setMessage("reply", reply);
msg->setInt32("connection-id", mConnectionID);
msg->post();
return;
}
reply->setInt32("result", -errno);
mState = DISCONNECTED;
close(mSocket);
mSocket = -1;
} else {
reply->setInt32("result", OK);
mState = CONNECTED;
mNextCSeq = 1;
postReceiveReponseEvent();
}
reply->post();
}
void DashPlayer::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<ABuffer> buffer;
CHECK(msg->findBuffer("buffer", &buffer));
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);
int64_t audioTimeUs;
(buffer->meta())->findInt64("timeUs", &audioTimeUs);
if ((mHasVideo && mIsFirstVideoframeReceived)
|| !mHasVideo){
postDrainAudioQueue();
return;
}
else
{
mPendingPostAudioDrains = true;
DPR_MSG_HIGH("Not rendering Audio Sample with TS: %lld as Video frame is not decoded", audioTimeUs);
}
} else {
mVideoQueue.push_back(entry);
int64_t videoTimeUs;
(buffer->meta())->findInt64("timeUs", &videoTimeUs);
if (!mIsFirstVideoframeReceived) {
mIsFirstVideoframeReceived = true;
DPR_MSG_HIGH("Received first video Sample with TS: %lld", videoTimeUs);
if (mPendingPostAudioDrains) {
mPendingPostAudioDrains = false;
postDrainAudioQueue();
}
}
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;
DPR_MSG_LOW("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 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<ABuffer> buffer;
CHECK(msg->findBuffer("buffer", &buffer));
sp<AMessage> notifyConsumed;
CHECK(msg->findMessage("notifyConsumed", ¬ifyConsumed));
QueueEntry entry;
entry.mBuffer = buffer;
entry.mNotifyConsumed = notifyConsumed;
entry.mOffset = 0;
entry.mFinalResult = OK;
if (audio) {
mDropvideo = true;
ALOGD(" audio data input");
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;
}
#ifndef ANDROID_DEFAULT_CODE
if(diff < -100000ll) {
// video data starts More than 0.1 secs before audio.
// Drop some video.
ALOGE("before playback, video is early than audio drop diff = %.2f", diff / 1E6);
(*mVideoQueue.begin()).mNotifyConsumed->post();
mVideoQueue.erase(mVideoQueue.begin());
return;
}
#endif
syncQueuesDone();
}
void ARTSPConnection::onConnect(const sp<AMessage> &msg) {
++mConnectionID;
if (mState != DISCONNECTED) {
if (mUIDValid) {
HTTPBase::UnRegisterSocketUserTag(mSocket);
HTTPBase::UnRegisterSocketUserMark(mSocket);
}
close(mSocket);
mSocket = -1;
flushPendingRequests();
}
mState = CONNECTING;
AString url;
CHECK(msg->findString("url", &url));
sp<AMessage> reply;
CHECK(msg->findMessage("reply", &reply));
AString host, path;
unsigned port;
if (!ParseURL(url.c_str(), &host, &port, &path, &mUser, &mPass)
|| (mUser.size() > 0 && mPass.size() == 0)) {
// If we have a user name but no password we have to give up
// right here, since we currently have no way of asking the user
// for this information.
ALOGE("Malformed rtsp url %s", url.c_str());
reply->setInt32("result", ERROR_MALFORMED);
reply->post();
mState = DISCONNECTED;
return;
}
if (mUser.size() > 0) {
ALOGV("user = '******', pass = '******'", mUser.c_str(), mPass.c_str());
}
#ifndef ANDROID_DEFAULT_CODE
if (!mProxyHost.empty()) {
ALOGI("connect through proxy %s:%d", mProxyHost.c_str(), mProxyPort);
host = mProxyHost;
port = mProxyPort;
}
#endif // #ifndef ANDROID_DEFAULT_CODE
struct hostent *ent = gethostbyname(host.c_str());
if (ent == NULL) {
ALOGE("Unknown host %s", host.c_str());
#ifndef ANDROID_DEFAULT_CODE
reply->setInt32("result", -EHOSTUNREACH);
#else
reply->setInt32("result", -ENOENT);
#endif // #ifndef ANDROID_DEFAULT_CODE
reply->post();
mState = DISCONNECTED;
return;
}
mSocket = socket(AF_INET, SOCK_STREAM, 0);
if (mUIDValid) {
HTTPBase::RegisterSocketUserTag(mSocket, mUID,
(uint32_t)*(uint32_t*) "RTSP");
HTTPBase::RegisterSocketUserMark(mSocket, mUID);
}
MakeSocketBlocking(mSocket, false);
struct sockaddr_in remote;
memset(remote.sin_zero, 0, sizeof(remote.sin_zero));
remote.sin_family = AF_INET;
remote.sin_addr.s_addr = *(in_addr_t *)ent->h_addr;
remote.sin_port = htons(port);
#ifndef ANDROID_DEFAULT_CODE
mRemote = remote;
struct timeval tv;
tv.tv_sec = kAccessUnitTimeoutUs / 1000000LL;
tv.tv_usec = 0;
if (setsockopt(mSocket, SOL_SOCKET, SO_RCVTIMEO, (char *)&tv, sizeof(tv)) < 0) {
ALOGE("can not set recv timeout");
reply->setInt32("result", -errno);
mState = DISCONNECTED;
close(mSocket);
mSocket = -1;
reply->post();
return;
}
ALOGI("connecting %s, %s:%d now",
host.c_str(), inet_ntoa(remote.sin_addr), port);
#endif // #ifndef ANDROID_DEFAULT_CODE
int err = ::connect(
mSocket, (const struct sockaddr *)&remote, sizeof(remote));
reply->setInt32("server-ip", ntohl(remote.sin_addr.s_addr));
if (err < 0) {
if (errno == EINPROGRESS) {
sp<AMessage> msg = new AMessage(kWhatCompleteConnection, id());
msg->setMessage("reply", reply);
msg->setInt32("connection-id", mConnectionID);
#ifndef ANDROID_DEFAULT_CODE
msg->setInt64("timestamp", ALooper::GetNowUs());
ALOGI("connection EINPROGRESS");
#endif // #ifndef ANDROID_DEFAULT_CODE
msg->post();
return;
}
reply->setInt32("result", -errno);
mState = DISCONNECTED;
if (mUIDValid) {
HTTPBase::UnRegisterSocketUserTag(mSocket);
HTTPBase::UnRegisterSocketUserMark(mSocket);
}
close(mSocket);
mSocket = -1;
} else {
reply->setInt32("result", OK);
mState = CONNECTED;
mNextCSeq = 1;
postReceiveReponseEvent();
}
reply->post();
}
void ARTSPConnection::onCompleteConnection(const sp<AMessage> &msg) {
sp<AMessage> reply;
CHECK(msg->findMessage("reply", &reply));
int32_t connectionID;
CHECK(msg->findInt32("connection-id", &connectionID));
if ((connectionID != mConnectionID) || mState != CONNECTING) {
// While we were attempting to connect, the attempt was
// cancelled.
reply->setInt32("result", -ECONNABORTED);
reply->post();
return;
}
struct timeval tv;
tv.tv_sec = 0;
tv.tv_usec = kSelectTimeoutUs;
fd_set ws;
FD_ZERO(&ws);
FD_SET(mSocket, &ws);
int res = select(mSocket + 1, NULL, &ws, NULL, &tv);
CHECK_GE(res, 0);
if (res == 0) {
// Timed out. Not yet connected.
#ifndef ANDROID_DEFAULT_CODE
int64_t then, now = ALooper::GetNowUs();
if (msg->findInt64("timestamp", &then) && now - then > kRequestTimeout) {
ALOGE("connection timeout %lld > %lld", now, then);
reply->setInt32("result", -110 /*ETIMEDOUT*/);
reply->post();
mState = DISCONNECTED;
close(mSocket);
mSocket = -1;
return;
}
if(mExited)
return;
#endif // #ifndef ANDROID_DEFAULT_CODE
msg->post();
return;
}
int err;
socklen_t optionLen = sizeof(err);
CHECK_EQ(getsockopt(mSocket, SOL_SOCKET, SO_ERROR, &err, &optionLen), 0);
CHECK_EQ(optionLen, (socklen_t)sizeof(err));
if (err != 0) {
ALOGE("err = %d (%s)", err, strerror(err));
reply->setInt32("result", -err);
mState = DISCONNECTED;
if (mUIDValid) {
HTTPBase::UnRegisterSocketUserTag(mSocket);
HTTPBase::UnRegisterSocketUserMark(mSocket);
}
close(mSocket);
mSocket = -1;
} else {
reply->setInt32("result", OK);
mState = CONNECTED;
mNextCSeq = 1;
postReceiveReponseEvent();
}
reply->post();
}
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 ARTSPConnection::onCompleteConnection(const sp<AMessage> &msg) {
sp<AMessage> reply;
CHECK(msg->findMessage("reply", &reply));
int32_t connectionID;
CHECK(msg->findInt32("connection-id", &connectionID));
if ((connectionID != mConnectionID) || mState != CONNECTING) {
// While we were attempting to connect, the attempt was
// cancelled.
reply->setInt32("result", -ECONNABORTED);
reply->post();
if (mAddrHeader != NULL) {
freeaddrinfo((struct addrinfo *)mAddrHeader);
mAddrHeader = NULL;
}
return;
}
int32_t port;
CHECK(msg->findInt32("port", &port));
struct timeval tv;
tv.tv_sec = 0;
tv.tv_usec = kSelectTimeoutUs;
fd_set ws;
FD_ZERO(&ws);
FD_SET(mSocket, &ws);
int res = select(mSocket + 1, NULL, &ws, NULL, &tv);
CHECK_GE(res, 0);
if (res == 0) {
// Timed out. Not yet connected.
msg->post();
return;
}
int err;
int ipver;
socklen_t optionLen = sizeof(err);
CHECK_EQ(getsockopt(mSocket, SOL_SOCKET, SO_ERROR, &err, &optionLen), 0);
CHECK_EQ(optionLen, (socklen_t)sizeof(err));
if (err != 0) {
ALOGE("err = %d (%s)", err, strerror(err));
if (mUIDValid) {
HTTPBase::UnRegisterSocketUserTag(mSocket);
HTTPBase::UnRegisterSocketUserMark(mSocket);
}
close(mSocket);
mSocket = -1;
mConnectionTimes++;
sp<AMessage> msg = new AMessage(kWhatReconnect, id());
msg->setMessage("reply", reply);
msg->setInt32("connection-id", mConnectionID);
msg->setInt32("port", port);
msg->post();
} else {
ALOGV("Connected in onCompleteConnection");
CHECK(msg->findInt32("ipversion", &ipver));
reply->setInt32("result", OK);
ALOGV("setting ipversion:%d", ipver);
reply->setInt32("ipversion", ipver);
mState = CONNECTED;
mNextCSeq = 1;
freeaddrinfo((struct addrinfo *)mAddrHeader);
mAddrHeader = NULL;
postReceiveReponseEvent();
reply->post();
}
}
void ARTSPConnection::onConnect(const sp<AMessage> &msg) {
++mConnectionID;
if (mState != DISCONNECTED) {
if (mUIDValid) {
HTTPBase::UnRegisterSocketUserTag(mSocket);
HTTPBase::UnRegisterSocketUserMark(mSocket);
}
close(mSocket);
mSocket = -1;
flushPendingRequests();
}
mState = CONNECTING;
AString url;
CHECK(msg->findString("url", &url));
sp<AMessage> reply;
CHECK(msg->findMessage("reply", &reply));
AString host, path;
unsigned port;
if (!ParseURL(url.c_str(), &host, &port, &path, &mUser, &mPass)
|| (mUser.size() > 0 && mPass.size() == 0)) {
// If we have a user name but no password we have to give up
// right here, since we currently have no way of asking the user
// for this information.
ALOGE("Malformed rtsp url %s", uriDebugString(url).c_str());
reply->setInt32("result", ERROR_MALFORMED);
reply->post();
mState = DISCONNECTED;
return;
}
if (mUser.size() > 0) {
ALOGV("user = '******', pass = '******'", mUser.c_str(), mPass.c_str());
}
struct addrinfo hints;
memset(&hints, 0, sizeof (hints));
hints.ai_flags = AI_PASSIVE;
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
mConnectionTimes = 0;
int err = getaddrinfo(host.c_str(), NULL, &hints, (struct addrinfo **)(&mAddrHeader));
if (err != 0 || mAddrHeader == NULL) {
ALOGE("Unknown host, err %d (%s)", err, gai_strerror(err));
reply->setInt32("result", -ENOENT);
reply->post();
mState = DISCONNECTED;
if (mAddrHeader != NULL) {
freeaddrinfo((struct addrinfo *)mAddrHeader);
mAddrHeader = NULL;
}
return;
}
if (!createSocketAndConnect(mAddrHeader, port, reply)) {
ALOGV("Failed to connect to %s", host.c_str());
reply->setInt32("result", -errno);
mState = DISCONNECTED;
mSocket = -1;
reply->post();
freeaddrinfo((struct addrinfo *)mAddrHeader);
mAddrHeader = NULL;
}
}
void NuPlayer::HTTPLiveSource::onSessionNotify(const sp<AMessage> &msg) {
int32_t what;
CHECK(msg->findInt32("what", &what));
switch (what) {
case LiveSession::kWhatPrepared:
{
// notify the current size here if we have it, otherwise report an initial size of (0,0)
sp<AMessage> format = getFormat(false /* audio */);
int32_t width;
int32_t height;
if (format != NULL &&
format->findInt32("width", &width) && format->findInt32("height", &height)) {
notifyVideoSizeChanged(format);
} else {
notifyVideoSizeChanged();
}
uint32_t flags = 0;
if (mLiveSession->isSeekable()) {
flags |= FLAG_CAN_PAUSE;
flags |= FLAG_CAN_SEEK;
flags |= FLAG_CAN_SEEK_BACKWARD;
flags |= FLAG_CAN_SEEK_FORWARD;
}
if (mLiveSession->hasDynamicDuration()) {
flags |= FLAG_DYNAMIC_DURATION;
}
notifyFlagsChanged(flags);
notifyPrepared();
break;
}
case LiveSession::kWhatPreparationFailed:
{
status_t err;
CHECK(msg->findInt32("err", &err));
notifyPrepared(err);
break;
}
case LiveSession::kWhatStreamsChanged:
{
uint32_t changedMask;
CHECK(msg->findInt32(
"changedMask", (int32_t *)&changedMask));
bool audio = changedMask & LiveSession::STREAMTYPE_AUDIO;
bool video = changedMask & LiveSession::STREAMTYPE_VIDEO;
sp<AMessage> reply;
CHECK(msg->findMessage("reply", &reply));
sp<AMessage> notify = dupNotify();
notify->setInt32("what", kWhatQueueDecoderShutdown);
notify->setInt32("audio", audio);
notify->setInt32("video", video);
notify->setMessage("reply", reply);
notify->post();
break;
}
case LiveSession::kWhatBufferingStart:
{
sp<AMessage> notify = dupNotify();
notify->setInt32("what", kWhatPauseOnBufferingStart);
notify->post();
break;
}
case LiveSession::kWhatBufferingEnd:
{
sp<AMessage> notify = dupNotify();
notify->setInt32("what", kWhatResumeOnBufferingEnd);
notify->post();
break;
}
case LiveSession::kWhatBufferingUpdate:
{
sp<AMessage> notify = dupNotify();
int32_t percentage;
CHECK(msg->findInt32("percentage", &percentage));
notify->setInt32("what", kWhatBufferingUpdate);
notify->setInt32("percentage", percentage);
notify->post();
break;
}
case LiveSession::kWhatMetadataDetected:
{
if (!mHasMetadata) {
mHasMetadata = true;
sp<AMessage> notify = dupNotify();
// notification without buffer triggers MEDIA_INFO_METADATA_UPDATE
notify->setInt32("what", kWhatTimedMetaData);
notify->post();
}
break;
}
case LiveSession::kWhatError:
{
break;
}
default:
TRESPASS();
}
}
