HTTPLiveSource.cpp revision 5ec347fcaf7fefe8fd9ccbaa365ffb070921a970 
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 "HTTPLiveSource"
19#include <utils/Log.h>
20
21#include "HTTPLiveSource.h"
22
23#include "AnotherPacketSource.h"
24#include "LiveDataSource.h"
25
26#include <media/IMediaHTTPService.h>
27#include <media/stagefright/foundation/ABuffer.h>
28#include <media/stagefright/foundation/ADebug.h>
29#include <media/stagefright/foundation/AMessage.h>
30#include <media/stagefright/MediaErrors.h>
31#include <media/stagefright/MetaData.h>
32#include <media/stagefright/MediaDefs.h>
33#include <media/stagefright/Utils.h>
34
35namespace android {
36
37NuPlayer::HTTPLiveSource::HTTPLiveSource(
38        const sp<AMessage> &notify,
39        const sp<IMediaHTTPService> &httpService,
40        const char *url,
41        const KeyedVector<String8, String8> *headers)
42    : Source(notify),
43      mHTTPService(httpService),
44      mURL(url),
45      mFlags(0),
46      mFinalResult(OK),
47      mOffset(0),
48      mFetchSubtitleDataGeneration(0),
49      mFetchMetaDataGeneration(0),
50      mHasMetadata(false),
51      mMetadataSelected(false) {
52    if (headers) {
53        mExtraHeaders = *headers;
54
55        ssize_t index =
56            mExtraHeaders.indexOfKey(String8("x-hide-urls-from-log"));
57
58        if (index >= 0) {
59            mFlags |= kFlagIncognito;
60
61            mExtraHeaders.removeItemsAt(index);
62        }
63    }
64}
65
66NuPlayer::HTTPLiveSource::~HTTPLiveSource() {
67    if (mLiveSession != NULL) {
68        mLiveSession->disconnect();
69
70        mLiveLooper->unregisterHandler(mLiveSession->id());
71        mLiveLooper->unregisterHandler(id());
72        mLiveLooper->stop();
73
74        mLiveSession.clear();
75        mLiveLooper.clear();
76    }
77}
78
79void NuPlayer::HTTPLiveSource::prepareAsync() {
80    if (mLiveLooper == NULL) {
81        mLiveLooper = new ALooper;
82        mLiveLooper->setName("http live");
83        mLiveLooper->start();
84
85        mLiveLooper->registerHandler(this);
86    }
87
88    sp<AMessage> notify = new AMessage(kWhatSessionNotify, this);
89
90    mLiveSession = new LiveSession(
91            notify,
92            (mFlags & kFlagIncognito) ? LiveSession::kFlagIncognito : 0,
93            mHTTPService);
94
95    mLiveLooper->registerHandler(mLiveSession);
96
97    mLiveSession->connectAsync(
98            mURL.c_str(), mExtraHeaders.isEmpty() ? NULL : &mExtraHeaders);
99}
100
101void NuPlayer::HTTPLiveSource::start() {
102}
103
104sp<MetaData> NuPlayer::HTTPLiveSource::getFormatMeta(bool audio) {
105    sp<MetaData> meta;
106    if (mLiveSession != NULL) {
107        mLiveSession->getStreamFormatMeta(
108                audio ? LiveSession::STREAMTYPE_AUDIO
109                      : LiveSession::STREAMTYPE_VIDEO,
110                &meta);
111    }
112
113    return meta;
114}
115
116sp<AMessage> NuPlayer::HTTPLiveSource::getFormat(bool audio) {
117    sp<MetaData> meta;
118    status_t err = -EWOULDBLOCK;
119    if (mLiveSession != NULL) {
120        err = mLiveSession->getStreamFormatMeta(
121                audio ? LiveSession::STREAMTYPE_AUDIO
122                      : LiveSession::STREAMTYPE_VIDEO,
123                &meta);
124    }
125
126    sp<AMessage> format;
127    if (err == -EWOULDBLOCK) {
128        format = new AMessage();
129        format->setInt32("err", err);
130        return format;
131    }
132
133    if (err != OK || convertMetaDataToMessage(meta, &format) != OK) {
134        return NULL;
135    }
136    return format;
137}
138
139status_t NuPlayer::HTTPLiveSource::feedMoreTSData() {
140    return OK;
141}
142
143status_t NuPlayer::HTTPLiveSource::dequeueAccessUnit(
144        bool audio, sp<ABuffer> *accessUnit) {
145    return mLiveSession->dequeueAccessUnit(
146            audio ? LiveSession::STREAMTYPE_AUDIO
147                  : LiveSession::STREAMTYPE_VIDEO,
148            accessUnit);
149}
150
151status_t NuPlayer::HTTPLiveSource::getDuration(int64_t *durationUs) {
152    return mLiveSession->getDuration(durationUs);
153}
154
155size_t NuPlayer::HTTPLiveSource::getTrackCount() const {
156    return mLiveSession->getTrackCount();
157}
158
159sp<AMessage> NuPlayer::HTTPLiveSource::getTrackInfo(size_t trackIndex) const {
160    return mLiveSession->getTrackInfo(trackIndex);
161}
162
163ssize_t NuPlayer::HTTPLiveSource::getSelectedTrack(media_track_type type) const {
164    if (mLiveSession == NULL) {
165        return -1;
166    } else if (type == MEDIA_TRACK_TYPE_METADATA) {
167        // MEDIA_TRACK_TYPE_METADATA is always last track
168        // mMetadataSelected can only be true when mHasMetadata is true
169        return mMetadataSelected ? (mLiveSession->getTrackCount() - 1) : -1;
170    } else {
171        return mLiveSession->getSelectedTrack(type);
172    }
173}
174
175status_t NuPlayer::HTTPLiveSource::selectTrack(size_t trackIndex, bool select, int64_t /*timeUs*/) {
176    if (mLiveSession == NULL) {
177        return INVALID_OPERATION;
178    }
179
180    status_t err = INVALID_OPERATION;
181    bool postFetchMsg = false, isSub = false;
182    if (!mHasMetadata || trackIndex != mLiveSession->getTrackCount() - 1) {
183        err = mLiveSession->selectTrack(trackIndex, select);
184        postFetchMsg = select;
185        isSub = true;
186    } else {
187        // metadata track; i.e. (mHasMetadata && trackIndex == mLiveSession->getTrackCount() - 1)
188        if (mMetadataSelected && !select) {
189            err = OK;
190        } else if (!mMetadataSelected && select) {
191            postFetchMsg = true;
192            err = OK;
193        } else {
194            err = BAD_VALUE; // behave as LiveSession::selectTrack
195        }
196
197        mMetadataSelected = select;
198    }
199
200    if (err == OK) {
201        int32_t &generation = isSub ? mFetchSubtitleDataGeneration : mFetchMetaDataGeneration;
202        generation++;
203        if (postFetchMsg) {
204            int32_t what = isSub ? kWhatFetchSubtitleData : kWhatFetchMetaData;
205            sp<AMessage> msg = new AMessage(what, this);
206            msg->setInt32("generation", generation);
207            msg->post();
208        }
209    }
210
211    // LiveSession::selectTrack returns BAD_VALUE when selecting the currently
212    // selected track, or unselecting a non-selected track. In this case it's an
213    // no-op so we return OK.
214    return (err == OK || err == BAD_VALUE) ? (status_t)OK : err;
215}
216
217status_t NuPlayer::HTTPLiveSource::seekTo(int64_t seekTimeUs, bool precise) {
218    return mLiveSession->seekTo(seekTimeUs, precise);
219}
220
221void NuPlayer::HTTPLiveSource::pollForRawData(
222        const sp<AMessage> &msg, int32_t currentGeneration,
223        LiveSession::StreamType fetchType, int32_t pushWhat) {
224
225    int32_t generation;
226    CHECK(msg->findInt32("generation", &generation));
227
228    if (generation != currentGeneration) {
229        return;
230    }
231
232    sp<ABuffer> buffer;
233    while (mLiveSession->dequeueAccessUnit(fetchType, &buffer) == OK) {
234
235        sp<AMessage> notify = dupNotify();
236        notify->setInt32("what", pushWhat);
237        notify->setBuffer("buffer", buffer);
238
239        int64_t timeUs, baseUs, delayUs;
240        CHECK(buffer->meta()->findInt64("baseUs", &baseUs));
241        CHECK(buffer->meta()->findInt64("timeUs", &timeUs));
242        delayUs = baseUs + timeUs - ALooper::GetNowUs();
243
244        if (fetchType == LiveSession::STREAMTYPE_SUBTITLES) {
245            notify->post();
246            msg->post(delayUs > 0ll ? delayUs : 0ll);
247            return;
248        } else if (fetchType == LiveSession::STREAMTYPE_METADATA) {
249            if (delayUs < -1000000ll) { // 1 second
250                continue;
251            }
252            notify->post();
253            // push all currently available metadata buffers in each invocation of pollForRawData
254            // continue;
255        } else {
256            TRESPASS();
257        }
258    }
259
260    // try again in 1 second
261    msg->post(1000000ll);
262}
263
264void NuPlayer::HTTPLiveSource::onMessageReceived(const sp<AMessage> &msg) {
265    switch (msg->what()) {
266        case kWhatSessionNotify:
267        {
268            onSessionNotify(msg);
269            break;
270        }
271
272        case kWhatFetchSubtitleData:
273        {
274            pollForRawData(
275                    msg, mFetchSubtitleDataGeneration,
276                    /* fetch */ LiveSession::STREAMTYPE_SUBTITLES,
277                    /* push */ kWhatSubtitleData);
278
279            break;
280        }
281
282        case kWhatFetchMetaData:
283        {
284            if (!mMetadataSelected) {
285                break;
286            }
287
288            pollForRawData(
289                    msg, mFetchMetaDataGeneration,
290                    /* fetch */ LiveSession::STREAMTYPE_METADATA,
291                    /* push */ kWhatTimedMetaData);
292
293            break;
294        }
295
296        default:
297            Source::onMessageReceived(msg);
298            break;
299    }
300}
301
302void NuPlayer::HTTPLiveSource::onSessionNotify(const sp<AMessage> &msg) {
303    int32_t what;
304    CHECK(msg->findInt32("what", &what));
305
306    switch (what) {
307        case LiveSession::kWhatPrepared:
308        {
309            // notify the current size here if we have it, otherwise report an initial size of (0,0)
310            sp<AMessage> format = getFormat(false /* audio */);
311            int32_t width;
312            int32_t height;
313            if (format != NULL &&
314                    format->findInt32("width", &width) && format->findInt32("height", &height)) {
315                notifyVideoSizeChanged(format);
316            } else {
317                notifyVideoSizeChanged();
318            }
319
320            uint32_t flags = 0;
321            if (mLiveSession->isSeekable()) {
322                flags |= FLAG_CAN_PAUSE;
323                flags |= FLAG_CAN_SEEK;
324                flags |= FLAG_CAN_SEEK_BACKWARD;
325                flags |= FLAG_CAN_SEEK_FORWARD;
326            }
327
328            if (mLiveSession->hasDynamicDuration()) {
329                flags |= FLAG_DYNAMIC_DURATION;
330            }
331
332            notifyFlagsChanged(flags);
333
334            notifyPrepared();
335            break;
336        }
337
338        case LiveSession::kWhatPreparationFailed:
339        {
340            status_t err;
341            CHECK(msg->findInt32("err", &err));
342
343            notifyPrepared(err);
344            break;
345        }
346
347        case LiveSession::kWhatStreamsChanged:
348        {
349            uint32_t changedMask;
350            CHECK(msg->findInt32(
351                        "changedMask", (int32_t *)&changedMask));
352
353            bool audio = changedMask & LiveSession::STREAMTYPE_AUDIO;
354            bool video = changedMask & LiveSession::STREAMTYPE_VIDEO;
355
356            sp<AMessage> reply;
357            CHECK(msg->findMessage("reply", &reply));
358
359            sp<AMessage> notify = dupNotify();
360            notify->setInt32("what", kWhatQueueDecoderShutdown);
361            notify->setInt32("audio", audio);
362            notify->setInt32("video", video);
363            notify->setMessage("reply", reply);
364            notify->post();
365            break;
366        }
367
368        case LiveSession::kWhatBufferingStart:
369        {
370            sp<AMessage> notify = dupNotify();
371            notify->setInt32("what", kWhatPauseOnBufferingStart);
372            notify->post();
373            break;
374        }
375
376        case LiveSession::kWhatBufferingEnd:
377        {
378            sp<AMessage> notify = dupNotify();
379            notify->setInt32("what", kWhatResumeOnBufferingEnd);
380            notify->post();
381            break;
382        }
383
384
385        case LiveSession::kWhatBufferingUpdate:
386        {
387            sp<AMessage> notify = dupNotify();
388            int32_t percentage;
389            CHECK(msg->findInt32("percentage", &percentage));
390            notify->setInt32("what", kWhatBufferingUpdate);
391            notify->setInt32("percentage", percentage);
392            notify->post();
393            break;
394        }
395
396        case LiveSession::kWhatMetadataDetected:
397        {
398            if (!mHasMetadata) {
399                mHasMetadata = true;
400
401                sp<AMessage> notify = dupNotify();
402                // notification without buffer triggers MEDIA_INFO_METADATA_UPDATE
403                notify->setInt32("what", kWhatTimedMetaData);
404                notify->post();
405            }
406            break;
407        }
408
409        case LiveSession::kWhatError:
410        {
411            break;
412        }
413
414        default:
415            TRESPASS();
416    }
417}
418
419}  // namespace android
420
421