blob: 83da0925065d8a1d99db73557806d0fe4325f57a [file] [log] [blame]
Andreas Huber2bfdd422011-10-11 15:24:07 -07001/*
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"
Oscar Rydhé81dd60e2012-02-20 10:15:48 +010025#include "SDPLoader.h"
Andreas Huber2bfdd422011-10-11 15:24:07 -070026
Andreas Huber1b86fe02014-01-29 11:13:26 -080027#include <media/IMediaHTTPService.h>
Andreas Huber49694682012-08-31 10:27:46 -070028#include <media/stagefright/MediaDefs.h>
Andreas Huber2bfdd422011-10-11 15:24:07 -070029#include <media/stagefright/MetaData.h>
30
31namespace android {
32
Chih-Hung Hsieh62309d52018-12-11 13:54:02 -080033const int64_t kNearEOSTimeoutUs = 2000000LL; // 2 secs
Roger Jönssoncfc30832013-01-21 16:26:41 +010034
Wei Jia48fa06d2016-12-20 15:30:49 -080035// Default Buffer Underflow/Prepare/StartServer/Overflow Marks
36static const int kUnderflowMarkMs = 1000; // 1 second
37static const int kPrepareMarkMs = 3000; // 3 seconds
38//static const int kStartServerMarkMs = 5000;
39static const int kOverflowMarkMs = 10000; // 10 seconds
Robert Shih641e0c72016-02-22 11:37:20 -080040
Andreas Huber2bfdd422011-10-11 15:24:07 -070041NuPlayer::RTSPSource::RTSPSource(
Andreas Huber5ab368a2013-02-05 10:14:26 -080042 const sp<AMessage> &notify,
Andreas Huber1b86fe02014-01-29 11:13:26 -080043 const sp<IMediaHTTPService> &httpService,
Andreas Huber2bfdd422011-10-11 15:24:07 -070044 const char *url,
45 const KeyedVector<String8, String8> *headers,
46 bool uidValid,
Oscar Rydhé81dd60e2012-02-20 10:15:48 +010047 uid_t uid,
48 bool isSDP)
Andreas Huber5ab368a2013-02-05 10:14:26 -080049 : Source(notify),
Andreas Huber1b86fe02014-01-29 11:13:26 -080050 mHTTPService(httpService),
Andreas Huber5ab368a2013-02-05 10:14:26 -080051 mURL(url),
Andreas Huber2bfdd422011-10-11 15:24:07 -070052 mUIDValid(uidValid),
53 mUID(uid),
54 mFlags(0),
Oscar Rydhé81dd60e2012-02-20 10:15:48 +010055 mIsSDP(isSDP),
Andreas Huber2bfdd422011-10-11 15:24:07 -070056 mState(DISCONNECTED),
57 mFinalResult(OK),
Andreas Huberee736e92011-12-08 13:04:50 -080058 mDisconnectReplyID(0),
Chong Zhang180d1b92014-12-02 18:35:35 -080059 mBuffering(false),
Robert Shih641e0c72016-02-22 11:37:20 -080060 mInPreparationPhase(true),
Robert Shihf1d261f2016-07-29 16:44:39 -070061 mEOSPending(false),
Roger Jönssoncfc30832013-01-21 16:26:41 +010062 mSeekGeneration(0),
63 mEOSTimeoutAudio(0),
64 mEOSTimeoutVideo(0) {
Wei Jia9bb38032017-03-23 18:00:38 -070065 mBufferingSettings.mInitialMarkMs = kPrepareMarkMs;
66 mBufferingSettings.mResumePlaybackMarkMs = kOverflowMarkMs;
Andreas Huber2bfdd422011-10-11 15:24:07 -070067 if (headers) {
68 mExtraHeaders = *headers;
69
70 ssize_t index =
71 mExtraHeaders.indexOfKey(String8("x-hide-urls-from-log"));
72
73 if (index >= 0) {
74 mFlags |= kFlagIncognito;
75
76 mExtraHeaders.removeItemsAt(index);
77 }
78 }
79}
80
81NuPlayer::RTSPSource::~RTSPSource() {
Andreas Huber602f5bb2013-04-15 16:18:56 -070082 if (mLooper != NULL) {
Chong Zhang1228d6b2014-08-12 21:25:48 -070083 mLooper->unregisterHandler(id());
Andreas Huber602f5bb2013-04-15 16:18:56 -070084 mLooper->stop();
85 }
Andreas Huber2bfdd422011-10-11 15:24:07 -070086}
87
Wei Jia9bb38032017-03-23 18:00:38 -070088status_t NuPlayer::RTSPSource::getBufferingSettings(
Wei Jia48fa06d2016-12-20 15:30:49 -080089 BufferingSettings* buffering /* nonnull */) {
Wei Jia9bb38032017-03-23 18:00:38 -070090 Mutex::Autolock _l(mBufferingSettingsLock);
91 *buffering = mBufferingSettings;
Wei Jia48fa06d2016-12-20 15:30:49 -080092 return OK;
93}
94
95status_t NuPlayer::RTSPSource::setBufferingSettings(const BufferingSettings& buffering) {
Wei Jia9bb38032017-03-23 18:00:38 -070096 Mutex::Autolock _l(mBufferingSettingsLock);
97 mBufferingSettings = buffering;
98 return OK;
Wei Jia48fa06d2016-12-20 15:30:49 -080099}
100
Andreas Huber57cea552013-02-05 13:59:56 -0800101void NuPlayer::RTSPSource::prepareAsync() {
Wei Jiace84b222016-01-14 14:39:42 -0800102 if (mIsSDP && mHTTPService == NULL) {
103 notifyPrepared(BAD_VALUE);
104 return;
105 }
106
Andreas Huber2bfdd422011-10-11 15:24:07 -0700107 if (mLooper == NULL) {
108 mLooper = new ALooper;
109 mLooper->setName("rtsp");
110 mLooper->start();
111
Chong Zhang1228d6b2014-08-12 21:25:48 -0700112 mLooper->registerHandler(this);
Andreas Huber2bfdd422011-10-11 15:24:07 -0700113 }
114
115 CHECK(mHandler == NULL);
Oscar Rydhé81dd60e2012-02-20 10:15:48 +0100116 CHECK(mSDPLoader == NULL);
Andreas Huber2bfdd422011-10-11 15:24:07 -0700117
Lajos Molnar1d15ab52015-03-04 16:46:34 -0800118 sp<AMessage> notify = new AMessage(kWhatNotify, this);
Andreas Huber2bfdd422011-10-11 15:24:07 -0700119
Andreas Huber2bfdd422011-10-11 15:24:07 -0700120 CHECK_EQ(mState, (int)DISCONNECTED);
121 mState = CONNECTING;
122
Oscar Rydhé81dd60e2012-02-20 10:15:48 +0100123 if (mIsSDP) {
124 mSDPLoader = new SDPLoader(notify,
125 (mFlags & kFlagIncognito) ? SDPLoader::kFlagIncognito : 0,
Andreas Huber81e68442014-02-05 11:52:33 -0800126 mHTTPService);
Oscar Rydhé81dd60e2012-02-20 10:15:48 +0100127
Andreas Huber57cea552013-02-05 13:59:56 -0800128 mSDPLoader->load(
129 mURL.c_str(), mExtraHeaders.isEmpty() ? NULL : &mExtraHeaders);
Oscar Rydhé81dd60e2012-02-20 10:15:48 +0100130 } else {
131 mHandler = new MyHandler(mURL.c_str(), notify, mUIDValid, mUID);
132 mLooper->registerHandler(mHandler);
133
134 mHandler->connect();
135 }
Roger Jönssoncfc30832013-01-21 16:26:41 +0100136
Chong Zhang180d1b92014-12-02 18:35:35 -0800137 startBufferingIfNecessary();
Andreas Huber57cea552013-02-05 13:59:56 -0800138}
139
140void NuPlayer::RTSPSource::start() {
Andreas Huber2bfdd422011-10-11 15:24:07 -0700141}
142
143void NuPlayer::RTSPSource::stop() {
James Dong58341812012-11-16 14:31:15 -0800144 if (mLooper == NULL) {
145 return;
146 }
Dichen Zhangfd3bbcb2019-08-08 17:15:01 -0700147
148 // Close socket before posting message to RTSPSource message handler.
149 close(mHandler->getARTSPConnection()->getSocket());
150
Lajos Molnar1d15ab52015-03-04 16:46:34 -0800151 sp<AMessage> msg = new AMessage(kWhatDisconnect, this);
Andreas Huber2bfdd422011-10-11 15:24:07 -0700152
153 sp<AMessage> dummy;
154 msg->postAndAwaitResponse(&dummy);
155}
156
157status_t NuPlayer::RTSPSource::feedMoreTSData() {
Chong Zhang180d1b92014-12-02 18:35:35 -0800158 Mutex::Autolock _l(mBufferingLock);
Andreas Huber2bfdd422011-10-11 15:24:07 -0700159 return mFinalResult;
160}
161
Andreas Huber84066782011-08-16 09:34:26 -0700162sp<MetaData> NuPlayer::RTSPSource::getFormatMeta(bool audio) {
Andreas Huber2bfdd422011-10-11 15:24:07 -0700163 sp<AnotherPacketSource> source = getSource(audio);
164
165 if (source == NULL) {
166 return NULL;
167 }
168
169 return source->getFormat();
170}
171
Andreas Huberbfd4d0d2012-05-17 14:18:50 -0700172bool NuPlayer::RTSPSource::haveSufficientDataOnAllTracks() {
173 // We're going to buffer at least 2 secs worth data on all tracks before
174 // starting playback (both at startup and after a seek).
175
Chih-Hung Hsieh62309d52018-12-11 13:54:02 -0800176 static const int64_t kMinDurationUs = 2000000LL;
Andreas Huberbfd4d0d2012-05-17 14:18:50 -0700177
Roger Jönssoncfc30832013-01-21 16:26:41 +0100178 int64_t mediaDurationUs = 0;
179 getDuration(&mediaDurationUs);
180 if ((mAudioTrack != NULL && mAudioTrack->isFinished(mediaDurationUs))
181 || (mVideoTrack != NULL && mVideoTrack->isFinished(mediaDurationUs))) {
182 return true;
183 }
184
Andreas Huberbfd4d0d2012-05-17 14:18:50 -0700185 status_t err;
186 int64_t durationUs;
187 if (mAudioTrack != NULL
188 && (durationUs = mAudioTrack->getBufferedDurationUs(&err))
189 < kMinDurationUs
190 && err == OK) {
191 ALOGV("audio track doesn't have enough data yet. (%.2f secs buffered)",
192 durationUs / 1E6);
193 return false;
194 }
195
196 if (mVideoTrack != NULL
197 && (durationUs = mVideoTrack->getBufferedDurationUs(&err))
198 < kMinDurationUs
199 && err == OK) {
200 ALOGV("video track doesn't have enough data yet. (%.2f secs buffered)",
201 durationUs / 1E6);
202 return false;
203 }
204
205 return true;
206}
207
Andreas Huber2bfdd422011-10-11 15:24:07 -0700208status_t NuPlayer::RTSPSource::dequeueAccessUnit(
209 bool audio, sp<ABuffer> *accessUnit) {
Chong Zhang180d1b92014-12-02 18:35:35 -0800210 if (!stopBufferingIfNecessary()) {
211 return -EWOULDBLOCK;
Andreas Huberbfd4d0d2012-05-17 14:18:50 -0700212 }
213
Andreas Huber2bfdd422011-10-11 15:24:07 -0700214 sp<AnotherPacketSource> source = getSource(audio);
215
216 if (source == NULL) {
217 return -EWOULDBLOCK;
218 }
219
220 status_t finalResult;
221 if (!source->hasBufferAvailable(&finalResult)) {
Roger Jönssoncfc30832013-01-21 16:26:41 +0100222 if (finalResult == OK) {
Roger Jönssoncfc30832013-01-21 16:26:41 +0100223
Robert Shihf1d261f2016-07-29 16:44:39 -0700224 // If other source already signaled EOS, this source should also return EOS
225 if (sourceReachedEOS(!audio)) {
Roger Jönssoncfc30832013-01-21 16:26:41 +0100226 return ERROR_END_OF_STREAM;
227 }
228
229 // If this source has detected near end, give it some time to retrieve more
Robert Shihf1d261f2016-07-29 16:44:39 -0700230 // data before returning EOS
231 int64_t mediaDurationUs = 0;
232 getDuration(&mediaDurationUs);
Roger Jönssoncfc30832013-01-21 16:26:41 +0100233 if (source->isFinished(mediaDurationUs)) {
234 int64_t eosTimeout = audio ? mEOSTimeoutAudio : mEOSTimeoutVideo;
235 if (eosTimeout == 0) {
236 setEOSTimeout(audio, ALooper::GetNowUs());
237 } else if ((ALooper::GetNowUs() - eosTimeout) > kNearEOSTimeoutUs) {
238 setEOSTimeout(audio, 0);
Roger Jönssoncfc30832013-01-21 16:26:41 +0100239 return ERROR_END_OF_STREAM;
240 }
241 return -EWOULDBLOCK;
242 }
243
Robert Shihf1d261f2016-07-29 16:44:39 -0700244 if (!sourceNearEOS(!audio)) {
Roger Jönssoncfc30832013-01-21 16:26:41 +0100245 // We should not enter buffering mode
246 // if any of the sources already have detected EOS.
Chong Zhang180d1b92014-12-02 18:35:35 -0800247 startBufferingIfNecessary();
Roger Jönssoncfc30832013-01-21 16:26:41 +0100248 }
249
250 return -EWOULDBLOCK;
251 }
252 return finalResult;
Andreas Huber2bfdd422011-10-11 15:24:07 -0700253 }
254
Roger Jönssoncfc30832013-01-21 16:26:41 +0100255 setEOSTimeout(audio, 0);
256
Andreas Huber2bfdd422011-10-11 15:24:07 -0700257 return source->dequeueAccessUnit(accessUnit);
258}
259
260sp<AnotherPacketSource> NuPlayer::RTSPSource::getSource(bool audio) {
Andreas Huber49694682012-08-31 10:27:46 -0700261 if (mTSParser != NULL) {
262 sp<MediaSource> source = mTSParser->getSource(
263 audio ? ATSParser::AUDIO : ATSParser::VIDEO);
264
265 return static_cast<AnotherPacketSource *>(source.get());
266 }
267
Andreas Huber2bfdd422011-10-11 15:24:07 -0700268 return audio ? mAudioTrack : mVideoTrack;
269}
270
Roger Jönssoncfc30832013-01-21 16:26:41 +0100271void NuPlayer::RTSPSource::setEOSTimeout(bool audio, int64_t timeout) {
272 if (audio) {
273 mEOSTimeoutAudio = timeout;
274 } else {
275 mEOSTimeoutVideo = timeout;
276 }
277}
278
Andreas Huber2bfdd422011-10-11 15:24:07 -0700279status_t NuPlayer::RTSPSource::getDuration(int64_t *durationUs) {
Chih-Hung Hsieh62309d52018-12-11 13:54:02 -0800280 *durationUs = -1LL;
Andreas Huber2bfdd422011-10-11 15:24:07 -0700281
282 int64_t audioDurationUs;
283 if (mAudioTrack != NULL
284 && mAudioTrack->getFormat()->findInt64(
285 kKeyDuration, &audioDurationUs)
286 && audioDurationUs > *durationUs) {
287 *durationUs = audioDurationUs;
288 }
289
290 int64_t videoDurationUs;
291 if (mVideoTrack != NULL
292 && mVideoTrack->getFormat()->findInt64(
293 kKeyDuration, &videoDurationUs)
294 && videoDurationUs > *durationUs) {
295 *durationUs = videoDurationUs;
296 }
297
298 return OK;
299}
300
Wei Jiac5de0912016-11-18 10:22:14 -0800301status_t NuPlayer::RTSPSource::seekTo(int64_t seekTimeUs, MediaPlayerSeekMode mode) {
Lajos Molnar1d15ab52015-03-04 16:46:34 -0800302 sp<AMessage> msg = new AMessage(kWhatPerformSeek, this);
Andreas Huberee736e92011-12-08 13:04:50 -0800303 msg->setInt32("generation", ++mSeekGeneration);
304 msg->setInt64("timeUs", seekTimeUs);
Wei Jiac5de0912016-11-18 10:22:14 -0800305 msg->setInt32("mode", mode);
Andreas Huberee736e92011-12-08 13:04:50 -0800306
Robert Shih8d237a52015-07-13 17:59:36 -0700307 sp<AMessage> response;
308 status_t err = msg->postAndAwaitResponse(&response);
309 if (err == OK && response != NULL) {
310 CHECK(response->findInt32("err", &err));
311 }
312
313 return err;
Andreas Huberee736e92011-12-08 13:04:50 -0800314}
315
316void NuPlayer::RTSPSource::performSeek(int64_t seekTimeUs) {
Andreas Huber2bfdd422011-10-11 15:24:07 -0700317 if (mState != CONNECTED) {
Robert Shih8d237a52015-07-13 17:59:36 -0700318 finishSeek(INVALID_OPERATION);
Andreas Huberee736e92011-12-08 13:04:50 -0800319 return;
Andreas Huber2bfdd422011-10-11 15:24:07 -0700320 }
321
322 mState = SEEKING;
323 mHandler->seek(seekTimeUs);
Robert Shihf1d261f2016-07-29 16:44:39 -0700324 mEOSPending = false;
Andreas Huber2bfdd422011-10-11 15:24:07 -0700325}
326
Robert Shih641e0c72016-02-22 11:37:20 -0800327void NuPlayer::RTSPSource::schedulePollBuffering() {
328 sp<AMessage> msg = new AMessage(kWhatPollBuffering, this);
Chih-Hung Hsieh62309d52018-12-11 13:54:02 -0800329 msg->post(1000000LL); // 1 second intervals
Robert Shih641e0c72016-02-22 11:37:20 -0800330}
331
332void NuPlayer::RTSPSource::checkBuffering(
Robert Shihf1d261f2016-07-29 16:44:39 -0700333 bool *prepared, bool *underflow, bool *overflow, bool *startServer, bool *finished) {
Robert Shih641e0c72016-02-22 11:37:20 -0800334 size_t numTracks = mTracks.size();
Robert Shihf1d261f2016-07-29 16:44:39 -0700335 size_t preparedCount, underflowCount, overflowCount, startCount, finishedCount;
336 preparedCount = underflowCount = overflowCount = startCount = finishedCount = 0;
Takahiro Aizawac622c582016-06-20 09:53:47 +0900337
338 size_t count = numTracks;
339 for (size_t i = 0; i < count; ++i) {
Robert Shih641e0c72016-02-22 11:37:20 -0800340 status_t finalResult;
341 TrackInfo *info = &mTracks.editItemAt(i);
342 sp<AnotherPacketSource> src = info->mSource;
Takahiro Aizawac622c582016-06-20 09:53:47 +0900343 if (src == NULL) {
344 --numTracks;
345 continue;
346 }
Robert Shih641e0c72016-02-22 11:37:20 -0800347 int64_t bufferedDurationUs = src->getBufferedDurationUs(&finalResult);
348
Wei Jia9bb38032017-03-23 18:00:38 -0700349 int64_t initialMarkUs;
350 int64_t maxRebufferingMarkUs;
351 {
352 Mutex::Autolock _l(mBufferingSettingsLock);
Chih-Hung Hsieh62309d52018-12-11 13:54:02 -0800353 initialMarkUs = mBufferingSettings.mInitialMarkMs * 1000LL;
Wei Jia9bb38032017-03-23 18:00:38 -0700354 // TODO: maxRebufferingMarkUs could be larger than
355 // mBufferingSettings.mResumePlaybackMarkMs * 1000ll.
Chih-Hung Hsieh62309d52018-12-11 13:54:02 -0800356 maxRebufferingMarkUs = mBufferingSettings.mResumePlaybackMarkMs * 1000LL;
Wei Jia9bb38032017-03-23 18:00:38 -0700357 }
Robert Shih641e0c72016-02-22 11:37:20 -0800358 // isFinished when duration is 0 checks for EOS result only
Wei Jia9bb38032017-03-23 18:00:38 -0700359 if (bufferedDurationUs > initialMarkUs
Wei Jia48fa06d2016-12-20 15:30:49 -0800360 || src->isFinished(/* duration */ 0)) {
Robert Shih641e0c72016-02-22 11:37:20 -0800361 ++preparedCount;
362 }
363
364 if (src->isFinished(/* duration */ 0)) {
365 ++overflowCount;
Robert Shihf1d261f2016-07-29 16:44:39 -0700366 ++finishedCount;
Robert Shih641e0c72016-02-22 11:37:20 -0800367 } else {
Wei Jia9bb38032017-03-23 18:00:38 -0700368 // TODO: redefine kUnderflowMarkMs to a fair value,
369 if (bufferedDurationUs < kUnderflowMarkMs * 1000) {
Robert Shih641e0c72016-02-22 11:37:20 -0800370 ++underflowCount;
371 }
Wei Jia9bb38032017-03-23 18:00:38 -0700372 if (bufferedDurationUs > maxRebufferingMarkUs) {
Robert Shih641e0c72016-02-22 11:37:20 -0800373 ++overflowCount;
374 }
Wei Jia48fa06d2016-12-20 15:30:49 -0800375 int64_t startServerMarkUs =
Chih-Hung Hsieh62309d52018-12-11 13:54:02 -0800376 (kUnderflowMarkMs * 1000LL + maxRebufferingMarkUs) / 2;
Wei Jia48fa06d2016-12-20 15:30:49 -0800377 if (bufferedDurationUs < startServerMarkUs) {
Robert Shih641e0c72016-02-22 11:37:20 -0800378 ++startCount;
379 }
380 }
381 }
382
383 *prepared = (preparedCount == numTracks);
384 *underflow = (underflowCount > 0);
385 *overflow = (overflowCount == numTracks);
386 *startServer = (startCount > 0);
Robert Shihf1d261f2016-07-29 16:44:39 -0700387 *finished = (finishedCount > 0);
Robert Shih641e0c72016-02-22 11:37:20 -0800388}
389
390void NuPlayer::RTSPSource::onPollBuffering() {
Robert Shihf1d261f2016-07-29 16:44:39 -0700391 bool prepared, underflow, overflow, startServer, finished;
392 checkBuffering(&prepared, &underflow, &overflow, &startServer, &finished);
Robert Shih641e0c72016-02-22 11:37:20 -0800393
394 if (prepared && mInPreparationPhase) {
395 mInPreparationPhase = false;
396 notifyPrepared();
397 }
398
399 if (!mInPreparationPhase && underflow) {
400 startBufferingIfNecessary();
401 }
402
Robert Shih91ea5712016-08-01 16:26:58 -0700403 if (haveSufficientDataOnAllTracks()) {
Robert Shih641e0c72016-02-22 11:37:20 -0800404 stopBufferingIfNecessary();
Robert Shih91ea5712016-08-01 16:26:58 -0700405 }
406
407 if (overflow && mHandler != NULL) {
Robert Shih641e0c72016-02-22 11:37:20 -0800408 mHandler->pause();
409 }
410
411 if (startServer && mHandler != NULL) {
412 mHandler->resume();
413 }
414
Robert Shihf1d261f2016-07-29 16:44:39 -0700415 if (finished && mHandler != NULL) {
416 mHandler->cancelAccessUnitTimeoutCheck();
417 }
418
Robert Shih641e0c72016-02-22 11:37:20 -0800419 schedulePollBuffering();
420}
421
Robert Shihf1d261f2016-07-29 16:44:39 -0700422void NuPlayer::RTSPSource::signalSourceEOS(status_t result) {
423 const bool audio = true;
424 const bool video = false;
425
426 sp<AnotherPacketSource> source = getSource(audio);
427 if (source != NULL) {
428 source->signalEOS(result);
429 }
430
431 source = getSource(video);
432 if (source != NULL) {
433 source->signalEOS(result);
434 }
435}
436
437bool NuPlayer::RTSPSource::sourceReachedEOS(bool audio) {
438 sp<AnotherPacketSource> source = getSource(audio);
439 status_t finalResult;
440 return (source != NULL &&
441 !source->hasBufferAvailable(&finalResult) &&
442 finalResult == ERROR_END_OF_STREAM);
443}
444
445bool NuPlayer::RTSPSource::sourceNearEOS(bool audio) {
446 sp<AnotherPacketSource> source = getSource(audio);
447 int64_t mediaDurationUs = 0;
448 getDuration(&mediaDurationUs);
449 return (source != NULL && source->isFinished(mediaDurationUs));
450}
451
452void NuPlayer::RTSPSource::onSignalEOS(const sp<AMessage> &msg) {
453 int32_t generation;
454 CHECK(msg->findInt32("generation", &generation));
455
456 if (generation != mSeekGeneration) {
457 return;
458 }
459
460 if (mEOSPending) {
461 signalSourceEOS(ERROR_END_OF_STREAM);
462 mEOSPending = false;
463 }
464}
465
466void NuPlayer::RTSPSource::postSourceEOSIfNecessary() {
467 const bool audio = true;
468 const bool video = false;
469 // If a source has detected near end, give it some time to retrieve more
470 // data before signaling EOS
471 if (sourceNearEOS(audio) || sourceNearEOS(video)) {
472 if (!mEOSPending) {
473 sp<AMessage> msg = new AMessage(kWhatSignalEOS, this);
474 msg->setInt32("generation", mSeekGeneration);
475 msg->post(kNearEOSTimeoutUs);
476 mEOSPending = true;
477 }
478 }
479}
480
Andreas Huber2bfdd422011-10-11 15:24:07 -0700481void NuPlayer::RTSPSource::onMessageReceived(const sp<AMessage> &msg) {
482 if (msg->what() == kWhatDisconnect) {
Lajos Molnar3f274362015-03-05 14:35:41 -0800483 sp<AReplyToken> replyID;
Andreas Huber2bfdd422011-10-11 15:24:07 -0700484 CHECK(msg->senderAwaitsResponse(&replyID));
485
486 mDisconnectReplyID = replyID;
487 finishDisconnectIfPossible();
488 return;
Andreas Huberee736e92011-12-08 13:04:50 -0800489 } else if (msg->what() == kWhatPerformSeek) {
490 int32_t generation;
491 CHECK(msg->findInt32("generation", &generation));
Robert Shih8d237a52015-07-13 17:59:36 -0700492 CHECK(msg->senderAwaitsResponse(&mSeekReplyID));
Andreas Huberee736e92011-12-08 13:04:50 -0800493
494 if (generation != mSeekGeneration) {
495 // obsolete.
Robert Shih8d237a52015-07-13 17:59:36 -0700496 finishSeek(OK);
Andreas Huberee736e92011-12-08 13:04:50 -0800497 return;
498 }
499
500 int64_t seekTimeUs;
Wei Jiac5de0912016-11-18 10:22:14 -0800501 int32_t mode;
Andreas Huberee736e92011-12-08 13:04:50 -0800502 CHECK(msg->findInt64("timeUs", &seekTimeUs));
Wei Jiac5de0912016-11-18 10:22:14 -0800503 CHECK(msg->findInt32("mode", &mode));
Andreas Huberee736e92011-12-08 13:04:50 -0800504
Wei Jiac5de0912016-11-18 10:22:14 -0800505 // TODO: add "mode" to performSeek.
506 performSeek(seekTimeUs/*, (MediaPlayerSeekMode)mode */);
Andreas Huberee736e92011-12-08 13:04:50 -0800507 return;
Robert Shih641e0c72016-02-22 11:37:20 -0800508 } else if (msg->what() == kWhatPollBuffering) {
509 onPollBuffering();
510 return;
Robert Shihf1d261f2016-07-29 16:44:39 -0700511 } else if (msg->what() == kWhatSignalEOS) {
512 onSignalEOS(msg);
513 return;
Andreas Huber2bfdd422011-10-11 15:24:07 -0700514 }
515
Colin Crossb8c35f92017-04-27 16:15:51 -0700516 CHECK_EQ(msg->what(), kWhatNotify);
Andreas Huber2bfdd422011-10-11 15:24:07 -0700517
518 int32_t what;
519 CHECK(msg->findInt32("what", &what));
520
521 switch (what) {
522 case MyHandler::kWhatConnected:
Andreas Huber7f475c32013-02-05 14:47:13 -0800523 {
Andreas Huber2bfdd422011-10-11 15:24:07 -0700524 onConnected();
Andreas Huber7f475c32013-02-05 14:47:13 -0800525
Chong Zhangced1c2f2014-08-08 15:22:35 -0700526 notifyVideoSizeChanged();
Andreas Huber7f475c32013-02-05 14:47:13 -0800527
528 uint32_t flags = 0;
529
530 if (mHandler->isSeekable()) {
Chong Zhang4b7069d2013-09-11 12:52:43 -0700531 flags = FLAG_CAN_PAUSE
532 | FLAG_CAN_SEEK
533 | FLAG_CAN_SEEK_BACKWARD
534 | FLAG_CAN_SEEK_FORWARD;
Andreas Huber7f475c32013-02-05 14:47:13 -0800535 }
536
537 notifyFlagsChanged(flags);
Robert Shih641e0c72016-02-22 11:37:20 -0800538 schedulePollBuffering();
Andreas Huber2bfdd422011-10-11 15:24:07 -0700539 break;
Andreas Huber7f475c32013-02-05 14:47:13 -0800540 }
Andreas Huber2bfdd422011-10-11 15:24:07 -0700541
542 case MyHandler::kWhatDisconnected:
Andreas Huber7f475c32013-02-05 14:47:13 -0800543 {
Andreas Huber2bfdd422011-10-11 15:24:07 -0700544 onDisconnected(msg);
545 break;
Andreas Huber7f475c32013-02-05 14:47:13 -0800546 }
Andreas Huber2bfdd422011-10-11 15:24:07 -0700547
548 case MyHandler::kWhatSeekDone:
549 {
550 mState = CONNECTED;
Wei Jia4ad74b22016-02-05 17:11:20 -0800551 // Unblock seekTo here in case we attempted to seek in a live stream
552 finishSeek(OK);
Robert Shih8d237a52015-07-13 17:59:36 -0700553 break;
554 }
555
556 case MyHandler::kWhatSeekPaused:
557 {
558 sp<AnotherPacketSource> source = getSource(true /* audio */);
559 if (source != NULL) {
560 source->queueDiscontinuity(ATSParser::DISCONTINUITY_NONE,
561 /* extra */ NULL,
562 /* discard */ true);
563 }
564 source = getSource(false /* video */);
565 if (source != NULL) {
566 source->queueDiscontinuity(ATSParser::DISCONTINUITY_NONE,
567 /* extra */ NULL,
568 /* discard */ true);
569 };
570
571 status_t err = OK;
572 msg->findInt32("err", &err);
Robert Shih8d237a52015-07-13 17:59:36 -0700573
574 if (err == OK) {
575 int64_t timeUs;
576 CHECK(msg->findInt64("time", &timeUs));
577 mHandler->continueSeekAfterPause(timeUs);
Wei Jia4ad74b22016-02-05 17:11:20 -0800578 } else {
579 finishSeek(err);
Robert Shih8d237a52015-07-13 17:59:36 -0700580 }
Andreas Huber2bfdd422011-10-11 15:24:07 -0700581 break;
582 }
583
584 case MyHandler::kWhatAccessUnit:
585 {
586 size_t trackIndex;
587 CHECK(msg->findSize("trackIndex", &trackIndex));
Andreas Huber49694682012-08-31 10:27:46 -0700588
589 if (mTSParser == NULL) {
590 CHECK_LT(trackIndex, mTracks.size());
591 } else {
592 CHECK_EQ(trackIndex, 0u);
593 }
Andreas Huber2bfdd422011-10-11 15:24:07 -0700594
Andreas Huber2d8bedd2012-02-21 14:38:23 -0800595 sp<ABuffer> accessUnit;
596 CHECK(msg->findBuffer("accessUnit", &accessUnit));
Andreas Huber2bfdd422011-10-11 15:24:07 -0700597
598 int32_t damaged;
599 if (accessUnit->meta()->findInt32("damaged", &damaged)
600 && damaged) {
Steve Blockdf64d152012-01-04 20:05:49 +0000601 ALOGI("dropping damaged access unit.");
Andreas Huber2bfdd422011-10-11 15:24:07 -0700602 break;
603 }
604
Andreas Huber49694682012-08-31 10:27:46 -0700605 if (mTSParser != NULL) {
606 size_t offset = 0;
607 status_t err = OK;
608 while (offset + 188 <= accessUnit->size()) {
609 err = mTSParser->feedTSPacket(
610 accessUnit->data() + offset, 188);
611 if (err != OK) {
612 break;
613 }
614
615 offset += 188;
616 }
617
618 if (offset < accessUnit->size()) {
619 err = ERROR_MALFORMED;
620 }
621
622 if (err != OK) {
Robert Shihf1d261f2016-07-29 16:44:39 -0700623 signalSourceEOS(err);
Andreas Huber49694682012-08-31 10:27:46 -0700624 }
Robert Shihf1d261f2016-07-29 16:44:39 -0700625
626 postSourceEOSIfNecessary();
Andreas Huber49694682012-08-31 10:27:46 -0700627 break;
628 }
629
Andreas Huber1906e5c2011-12-08 12:27:47 -0800630 TrackInfo *info = &mTracks.editItemAt(trackIndex);
631
632 sp<AnotherPacketSource> source = info->mSource;
Andreas Huber2bfdd422011-10-11 15:24:07 -0700633 if (source != NULL) {
Andreas Huber2bfdd422011-10-11 15:24:07 -0700634 uint32_t rtpTime;
635 CHECK(accessUnit->meta()->findInt32("rtp-time", (int32_t *)&rtpTime));
636
Andreas Huber1906e5c2011-12-08 12:27:47 -0800637 if (!info->mNPTMappingValid) {
638 // This is a live stream, we didn't receive any normal
Andreas Huberc9d16962012-05-21 11:12:40 -0700639 // playtime mapping. We won't map to npt time.
640 source->queueAccessUnit(accessUnit);
641 break;
Andreas Huber1906e5c2011-12-08 12:27:47 -0800642 }
643
Andreas Huber2bfdd422011-10-11 15:24:07 -0700644 int64_t nptUs =
Andreas Huber1906e5c2011-12-08 12:27:47 -0800645 ((double)rtpTime - (double)info->mRTPTime)
646 / info->mTimeScale
Chih-Hung Hsieh62309d52018-12-11 13:54:02 -0800647 * 1000000LL
Andreas Huber1906e5c2011-12-08 12:27:47 -0800648 + info->mNormalPlaytimeUs;
Andreas Huber2bfdd422011-10-11 15:24:07 -0700649
650 accessUnit->meta()->setInt64("timeUs", nptUs);
Andreas Huber2bfdd422011-10-11 15:24:07 -0700651
652 source->queueAccessUnit(accessUnit);
653 }
Robert Shihf1d261f2016-07-29 16:44:39 -0700654 postSourceEOSIfNecessary();
Andreas Huber2bfdd422011-10-11 15:24:07 -0700655 break;
656 }
657
658 case MyHandler::kWhatEOS:
659 {
Andreas Huber2bfdd422011-10-11 15:24:07 -0700660 int32_t finalResult;
661 CHECK(msg->findInt32("finalResult", &finalResult));
662 CHECK_NE(finalResult, (status_t)OK);
663
Andreas Huber49694682012-08-31 10:27:46 -0700664 if (mTSParser != NULL) {
Robert Shihf1d261f2016-07-29 16:44:39 -0700665 signalSourceEOS(finalResult);
Andreas Huber49694682012-08-31 10:27:46 -0700666 }
667
668 size_t trackIndex;
669 CHECK(msg->findSize("trackIndex", &trackIndex));
670 CHECK_LT(trackIndex, mTracks.size());
671
Andreas Huber2bfdd422011-10-11 15:24:07 -0700672 TrackInfo *info = &mTracks.editItemAt(trackIndex);
673 sp<AnotherPacketSource> source = info->mSource;
674 if (source != NULL) {
675 source->signalEOS(finalResult);
676 }
677
678 break;
679 }
680
681 case MyHandler::kWhatSeekDiscontinuity:
682 {
683 size_t trackIndex;
684 CHECK(msg->findSize("trackIndex", &trackIndex));
685 CHECK_LT(trackIndex, mTracks.size());
686
687 TrackInfo *info = &mTracks.editItemAt(trackIndex);
688 sp<AnotherPacketSource> source = info->mSource;
689 if (source != NULL) {
Chong Zhang632740c2014-06-26 13:03:47 -0700690 source->queueDiscontinuity(
Wei Jiafef808d2014-10-31 17:57:05 -0700691 ATSParser::DISCONTINUITY_TIME,
Chong Zhang632740c2014-06-26 13:03:47 -0700692 NULL,
693 true /* discard */);
Andreas Huber2bfdd422011-10-11 15:24:07 -0700694 }
695
696 break;
697 }
698
699 case MyHandler::kWhatNormalPlayTimeMapping:
700 {
701 size_t trackIndex;
702 CHECK(msg->findSize("trackIndex", &trackIndex));
703 CHECK_LT(trackIndex, mTracks.size());
704
705 uint32_t rtpTime;
706 CHECK(msg->findInt32("rtpTime", (int32_t *)&rtpTime));
707
708 int64_t nptUs;
709 CHECK(msg->findInt64("nptUs", &nptUs));
710
711 TrackInfo *info = &mTracks.editItemAt(trackIndex);
712 info->mRTPTime = rtpTime;
713 info->mNormalPlaytimeUs = nptUs;
Andreas Huber1906e5c2011-12-08 12:27:47 -0800714 info->mNPTMappingValid = true;
Andreas Huber2bfdd422011-10-11 15:24:07 -0700715 break;
716 }
717
Oscar Rydhé81dd60e2012-02-20 10:15:48 +0100718 case SDPLoader::kWhatSDPLoaded:
719 {
720 onSDPLoaded(msg);
721 break;
722 }
723
Andreas Huber2bfdd422011-10-11 15:24:07 -0700724 default:
725 TRESPASS();
726 }
727}
728
729void NuPlayer::RTSPSource::onConnected() {
730 CHECK(mAudioTrack == NULL);
731 CHECK(mVideoTrack == NULL);
732
733 size_t numTracks = mHandler->countTracks();
734 for (size_t i = 0; i < numTracks; ++i) {
735 int32_t timeScale;
736 sp<MetaData> format = mHandler->getTrackFormat(i, &timeScale);
737
738 const char *mime;
739 CHECK(format->findCString(kKeyMIMEType, &mime));
740
Andreas Huber49694682012-08-31 10:27:46 -0700741 if (!strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_MPEG2TS)) {
742 // Very special case for MPEG2 Transport Streams.
743 CHECK_EQ(numTracks, 1u);
744
745 mTSParser = new ATSParser;
746 return;
747 }
748
Andreas Huber2bfdd422011-10-11 15:24:07 -0700749 bool isAudio = !strncasecmp(mime, "audio/", 6);
750 bool isVideo = !strncasecmp(mime, "video/", 6);
751
752 TrackInfo info;
753 info.mTimeScale = timeScale;
754 info.mRTPTime = 0;
Chih-Hung Hsieh62309d52018-12-11 13:54:02 -0800755 info.mNormalPlaytimeUs = 0LL;
Andreas Huber1906e5c2011-12-08 12:27:47 -0800756 info.mNPTMappingValid = false;
Andreas Huber2bfdd422011-10-11 15:24:07 -0700757
758 if ((isAudio && mAudioTrack == NULL)
759 || (isVideo && mVideoTrack == NULL)) {
760 sp<AnotherPacketSource> source = new AnotherPacketSource(format);
761
762 if (isAudio) {
763 mAudioTrack = source;
764 } else {
765 mVideoTrack = source;
766 }
767
768 info.mSource = source;
769 }
770
771 mTracks.push(info);
772 }
773
774 mState = CONNECTED;
775}
776
Oscar Rydhé81dd60e2012-02-20 10:15:48 +0100777void NuPlayer::RTSPSource::onSDPLoaded(const sp<AMessage> &msg) {
778 status_t err;
779 CHECK(msg->findInt32("result", &err));
780
781 mSDPLoader.clear();
782
783 if (mDisconnectReplyID != 0) {
784 err = UNKNOWN_ERROR;
785 }
786
787 if (err == OK) {
788 sp<ASessionDescription> desc;
789 sp<RefBase> obj;
790 CHECK(msg->findObject("description", &obj));
791 desc = static_cast<ASessionDescription *>(obj.get());
792
793 AString rtspUri;
794 if (!desc->findAttribute(0, "a=control", &rtspUri)) {
795 ALOGE("Unable to find url in SDP");
796 err = UNKNOWN_ERROR;
797 } else {
Lajos Molnar1d15ab52015-03-04 16:46:34 -0800798 sp<AMessage> notify = new AMessage(kWhatNotify, this);
Oscar Rydhé81dd60e2012-02-20 10:15:48 +0100799
800 mHandler = new MyHandler(rtspUri.c_str(), notify, mUIDValid, mUID);
801 mLooper->registerHandler(mHandler);
802
803 mHandler->loadSDP(desc);
804 }
805 }
806
807 if (err != OK) {
Andreas Huber7f475c32013-02-05 14:47:13 -0800808 if (mState == CONNECTING) {
809 // We're still in the preparation phase, signal that it
810 // failed.
811 notifyPrepared(err);
812 }
813
Oscar Rydhé81dd60e2012-02-20 10:15:48 +0100814 mState = DISCONNECTED;
Chong Zhang180d1b92014-12-02 18:35:35 -0800815 setError(err);
Oscar Rydhé81dd60e2012-02-20 10:15:48 +0100816
817 if (mDisconnectReplyID != 0) {
818 finishDisconnectIfPossible();
819 }
820 }
821}
822
Andreas Huber2bfdd422011-10-11 15:24:07 -0700823void NuPlayer::RTSPSource::onDisconnected(const sp<AMessage> &msg) {
Fredrik Rosin0ad03bc2013-03-06 13:42:53 +0100824 if (mState == DISCONNECTED) {
825 return;
826 }
827
Andreas Huber2bfdd422011-10-11 15:24:07 -0700828 status_t err;
829 CHECK(msg->findInt32("result", &err));
830 CHECK_NE(err, (status_t)OK);
831
832 mLooper->unregisterHandler(mHandler->id());
833 mHandler.clear();
834
Andreas Huber7f475c32013-02-05 14:47:13 -0800835 if (mState == CONNECTING) {
836 // We're still in the preparation phase, signal that it
837 // failed.
838 notifyPrepared(err);
839 }
840
Andreas Huber2bfdd422011-10-11 15:24:07 -0700841 mState = DISCONNECTED;
Chong Zhang180d1b92014-12-02 18:35:35 -0800842 setError(err);
Andreas Huber2bfdd422011-10-11 15:24:07 -0700843
844 if (mDisconnectReplyID != 0) {
845 finishDisconnectIfPossible();
846 }
847}
848
849void NuPlayer::RTSPSource::finishDisconnectIfPossible() {
850 if (mState != DISCONNECTED) {
Oscar Rydhé81dd60e2012-02-20 10:15:48 +0100851 if (mHandler != NULL) {
852 mHandler->disconnect();
853 } else if (mSDPLoader != NULL) {
854 mSDPLoader->cancel();
855 }
Andreas Huber2bfdd422011-10-11 15:24:07 -0700856 return;
857 }
858
859 (new AMessage)->postReply(mDisconnectReplyID);
860 mDisconnectReplyID = 0;
861}
862
Chong Zhang180d1b92014-12-02 18:35:35 -0800863void NuPlayer::RTSPSource::setError(status_t err) {
864 Mutex::Autolock _l(mBufferingLock);
865 mFinalResult = err;
866}
867
868void NuPlayer::RTSPSource::startBufferingIfNecessary() {
869 Mutex::Autolock _l(mBufferingLock);
870
871 if (!mBuffering) {
872 mBuffering = true;
873
874 sp<AMessage> notify = dupNotify();
Wei Jiac9ff2002016-05-24 16:23:48 -0700875 notify->setInt32("what", kWhatPauseOnBufferingStart);
Chong Zhang180d1b92014-12-02 18:35:35 -0800876 notify->post();
877 }
878}
879
880bool NuPlayer::RTSPSource::stopBufferingIfNecessary() {
881 Mutex::Autolock _l(mBufferingLock);
882
883 if (mBuffering) {
884 if (!haveSufficientDataOnAllTracks()) {
885 return false;
886 }
887
888 mBuffering = false;
889
890 sp<AMessage> notify = dupNotify();
Wei Jiac9ff2002016-05-24 16:23:48 -0700891 notify->setInt32("what", kWhatResumeOnBufferingEnd);
Chong Zhang180d1b92014-12-02 18:35:35 -0800892 notify->post();
893 }
894
895 return true;
896}
897
Robert Shih8d237a52015-07-13 17:59:36 -0700898void NuPlayer::RTSPSource::finishSeek(status_t err) {
Wei Jia4ad74b22016-02-05 17:11:20 -0800899 if (mSeekReplyID == NULL) {
900 return;
901 }
Robert Shih8d237a52015-07-13 17:59:36 -0700902 sp<AMessage> seekReply = new AMessage;
903 seekReply->setInt32("err", err);
904 seekReply->postReply(mSeekReplyID);
905 mSeekReplyID = NULL;
906}
Chong Zhang180d1b92014-12-02 18:35:35 -0800907
Andreas Huber2bfdd422011-10-11 15:24:07 -0700908} // namespace android