AwesomePlayer.cpp revision ff53123821a3ec2e71fdb1a971ea2cbae3119826 
1/*
2 * Copyright (C) 2009 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 "AwesomePlayer"
19#include <utils/Log.h>
20
21#include <dlfcn.h>
22
23#include "include/ARTSPController.h"
24#include "include/AwesomePlayer.h"
25#include "include/LiveSource.h"
26#include "include/SoftwareRenderer.h"
27#include "include/NuCachedSource2.h"
28#include "include/ThrottledSource.h"
29
30#include "ARTPSession.h"
31#include "APacketSource.h"
32#include "ASessionDescription.h"
33#include "UDPPusher.h"
34
35#include <binder/IPCThreadState.h>
36#include <media/stagefright/AudioPlayer.h>
37#include <media/stagefright/DataSource.h>
38#include <media/stagefright/FileSource.h>
39#include <media/stagefright/MediaBuffer.h>
40#include <media/stagefright/MediaDefs.h>
41#include <media/stagefright/MediaExtractor.h>
42#include <media/stagefright/MediaDebug.h>
43#include <media/stagefright/MediaSource.h>
44#include <media/stagefright/MetaData.h>
45#include <media/stagefright/OMXCodec.h>
46
47#include <surfaceflinger/ISurface.h>
48
49#include <media/stagefright/foundation/ALooper.h>
50
51namespace android {
52
53struct AwesomeEvent : public TimedEventQueue::Event {
54    AwesomeEvent(
55            AwesomePlayer *player,
56            void (AwesomePlayer::*method)())
57        : mPlayer(player),
58          mMethod(method) {
59    }
60
61protected:
62    virtual ~AwesomeEvent() {}
63
64    virtual void fire(TimedEventQueue *queue, int64_t /* now_us */) {
65        (mPlayer->*mMethod)();
66    }
67
68private:
69    AwesomePlayer *mPlayer;
70    void (AwesomePlayer::*mMethod)();
71
72    AwesomeEvent(const AwesomeEvent &);
73    AwesomeEvent &operator=(const AwesomeEvent &);
74};
75
76struct AwesomeRemoteRenderer : public AwesomeRenderer {
77    AwesomeRemoteRenderer(const sp<IOMXRenderer> &target)
78        : mTarget(target) {
79    }
80
81    virtual void render(MediaBuffer *buffer) {
82        void *id;
83        if (buffer->meta_data()->findPointer(kKeyBufferID, &id)) {
84            mTarget->render((IOMX::buffer_id)id);
85        }
86    }
87
88private:
89    sp<IOMXRenderer> mTarget;
90
91    AwesomeRemoteRenderer(const AwesomeRemoteRenderer &);
92    AwesomeRemoteRenderer &operator=(const AwesomeRemoteRenderer &);
93};
94
95struct AwesomeLocalRenderer : public AwesomeRenderer {
96    AwesomeLocalRenderer(
97            bool previewOnly,
98            const char *componentName,
99            OMX_COLOR_FORMATTYPE colorFormat,
100            const sp<ISurface> &surface,
101            size_t displayWidth, size_t displayHeight,
102            size_t decodedWidth, size_t decodedHeight)
103        : mTarget(NULL),
104          mLibHandle(NULL) {
105            init(previewOnly, componentName,
106                 colorFormat, surface, displayWidth,
107                 displayHeight, decodedWidth, decodedHeight);
108    }
109
110    virtual void render(MediaBuffer *buffer) {
111        render((const uint8_t *)buffer->data() + buffer->range_offset(),
112               buffer->range_length());
113    }
114
115    void render(const void *data, size_t size) {
116        mTarget->render(data, size, NULL);
117    }
118
119protected:
120    virtual ~AwesomeLocalRenderer() {
121        delete mTarget;
122        mTarget = NULL;
123
124        if (mLibHandle) {
125            dlclose(mLibHandle);
126            mLibHandle = NULL;
127        }
128    }
129
130private:
131    VideoRenderer *mTarget;
132    void *mLibHandle;
133
134    void init(
135            bool previewOnly,
136            const char *componentName,
137            OMX_COLOR_FORMATTYPE colorFormat,
138            const sp<ISurface> &surface,
139            size_t displayWidth, size_t displayHeight,
140            size_t decodedWidth, size_t decodedHeight);
141
142    AwesomeLocalRenderer(const AwesomeLocalRenderer &);
143    AwesomeLocalRenderer &operator=(const AwesomeLocalRenderer &);;
144};
145
146void AwesomeLocalRenderer::init(
147        bool previewOnly,
148        const char *componentName,
149        OMX_COLOR_FORMATTYPE colorFormat,
150        const sp<ISurface> &surface,
151        size_t displayWidth, size_t displayHeight,
152        size_t decodedWidth, size_t decodedHeight) {
153    if (!previewOnly) {
154        // We will stick to the vanilla software-color-converting renderer
155        // for "previewOnly" mode, to avoid unneccessarily switching overlays
156        // more often than necessary.
157
158        mLibHandle = dlopen("libstagefrighthw.so", RTLD_NOW);
159
160        if (mLibHandle) {
161            typedef VideoRenderer *(*CreateRendererFunc)(
162                    const sp<ISurface> &surface,
163                    const char *componentName,
164                    OMX_COLOR_FORMATTYPE colorFormat,
165                    size_t displayWidth, size_t displayHeight,
166                    size_t decodedWidth, size_t decodedHeight);
167
168            CreateRendererFunc func =
169                (CreateRendererFunc)dlsym(
170                        mLibHandle,
171                        "_Z14createRendererRKN7android2spINS_8ISurfaceEEEPKc20"
172                        "OMX_COLOR_FORMATTYPEjjjj");
173
174            if (func) {
175                mTarget =
176                    (*func)(surface, componentName, colorFormat,
177                        displayWidth, displayHeight,
178                        decodedWidth, decodedHeight);
179            }
180        }
181    }
182
183    if (mTarget == NULL) {
184        mTarget = new SoftwareRenderer(
185                colorFormat, surface, displayWidth, displayHeight,
186                decodedWidth, decodedHeight);
187    }
188}
189
190AwesomePlayer::AwesomePlayer()
191    : mQueueStarted(false),
192      mTimeSource(NULL),
193      mVideoRendererIsPreview(false),
194      mAudioPlayer(NULL),
195      mFlags(0),
196      mExtractorFlags(0),
197      mLastVideoBuffer(NULL),
198      mVideoBuffer(NULL),
199      mSuspensionState(NULL) {
200    CHECK_EQ(mClient.connect(), OK);
201
202    DataSource::RegisterDefaultSniffers();
203
204    mVideoEvent = new AwesomeEvent(this, &AwesomePlayer::onVideoEvent);
205    mVideoEventPending = false;
206    mStreamDoneEvent = new AwesomeEvent(this, &AwesomePlayer::onStreamDone);
207    mStreamDoneEventPending = false;
208    mBufferingEvent = new AwesomeEvent(this, &AwesomePlayer::onBufferingUpdate);
209    mBufferingEventPending = false;
210
211    mCheckAudioStatusEvent = new AwesomeEvent(
212            this, &AwesomePlayer::onCheckAudioStatus);
213
214    mAudioStatusEventPending = false;
215
216    reset();
217}
218
219AwesomePlayer::~AwesomePlayer() {
220    if (mQueueStarted) {
221        mQueue.stop();
222    }
223
224    reset();
225
226    mClient.disconnect();
227}
228
229void AwesomePlayer::cancelPlayerEvents(bool keepBufferingGoing) {
230    mQueue.cancelEvent(mVideoEvent->eventID());
231    mVideoEventPending = false;
232    mQueue.cancelEvent(mStreamDoneEvent->eventID());
233    mStreamDoneEventPending = false;
234    mQueue.cancelEvent(mCheckAudioStatusEvent->eventID());
235    mAudioStatusEventPending = false;
236
237    if (!keepBufferingGoing) {
238        mQueue.cancelEvent(mBufferingEvent->eventID());
239        mBufferingEventPending = false;
240    }
241}
242
243void AwesomePlayer::setListener(const wp<MediaPlayerBase> &listener) {
244    Mutex::Autolock autoLock(mLock);
245    mListener = listener;
246}
247
248status_t AwesomePlayer::setDataSource(
249        const char *uri, const KeyedVector<String8, String8> *headers) {
250    Mutex::Autolock autoLock(mLock);
251    return setDataSource_l(uri, headers);
252}
253
254status_t AwesomePlayer::setDataSource_l(
255        const char *uri, const KeyedVector<String8, String8> *headers) {
256    reset_l();
257
258    mUri = uri;
259
260    if (headers) {
261        mUriHeaders = *headers;
262    }
263
264    // The actual work will be done during preparation in the call to
265    // ::finishSetDataSource_l to avoid blocking the calling thread in
266    // setDataSource for any significant time.
267
268    return OK;
269}
270
271status_t AwesomePlayer::setDataSource(
272        int fd, int64_t offset, int64_t length) {
273#if 0
274    // return setDataSource("httplive://iphoned5.akamai.com.edgesuite.net/mhbarron/nasatv/nasatv_96.m3u8");
275    // return setDataSource("httplive://iphoned5.akamai.com.edgesuite.net/mhbarron/nasatv/nasatv_1500.m3u8");
276    return setDataSource("httplive://iphone.video.hsn.com/iPhone_high.m3u8");
277    // return setDataSource("httplive://iphoned5.akamai.com.edgesuite.net/mhbarron/iphonewebcast/webcast090209_all/webcast090209_all.m3u8");
278    // return setDataSource("httplive://qthttp.akamai.com.edgesuite.net/iphone_demo/Video_Content/usat/tt_062209_iphone/hi/prog_index.m3u8");
279    // return setDataSource("httplive://qthttp.akamai.com.edgesuite.net/iphone_demo/Video_Content/usat/tt_googmaps/hi/prog_index.m3u8");
280    // return setDataSource("httplive://qthttp.akamai.com.edgesuite.net/iphone_demo/Video_Content/mtv/ni_spo_25a_rt74137_clip_syn/hi/prog_index.m3u8");
281#endif
282
283    Mutex::Autolock autoLock(mLock);
284
285    reset_l();
286
287    sp<DataSource> dataSource = new FileSource(fd, offset, length);
288
289    status_t err = dataSource->initCheck();
290
291    if (err != OK) {
292        return err;
293    }
294
295    mFileSource = dataSource;
296
297    return setDataSource_l(dataSource);
298}
299
300status_t AwesomePlayer::setDataSource_l(
301        const sp<DataSource> &dataSource) {
302    sp<MediaExtractor> extractor = MediaExtractor::Create(dataSource);
303
304    if (extractor == NULL) {
305        return UNKNOWN_ERROR;
306    }
307
308    return setDataSource_l(extractor);
309}
310
311status_t AwesomePlayer::setDataSource_l(const sp<MediaExtractor> &extractor) {
312    bool haveAudio = false;
313    bool haveVideo = false;
314    for (size_t i = 0; i < extractor->countTracks(); ++i) {
315        sp<MetaData> meta = extractor->getTrackMetaData(i);
316
317        const char *mime;
318        CHECK(meta->findCString(kKeyMIMEType, &mime));
319
320        if (!haveVideo && !strncasecmp(mime, "video/", 6)) {
321            setVideoSource(extractor->getTrack(i));
322            haveVideo = true;
323        } else if (!haveAudio && !strncasecmp(mime, "audio/", 6)) {
324            setAudioSource(extractor->getTrack(i));
325            haveAudio = true;
326        }
327
328        if (haveAudio && haveVideo) {
329            break;
330        }
331    }
332
333    if (!haveAudio && !haveVideo) {
334        return UNKNOWN_ERROR;
335    }
336
337    mExtractorFlags = extractor->flags();
338
339    return OK;
340}
341
342void AwesomePlayer::reset() {
343    Mutex::Autolock autoLock(mLock);
344    reset_l();
345}
346
347void AwesomePlayer::reset_l() {
348    if (mFlags & PREPARING) {
349        mFlags |= PREPARE_CANCELLED;
350        if (mConnectingDataSource != NULL) {
351            LOGI("interrupting the connection process");
352            mConnectingDataSource->disconnect();
353        }
354    }
355
356    while (mFlags & PREPARING) {
357        mPreparedCondition.wait(mLock);
358    }
359
360    cancelPlayerEvents();
361
362    mCachedSource.clear();
363    mAudioTrack.clear();
364    mVideoTrack.clear();
365
366    // Shutdown audio first, so that the respone to the reset request
367    // appears to happen instantaneously as far as the user is concerned
368    // If we did this later, audio would continue playing while we
369    // shutdown the video-related resources and the player appear to
370    // not be as responsive to a reset request.
371    if (mAudioPlayer == NULL && mAudioSource != NULL) {
372        // If we had an audio player, it would have effectively
373        // taken possession of the audio source and stopped it when
374        // _it_ is stopped. Otherwise this is still our responsibility.
375        mAudioSource->stop();
376    }
377    mAudioSource.clear();
378
379    mTimeSource = NULL;
380
381    delete mAudioPlayer;
382    mAudioPlayer = NULL;
383
384    mVideoRenderer.clear();
385
386    if (mLastVideoBuffer) {
387        mLastVideoBuffer->release();
388        mLastVideoBuffer = NULL;
389    }
390
391    if (mVideoBuffer) {
392        mVideoBuffer->release();
393        mVideoBuffer = NULL;
394    }
395
396    mRTSPController.clear();
397    mRTPPusher.clear();
398    mRTCPPusher.clear();
399    mRTPSession.clear();
400
401    if (mVideoSource != NULL) {
402        mVideoSource->stop();
403
404        // The following hack is necessary to ensure that the OMX
405        // component is completely released by the time we may try
406        // to instantiate it again.
407        wp<MediaSource> tmp = mVideoSource;
408        mVideoSource.clear();
409        while (tmp.promote() != NULL) {
410            usleep(1000);
411        }
412        IPCThreadState::self()->flushCommands();
413    }
414
415    mDurationUs = -1;
416    mFlags = 0;
417    mExtractorFlags = 0;
418    mVideoWidth = mVideoHeight = -1;
419    mTimeSourceDeltaUs = 0;
420    mVideoTimeUs = 0;
421
422    mSeeking = false;
423    mSeekNotificationSent = false;
424    mSeekTimeUs = 0;
425
426    mUri.setTo("");
427    mUriHeaders.clear();
428
429    mFileSource.clear();
430
431    delete mSuspensionState;
432    mSuspensionState = NULL;
433}
434
435void AwesomePlayer::notifyListener_l(int msg, int ext1, int ext2) {
436    if (mListener != NULL) {
437        sp<MediaPlayerBase> listener = mListener.promote();
438
439        if (listener != NULL) {
440            listener->sendEvent(msg, ext1, ext2);
441        }
442    }
443}
444
445void AwesomePlayer::onBufferingUpdate() {
446    Mutex::Autolock autoLock(mLock);
447    if (!mBufferingEventPending) {
448        return;
449    }
450    mBufferingEventPending = false;
451
452    if (mCachedSource == NULL) {
453        return;
454    }
455
456    size_t lowWatermark = 400000;
457    size_t highWatermark = 1000000;
458
459    off_t size;
460    if (mDurationUs >= 0 && mCachedSource->getSize(&size) == OK) {
461        int64_t bitrate = size * 8000000ll / mDurationUs;  // in bits/sec
462
463        size_t cachedSize = mCachedSource->cachedSize();
464        int64_t cachedDurationUs = cachedSize * 8000000ll / bitrate;
465
466        double percentage = (double)cachedDurationUs / mDurationUs;
467
468        notifyListener_l(MEDIA_BUFFERING_UPDATE, percentage * 100.0);
469
470        lowWatermark = 2 * bitrate / 8;  // 2 secs
471        highWatermark = 10 * bitrate / 8;  // 10 secs
472    }
473
474    bool eos;
475    size_t cachedDataRemaining = mCachedSource->approxDataRemaining(&eos);
476
477    if ((mFlags & PLAYING) && !eos && (cachedDataRemaining < lowWatermark)) {
478        LOGI("cache is running low (< %d) , pausing.", lowWatermark);
479        mFlags |= CACHE_UNDERRUN;
480        pause_l();
481        notifyListener_l(MEDIA_INFO, MEDIA_INFO_BUFFERING_START);
482    } else if ((mFlags & CACHE_UNDERRUN)
483            && (eos || cachedDataRemaining > highWatermark)) {
484        LOGI("cache has filled up (> %d), resuming.", highWatermark);
485        mFlags &= ~CACHE_UNDERRUN;
486        play_l();
487        notifyListener_l(MEDIA_INFO, MEDIA_INFO_BUFFERING_END);
488    }
489
490    postBufferingEvent_l();
491}
492
493void AwesomePlayer::onStreamDone() {
494    // Posted whenever any stream finishes playing.
495
496    Mutex::Autolock autoLock(mLock);
497    if (!mStreamDoneEventPending) {
498        return;
499    }
500    mStreamDoneEventPending = false;
501
502    if (mStreamDoneStatus != ERROR_END_OF_STREAM) {
503        LOGV("MEDIA_ERROR %d", mStreamDoneStatus);
504
505        notifyListener_l(
506                MEDIA_ERROR, MEDIA_ERROR_UNKNOWN, mStreamDoneStatus);
507
508        pause_l();
509
510        mFlags |= AT_EOS;
511        return;
512    }
513
514    const bool allDone =
515        (mVideoSource == NULL || (mFlags & VIDEO_AT_EOS))
516            && (mAudioSource == NULL || (mFlags & AUDIO_AT_EOS));
517
518    if (!allDone) {
519        return;
520    }
521
522    if (mFlags & LOOPING) {
523        seekTo_l(0);
524
525        if (mVideoSource != NULL) {
526            postVideoEvent_l();
527        }
528    } else {
529        LOGV("MEDIA_PLAYBACK_COMPLETE");
530        notifyListener_l(MEDIA_PLAYBACK_COMPLETE);
531
532        pause_l();
533
534        mFlags |= AT_EOS;
535    }
536}
537
538status_t AwesomePlayer::play() {
539    Mutex::Autolock autoLock(mLock);
540
541    mFlags &= ~CACHE_UNDERRUN;
542
543    return play_l();
544}
545
546status_t AwesomePlayer::play_l() {
547    if (mFlags & PLAYING) {
548        return OK;
549    }
550
551    if (!(mFlags & PREPARED)) {
552        status_t err = prepare_l();
553
554        if (err != OK) {
555            return err;
556        }
557    }
558
559    mFlags |= PLAYING;
560    mFlags |= FIRST_FRAME;
561
562    bool deferredAudioSeek = false;
563
564    if (mAudioSource != NULL) {
565        if (mAudioPlayer == NULL) {
566            if (mAudioSink != NULL) {
567                mAudioPlayer = new AudioPlayer(mAudioSink);
568                mAudioPlayer->setSource(mAudioSource);
569
570                // We've already started the MediaSource in order to enable
571                // the prefetcher to read its data.
572                status_t err = mAudioPlayer->start(
573                        true /* sourceAlreadyStarted */);
574
575                if (err != OK) {
576                    delete mAudioPlayer;
577                    mAudioPlayer = NULL;
578
579                    mFlags &= ~(PLAYING | FIRST_FRAME);
580
581                    return err;
582                }
583
584                mTimeSource = mAudioPlayer;
585
586                deferredAudioSeek = true;
587
588                mWatchForAudioSeekComplete = false;
589                mWatchForAudioEOS = true;
590            }
591        } else {
592            mAudioPlayer->resume();
593        }
594
595        postCheckAudioStatusEvent_l();
596    }
597
598    if (mTimeSource == NULL && mAudioPlayer == NULL) {
599        mTimeSource = &mSystemTimeSource;
600    }
601
602    if (mVideoSource != NULL) {
603        // Kick off video playback
604        postVideoEvent_l();
605    }
606
607    if (deferredAudioSeek) {
608        // If there was a seek request while we were paused
609        // and we're just starting up again, honor the request now.
610        seekAudioIfNecessary_l();
611    }
612
613    if (mFlags & AT_EOS) {
614        // Legacy behaviour, if a stream finishes playing and then
615        // is started again, we play from the start...
616        seekTo_l(0);
617    }
618
619    return OK;
620}
621
622void AwesomePlayer::initRenderer_l() {
623    if (mISurface != NULL) {
624        sp<MetaData> meta = mVideoSource->getFormat();
625
626        int32_t format;
627        const char *component;
628        int32_t decodedWidth, decodedHeight;
629        CHECK(meta->findInt32(kKeyColorFormat, &format));
630        CHECK(meta->findCString(kKeyDecoderComponent, &component));
631        CHECK(meta->findInt32(kKeyWidth, &decodedWidth));
632        CHECK(meta->findInt32(kKeyHeight, &decodedHeight));
633
634        mVideoRenderer.clear();
635
636        // Must ensure that mVideoRenderer's destructor is actually executed
637        // before creating a new one.
638        IPCThreadState::self()->flushCommands();
639
640        if (!strncmp("OMX.", component, 4)) {
641            // Our OMX codecs allocate buffers on the media_server side
642            // therefore they require a remote IOMXRenderer that knows how
643            // to display them.
644            mVideoRenderer = new AwesomeRemoteRenderer(
645                mClient.interface()->createRenderer(
646                        mISurface, component,
647                        (OMX_COLOR_FORMATTYPE)format,
648                        decodedWidth, decodedHeight,
649                        mVideoWidth, mVideoHeight));
650        } else {
651            // Other decoders are instantiated locally and as a consequence
652            // allocate their buffers in local address space.
653            mVideoRenderer = new AwesomeLocalRenderer(
654                false,  // previewOnly
655                component,
656                (OMX_COLOR_FORMATTYPE)format,
657                mISurface,
658                mVideoWidth, mVideoHeight,
659                decodedWidth, decodedHeight);
660        }
661    }
662}
663
664status_t AwesomePlayer::pause() {
665    Mutex::Autolock autoLock(mLock);
666
667    mFlags &= ~CACHE_UNDERRUN;
668
669    return pause_l();
670}
671
672status_t AwesomePlayer::pause_l() {
673    if (!(mFlags & PLAYING)) {
674        return OK;
675    }
676
677    cancelPlayerEvents(true /* keepBufferingGoing */);
678
679    if (mAudioPlayer != NULL) {
680        mAudioPlayer->pause();
681    }
682
683    mFlags &= ~PLAYING;
684
685    return OK;
686}
687
688bool AwesomePlayer::isPlaying() const {
689    return (mFlags & PLAYING) || (mFlags & CACHE_UNDERRUN);
690}
691
692void AwesomePlayer::setISurface(const sp<ISurface> &isurface) {
693    Mutex::Autolock autoLock(mLock);
694
695    mISurface = isurface;
696}
697
698void AwesomePlayer::setAudioSink(
699        const sp<MediaPlayerBase::AudioSink> &audioSink) {
700    Mutex::Autolock autoLock(mLock);
701
702    mAudioSink = audioSink;
703}
704
705status_t AwesomePlayer::setLooping(bool shouldLoop) {
706    Mutex::Autolock autoLock(mLock);
707
708    mFlags = mFlags & ~LOOPING;
709
710    if (shouldLoop) {
711        mFlags |= LOOPING;
712    }
713
714    return OK;
715}
716
717status_t AwesomePlayer::getDuration(int64_t *durationUs) {
718    Mutex::Autolock autoLock(mMiscStateLock);
719
720    if (mDurationUs < 0) {
721        return UNKNOWN_ERROR;
722    }
723
724    *durationUs = mDurationUs;
725
726    return OK;
727}
728
729status_t AwesomePlayer::getPosition(int64_t *positionUs) {
730    if (mSeeking) {
731        *positionUs = mSeekTimeUs;
732    } else if (mVideoSource != NULL) {
733        Mutex::Autolock autoLock(mMiscStateLock);
734        *positionUs = mVideoTimeUs;
735    } else if (mAudioPlayer != NULL) {
736        *positionUs = mAudioPlayer->getMediaTimeUs();
737    } else {
738        *positionUs = 0;
739    }
740
741    return OK;
742}
743
744status_t AwesomePlayer::seekTo(int64_t timeUs) {
745    if (mExtractorFlags
746            & (MediaExtractor::CAN_SEEK_FORWARD
747                | MediaExtractor::CAN_SEEK_BACKWARD)) {
748        Mutex::Autolock autoLock(mLock);
749        return seekTo_l(timeUs);
750    }
751
752    return OK;
753}
754
755status_t AwesomePlayer::seekTo_l(int64_t timeUs) {
756    if (mFlags & CACHE_UNDERRUN) {
757        mFlags &= ~CACHE_UNDERRUN;
758        play_l();
759    }
760
761    mSeeking = true;
762    mSeekNotificationSent = false;
763    mSeekTimeUs = timeUs;
764    mFlags &= ~(AT_EOS | AUDIO_AT_EOS | VIDEO_AT_EOS);
765
766    seekAudioIfNecessary_l();
767
768    if (!(mFlags & PLAYING)) {
769        LOGV("seeking while paused, sending SEEK_COMPLETE notification"
770             " immediately.");
771
772        notifyListener_l(MEDIA_SEEK_COMPLETE);
773        mSeekNotificationSent = true;
774    }
775
776    return OK;
777}
778
779void AwesomePlayer::seekAudioIfNecessary_l() {
780    if (mSeeking && mVideoSource == NULL && mAudioPlayer != NULL) {
781        mAudioPlayer->seekTo(mSeekTimeUs);
782
783        mWatchForAudioSeekComplete = true;
784        mWatchForAudioEOS = true;
785        mSeekNotificationSent = false;
786    }
787}
788
789status_t AwesomePlayer::getVideoDimensions(
790        int32_t *width, int32_t *height) const {
791    Mutex::Autolock autoLock(mLock);
792
793    if (mVideoWidth < 0 || mVideoHeight < 0) {
794        return UNKNOWN_ERROR;
795    }
796
797    *width = mVideoWidth;
798    *height = mVideoHeight;
799
800    return OK;
801}
802
803void AwesomePlayer::setAudioSource(sp<MediaSource> source) {
804    CHECK(source != NULL);
805
806    mAudioTrack = source;
807}
808
809status_t AwesomePlayer::initAudioDecoder() {
810    sp<MetaData> meta = mAudioTrack->getFormat();
811
812    const char *mime;
813    CHECK(meta->findCString(kKeyMIMEType, &mime));
814
815    if (!strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_RAW)) {
816        mAudioSource = mAudioTrack;
817    } else {
818        mAudioSource = OMXCodec::Create(
819                mClient.interface(), mAudioTrack->getFormat(),
820                false, // createEncoder
821                mAudioTrack);
822    }
823
824    if (mAudioSource != NULL) {
825        int64_t durationUs;
826        if (mAudioTrack->getFormat()->findInt64(kKeyDuration, &durationUs)) {
827            Mutex::Autolock autoLock(mMiscStateLock);
828            if (mDurationUs < 0 || durationUs > mDurationUs) {
829                mDurationUs = durationUs;
830            }
831        }
832
833        status_t err = mAudioSource->start();
834
835        if (err != OK) {
836            mAudioSource.clear();
837            return err;
838        }
839    } else if (!strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_QCELP)) {
840        // For legacy reasons we're simply going to ignore the absence
841        // of an audio decoder for QCELP instead of aborting playback
842        // altogether.
843        return OK;
844    }
845
846    return mAudioSource != NULL ? OK : UNKNOWN_ERROR;
847}
848
849void AwesomePlayer::setVideoSource(sp<MediaSource> source) {
850    CHECK(source != NULL);
851
852    mVideoTrack = source;
853}
854
855status_t AwesomePlayer::initVideoDecoder() {
856    uint32_t flags = 0;
857#if 0
858    if (mRTPSession != NULL) {
859        // XXX hack.
860
861        const char *mime;
862        CHECK(mVideoTrack->getFormat()->findCString(kKeyMIMEType, &mime));
863        if (!strcasecmp(mime, MEDIA_MIMETYPE_VIDEO_AVC)) {
864            flags |= OMXCodec::kPreferSoftwareCodecs;
865        }
866    }
867#endif
868
869    mVideoSource = OMXCodec::Create(
870            mClient.interface(), mVideoTrack->getFormat(),
871            false, // createEncoder
872            mVideoTrack,
873            NULL, flags);
874
875    if (mVideoSource != NULL) {
876        int64_t durationUs;
877        if (mVideoTrack->getFormat()->findInt64(kKeyDuration, &durationUs)) {
878            Mutex::Autolock autoLock(mMiscStateLock);
879            if (mDurationUs < 0 || durationUs > mDurationUs) {
880                mDurationUs = durationUs;
881            }
882        }
883
884        CHECK(mVideoTrack->getFormat()->findInt32(kKeyWidth, &mVideoWidth));
885        CHECK(mVideoTrack->getFormat()->findInt32(kKeyHeight, &mVideoHeight));
886
887        status_t err = mVideoSource->start();
888
889        if (err != OK) {
890            mVideoSource.clear();
891            return err;
892        }
893    }
894
895    return mVideoSource != NULL ? OK : UNKNOWN_ERROR;
896}
897
898void AwesomePlayer::onVideoEvent() {
899    Mutex::Autolock autoLock(mLock);
900    if (!mVideoEventPending) {
901        // The event has been cancelled in reset_l() but had already
902        // been scheduled for execution at that time.
903        return;
904    }
905    mVideoEventPending = false;
906
907    if (mSeeking) {
908        if (mLastVideoBuffer) {
909            mLastVideoBuffer->release();
910            mLastVideoBuffer = NULL;
911        }
912
913        if (mVideoBuffer) {
914            mVideoBuffer->release();
915            mVideoBuffer = NULL;
916        }
917
918        if (mCachedSource != NULL && mAudioSource != NULL) {
919            // We're going to seek the video source first, followed by
920            // the audio source.
921            // In order to avoid jumps in the DataSource offset caused by
922            // the audio codec prefetching data from the old locations
923            // while the video codec is already reading data from the new
924            // locations, we'll "pause" the audio source, causing it to
925            // stop reading input data until a subsequent seek.
926
927            if (mAudioPlayer != NULL) {
928                mAudioPlayer->pause();
929            }
930            mAudioSource->pause();
931        }
932    }
933
934    if (!mVideoBuffer) {
935        MediaSource::ReadOptions options;
936        if (mSeeking) {
937            LOGV("seeking to %lld us (%.2f secs)", mSeekTimeUs, mSeekTimeUs / 1E6);
938
939            options.setSeekTo(
940                    mSeekTimeUs, MediaSource::ReadOptions::SEEK_CLOSEST_SYNC);
941        }
942        for (;;) {
943            status_t err = mVideoSource->read(&mVideoBuffer, &options);
944            options.clearSeekTo();
945
946            if (err != OK) {
947                CHECK_EQ(mVideoBuffer, NULL);
948
949                if (err == INFO_FORMAT_CHANGED) {
950                    LOGV("VideoSource signalled format change.");
951
952                    if (mVideoRenderer != NULL) {
953                        mVideoRendererIsPreview = false;
954                        initRenderer_l();
955                    }
956                    continue;
957                }
958
959                mFlags |= VIDEO_AT_EOS;
960                postStreamDoneEvent_l(err);
961                return;
962            }
963
964            if (mVideoBuffer->range_length() == 0) {
965                // Some decoders, notably the PV AVC software decoder
966                // return spurious empty buffers that we just want to ignore.
967
968                mVideoBuffer->release();
969                mVideoBuffer = NULL;
970                continue;
971            }
972
973            break;
974        }
975    }
976
977    int64_t timeUs;
978    CHECK(mVideoBuffer->meta_data()->findInt64(kKeyTime, &timeUs));
979
980    {
981        Mutex::Autolock autoLock(mMiscStateLock);
982        mVideoTimeUs = timeUs;
983    }
984
985    if (mSeeking) {
986        if (mAudioPlayer != NULL) {
987            LOGV("seeking audio to %lld us (%.2f secs).", timeUs, timeUs / 1E6);
988
989            mAudioPlayer->seekTo(timeUs);
990            mAudioPlayer->resume();
991            mWatchForAudioSeekComplete = true;
992            mWatchForAudioEOS = true;
993        } else if (!mSeekNotificationSent) {
994            // If we're playing video only, report seek complete now,
995            // otherwise audio player will notify us later.
996            notifyListener_l(MEDIA_SEEK_COMPLETE);
997        }
998
999        mFlags |= FIRST_FRAME;
1000        mSeeking = false;
1001        mSeekNotificationSent = false;
1002    }
1003
1004    TimeSource *ts = (mFlags & AUDIO_AT_EOS) ? &mSystemTimeSource : mTimeSource;
1005
1006    if (mFlags & FIRST_FRAME) {
1007        mFlags &= ~FIRST_FRAME;
1008
1009        mTimeSourceDeltaUs = ts->getRealTimeUs() - timeUs;
1010    }
1011
1012    int64_t realTimeUs, mediaTimeUs;
1013    if (!(mFlags & AUDIO_AT_EOS) && mAudioPlayer != NULL
1014        && mAudioPlayer->getMediaTimeMapping(&realTimeUs, &mediaTimeUs)) {
1015        mTimeSourceDeltaUs = realTimeUs - mediaTimeUs;
1016    }
1017
1018    int64_t nowUs = ts->getRealTimeUs() - mTimeSourceDeltaUs;
1019
1020    int64_t latenessUs = nowUs - timeUs;
1021
1022    if (latenessUs > 40000) {
1023        // We're more than 40ms late.
1024        LOGV("we're late by %lld us (%.2f secs)", latenessUs, latenessUs / 1E6);
1025
1026        mVideoBuffer->release();
1027        mVideoBuffer = NULL;
1028
1029        postVideoEvent_l();
1030        return;
1031    }
1032
1033    if (latenessUs < -10000) {
1034        // We're more than 10ms early.
1035
1036        postVideoEvent_l(10000);
1037        return;
1038    }
1039
1040    if (mVideoRendererIsPreview || mVideoRenderer == NULL) {
1041        mVideoRendererIsPreview = false;
1042
1043        initRenderer_l();
1044    }
1045
1046    if (mVideoRenderer != NULL) {
1047        mVideoRenderer->render(mVideoBuffer);
1048    }
1049
1050    if (mLastVideoBuffer) {
1051        mLastVideoBuffer->release();
1052        mLastVideoBuffer = NULL;
1053    }
1054    mLastVideoBuffer = mVideoBuffer;
1055    mVideoBuffer = NULL;
1056
1057    postVideoEvent_l();
1058}
1059
1060void AwesomePlayer::postVideoEvent_l(int64_t delayUs) {
1061    if (mVideoEventPending) {
1062        return;
1063    }
1064
1065    mVideoEventPending = true;
1066    mQueue.postEventWithDelay(mVideoEvent, delayUs < 0 ? 10000 : delayUs);
1067}
1068
1069void AwesomePlayer::postStreamDoneEvent_l(status_t status) {
1070    if (mStreamDoneEventPending) {
1071        return;
1072    }
1073    mStreamDoneEventPending = true;
1074
1075    mStreamDoneStatus = status;
1076    mQueue.postEvent(mStreamDoneEvent);
1077}
1078
1079void AwesomePlayer::postBufferingEvent_l() {
1080    if (mBufferingEventPending) {
1081        return;
1082    }
1083    mBufferingEventPending = true;
1084    mQueue.postEventWithDelay(mBufferingEvent, 1000000ll);
1085}
1086
1087void AwesomePlayer::postCheckAudioStatusEvent_l() {
1088    if (mAudioStatusEventPending) {
1089        return;
1090    }
1091    mAudioStatusEventPending = true;
1092    mQueue.postEventWithDelay(mCheckAudioStatusEvent, 100000ll);
1093}
1094
1095void AwesomePlayer::onCheckAudioStatus() {
1096    Mutex::Autolock autoLock(mLock);
1097    if (!mAudioStatusEventPending) {
1098        // Event was dispatched and while we were blocking on the mutex,
1099        // has already been cancelled.
1100        return;
1101    }
1102
1103    mAudioStatusEventPending = false;
1104
1105    if (mWatchForAudioSeekComplete && !mAudioPlayer->isSeeking()) {
1106        mWatchForAudioSeekComplete = false;
1107
1108        if (!mSeekNotificationSent) {
1109            notifyListener_l(MEDIA_SEEK_COMPLETE);
1110            mSeekNotificationSent = true;
1111        }
1112
1113        mSeeking = false;
1114    }
1115
1116    status_t finalStatus;
1117    if (mWatchForAudioEOS && mAudioPlayer->reachedEOS(&finalStatus)) {
1118        mWatchForAudioEOS = false;
1119        mFlags |= AUDIO_AT_EOS;
1120        mFlags |= FIRST_FRAME;
1121        postStreamDoneEvent_l(finalStatus);
1122    }
1123
1124    postCheckAudioStatusEvent_l();
1125}
1126
1127status_t AwesomePlayer::prepare() {
1128    Mutex::Autolock autoLock(mLock);
1129    return prepare_l();
1130}
1131
1132status_t AwesomePlayer::prepare_l() {
1133    if (mFlags & PREPARED) {
1134        return OK;
1135    }
1136
1137    if (mFlags & PREPARING) {
1138        return UNKNOWN_ERROR;
1139    }
1140
1141    mIsAsyncPrepare = false;
1142    status_t err = prepareAsync_l();
1143
1144    if (err != OK) {
1145        return err;
1146    }
1147
1148    while (mFlags & PREPARING) {
1149        mPreparedCondition.wait(mLock);
1150    }
1151
1152    return mPrepareResult;
1153}
1154
1155status_t AwesomePlayer::prepareAsync() {
1156    Mutex::Autolock autoLock(mLock);
1157
1158    if (mFlags & PREPARING) {
1159        return UNKNOWN_ERROR;  // async prepare already pending
1160    }
1161
1162    mIsAsyncPrepare = true;
1163    return prepareAsync_l();
1164}
1165
1166status_t AwesomePlayer::prepareAsync_l() {
1167    if (mFlags & PREPARING) {
1168        return UNKNOWN_ERROR;  // async prepare already pending
1169    }
1170
1171    if (!mQueueStarted) {
1172        mQueue.start();
1173        mQueueStarted = true;
1174    }
1175
1176    mFlags |= PREPARING;
1177    mAsyncPrepareEvent = new AwesomeEvent(
1178            this, &AwesomePlayer::onPrepareAsyncEvent);
1179
1180    mQueue.postEvent(mAsyncPrepareEvent);
1181
1182    return OK;
1183}
1184
1185status_t AwesomePlayer::finishSetDataSource_l() {
1186    sp<DataSource> dataSource;
1187
1188    if (!strncasecmp("http://", mUri.string(), 7)) {
1189        mConnectingDataSource = new NuHTTPDataSource;
1190
1191        mLock.unlock();
1192        status_t err = mConnectingDataSource->connect(mUri, &mUriHeaders);
1193        mLock.lock();
1194
1195        if (err != OK) {
1196            mConnectingDataSource.clear();
1197
1198            LOGI("mConnectingDataSource->connect() returned %d", err);
1199            return err;
1200        }
1201
1202#if 0
1203        mCachedSource = new NuCachedSource2(
1204                new ThrottledSource(
1205                    mConnectingDataSource, 50 * 1024 /* bytes/sec */));
1206#else
1207        mCachedSource = new NuCachedSource2(mConnectingDataSource);
1208#endif
1209        mConnectingDataSource.clear();
1210
1211        dataSource = mCachedSource;
1212    } else if (!strncasecmp(mUri.string(), "httplive://", 11)) {
1213        String8 uri("http://");
1214        uri.append(mUri.string() + 11);
1215
1216        dataSource = new LiveSource(uri.string());
1217
1218        mCachedSource = new NuCachedSource2(dataSource);
1219        dataSource = mCachedSource;
1220
1221        sp<MediaExtractor> extractor =
1222            MediaExtractor::Create(dataSource, MEDIA_MIMETYPE_CONTAINER_MPEG2TS);
1223
1224        return setDataSource_l(extractor);
1225    } else if (!strcmp("rtsp://gtalk", mUri.string())) {
1226        if (mLooper == NULL) {
1227            mLooper = new ALooper;
1228            mLooper->start(
1229                    false /* runOnCallingThread */,
1230                    false /* canCallJava */,
1231                    PRIORITY_HIGHEST);
1232        }
1233
1234#if 0
1235        mRTPPusher = new UDPPusher("/data/misc/rtpout.bin", 5434);
1236        mLooper->registerHandler(mRTPPusher);
1237
1238        mRTCPPusher = new UDPPusher("/data/misc/rtcpout.bin", 5435);
1239        mLooper->registerHandler(mRTCPPusher);
1240#endif
1241
1242        mRTPSession = new ARTPSession;
1243        mLooper->registerHandler(mRTPSession);
1244
1245#if 0
1246        // My AMR SDP
1247        static const char *raw =
1248            "v=0\r\n"
1249            "o=- 64 233572944 IN IP4 127.0.0.0\r\n"
1250            "s=QuickTime\r\n"
1251            "t=0 0\r\n"
1252            "a=range:npt=0-315\r\n"
1253            "a=isma-compliance:2,2.0,2\r\n"
1254            "m=audio 5434 RTP/AVP 97\r\n"
1255            "c=IN IP4 127.0.0.1\r\n"
1256            "b=AS:30\r\n"
1257            "a=rtpmap:97 AMR/8000/1\r\n"
1258            "a=fmtp:97 octet-align\r\n";
1259#elif 1
1260        // My GTalk H.264 SDP
1261        static const char *raw =
1262            "v=0\r\n"
1263            "o=- 64 233572944 IN IP4 127.0.0.0\r\n"
1264            "s=QuickTime\r\n"
1265            "t=0 0\r\n"
1266            "a=range:npt=0-315\r\n"
1267            "a=isma-compliance:2,2.0,2\r\n"
1268            "m=video 5434 RTP/AVP 97\r\n"
1269            "c=IN IP4 127.0.0.1\r\n"
1270            "b=AS:30\r\n"
1271            "a=rtpmap:97 H264/90000\r\n"
1272            "a=cliprect:0,0,200,320\r\n"
1273            "a=framesize:97 320-200\r\n";
1274#else
1275        // GTalk H263 SDP
1276        static const char *raw =
1277            "v=0\r\n"
1278            "o=- 64 233572944 IN IP4 127.0.0.0\r\n"
1279            "s=QuickTime\r\n"
1280            "t=0 0\r\n"
1281            "a=range:npt=0-315\r\n"
1282            "a=isma-compliance:2,2.0,2\r\n"
1283            "m=video 5434 RTP/AVP 98\r\n"
1284            "c=IN IP4 127.0.0.1\r\n"
1285            "b=AS:30\r\n"
1286            "a=rtpmap:98 H263-1998/90000\r\n"
1287            "a=cliprect:0,0,200,320\r\n"
1288            "a=framesize:98 320-200\r\n";
1289#endif
1290
1291        sp<ASessionDescription> desc = new ASessionDescription;
1292        CHECK(desc->setTo(raw, strlen(raw)));
1293
1294        CHECK_EQ(mRTPSession->setup(desc), (status_t)OK);
1295
1296        if (mRTPPusher != NULL) {
1297            mRTPPusher->start();
1298        }
1299
1300        if (mRTCPPusher != NULL) {
1301            mRTCPPusher->start();
1302        }
1303
1304        CHECK_EQ(mRTPSession->countTracks(), 1u);
1305        sp<MediaSource> source = mRTPSession->trackAt(0);
1306
1307#if 0
1308        bool eos;
1309        while (((APacketSource *)source.get())
1310                ->getQueuedDuration(&eos) < 5000000ll && !eos) {
1311            usleep(100000ll);
1312        }
1313#endif
1314
1315        const char *mime;
1316        CHECK(source->getFormat()->findCString(kKeyMIMEType, &mime));
1317
1318        if (!strncasecmp("video/", mime, 6)) {
1319            setVideoSource(source);
1320        } else {
1321            CHECK(!strncasecmp("audio/", mime, 6));
1322            setAudioSource(source);
1323        }
1324
1325        mExtractorFlags = MediaExtractor::CAN_PAUSE;
1326
1327        return OK;
1328    } else if (!strncasecmp("rtsp://", mUri.string(), 7)) {
1329        if (mLooper == NULL) {
1330            mLooper = new ALooper;
1331            mLooper->start();
1332        }
1333        mRTSPController = new ARTSPController(mLooper);
1334        status_t err = mRTSPController->connect(mUri.string());
1335
1336        LOGI("ARTSPController::connect returned %d", err);
1337
1338        if (err != OK) {
1339            mRTSPController.clear();
1340            return err;
1341        }
1342
1343        sp<MediaExtractor> extractor = mRTSPController.get();
1344        return setDataSource_l(extractor);
1345    } else {
1346        dataSource = DataSource::CreateFromURI(mUri.string(), &mUriHeaders);
1347    }
1348
1349    if (dataSource == NULL) {
1350        return UNKNOWN_ERROR;
1351    }
1352
1353    sp<MediaExtractor> extractor = MediaExtractor::Create(dataSource);
1354
1355    if (extractor == NULL) {
1356        return UNKNOWN_ERROR;
1357    }
1358
1359    return setDataSource_l(extractor);
1360}
1361
1362void AwesomePlayer::abortPrepare(status_t err) {
1363    CHECK(err != OK);
1364
1365    if (mIsAsyncPrepare) {
1366        notifyListener_l(MEDIA_ERROR, MEDIA_ERROR_UNKNOWN, err);
1367    }
1368
1369    mPrepareResult = err;
1370    mFlags &= ~(PREPARING|PREPARE_CANCELLED);
1371    mAsyncPrepareEvent = NULL;
1372    mPreparedCondition.broadcast();
1373}
1374
1375// static
1376bool AwesomePlayer::ContinuePreparation(void *cookie) {
1377    AwesomePlayer *me = static_cast<AwesomePlayer *>(cookie);
1378
1379    return (me->mFlags & PREPARE_CANCELLED) == 0;
1380}
1381
1382void AwesomePlayer::onPrepareAsyncEvent() {
1383    {
1384        Mutex::Autolock autoLock(mLock);
1385
1386        if (mFlags & PREPARE_CANCELLED) {
1387            LOGI("prepare was cancelled before doing anything");
1388            abortPrepare(UNKNOWN_ERROR);
1389            return;
1390        }
1391
1392        if (mUri.size() > 0) {
1393            status_t err = finishSetDataSource_l();
1394
1395            if (err != OK) {
1396                abortPrepare(err);
1397                return;
1398            }
1399        }
1400
1401        if (mVideoTrack != NULL && mVideoSource == NULL) {
1402            status_t err = initVideoDecoder();
1403
1404            if (err != OK) {
1405                abortPrepare(err);
1406                return;
1407            }
1408        }
1409
1410        if (mAudioTrack != NULL && mAudioSource == NULL) {
1411            status_t err = initAudioDecoder();
1412
1413            if (err != OK) {
1414                abortPrepare(err);
1415                return;
1416            }
1417        }
1418    }
1419
1420    Mutex::Autolock autoLock(mLock);
1421
1422    if (mIsAsyncPrepare) {
1423        if (mVideoWidth < 0 || mVideoHeight < 0) {
1424            notifyListener_l(MEDIA_SET_VIDEO_SIZE, 0, 0);
1425        } else {
1426            notifyListener_l(MEDIA_SET_VIDEO_SIZE, mVideoWidth, mVideoHeight);
1427        }
1428
1429        notifyListener_l(MEDIA_PREPARED);
1430    }
1431
1432    mPrepareResult = OK;
1433    mFlags &= ~(PREPARING|PREPARE_CANCELLED);
1434    mFlags |= PREPARED;
1435    mAsyncPrepareEvent = NULL;
1436    mPreparedCondition.broadcast();
1437
1438    postBufferingEvent_l();
1439}
1440
1441status_t AwesomePlayer::suspend() {
1442    LOGV("suspend");
1443    Mutex::Autolock autoLock(mLock);
1444
1445    if (mSuspensionState != NULL) {
1446        if (mLastVideoBuffer == NULL) {
1447            //go into here if video is suspended again
1448            //after resuming without being played between
1449            //them
1450            SuspensionState *state = mSuspensionState;
1451            mSuspensionState = NULL;
1452            reset_l();
1453            mSuspensionState = state;
1454            return OK;
1455        }
1456
1457        delete mSuspensionState;
1458        mSuspensionState = NULL;
1459    }
1460
1461    if (mFlags & PREPARING) {
1462        mFlags |= PREPARE_CANCELLED;
1463        if (mConnectingDataSource != NULL) {
1464            LOGI("interrupting the connection process");
1465            mConnectingDataSource->disconnect();
1466        }
1467    }
1468
1469    while (mFlags & PREPARING) {
1470        mPreparedCondition.wait(mLock);
1471    }
1472
1473    SuspensionState *state = new SuspensionState;
1474    state->mUri = mUri;
1475    state->mUriHeaders = mUriHeaders;
1476    state->mFileSource = mFileSource;
1477
1478    state->mFlags = mFlags & (PLAYING | LOOPING | AT_EOS);
1479    getPosition(&state->mPositionUs);
1480
1481    if (mLastVideoBuffer) {
1482        size_t size = mLastVideoBuffer->range_length();
1483        if (size) {
1484            state->mLastVideoFrameSize = size;
1485            state->mLastVideoFrame = malloc(size);
1486            memcpy(state->mLastVideoFrame,
1487                   (const uint8_t *)mLastVideoBuffer->data()
1488                        + mLastVideoBuffer->range_offset(),
1489                   size);
1490
1491            state->mVideoWidth = mVideoWidth;
1492            state->mVideoHeight = mVideoHeight;
1493
1494            sp<MetaData> meta = mVideoSource->getFormat();
1495            CHECK(meta->findInt32(kKeyColorFormat, &state->mColorFormat));
1496            CHECK(meta->findInt32(kKeyWidth, &state->mDecodedWidth));
1497            CHECK(meta->findInt32(kKeyHeight, &state->mDecodedHeight));
1498        }
1499    }
1500
1501    reset_l();
1502
1503    mSuspensionState = state;
1504
1505    return OK;
1506}
1507
1508status_t AwesomePlayer::resume() {
1509    LOGV("resume");
1510    Mutex::Autolock autoLock(mLock);
1511
1512    if (mSuspensionState == NULL) {
1513        return INVALID_OPERATION;
1514    }
1515
1516    SuspensionState *state = mSuspensionState;
1517    mSuspensionState = NULL;
1518
1519    status_t err;
1520    if (state->mFileSource != NULL) {
1521        err = setDataSource_l(state->mFileSource);
1522
1523        if (err == OK) {
1524            mFileSource = state->mFileSource;
1525        }
1526    } else {
1527        err = setDataSource_l(state->mUri, &state->mUriHeaders);
1528    }
1529
1530    if (err != OK) {
1531        delete state;
1532        state = NULL;
1533
1534        return err;
1535    }
1536
1537    seekTo_l(state->mPositionUs);
1538
1539    mFlags = state->mFlags & (LOOPING | AT_EOS);
1540
1541    if (state->mLastVideoFrame && mISurface != NULL) {
1542        mVideoRenderer =
1543            new AwesomeLocalRenderer(
1544                    true,  // previewOnly
1545                    "",
1546                    (OMX_COLOR_FORMATTYPE)state->mColorFormat,
1547                    mISurface,
1548                    state->mVideoWidth,
1549                    state->mVideoHeight,
1550                    state->mDecodedWidth,
1551                    state->mDecodedHeight);
1552
1553        mVideoRendererIsPreview = true;
1554
1555        ((AwesomeLocalRenderer *)mVideoRenderer.get())->render(
1556                state->mLastVideoFrame, state->mLastVideoFrameSize);
1557    }
1558
1559    if (state->mFlags & PLAYING) {
1560        play_l();
1561    }
1562
1563    mSuspensionState = state;
1564    state = NULL;
1565
1566    return OK;
1567}
1568
1569uint32_t AwesomePlayer::flags() const {
1570    return mExtractorFlags;
1571}
1572
1573}  // namespace android
1574
1575