void NuPlayer::RTSPSource::onPollBuffering() {
bool prepared, underflow, overflow, startServer, finished;
checkBuffering(&prepared, &underflow, &overflow, &startServer, &finished);
if (prepared && mInPreparationPhase) {
mInPreparationPhase = false;
notifyPrepared();
}
if (!mInPreparationPhase && underflow) {
startBufferingIfNecessary();
}
if (haveSufficientDataOnAllTracks()) {
stopBufferingIfNecessary();
}
if (overflow && mHandler != NULL) {
mHandler->pause();
}
if (startServer && mHandler != NULL) {
mHandler->resume();
}
if (finished && mHandler != NULL) {
mHandler->cancelAccessUnitTimeoutCheck();
}
schedulePollBuffering();
}
void NuPlayer::RTSPSource::onDisconnected(const sp<AMessage> &msg) {
if (mState == DISCONNECTED) {
return;
}
status_t err;
CHECK(msg->findInt32("result", &err));
CHECK_NE(err, (status_t)OK);
mLooper->unregisterHandler(mHandler->id());
mHandler.clear();
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::DashMpdSource::onSessionNotify(const sp<AMessage> &msg)
{
int32_t what;
CHECK(msg->findInt32("what", &what));
switch (what)
{
case DashSession::kWhatPrepared:
{
notifyVideoSizeChanged(0, 0);
uint32_t flags = FLAG_CAN_PAUSE;
if (mDashSession->isSeekable())
{
flags |= FLAG_CAN_SEEK;
flags |= FLAG_CAN_SEEK_BACKWARD;
flags |= FLAG_CAN_SEEK_FORWARD;
}
if (mDashSession->hasDynamicDuration())
{
flags |= FLAG_DYNAMIC_DURATION;
}
notifyFlagsChanged(flags);
notifyPrepared();
break;
};
case DashSession::kWhatPreparationFailed:
{
status_t err;
CHECK(msg->findInt32("err", &err));
notifyPrepared(err);
break;
};
default:
TRESPASS();
};
};
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::RTSPSource::prepareAsync() {
if (mIsSDP && mHTTPService == NULL) {
notifyPrepared(BAD_VALUE);
return;
}
if (mLooper == NULL) {
mLooper = new ALooper;
mLooper->setName("rtsp");
mLooper->start();
mLooper->registerHandler(this);
}
CHECK(mHandler == NULL);
CHECK(mSDPLoader == NULL);
sp<AMessage> notify = new AMessage(kWhatNotify, this);
CHECK_EQ(mState, (int)DISCONNECTED);
mState = CONNECTING;
if (mIsSDP) {
mSDPLoader = new SDPLoader(notify,
(mFlags & kFlagIncognito) ? SDPLoader::kFlagIncognito : 0,
mHTTPService);
mSDPLoader->load(
mURL.c_str(), mExtraHeaders.isEmpty() ? NULL : &mExtraHeaders);
} else {
mHandler = new MyHandler(mURL.c_str(), notify, mUIDValid, mUID);
mLooper->registerHandler(mHandler);
mHandler->connect();
}
startBufferingIfNecessary();
}
//--------------------------------------------------
// Event handlers
void AacBqToPcmCbRenderer::onPrepare() {
SL_LOGD("AacBqToPcmCbRenderer::onPrepare()");
Mutex::Autolock _l(mBufferSourceLock);
// Initialize the PCM format info with the known parameters before the start of the decode
{
android::Mutex::Autolock autoLock(mPcmFormatLock);
mPcmFormatValues[ANDROID_KEY_INDEX_PCMFORMAT_BITSPERSAMPLE] = SL_PCMSAMPLEFORMAT_FIXED_16;
mPcmFormatValues[ANDROID_KEY_INDEX_PCMFORMAT_CONTAINERSIZE] = 16;
//FIXME not true on all platforms
mPcmFormatValues[ANDROID_KEY_INDEX_PCMFORMAT_ENDIANNESS] = SL_BYTEORDER_LITTLEENDIAN;
// initialization with the default values: they will be replaced by the actual values
// once the decoder has figured them out
mPcmFormatValues[ANDROID_KEY_INDEX_PCMFORMAT_NUMCHANNELS] = UNKNOWN_NUMCHANNELS;
mPcmFormatValues[ANDROID_KEY_INDEX_PCMFORMAT_SAMPLERATE] = UNKNOWN_SAMPLERATE;
mPcmFormatValues[ANDROID_KEY_INDEX_PCMFORMAT_CHANNELMASK] = SL_ANDROID_UNKNOWN_CHANNELMASK;
}
sp<MediaExtractor> extractor = new AacAdtsExtractor(mBqSource);
// only decoding a single track of data
const size_t kTrackToDecode = 0;
sp<IMediaSource> source = extractor->getTrack(kTrackToDecode);
if (source == 0) {
SL_LOGE("AacBqToPcmCbRenderer::onPrepare: error getting source from extractor");
notifyPrepared(ERROR_UNSUPPORTED);
return;
}
// the audio content is not raw PCM, so we need a decoder
source = SimpleDecodingSource::Create(source);
if (source == NULL) {
SL_LOGE("AacBqToPcmCbRenderer::onPrepare: Could not instantiate decoder.");
notifyPrepared(ERROR_UNSUPPORTED);
return;
}
sp<MetaData> meta = source->getFormat();
SL_LOGD("AacBqToPcmCbRenderer::onPrepare() after instantiating decoder");
if (source->start() != OK) {
SL_LOGE("AacBqToPcmCbRenderer::onPrepare() Failed to start source/decoder.");
notifyPrepared(MEDIA_ERROR_BASE);
return;
}
//---------------------------------
int32_t channelCount;
CHECK(meta->findInt32(kKeyChannelCount, &channelCount));
int32_t sr;
CHECK(meta->findInt32(kKeySampleRate, &sr));
// FIXME similar to AudioSfDecoder::onPrepare()
// already "good to go" (compare to AudioSfDecoder::onPrepare)
mCacheStatus = kStatusHigh;
mCacheFill = 1000;
notifyStatus();
notifyCacheFill();
{
android::Mutex::Autolock autoLock(mPcmFormatLock);
mPcmFormatValues[ANDROID_KEY_INDEX_PCMFORMAT_SAMPLERATE] = sr;
mPcmFormatValues[ANDROID_KEY_INDEX_PCMFORMAT_NUMCHANNELS] = channelCount;
mPcmFormatValues[ANDROID_KEY_INDEX_PCMFORMAT_CHANNELMASK] =
sles_channel_out_mask_from_count(channelCount);
}
SL_LOGV("AacBqToPcmCbRenderer::onPrepare() channel count=%d SR=%d",
channelCount, sr);
//---------------------------------
// The data source, and audio source (a decoder) are ready to be used
mDataSource = mBqSource;
mAudioSource = source;
mAudioSourceStarted = true;
//-------------------------------------
// signal successful completion of prepare
mStateFlags |= kFlagPrepared;
// skipping past AudioToCbRenderer and AudioSfDecoder
GenericPlayer::onPrepare();
SL_LOGD("AacBqToPcmCbRenderer::onPrepare() done, mStateFlags=0x%x", mStateFlags);
}
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::StreamingSource::prepareAsync() {
notifyVideoSizeChanged();
notifyFlagsChanged(0);
notifyPrepared();
}
void NuPlayer::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;
}
CHECK_EQ(msg->what(), (int)kWhatNotify);
int32_t what;
CHECK(msg->findInt32("what", &what));
switch (what) {
case MyHandler::kWhatConnected:
{
onConnected();
notifyVideoSizeChanged(0, 0);
uint32_t flags = 0;
if (mHandler->isSeekable()) {
flags = FLAG_CAN_PAUSE
| FLAG_CAN_SEEK
| FLAG_CAN_SEEK_BACKWARD
| FLAG_CAN_SEEK_FORWARD;
}
notifyFlagsChanged(flags);
notifyPrepared();
break;
}
case MyHandler::kWhatDisconnected:
{
onDisconnected(msg);
break;
}
case MyHandler::kWhatSeekDone:
{
mState = CONNECTED;
break;
}
case MyHandler::kWhatAccessUnit:
{
size_t trackIndex;
CHECK(msg->findSize("trackIndex", &trackIndex));
if (mTSParser == NULL) {
CHECK_LT(trackIndex, mTracks.size());
} else {
CHECK_EQ(trackIndex, 0u);
}
sp<ABuffer> accessUnit;
CHECK(msg->findBuffer("accessUnit", &accessUnit));
int32_t damaged;
if (accessUnit->meta()->findInt32("damaged", &damaged)
&& damaged) {
break;
}
if (mTSParser != NULL) {
size_t offset = 0;
status_t err = OK;
while (offset + 188 <= accessUnit->size()) {
err = mTSParser->feedTSPacket(
accessUnit->data() + offset, 188);
if (err != OK) {
break;
}
offset += 188;
}
if (offset < accessUnit->size()) {
err = ERROR_MALFORMED;
}
if (err != OK) {
sp<AnotherPacketSource> source = getSource(false /* audio */);
if (source != NULL) {
source->signalEOS(err);
}
source = getSource(true /* audio */);
if (source != NULL) {
source->signalEOS(err);
}
}
break;
}
TrackInfo *info = &mTracks.editItemAt(trackIndex);
sp<AnotherPacketSource> source = info->mSource;
if (source != NULL) {
uint32_t rtpTime;
CHECK(accessUnit->meta()->findInt32("rtp-time", (int32_t *)&rtpTime));
if (!info->mNPTMappingValid) {
// This is a live stream, we didn't receive any normal
// playtime mapping. We won't map to npt time.
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);
source->queueAccessUnit(accessUnit);
}
break;
}
case MyHandler::kWhatEOS:
{
int32_t finalResult;
CHECK(msg->findInt32("finalResult", &finalResult));
CHECK_NE(finalResult, (status_t)OK);
if (mTSParser != NULL) {
sp<AnotherPacketSource> source = getSource(false /* audio */);
if (source != NULL) {
source->signalEOS(finalResult);
}
source = getSource(true /* audio */);
if (source != NULL) {
source->signalEOS(finalResult);
}
return;
}
size_t trackIndex;
CHECK(msg->findSize("trackIndex", &trackIndex));
CHECK_LT(trackIndex, mTracks.size());
TrackInfo *info = &mTracks.editItemAt(trackIndex);
sp<AnotherPacketSource> source = info->mSource;
if (source != NULL) {
source->signalEOS(finalResult);
}
break;
}
case MyHandler::kWhatSeekDiscontinuity:
{
size_t trackIndex;
CHECK(msg->findSize("trackIndex", &trackIndex));
CHECK_LT(trackIndex, mTracks.size());
TrackInfo *info = &mTracks.editItemAt(trackIndex);
sp<AnotherPacketSource> source = info->mSource;
if (source != NULL) {
source->queueDiscontinuity(ATSParser::DISCONTINUITY_SEEK, NULL);
}
break;
}
case MyHandler::kWhatNormalPlayTimeMapping:
{
size_t trackIndex;
CHECK(msg->findSize("trackIndex", &trackIndex));
CHECK_LT(trackIndex, mTracks.size());
uint32_t rtpTime;
CHECK(msg->findInt32("rtpTime", (int32_t *)&rtpTime));
int64_t nptUs;
CHECK(msg->findInt64("nptUs", &nptUs));
TrackInfo *info = &mTracks.editItemAt(trackIndex);
info->mRTPTime = rtpTime;
info->mNormalPlaytimeUs = nptUs;
info->mNPTMappingValid = true;
break;
}
case SDPLoader::kWhatSDPLoaded:
{
onSDPLoaded(msg);
break;
}
default:
TRESPASS();
}
}
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();
}
}
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();
}
}
void MP4Source::prepareAsync() {
notifyVideoSizeChanged(0, 0);
notifyFlagsChanged(0);
notifyPrepared();
}
