1 /*
2 * Copyright (C) 2010 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 //#define LOG_NDEBUG 0
18 #define LOG_TAG "RTSPSource"
19 #include <utils/Log.h>
20
21 #include "RTSPSource.h"
22
23 #include "AnotherPacketSource.h"
24 #include "MyHandler.h"
25 #include "SDPLoader.h"
26
27 #include <media/stagefright/MediaDefs.h>
28 #include <media/stagefright/MetaData.h>
29
30 namespace android {
31
32 const int64_t kNearEOSTimeoutUs = 2000000ll; // 2 secs
33
RTSPSource(const sp<AMessage> & notify,const char * url,const KeyedVector<String8,String8> * headers,bool uidValid,uid_t uid,bool isSDP)34 NuPlayer::RTSPSource::RTSPSource(
35 const sp<AMessage> ¬ify,
36 const char *url,
37 const KeyedVector<String8, String8> *headers,
38 bool uidValid,
39 uid_t uid,
40 bool isSDP)
41 : Source(notify),
42 mURL(url),
43 mUIDValid(uidValid),
44 mUID(uid),
45 mFlags(0),
46 mIsSDP(isSDP),
47 mState(DISCONNECTED),
48 mFinalResult(OK),
49 mDisconnectReplyID(0),
50 mBuffering(true),
51 mSeekGeneration(0),
52 mEOSTimeoutAudio(0),
53 mEOSTimeoutVideo(0) {
54 if (headers) {
55 mExtraHeaders = *headers;
56
57 ssize_t index =
58 mExtraHeaders.indexOfKey(String8("x-hide-urls-from-log"));
59
60 if (index >= 0) {
61 mFlags |= kFlagIncognito;
62
63 mExtraHeaders.removeItemsAt(index);
64 }
65 }
66 }
67
~RTSPSource()68 NuPlayer::RTSPSource::~RTSPSource() {
69 if (mLooper != NULL) {
70 mLooper->stop();
71 }
72 }
73
prepareAsync()74 void NuPlayer::RTSPSource::prepareAsync() {
75 if (mLooper == NULL) {
76 mLooper = new ALooper;
77 mLooper->setName("rtsp");
78 mLooper->start();
79
80 mReflector = new AHandlerReflector<RTSPSource>(this);
81 mLooper->registerHandler(mReflector);
82 }
83
84 CHECK(mHandler == NULL);
85 CHECK(mSDPLoader == NULL);
86
87 sp<AMessage> notify = new AMessage(kWhatNotify, mReflector->id());
88
89 CHECK_EQ(mState, (int)DISCONNECTED);
90 mState = CONNECTING;
91
92 if (mIsSDP) {
93 mSDPLoader = new SDPLoader(notify,
94 (mFlags & kFlagIncognito) ? SDPLoader::kFlagIncognito : 0,
95 mUIDValid, mUID);
96
97 mSDPLoader->load(
98 mURL.c_str(), mExtraHeaders.isEmpty() ? NULL : &mExtraHeaders);
99 } else {
100 mHandler = new MyHandler(mURL.c_str(), notify, mUIDValid, mUID);
101 mLooper->registerHandler(mHandler);
102
103 mHandler->connect();
104 }
105
106 sp<AMessage> notifyStart = dupNotify();
107 notifyStart->setInt32("what", kWhatBufferingStart);
108 notifyStart->post();
109 }
110
start()111 void NuPlayer::RTSPSource::start() {
112 }
113
stop()114 void NuPlayer::RTSPSource::stop() {
115 if (mLooper == NULL) {
116 return;
117 }
118 sp<AMessage> msg = new AMessage(kWhatDisconnect, mReflector->id());
119
120 sp<AMessage> dummy;
121 msg->postAndAwaitResponse(&dummy);
122 }
123
pause()124 void NuPlayer::RTSPSource::pause() {
125 int64_t mediaDurationUs = 0;
126 getDuration(&mediaDurationUs);
127 for (size_t index = 0; index < mTracks.size(); index++) {
128 TrackInfo *info = &mTracks.editItemAt(index);
129 sp<AnotherPacketSource> source = info->mSource;
130
131 // Check if EOS or ERROR is received
132 if (source != NULL && source->isFinished(mediaDurationUs)) {
133 return;
134 }
135 }
136 mHandler->pause();
137 }
138
resume()139 void NuPlayer::RTSPSource::resume() {
140 mHandler->resume();
141 }
142
feedMoreTSData()143 status_t NuPlayer::RTSPSource::feedMoreTSData() {
144 return mFinalResult;
145 }
146
getFormatMeta(bool audio)147 sp<MetaData> NuPlayer::RTSPSource::getFormatMeta(bool audio) {
148 sp<AnotherPacketSource> source = getSource(audio);
149
150 if (source == NULL) {
151 return NULL;
152 }
153
154 return source->getFormat();
155 }
156
haveSufficientDataOnAllTracks()157 bool NuPlayer::RTSPSource::haveSufficientDataOnAllTracks() {
158 // We're going to buffer at least 2 secs worth data on all tracks before
159 // starting playback (both at startup and after a seek).
160
161 static const int64_t kMinDurationUs = 2000000ll;
162
163 int64_t mediaDurationUs = 0;
164 getDuration(&mediaDurationUs);
165 if ((mAudioTrack != NULL && mAudioTrack->isFinished(mediaDurationUs))
166 || (mVideoTrack != NULL && mVideoTrack->isFinished(mediaDurationUs))) {
167 return true;
168 }
169
170 status_t err;
171 int64_t durationUs;
172 if (mAudioTrack != NULL
173 && (durationUs = mAudioTrack->getBufferedDurationUs(&err))
174 < kMinDurationUs
175 && err == OK) {
176 ALOGV("audio track doesn't have enough data yet. (%.2f secs buffered)",
177 durationUs / 1E6);
178 return false;
179 }
180
181 if (mVideoTrack != NULL
182 && (durationUs = mVideoTrack->getBufferedDurationUs(&err))
183 < kMinDurationUs
184 && err == OK) {
185 ALOGV("video track doesn't have enough data yet. (%.2f secs buffered)",
186 durationUs / 1E6);
187 return false;
188 }
189
190 return true;
191 }
192
dequeueAccessUnit(bool audio,sp<ABuffer> * accessUnit)193 status_t NuPlayer::RTSPSource::dequeueAccessUnit(
194 bool audio, sp<ABuffer> *accessUnit) {
195 if (mBuffering) {
196 if (!haveSufficientDataOnAllTracks()) {
197 return -EWOULDBLOCK;
198 }
199
200 mBuffering = false;
201
202 sp<AMessage> notify = dupNotify();
203 notify->setInt32("what", kWhatBufferingEnd);
204 notify->post();
205 }
206
207 sp<AnotherPacketSource> source = getSource(audio);
208
209 if (source == NULL) {
210 return -EWOULDBLOCK;
211 }
212
213 status_t finalResult;
214 if (!source->hasBufferAvailable(&finalResult)) {
215 if (finalResult == OK) {
216 int64_t mediaDurationUs = 0;
217 getDuration(&mediaDurationUs);
218 sp<AnotherPacketSource> otherSource = getSource(!audio);
219 status_t otherFinalResult;
220
221 // If other source already signaled EOS, this source should also signal EOS
222 if (otherSource != NULL &&
223 !otherSource->hasBufferAvailable(&otherFinalResult) &&
224 otherFinalResult == ERROR_END_OF_STREAM) {
225 source->signalEOS(ERROR_END_OF_STREAM);
226 return ERROR_END_OF_STREAM;
227 }
228
229 // If this source has detected near end, give it some time to retrieve more
230 // data before signaling EOS
231 if (source->isFinished(mediaDurationUs)) {
232 int64_t eosTimeout = audio ? mEOSTimeoutAudio : mEOSTimeoutVideo;
233 if (eosTimeout == 0) {
234 setEOSTimeout(audio, ALooper::GetNowUs());
235 } else if ((ALooper::GetNowUs() - eosTimeout) > kNearEOSTimeoutUs) {
236 setEOSTimeout(audio, 0);
237 source->signalEOS(ERROR_END_OF_STREAM);
238 return ERROR_END_OF_STREAM;
239 }
240 return -EWOULDBLOCK;
241 }
242
243 if (!(otherSource != NULL && otherSource->isFinished(mediaDurationUs))) {
244 // We should not enter buffering mode
245 // if any of the sources already have detected EOS.
246 mBuffering = true;
247
248 sp<AMessage> notify = dupNotify();
249 notify->setInt32("what", kWhatBufferingStart);
250 notify->post();
251 }
252
253 return -EWOULDBLOCK;
254 }
255 return finalResult;
256 }
257
258 setEOSTimeout(audio, 0);
259
260 return source->dequeueAccessUnit(accessUnit);
261 }
262
getSource(bool audio)263 sp<AnotherPacketSource> NuPlayer::RTSPSource::getSource(bool audio) {
264 if (mTSParser != NULL) {
265 sp<MediaSource> source = mTSParser->getSource(
266 audio ? ATSParser::AUDIO : ATSParser::VIDEO);
267
268 return static_cast<AnotherPacketSource *>(source.get());
269 }
270
271 return audio ? mAudioTrack : mVideoTrack;
272 }
273
setEOSTimeout(bool audio,int64_t timeout)274 void NuPlayer::RTSPSource::setEOSTimeout(bool audio, int64_t timeout) {
275 if (audio) {
276 mEOSTimeoutAudio = timeout;
277 } else {
278 mEOSTimeoutVideo = timeout;
279 }
280 }
281
getDuration(int64_t * durationUs)282 status_t NuPlayer::RTSPSource::getDuration(int64_t *durationUs) {
283 *durationUs = 0ll;
284
285 int64_t audioDurationUs;
286 if (mAudioTrack != NULL
287 && mAudioTrack->getFormat()->findInt64(
288 kKeyDuration, &audioDurationUs)
289 && audioDurationUs > *durationUs) {
290 *durationUs = audioDurationUs;
291 }
292
293 int64_t videoDurationUs;
294 if (mVideoTrack != NULL
295 && mVideoTrack->getFormat()->findInt64(
296 kKeyDuration, &videoDurationUs)
297 && videoDurationUs > *durationUs) {
298 *durationUs = videoDurationUs;
299 }
300
301 return OK;
302 }
303
seekTo(int64_t seekTimeUs)304 status_t NuPlayer::RTSPSource::seekTo(int64_t seekTimeUs) {
305 sp<AMessage> msg = new AMessage(kWhatPerformSeek, mReflector->id());
306 msg->setInt32("generation", ++mSeekGeneration);
307 msg->setInt64("timeUs", seekTimeUs);
308 msg->post(200000ll);
309
310 return OK;
311 }
312
performSeek(int64_t seekTimeUs)313 void NuPlayer::RTSPSource::performSeek(int64_t seekTimeUs) {
314 if (mState != CONNECTED) {
315 return;
316 }
317
318 mState = SEEKING;
319 mHandler->seek(seekTimeUs);
320 }
321
onMessageReceived(const sp<AMessage> & msg)322 void NuPlayer::RTSPSource::onMessageReceived(const sp<AMessage> &msg) {
323 if (msg->what() == kWhatDisconnect) {
324 uint32_t replyID;
325 CHECK(msg->senderAwaitsResponse(&replyID));
326
327 mDisconnectReplyID = replyID;
328 finishDisconnectIfPossible();
329 return;
330 } else if (msg->what() == kWhatPerformSeek) {
331 int32_t generation;
332 CHECK(msg->findInt32("generation", &generation));
333
334 if (generation != mSeekGeneration) {
335 // obsolete.
336 return;
337 }
338
339 int64_t seekTimeUs;
340 CHECK(msg->findInt64("timeUs", &seekTimeUs));
341
342 performSeek(seekTimeUs);
343 return;
344 }
345
346 CHECK_EQ(msg->what(), (int)kWhatNotify);
347
348 int32_t what;
349 CHECK(msg->findInt32("what", &what));
350
351 switch (what) {
352 case MyHandler::kWhatConnected:
353 {
354 onConnected();
355
356 notifyVideoSizeChanged(0, 0);
357
358 uint32_t flags = 0;
359
360 if (mHandler->isSeekable()) {
361 flags = FLAG_CAN_PAUSE
362 | FLAG_CAN_SEEK
363 | FLAG_CAN_SEEK_BACKWARD
364 | FLAG_CAN_SEEK_FORWARD;
365 }
366
367 notifyFlagsChanged(flags);
368 notifyPrepared();
369 break;
370 }
371
372 case MyHandler::kWhatDisconnected:
373 {
374 onDisconnected(msg);
375 break;
376 }
377
378 case MyHandler::kWhatSeekDone:
379 {
380 mState = CONNECTED;
381 break;
382 }
383
384 case MyHandler::kWhatAccessUnit:
385 {
386 size_t trackIndex;
387 CHECK(msg->findSize("trackIndex", &trackIndex));
388
389 if (mTSParser == NULL) {
390 CHECK_LT(trackIndex, mTracks.size());
391 } else {
392 CHECK_EQ(trackIndex, 0u);
393 }
394
395 sp<ABuffer> accessUnit;
396 CHECK(msg->findBuffer("accessUnit", &accessUnit));
397
398 int32_t damaged;
399 if (accessUnit->meta()->findInt32("damaged", &damaged)
400 && damaged) {
401 ALOGI("dropping damaged access unit.");
402 break;
403 }
404
405 if (mTSParser != NULL) {
406 size_t offset = 0;
407 status_t err = OK;
408 while (offset + 188 <= accessUnit->size()) {
409 err = mTSParser->feedTSPacket(
410 accessUnit->data() + offset, 188);
411 if (err != OK) {
412 break;
413 }
414
415 offset += 188;
416 }
417
418 if (offset < accessUnit->size()) {
419 err = ERROR_MALFORMED;
420 }
421
422 if (err != OK) {
423 sp<AnotherPacketSource> source = getSource(false /* audio */);
424 if (source != NULL) {
425 source->signalEOS(err);
426 }
427
428 source = getSource(true /* audio */);
429 if (source != NULL) {
430 source->signalEOS(err);
431 }
432 }
433 break;
434 }
435
436 TrackInfo *info = &mTracks.editItemAt(trackIndex);
437
438 sp<AnotherPacketSource> source = info->mSource;
439 if (source != NULL) {
440 uint32_t rtpTime;
441 CHECK(accessUnit->meta()->findInt32("rtp-time", (int32_t *)&rtpTime));
442
443 if (!info->mNPTMappingValid) {
444 // This is a live stream, we didn't receive any normal
445 // playtime mapping. We won't map to npt time.
446 source->queueAccessUnit(accessUnit);
447 break;
448 }
449
450 int64_t nptUs =
451 ((double)rtpTime - (double)info->mRTPTime)
452 / info->mTimeScale
453 * 1000000ll
454 + info->mNormalPlaytimeUs;
455
456 accessUnit->meta()->setInt64("timeUs", nptUs);
457
458 source->queueAccessUnit(accessUnit);
459 }
460 break;
461 }
462
463 case MyHandler::kWhatEOS:
464 {
465 int32_t finalResult;
466 CHECK(msg->findInt32("finalResult", &finalResult));
467 CHECK_NE(finalResult, (status_t)OK);
468
469 if (mTSParser != NULL) {
470 sp<AnotherPacketSource> source = getSource(false /* audio */);
471 if (source != NULL) {
472 source->signalEOS(finalResult);
473 }
474
475 source = getSource(true /* audio */);
476 if (source != NULL) {
477 source->signalEOS(finalResult);
478 }
479
480 return;
481 }
482
483 size_t trackIndex;
484 CHECK(msg->findSize("trackIndex", &trackIndex));
485 CHECK_LT(trackIndex, mTracks.size());
486
487 TrackInfo *info = &mTracks.editItemAt(trackIndex);
488 sp<AnotherPacketSource> source = info->mSource;
489 if (source != NULL) {
490 source->signalEOS(finalResult);
491 }
492
493 break;
494 }
495
496 case MyHandler::kWhatSeekDiscontinuity:
497 {
498 size_t trackIndex;
499 CHECK(msg->findSize("trackIndex", &trackIndex));
500 CHECK_LT(trackIndex, mTracks.size());
501
502 TrackInfo *info = &mTracks.editItemAt(trackIndex);
503 sp<AnotherPacketSource> source = info->mSource;
504 if (source != NULL) {
505 source->queueDiscontinuity(ATSParser::DISCONTINUITY_SEEK, NULL);
506 }
507
508 break;
509 }
510
511 case MyHandler::kWhatNormalPlayTimeMapping:
512 {
513 size_t trackIndex;
514 CHECK(msg->findSize("trackIndex", &trackIndex));
515 CHECK_LT(trackIndex, mTracks.size());
516
517 uint32_t rtpTime;
518 CHECK(msg->findInt32("rtpTime", (int32_t *)&rtpTime));
519
520 int64_t nptUs;
521 CHECK(msg->findInt64("nptUs", &nptUs));
522
523 TrackInfo *info = &mTracks.editItemAt(trackIndex);
524 info->mRTPTime = rtpTime;
525 info->mNormalPlaytimeUs = nptUs;
526 info->mNPTMappingValid = true;
527 break;
528 }
529
530 case SDPLoader::kWhatSDPLoaded:
531 {
532 onSDPLoaded(msg);
533 break;
534 }
535
536 default:
537 TRESPASS();
538 }
539 }
540
onConnected()541 void NuPlayer::RTSPSource::onConnected() {
542 CHECK(mAudioTrack == NULL);
543 CHECK(mVideoTrack == NULL);
544
545 size_t numTracks = mHandler->countTracks();
546 for (size_t i = 0; i < numTracks; ++i) {
547 int32_t timeScale;
548 sp<MetaData> format = mHandler->getTrackFormat(i, &timeScale);
549
550 const char *mime;
551 CHECK(format->findCString(kKeyMIMEType, &mime));
552
553 if (!strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_MPEG2TS)) {
554 // Very special case for MPEG2 Transport Streams.
555 CHECK_EQ(numTracks, 1u);
556
557 mTSParser = new ATSParser;
558 return;
559 }
560
561 bool isAudio = !strncasecmp(mime, "audio/", 6);
562 bool isVideo = !strncasecmp(mime, "video/", 6);
563
564 TrackInfo info;
565 info.mTimeScale = timeScale;
566 info.mRTPTime = 0;
567 info.mNormalPlaytimeUs = 0ll;
568 info.mNPTMappingValid = false;
569
570 if ((isAudio && mAudioTrack == NULL)
571 || (isVideo && mVideoTrack == NULL)) {
572 sp<AnotherPacketSource> source = new AnotherPacketSource(format);
573
574 if (isAudio) {
575 mAudioTrack = source;
576 } else {
577 mVideoTrack = source;
578 }
579
580 info.mSource = source;
581 }
582
583 mTracks.push(info);
584 }
585
586 mState = CONNECTED;
587 }
588
onSDPLoaded(const sp<AMessage> & msg)589 void NuPlayer::RTSPSource::onSDPLoaded(const sp<AMessage> &msg) {
590 status_t err;
591 CHECK(msg->findInt32("result", &err));
592
593 mSDPLoader.clear();
594
595 if (mDisconnectReplyID != 0) {
596 err = UNKNOWN_ERROR;
597 }
598
599 if (err == OK) {
600 sp<ASessionDescription> desc;
601 sp<RefBase> obj;
602 CHECK(msg->findObject("description", &obj));
603 desc = static_cast<ASessionDescription *>(obj.get());
604
605 AString rtspUri;
606 if (!desc->findAttribute(0, "a=control", &rtspUri)) {
607 ALOGE("Unable to find url in SDP");
608 err = UNKNOWN_ERROR;
609 } else {
610 sp<AMessage> notify = new AMessage(kWhatNotify, mReflector->id());
611
612 mHandler = new MyHandler(rtspUri.c_str(), notify, mUIDValid, mUID);
613 mLooper->registerHandler(mHandler);
614
615 mHandler->loadSDP(desc);
616 }
617 }
618
619 if (err != OK) {
620 if (mState == CONNECTING) {
621 // We're still in the preparation phase, signal that it
622 // failed.
623 notifyPrepared(err);
624 }
625
626 mState = DISCONNECTED;
627 mFinalResult = err;
628
629 if (mDisconnectReplyID != 0) {
630 finishDisconnectIfPossible();
631 }
632 }
633 }
634
onDisconnected(const sp<AMessage> & msg)635 void NuPlayer::RTSPSource::onDisconnected(const sp<AMessage> &msg) {
636 if (mState == DISCONNECTED) {
637 return;
638 }
639
640 status_t err;
641 CHECK(msg->findInt32("result", &err));
642 CHECK_NE(err, (status_t)OK);
643
644 mLooper->unregisterHandler(mHandler->id());
645 mHandler.clear();
646
647 if (mState == CONNECTING) {
648 // We're still in the preparation phase, signal that it
649 // failed.
650 notifyPrepared(err);
651 }
652
653 mState = DISCONNECTED;
654 mFinalResult = err;
655
656 if (mDisconnectReplyID != 0) {
657 finishDisconnectIfPossible();
658 }
659 }
660
finishDisconnectIfPossible()661 void NuPlayer::RTSPSource::finishDisconnectIfPossible() {
662 if (mState != DISCONNECTED) {
663 if (mHandler != NULL) {
664 mHandler->disconnect();
665 } else if (mSDPLoader != NULL) {
666 mSDPLoader->cancel();
667 }
668 return;
669 }
670
671 (new AMessage)->postReply(mDisconnectReplyID);
672 mDisconnectReplyID = 0;
673 }
674
675 } // namespace android
676