NuPlayer.cpp revision f933441648ef6a71dee783d733aac17b9508b452 
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 "NuPlayer"
19#include <utils/Log.h>
20
21#include "NuPlayer.h"
22#include "NuPlayerDecoder.h"
23#include "NuPlayerRenderer.h"
24#include "NuPlayerStreamListener.h"
25
26#include <media/stagefright/foundation/ABuffer.h>
27#include <media/stagefright/foundation/ADebug.h>
28#include <media/stagefright/foundation/AMessage.h>
29#include <media/stagefright/ACodec.h>
30#include <media/stagefright/MediaErrors.h>
31#include <media/stagefright/MetaData.h>
32#include <surfaceflinger/Surface.h>
33
34namespace android {
35
36////////////////////////////////////////////////////////////////////////////////
37
38NuPlayer::NuPlayer()
39    : mEOS(false),
40      mAudioEOS(false),
41      mVideoEOS(false),
42      mFlushingAudio(NONE),
43      mFlushingVideo(NONE) {
44}
45
46NuPlayer::~NuPlayer() {
47}
48
49void NuPlayer::setListener(const wp<MediaPlayerBase> &listener) {
50    mListener = listener;
51}
52
53void NuPlayer::setDataSource(const sp<IStreamSource> &source) {
54    sp<AMessage> msg = new AMessage(kWhatSetDataSource, id());
55
56    source->incStrong(this);
57    msg->setPointer("source", source.get());  // XXX unsafe.
58
59    msg->post();
60}
61
62void NuPlayer::setVideoSurface(const sp<Surface> &surface) {
63    sp<AMessage> msg = new AMessage(kWhatSetVideoSurface, id());
64    msg->setObject("surface", surface);
65    msg->post();
66}
67
68void NuPlayer::setAudioSink(const sp<MediaPlayerBase::AudioSink> &sink) {
69    sp<AMessage> msg = new AMessage(kWhatSetAudioSink, id());
70    msg->setObject("sink", sink);
71    msg->post();
72}
73
74void NuPlayer::start() {
75    (new AMessage(kWhatStart, id()))->post();
76}
77
78void NuPlayer::onMessageReceived(const sp<AMessage> &msg) {
79    switch (msg->what()) {
80        case kWhatSetDataSource:
81        {
82            LOGI("kWhatSetDataSource");
83
84            CHECK(mSource == NULL);
85
86            void *ptr;
87            CHECK(msg->findPointer("source", &ptr));
88
89            mSource = static_cast<IStreamSource *>(ptr);
90            mSource->decStrong(this);
91
92            mStreamListener = new NuPlayerStreamListener(mSource, id());
93            mTSParser = new ATSParser;
94            break;
95        }
96
97        case kWhatSetVideoSurface:
98        {
99            LOGI("kWhatSetVideoSurface");
100
101            sp<RefBase> obj;
102            CHECK(msg->findObject("surface", &obj));
103
104            mSurface = static_cast<Surface *>(obj.get());
105            break;
106        }
107
108        case kWhatSetAudioSink:
109        {
110            LOGI("kWhatSetAudioSink");
111
112            sp<RefBase> obj;
113            CHECK(msg->findObject("sink", &obj));
114
115            mAudioSink = static_cast<MediaPlayerBase::AudioSink *>(obj.get());
116            break;
117        }
118
119        case kWhatStart:
120        {
121            mStreamListener->start();
122
123            mRenderer = new Renderer(
124                    mAudioSink,
125                    new AMessage(kWhatRendererNotify, id()));
126
127            looper()->registerHandler(mRenderer);
128
129            (new AMessage(kWhatScanSources, id()))->post();
130            break;
131        }
132
133        case kWhatScanSources:
134        {
135            instantiateDecoder(false, &mVideoDecoder);
136
137            if (mAudioSink != NULL) {
138                instantiateDecoder(true, &mAudioDecoder);
139            }
140
141            if (mEOS) {
142                break;
143            }
144
145            feedMoreTSData();
146
147            if (mAudioDecoder == NULL || mVideoDecoder == NULL) {
148                msg->post(100000ll);
149            }
150            break;
151        }
152
153        case kWhatVideoNotify:
154        case kWhatAudioNotify:
155        {
156            bool audio = msg->what() == kWhatAudioNotify;
157
158            sp<AMessage> codecRequest;
159            CHECK(msg->findMessage("codec-request", &codecRequest));
160
161            int32_t what;
162            CHECK(codecRequest->findInt32("what", &what));
163
164            if (what == ACodec::kWhatFillThisBuffer) {
165                status_t err = feedDecoderInputData(
166                        audio, codecRequest);
167
168                if (err == -EWOULDBLOCK && !mEOS) {
169                    feedMoreTSData();
170                    msg->post();
171                }
172            } else if (what == ACodec::kWhatEOS) {
173                mRenderer->queueEOS(audio, ERROR_END_OF_STREAM);
174            } else if (what == ACodec::kWhatFlushCompleted) {
175                if (audio) {
176                    CHECK_EQ((int)mFlushingAudio, (int)FLUSHING_DECODER);
177                    mFlushingAudio = FLUSHED;
178                } else {
179                    CHECK_EQ((int)mFlushingVideo, (int)FLUSHING_DECODER);
180                    mFlushingVideo = FLUSHED;
181                }
182
183                LOGI("decoder %s flush completed", audio ? "audio" : "video");
184
185                if (mFlushingAudio == FLUSHED && mFlushingVideo == FLUSHED) {
186                    LOGI("both audio and video are flushed now.");
187
188                    mRenderer->signalTimeDiscontinuity();
189
190                    if (mAudioDecoder != NULL) {
191                        mAudioDecoder->signalResume();
192                    }
193
194                    if (mVideoDecoder != NULL) {
195                        mVideoDecoder->signalResume();
196                    }
197
198                    mFlushingAudio = NONE;
199                    mFlushingVideo = NONE;
200                }
201            } else {
202                CHECK_EQ((int)what, (int)ACodec::kWhatDrainThisBuffer);
203
204                renderBuffer(audio, codecRequest);
205            }
206
207            break;
208        }
209
210        case kWhatRendererNotify:
211        {
212            int32_t what;
213            CHECK(msg->findInt32("what", &what));
214
215            if (what == Renderer::kWhatEOS) {
216                int32_t audio;
217                CHECK(msg->findInt32("audio", &audio));
218
219                if (audio) {
220                    mAudioEOS = true;
221                } else {
222                    mVideoEOS = true;
223                }
224
225                LOGI("reached %s EOS", audio ? "audio" : "video");
226
227                if ((mAudioEOS || mAudioDecoder == NULL)
228                        && (mVideoEOS || mVideoDecoder == NULL)) {
229                    notifyListener(MEDIA_PLAYBACK_COMPLETE, 0, 0);
230                }
231            } else {
232                CHECK_EQ(what, (int32_t)Renderer::kWhatFlushComplete);
233
234                int32_t audio;
235                CHECK(msg->findInt32("audio", &audio));
236
237                LOGI("renderer %s flush completed.", audio ? "audio" : "video");
238            }
239            break;
240        }
241
242        case kWhatMoreDataQueued:
243        {
244            break;
245        }
246
247        default:
248            TRESPASS();
249            break;
250    }
251}
252
253void NuPlayer::feedMoreTSData() {
254    CHECK(!mEOS);
255
256    for (int32_t i = 0; i < 10; ++i) {
257        char buffer[188];
258        ssize_t n = mStreamListener->read(buffer, sizeof(buffer));
259
260        if (n == 0) {
261            LOGI("input data EOS reached.");
262            mTSParser->signalEOS(ERROR_END_OF_STREAM);
263            mEOS = true;
264            break;
265        } else if (n == INFO_DISCONTINUITY) {
266            mTSParser->signalDiscontinuity(ATSParser::DISCONTINUITY_SEEK);
267        } else if (n < 0) {
268            CHECK_EQ(n, -EWOULDBLOCK);
269            break;
270        } else {
271            if (buffer[0] == 0x00) {
272                // XXX legacy
273                mTSParser->signalDiscontinuity(ATSParser::DISCONTINUITY_SEEK);
274            } else {
275                mTSParser->feedTSPacket(buffer, sizeof(buffer));
276            }
277        }
278    }
279}
280
281status_t NuPlayer::dequeueNextAccessUnit(
282        ATSParser::SourceType *type, sp<ABuffer> *accessUnit) {
283    accessUnit->clear();
284
285    status_t audioErr = -EWOULDBLOCK;
286    int64_t audioTimeUs;
287
288    sp<AnotherPacketSource> audioSource =
289        static_cast<AnotherPacketSource *>(
290                mTSParser->getSource(ATSParser::MPEG2ADTS_AUDIO).get());
291
292    if (audioSource != NULL) {
293        audioErr = audioSource->nextBufferTime(&audioTimeUs);
294    }
295
296    status_t videoErr = -EWOULDBLOCK;
297    int64_t videoTimeUs;
298
299    sp<AnotherPacketSource> videoSource =
300        static_cast<AnotherPacketSource *>(
301                mTSParser->getSource(ATSParser::AVC_VIDEO).get());
302
303    if (videoSource != NULL) {
304        videoErr = videoSource->nextBufferTime(&videoTimeUs);
305    }
306
307    if (audioErr == -EWOULDBLOCK || videoErr == -EWOULDBLOCK) {
308        return -EWOULDBLOCK;
309    }
310
311    if (audioErr != OK && videoErr != OK) {
312        return audioErr;
313    }
314
315    if (videoErr != OK || (audioErr == OK && audioTimeUs < videoTimeUs)) {
316        *type = ATSParser::MPEG2ADTS_AUDIO;
317        return audioSource->dequeueAccessUnit(accessUnit);
318    } else {
319        *type = ATSParser::AVC_VIDEO;
320        return videoSource->dequeueAccessUnit(accessUnit);
321    }
322}
323
324status_t NuPlayer::dequeueAccessUnit(
325        ATSParser::SourceType type, sp<ABuffer> *accessUnit) {
326    sp<AnotherPacketSource> source =
327        static_cast<AnotherPacketSource *>(mTSParser->getSource(type).get());
328
329    if (source == NULL) {
330        return -EWOULDBLOCK;
331    }
332
333    status_t finalResult;
334    if (!source->hasBufferAvailable(&finalResult)) {
335        return finalResult == OK ? -EWOULDBLOCK : finalResult;
336    }
337
338    return source->dequeueAccessUnit(accessUnit);
339}
340
341status_t NuPlayer::instantiateDecoder(
342        bool audio, sp<Decoder> *decoder) {
343    if (*decoder != NULL) {
344        return OK;
345    }
346
347    ATSParser::SourceType type =
348        audio ? ATSParser::MPEG2ADTS_AUDIO : ATSParser::AVC_VIDEO;
349
350    sp<AnotherPacketSource> source =
351        static_cast<AnotherPacketSource *>(
352                mTSParser->getSource(type).get());
353
354    if (source == NULL) {
355        return -EWOULDBLOCK;
356    }
357
358    sp<AMessage> notify =
359        new AMessage(audio ? kWhatAudioNotify : kWhatVideoNotify,
360                     id());
361
362    *decoder = new Decoder(notify, audio ? NULL : mSurface);
363    looper()->registerHandler(*decoder);
364
365    const sp<MetaData> &meta = source->getFormat();
366    (*decoder)->configure(meta);
367
368    if (audio) {
369        int32_t sampleRate;
370        int32_t channelCount;
371        CHECK(meta->findInt32(kKeySampleRate, &sampleRate));
372        CHECK(meta->findInt32(kKeyChannelCount, &channelCount));
373
374        channelCount = 2;  // XXX
375
376        CHECK_EQ(mAudioSink->open(sampleRate, channelCount), (status_t)OK);
377        mAudioSink->start();
378    }
379
380    return OK;
381}
382
383status_t NuPlayer::feedDecoderInputData(bool audio, const sp<AMessage> &msg) {
384    sp<AMessage> reply;
385    CHECK(msg->findMessage("reply", &reply));
386
387    if ((audio && mFlushingAudio == FLUSHING_DECODER)
388            || (!audio && mFlushingVideo == FLUSHING_DECODER)) {
389        reply->setInt32("err", INFO_DISCONTINUITY);
390        reply->post();
391        return OK;
392    }
393
394    sp<ABuffer> accessUnit;
395    status_t err = dequeueAccessUnit(
396            audio ? ATSParser::MPEG2ADTS_AUDIO : ATSParser::AVC_VIDEO,
397            &accessUnit);
398
399    if (err == -EWOULDBLOCK) {
400        return err;
401    } else if (err != OK) {
402        if (err == INFO_DISCONTINUITY) {
403            LOGI("%s discontinuity", audio ? "audio" : "video");
404            (audio ? mAudioDecoder : mVideoDecoder)->signalFlush();
405            mRenderer->flush(audio);
406
407            if (audio) {
408                CHECK(mFlushingAudio == NONE
409                        || mFlushingAudio == AWAITING_DISCONTINUITY);
410                mFlushingAudio = FLUSHING_DECODER;
411                if (mFlushingVideo == NONE) {
412                    mFlushingVideo = (mVideoDecoder != NULL)
413                        ? AWAITING_DISCONTINUITY
414                        : FLUSHED;
415                }
416            } else {
417                CHECK(mFlushingVideo == NONE
418                        || mFlushingVideo == AWAITING_DISCONTINUITY);
419                mFlushingVideo = FLUSHING_DECODER;
420                if (mFlushingAudio == NONE) {
421                    mFlushingAudio = (mAudioDecoder != NULL)
422                        ? AWAITING_DISCONTINUITY
423                        : FLUSHED;
424                }
425            }
426        }
427
428        reply->setInt32("err", err);
429        reply->post();
430        return OK;
431    }
432
433    LOGV("returned a valid buffer of %s data", audio ? "audio" : "video");
434
435#if 0
436    int64_t mediaTimeUs;
437    CHECK(accessUnit->meta()->findInt64("timeUs", &mediaTimeUs));
438    LOGI("feeding %s input buffer at media time %.2f secs",
439         audio ? "audio" : "video",
440         mediaTimeUs / 1E6);
441#endif
442
443    reply->setObject("buffer", accessUnit);
444    reply->post();
445
446    return OK;
447}
448
449void NuPlayer::renderBuffer(bool audio, const sp<AMessage> &msg) {
450    LOGV("renderBuffer %s", audio ? "audio" : "video");
451
452    sp<AMessage> reply;
453    CHECK(msg->findMessage("reply", &reply));
454
455    sp<RefBase> obj;
456    CHECK(msg->findObject("buffer", &obj));
457
458    sp<ABuffer> buffer = static_cast<ABuffer *>(obj.get());
459
460    mRenderer->queueBuffer(audio, buffer, reply);
461}
462
463void NuPlayer::notifyListener(int msg, int ext1, int ext2) {
464    if (mListener == NULL) {
465        return;
466    }
467
468    sp<MediaPlayerBase> listener = mListener.promote();
469
470    if (listener == NULL) {
471        return;
472    }
473
474    listener->sendEvent(msg, ext1, ext2);
475}
476
477}  // namespace android
478